MD History: Add icon in top right of page when showing synced results

chrome/browser/resources/md_history/app.crisper.js

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 function PromiseResolver() {
   this.resolve_;
   this.reject_;
   this.promise_ = new Promise(function(resolve, reject) {
     this.resolve_ = resolve;
     this.reject_ = reject;
   }.bind(this));
@@ skipping 2247 matching lines @@
       this.tabIndex = this._oldTabIndex;
     }
   },
   _changedControlState: function() {
     if (this._controlStateChanged) {
       this._controlStateChanged();
     }
   }
 };
 
-Polymer.IronButtonStateImpl = {
+Polymer.IronFitBehavior = {
   properties: {
-    pressed: {
+    sizingTarget: {
+      type: Object,
+      value: function() {
+        return this;
+      }
+    },
+    fitInto: {
+      type: Object,
+      value: window
+    },
+    noOverlap: {
+      type: Boolean
+    },
+    positionTarget: {
+      type: Element
+    },
+    horizontalAlign: {
+      type: String
+    },
+    verticalAlign: {
+      type: String
+    },
+    dynamicAlign: {
+      type: Boolean
+    },
+    horizontalOffset: {
+      type: Number,
+      value: 0,
+      notify: true
+    },
+    verticalOffset: {
+      type: Number,
+      value: 0,
+      notify: true
+    },
+    autoFitOnAttach: {
       type: Boolean,
-      readOnly: true,
-      value: false,
-      reflectToAttribute: true,
-      observer: '_pressedChanged'
-    },
-    toggles: {
-      type: Boolean,
-      value: false,
-      reflectToAttribute: true
-    },
-    active: {
-      type: Boolean,
-      value: false,
-      notify: true,
-      reflectToAttribute: true
-    },
-    pointerDown: {
-      type: Boolean,
-      readOnly: true,
       value: false
     },
-    receivedFocusFromKeyboard: {
-      type: Boolean,
-      readOnly: true
-    },
-    ariaActiveAttribute: {
-      type: String,
-      value: 'aria-pressed',
-      observer: '_ariaActiveAttributeChanged'
-    }
-  },
-  listeners: {
-    down: '_downHandler',
-    up: '_upHandler',
-    tap: '_tapHandler'
-  },
-  observers: [ '_detectKeyboardFocus(focused)', '_activeChanged(active, ariaActiveAttribute)' ],
-  keyBindings: {
-    'enter:keydown': '_asyncClick',
-    'space:keydown': '_spaceKeyDownHandler',
-    'space:keyup': '_spaceKeyUpHandler'
-  },
-  _mouseEventRe: /^mouse/,
-  _tapHandler: function() {
-    if (this.toggles) {
-      this._userActivate(!this.active);
+    _fitInfo: {
+      type: Object
+    }
+  },
+  get _fitWidth() {
+    var fitWidth;
+    if (this.fitInto === window) {
+      fitWidth = this.fitInto.innerWidth;
     } else {
-      this.active = false;
-    }
-  },
-  _detectKeyboardFocus: function(focused) {
-    this._setReceivedFocusFromKeyboard(!this.pointerDown && focused);
-  },
-  _userActivate: function(active) {
-    if (this.active !== active) {
-      this.active = active;
-      this.fire('change');
-    }
-  },
-  _downHandler: function(event) {
-    this._setPointerDown(true);
-    this._setPressed(true);
-    this._setReceivedFocusFromKeyboard(false);
-  },
-  _upHandler: function() {
-    this._setPointerDown(false);
-    this._setPressed(false);
-  },
-  _spaceKeyDownHandler: function(event) {
-    var keyboardEvent = event.detail.keyboardEvent;
-    var target = Polymer.dom(keyboardEvent).localTarget;
-    if (this.isLightDescendant(target)) return;
-    keyboardEvent.preventDefault();
-    keyboardEvent.stopImmediatePropagation();
-    this._setPressed(true);
-  },
-  _spaceKeyUpHandler: function(event) {
-    var keyboardEvent = event.detail.keyboardEvent;
-    var target = Polymer.dom(keyboardEvent).localTarget;
-    if (this.isLightDescendant(target)) return;
-    if (this.pressed) {
-      this._asyncClick();
-    }
-    this._setPressed(false);
-  },
-  _asyncClick: function() {
-    this.async(function() {
-      this.click();
-    }, 1);
-  },
-  _pressedChanged: function(pressed) {
-    this._changedButtonState();
-  },
-  _ariaActiveAttributeChanged: function(value, oldValue) {
-    if (oldValue && oldValue != value && this.hasAttribute(oldValue)) {
-      this.removeAttribute(oldValue);
-    }
-  },
-  _activeChanged: function(active, ariaActiveAttribute) {
-    if (this.toggles) {
-      this.setAttribute(this.ariaActiveAttribute, active ? 'true' : 'false');
+      fitWidth = this.fitInto.getBoundingClientRect().width;
+    }
+    return fitWidth;
+  },
+  get _fitHeight() {
+    var fitHeight;
+    if (this.fitInto === window) {
+      fitHeight = this.fitInto.innerHeight;
     } else {
-      this.removeAttribute(this.ariaActiveAttribute);
-    }
-    this._changedButtonState();
-  },
-  _controlStateChanged: function() {
-    if (this.disabled) {
-      this._setPressed(false);
+      fitHeight = this.fitInto.getBoundingClientRect().height;
+    }
+    return fitHeight;
+  },
+  get _fitLeft() {
+    var fitLeft;
+    if (this.fitInto === window) {
+      fitLeft = 0;
     } else {
-      this._changedButtonState();
-    }
-  },
-  _changedButtonState: function() {
-    if (this._buttonStateChanged) {
-      this._buttonStateChanged();
-    }
+      fitLeft = this.fitInto.getBoundingClientRect().left;
+    }
+    return fitLeft;
+  },
+  get _fitTop() {
+    var fitTop;
+    if (this.fitInto === window) {
+      fitTop = 0;
+    } else {
+      fitTop = this.fitInto.getBoundingClientRect().top;
+    }
+    return fitTop;
+  },
+  get _defaultPositionTarget() {
+    var parent = Polymer.dom(this).parentNode;
+    if (parent && parent.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+      parent = parent.host;
+    }
+    return parent;
+  },
+  get _localeHorizontalAlign() {
+    if (this._isRTL) {
+      if (this.horizontalAlign === 'right') {
+        return 'left';
+      }
+      if (this.horizontalAlign === 'left') {
+        return 'right';
+      }
+    }
+    return this.horizontalAlign;
+  },
+  attached: function() {
+    this._isRTL = window.getComputedStyle(this).direction == 'rtl';
+    this.positionTarget = this.positionTarget || this._defaultPositionTarget;
+    if (this.autoFitOnAttach) {
+      if (window.getComputedStyle(this).display === 'none') {
+        setTimeout(function() {
+          this.fit();
+        }.bind(this));
+      } else {
+        this.fit();
+      }
+    }
+  },
+  fit: function() {
+    this.position();
+    this.constrain();
+    this.center();
+  },
+  _discoverInfo: function() {
+    if (this._fitInfo) {
+      return;
+    }
+    var target = window.getComputedStyle(this);
+    var sizer = window.getComputedStyle(this.sizingTarget);
+    this._fitInfo = {
+      inlineStyle: {
+        top: this.style.top || '',
+        left: this.style.left || '',
+        position: this.style.position || ''
+      },
+      sizerInlineStyle: {
+        maxWidth: this.sizingTarget.style.maxWidth || '',
+        maxHeight: this.sizingTarget.style.maxHeight || '',
+        boxSizing: this.sizingTarget.style.boxSizing || ''
+      },
+      positionedBy: {
+        vertically: target.top !== 'auto' ? 'top' : target.bottom !== 'auto' ? 'bottom' : null,
+        horizontally: target.left !== 'auto' ? 'left' : target.right !== 'auto' ? 'right' : null
+      },
+      sizedBy: {
+        height: sizer.maxHeight !== 'none',
+        width: sizer.maxWidth !== 'none',
+        minWidth: parseInt(sizer.minWidth, 10) || 0,
+        minHeight: parseInt(sizer.minHeight, 10) || 0
+      },
+      margin: {
+        top: parseInt(target.marginTop, 10) || 0,
+        right: parseInt(target.marginRight, 10) || 0,
+        bottom: parseInt(target.marginBottom, 10) || 0,
+        left: parseInt(target.marginLeft, 10) || 0
+      }
+    };
+    if (this.verticalOffset) {
+      this._fitInfo.margin.top = this._fitInfo.margin.bottom = this.verticalOffset;
+      this._fitInfo.inlineStyle.marginTop = this.style.marginTop || '';
+      this._fitInfo.inlineStyle.marginBottom = this.style.marginBottom || '';
+      this.style.marginTop = this.style.marginBottom = this.verticalOffset + 'px';
+    }
+    if (this.horizontalOffset) {
+      this._fitInfo.margin.left = this._fitInfo.margin.right = this.horizontalOffset;
+      this._fitInfo.inlineStyle.marginLeft = this.style.marginLeft || '';
+      this._fitInfo.inlineStyle.marginRight = this.style.marginRight || '';
+      this.style.marginLeft = this.style.marginRight = this.horizontalOffset + 'px';
+    }
+  },
+  resetFit: function() {
+    var info = this._fitInfo || {};
+    for (var property in info.sizerInlineStyle) {
+      this.sizingTarget.style[property] = info.sizerInlineStyle[property];
+    }
+    for (var property in info.inlineStyle) {
+      this.style[property] = info.inlineStyle[property];
+    }
+    this._fitInfo = null;
+  },
+  refit: function() {
+    var scrollLeft = this.sizingTarget.scrollLeft;
+    var scrollTop = this.sizingTarget.scrollTop;
+    this.resetFit();
+    this.fit();
+    this.sizingTarget.scrollLeft = scrollLeft;
+    this.sizingTarget.scrollTop = scrollTop;
+  },
+  position: function() {
+    if (!this.horizontalAlign && !this.verticalAlign) {
+      return;
+    }
+    this._discoverInfo();
+    this.style.position = 'fixed';
+    this.sizingTarget.style.boxSizing = 'border-box';
+    this.style.left = '0px';
+    this.style.top = '0px';
+    var rect = this.getBoundingClientRect();
+    var positionRect = this.__getNormalizedRect(this.positionTarget);
+    var fitRect = this.__getNormalizedRect(this.fitInto);
+    var margin = this._fitInfo.margin;
+    var size = {
+      width: rect.width + margin.left + margin.right,
+      height: rect.height + margin.top + margin.bottom
+    };
+    var position = this.__getPosition(this._localeHorizontalAlign, this.verticalAlign, size, positionRect, fitRect);
+    var left = position.left + margin.left;
+    var top = position.top + margin.top;
+    var right = Math.min(fitRect.right - margin.right, left + rect.width);
+    var bottom = Math.min(fitRect.bottom - margin.bottom, top + rect.height);
+    var minWidth = this._fitInfo.sizedBy.minWidth;
+    var minHeight = this._fitInfo.sizedBy.minHeight;
+    if (left < margin.left) {
+      left = margin.left;
+      if (right - left < minWidth) {
+        left = right - minWidth;
+      }
+    }
+    if (top < margin.top) {
+      top = margin.top;
+      if (bottom - top < minHeight) {
+        top = bottom - minHeight;
+      }
+    }
+    this.sizingTarget.style.maxWidth = right - left + 'px';
+    this.sizingTarget.style.maxHeight = bottom - top + 'px';
+    this.style.left = left - rect.left + 'px';
+    this.style.top = top - rect.top + 'px';
+  },
+  constrain: function() {
+    if (this.horizontalAlign || this.verticalAlign) {
+      return;
+    }
+    this._discoverInfo();
+    var info = this._fitInfo;
+    if (!info.positionedBy.vertically) {
+      this.style.position = 'fixed';
+      this.style.top = '0px';
+    }
+    if (!info.positionedBy.horizontally) {
+      this.style.position = 'fixed';
+      this.style.left = '0px';
+    }
+    this.sizingTarget.style.boxSizing = 'border-box';
+    var rect = this.getBoundingClientRect();
+    if (!info.sizedBy.height) {
+      this.__sizeDimension(rect, info.positionedBy.vertically, 'top', 'bottom', 'Height');
+    }
+    if (!info.sizedBy.width) {
+      this.__sizeDimension(rect, info.positionedBy.horizontally, 'left', 'right', 'Width');
+    }
+  },
+  _sizeDimension: function(rect, positionedBy, start, end, extent) {
+    this.__sizeDimension(rect, positionedBy, start, end, extent);
+  },
+  __sizeDimension: function(rect, positionedBy, start, end, extent) {
+    var info = this._fitInfo;
+    var fitRect = this.__getNormalizedRect(this.fitInto);
+    var max = extent === 'Width' ? fitRect.width : fitRect.height;
+    var flip = positionedBy === end;
+    var offset = flip ? max - rect[end] : rect[start];
+    var margin = info.margin[flip ? start : end];
+    var offsetExtent = 'offset' + extent;
+    var sizingOffset = this[offsetExtent] - this.sizingTarget[offsetExtent];
+    this.sizingTarget.style['max' + extent] = max - margin - offset - sizingOffset + 'px';
+  },
+  center: function() {
+    if (this.horizontalAlign || this.verticalAlign) {
+      return;
+    }
+    this._discoverInfo();
+    var positionedBy = this._fitInfo.positionedBy;
+    if (positionedBy.vertically && positionedBy.horizontally) {
+      return;
+    }
+    this.style.position = 'fixed';
+    if (!positionedBy.vertically) {
+      this.style.top = '0px';
+    }
+    if (!positionedBy.horizontally) {
+      this.style.left = '0px';
+    }
+    var rect = this.getBoundingClientRect();
+    var fitRect = this.__getNormalizedRect(this.fitInto);
+    if (!positionedBy.vertically) {
+      var top = fitRect.top - rect.top + (fitRect.height - rect.height) / 2;
+      this.style.top = top + 'px';
+    }
+    if (!positionedBy.horizontally) {
+      var left = fitRect.left - rect.left + (fitRect.width - rect.width) / 2;
+      this.style.left = left + 'px';
+    }
+  },
+  __getNormalizedRect: function(target) {
+    if (target === document.documentElement || target === window) {
+      return {
+        top: 0,
+        left: 0,
+        width: window.innerWidth,
+        height: window.innerHeight,
+        right: window.innerWidth,
+        bottom: window.innerHeight
+      };
+    }
+    return target.getBoundingClientRect();
+  },
+  __getCroppedArea: function(position, size, fitRect) {
+    var verticalCrop = Math.min(0, position.top) + Math.min(0, fitRect.bottom - (position.top + size.height));
+    var horizontalCrop = Math.min(0, position.left) + Math.min(0, fitRect.right - (position.left + size.width));
+    return Math.abs(verticalCrop) * size.width + Math.abs(horizontalCrop) * size.height;
+  },
+  __getPosition: function(hAlign, vAlign, size, positionRect, fitRect) {
+    var positions = [ {
+      verticalAlign: 'top',
+      horizontalAlign: 'left',
+      top: positionRect.top,
+      left: positionRect.left
+    }, {
+      verticalAlign: 'top',
+      horizontalAlign: 'right',
+      top: positionRect.top,
+      left: positionRect.right - size.width
+    }, {
+      verticalAlign: 'bottom',
+      horizontalAlign: 'left',
+      top: positionRect.bottom - size.height,
+      left: positionRect.left
+    }, {
+      verticalAlign: 'bottom',
+      horizontalAlign: 'right',
+      top: positionRect.bottom - size.height,
+      left: positionRect.right - size.width
+    } ];
+    if (this.noOverlap) {
+      for (var i = 0, l = positions.length; i < l; i++) {
+        var copy = {};
+        for (var key in positions[i]) {
+          copy[key] = positions[i][key];
+        }
+        positions.push(copy);
+      }
+      positions[0].top = positions[1].top += positionRect.height;
+      positions[2].top = positions[3].top -= positionRect.height;
+      positions[4].left = positions[6].left += positionRect.width;
+      positions[5].left = positions[7].left -= positionRect.width;
+    }
+    vAlign = vAlign === 'auto' ? null : vAlign;
+    hAlign = hAlign === 'auto' ? null : hAlign;
+    var position;
+    for (var i = 0; i < positions.length; i++) {
+      var pos = positions[i];
+      if (!this.dynamicAlign && !this.noOverlap && pos.verticalAlign === vAlign && pos.horizontalAlign === hAlign) {
+        position = pos;
+        break;
+      }
+      var alignOk = (!vAlign || pos.verticalAlign === vAlign) && (!hAlign || pos.horizontalAlign === hAlign);
+      if (!this.dynamicAlign && !alignOk) {
+        continue;
+      }
+      position = position || pos;
+      pos.croppedArea = this.__getCroppedArea(pos, size, fitRect);
+      var diff = pos.croppedArea - position.croppedArea;
+      if (diff < 0 || diff === 0 && alignOk) {
+        position = pos;
+      }
+      if (position.croppedArea === 0 && alignOk) {
+        break;
+      }
+    }
+    return position;
   }
 };
 
-Polymer.IronButtonState = [ Polymer.IronA11yKeysBehavior, Polymer.IronButtonStateImpl ];
-
 (function() {
-  var Utility = {
-    distance: function(x1, y1, x2, y2) {
-      var xDelta = x1 - x2;
-      var yDelta = y1 - y2;
-      return Math.sqrt(xDelta * xDelta + yDelta * yDelta);
-    },
-    now: window.performance && window.performance.now ? window.performance.now.bind(window.performance) : Date.now
-  };
-  function ElementMetrics(element) {
-    this.element = element;
-    this.width = this.boundingRect.width;
-    this.height = this.boundingRect.height;
-    this.size = Math.max(this.width, this.height);
-  }
-  ElementMetrics.prototype = {
-    get boundingRect() {
-      return this.element.getBoundingClientRect();
-    },
-    furthestCornerDistanceFrom: function(x, y) {
-      var topLeft = Utility.distance(x, y, 0, 0);
-      var topRight = Utility.distance(x, y, this.width, 0);
-      var bottomLeft = Utility.distance(x, y, 0, this.height);
-      var bottomRight = Utility.distance(x, y, this.width, this.height);
-      return Math.max(topLeft, topRight, bottomLeft, bottomRight);
-    }
-  };
-  function Ripple(element) {
-    this.element = element;
-    this.color = window.getComputedStyle(element).color;
-    this.wave = document.createElement('div');
-    this.waveContainer = document.createElement('div');
-    this.wave.style.backgroundColor = this.color;
-    this.wave.classList.add('wave');
-    this.waveContainer.classList.add('wave-container');
-    Polymer.dom(this.waveContainer).appendChild(this.wave);
-    this.resetInteractionState();
-  }
-  Ripple.MAX_RADIUS = 300;
-  Ripple.prototype = {
-    get recenters() {
-      return this.element.recenters;
-    },
-    get center() {
-      return this.element.center;
-    },
-    get mouseDownElapsed() {
-      var elapsed;
-      if (!this.mouseDownStart) {
-        return 0;
-      }
-      elapsed = Utility.now() - this.mouseDownStart;
-      if (this.mouseUpStart) {
-        elapsed -= this.mouseUpElapsed;
-      }
-      return elapsed;
-    },
-    get mouseUpElapsed() {
-      return this.mouseUpStart ? Utility.now() - this.mouseUpStart : 0;
-    },
-    get mouseDownElapsedSeconds() {
-      return this.mouseDownElapsed / 1e3;
-    },
-    get mouseUpElapsedSeconds() {
-      return this.mouseUpElapsed / 1e3;
-    },
-    get mouseInteractionSeconds() {
-      return this.mouseDownElapsedSeconds + this.mouseUpElapsedSeconds;
-    },
-    get initialOpacity() {
-      return this.element.initialOpacity;
-    },
-    get opacityDecayVelocity() {
-      return this.element.opacityDecayVelocity;
-    },
-    get radius() {
-      var width2 = this.containerMetrics.width * this.containerMetrics.width;
-      var height2 = this.containerMetrics.height * this.containerMetrics.height;
-      var waveRadius = Math.min(Math.sqrt(width2 + height2), Ripple.MAX_RADIUS) * 1.1 + 5;
-      var duration = 1.1 - .2 * (waveRadius / Ripple.MAX_RADIUS);
-      var timeNow = this.mouseInteractionSeconds / duration;
-      var size = waveRadius * (1 - Math.pow(80, -timeNow));
-      return Math.abs(size);
-    },
-    get opacity() {
-      if (!this.mouseUpStart) {
-        return this.initialOpacity;
-      }
-      return Math.max(0, this.initialOpacity - this.mouseUpElapsedSeconds * this.opacityDecayVelocity);
-    },
-    get outerOpacity() {
-      var outerOpacity = this.mouseUpElapsedSeconds * .3;
-      var waveOpacity = this.opacity;
-      return Math.max(0, Math.min(outerOpacity, waveOpacity));
-    },
-    get isOpacityFullyDecayed() {
-      return this.opacity < .01 && this.radius >= Math.min(this.maxRadius, Ripple.MAX_RADIUS);
-    },
-    get isRestingAtMaxRadius() {
-      return this.opacity >= this.initialOpacity && this.radius >= Math.min(this.maxRadius, Ripple.MAX_RADIUS);
-    },
-    get isAnimationComplete() {
-      return this.mouseUpStart ? this.isOpacityFullyDecayed : this.isRestingAtMaxRadius;
-    },
-    get translationFraction() {
-      return Math.min(1, this.radius / this.containerMetrics.size * 2 / Math.sqrt(2));
-    },
-    get xNow() {
-      if (this.xEnd) {
-        return this.xStart + this.translationFraction * (this.xEnd - this.xStart);
-      }
-      return this.xStart;
-    },
-    get yNow() {
-      if (this.yEnd) {
-        return this.yStart + this.translationFraction * (this.yEnd - this.yStart);
-      }
-      return this.yStart;
-    },
-    get isMouseDown() {
-      return this.mouseDownStart && !this.mouseUpStart;
-    },
-    resetInteractionState: function() {
-      this.maxRadius = 0;
-      this.mouseDownStart = 0;
-      this.mouseUpStart = 0;
-      this.xStart = 0;
-      this.yStart = 0;
-      this.xEnd = 0;
-      this.yEnd = 0;
-      this.slideDistance = 0;
-      this.containerMetrics = new ElementMetrics(this.element);
-    },
-    draw: function() {
-      var scale;
-      var translateString;
-      var dx;
-      var dy;
-      this.wave.style.opacity = this.opacity;
-      scale = this.radius / (this.containerMetrics.size / 2);
-      dx = this.xNow - this.containerMetrics.width / 2;
-      dy = this.yNow - this.containerMetrics.height / 2;
-      this.waveContainer.style.webkitTransform = 'translate(' + dx + 'px, ' + dy + 'px)';
-      this.waveContainer.style.transform = 'translate3d(' + dx + 'px, ' + dy + 'px, 0)';
-      this.wave.style.webkitTransform = 'scale(' + scale + ',' + scale + ')';
-      this.wave.style.transform = 'scale3d(' + scale + ',' + scale + ',1)';
-    },
-    downAction: function(event) {
-      var xCenter = this.containerMetrics.width / 2;
-      var yCenter = this.containerMetrics.height / 2;
-      this.resetInteractionState();
-      this.mouseDownStart = Utility.now();
-      if (this.center) {
-        this.xStart = xCenter;
-        this.yStart = yCenter;
-        this.slideDistance = Utility.distance(this.xStart, this.yStart, this.xEnd, this.yEnd);
-      } else {
-        this.xStart = event ? event.detail.x - this.containerMetrics.boundingRect.left : this.containerMetrics.width / 2;
-        this.yStart = event ? event.detail.y - this.containerMetrics.boundingRect.top : this.containerMetrics.height / 2;
-      }
-      if (this.recenters) {
-        this.xEnd = xCenter;
-        this.yEnd = yCenter;
-        this.slideDistance = Utility.distance(this.xStart, this.yStart, this.xEnd, this.yEnd);
-      }
-      this.maxRadius = this.containerMetrics.furthestCornerDistanceFrom(this.xStart, this.yStart);
-      this.waveContainer.style.top = (this.containerMetrics.height - this.containerMetrics.size) / 2 + 'px';
-      this.waveContainer.style.left = (this.containerMetrics.width - this.containerMetrics.size) / 2 + 'px';
-      this.waveContainer.style.width = this.containerMetrics.size + 'px';
-      this.waveContainer.style.height = this.containerMetrics.size + 'px';
-    },
-    upAction: function(event) {
-      if (!this.isMouseDown) {
-        return;
-      }
-      this.mouseUpStart = Utility.now();
-    },
-    remove: function() {
-      Polymer.dom(this.waveContainer.parentNode).removeChild(this.waveContainer);
-    }
-  };
+  'use strict';
   Polymer({
-    is: 'paper-ripple',
-    behaviors: [ Polymer.IronA11yKeysBehavior ],
+    is: 'iron-overlay-backdrop',
     properties: {
-      initialOpacity: {
-        type: Number,
-        value: .25
-      },
-      opacityDecayVelocity: {
-        type: Number,
-        value: .8
-      },
-      recenters: {
-        type: Boolean,
-        value: false
-      },
-      center: {
-        type: Boolean,
-        value: false
-      },
-      ripples: {
-        type: Array,
-        value: function() {
-          return [];
-        }
-      },
-      animating: {
-        type: Boolean,
-        readOnly: true,
+      opened: {
         reflectToAttribute: true,
-        value: false
-      },
-      holdDown: {
         type: Boolean,
         value: false,
-        observer: '_holdDownChanged'
-      },
-      noink: {
-        type: Boolean,
-        value: false
-      },
-      _animating: {
-        type: Boolean
-      },
-      _boundAnimate: {
-        type: Function,
-        value: function() {
-          return this.animate.bind(this);
+        observer: '_openedChanged'
+      }
+    },
+    listeners: {
+      transitionend: '_onTransitionend'
+    },
+    created: function() {
+      this.__openedRaf = null;
+    },
+    attached: function() {
+      this.opened && this._openedChanged(this.opened);
+    },
+    prepare: function() {
+      if (this.opened && !this.parentNode) {
+        Polymer.dom(document.body).appendChild(this);
+      }
+    },
+    open: function() {
+      this.opened = true;
+    },
+    close: function() {
+      this.opened = false;
+    },
+    complete: function() {
+      if (!this.opened && this.parentNode === document.body) {
+        Polymer.dom(this.parentNode).removeChild(this);
+      }
+    },
+    _onTransitionend: function(event) {
+      if (event && event.target === this) {
+        this.complete();
+      }
+    },
+    _openedChanged: function(opened) {
+      if (opened) {
+        this.prepare();
+      } else {
+        var cs = window.getComputedStyle(this);
+        if (cs.transitionDuration === '0s' || cs.opacity == 0) {
+          this.complete();
         }
       }
-    },
-    get target() {
-      return this.keyEventTarget;
-    },
-    keyBindings: {
-      'enter:keydown': '_onEnterKeydown',
-      'space:keydown': '_onSpaceKeydown',
-      'space:keyup': '_onSpaceKeyup'
-    },
-    attached: function() {
-      if (this.parentNode.nodeType == 11) {
-        this.keyEventTarget = Polymer.dom(this).getOwnerRoot().host;
-      } else {
-        this.keyEventTarget = this.parentNode;
-      }
-      var keyEventTarget = this.keyEventTarget;
-      this.listen(keyEventTarget, 'up', 'uiUpAction');
-      this.listen(keyEventTarget, 'down', 'uiDownAction');
-    },
-    detached: function() {
-      this.unlisten(this.keyEventTarget, 'up', 'uiUpAction');
-      this.unlisten(this.keyEventTarget, 'down', 'uiDownAction');
-      this.keyEventTarget = null;
-    },
-    get shouldKeepAnimating() {
-      for (var index = 0; index < this.ripples.length; ++index) {
-        if (!this.ripples[index].isAnimationComplete) {
-          return true;
-        }
-      }
-      return false;
-    },
-    simulatedRipple: function() {
-      this.downAction(null);
-      this.async(function() {
-        this.upAction();
-      }, 1);
-    },
-    uiDownAction: function(event) {
-      if (!this.noink) {
-        this.downAction(event);
-      }
-    },
-    downAction: function(event) {
-      if (this.holdDown && this.ripples.length > 0) {
+      if (!this.isAttached) {
         return;
       }
-      var ripple = this.addRipple();
-      ripple.downAction(event);
-      if (!this._animating) {
-        this._animating = true;
-        this.animate();
-      }
-    },
-    uiUpAction: function(event) {
-      if (!this.noink) {
-        this.upAction(event);
-      }
-    },
-    upAction: function(event) {
-      if (this.holdDown) {
-        return;
-      }
-      this.ripples.forEach(function(ripple) {
-        ripple.upAction(event);
-      });
-      this._animating = true;
-      this.animate();
-    },
-    onAnimationComplete: function() {
-      this._animating = false;
-      this.$.background.style.backgroundColor = null;
-      this.fire('transitionend');
-    },
-    addRipple: function() {
-      var ripple = new Ripple(this);
-      Polymer.dom(this.$.waves).appendChild(ripple.waveContainer);
-      this.$.background.style.backgroundColor = ripple.color;
-      this.ripples.push(ripple);
-      this._setAnimating(true);
-      return ripple;
-    },
-    removeRipple: function(ripple) {
-      var rippleIndex = this.ripples.indexOf(ripple);
-      if (rippleIndex < 0) {
-        return;
-      }
-      this.ripples.splice(rippleIndex, 1);
-      ripple.remove();
-      if (!this.ripples.length) {
-        this._setAnimating(false);
-      }
-    },
-    animate: function() {
-      if (!this._animating) {
-        return;
-      }
-      var index;
-      var ripple;
-      for (index = 0; index < this.ripples.length; ++index) {
-        ripple = this.ripples[index];
-        ripple.draw();
-        this.$.background.style.opacity = ripple.outerOpacity;
-        if (ripple.isOpacityFullyDecayed && !ripple.isRestingAtMaxRadius) {
-          this.removeRipple(ripple);
-        }
-      }
-      if (!this.shouldKeepAnimating && this.ripples.length === 0) {
-        this.onAnimationComplete();
-      } else {
-        window.requestAnimationFrame(this._boundAnimate);
-      }
-    },
-    _onEnterKeydown: function() {
-      this.uiDownAction();
-      this.async(this.uiUpAction, 1);
-    },
-    _onSpaceKeydown: function() {
-      this.uiDownAction();
-    },
-    _onSpaceKeyup: function() {
-      this.uiUpAction();
-    },
-    _holdDownChanged: function(newVal, oldVal) {
-      if (oldVal === undefined) {
-        return;
-      }
-      if (newVal) {
-        this.downAction();
-      } else {
-        this.upAction();
-      }
+      if (this.__openedRaf) {
+        window.cancelAnimationFrame(this.__openedRaf);
+        this.__openedRaf = null;
+      }
+      this.scrollTop = this.scrollTop;
+      this.__openedRaf = window.requestAnimationFrame(function() {
+        this.__openedRaf = null;
+        this.toggleClass('opened', this.opened);
+      }.bind(this));
     }
   });
 })();
 
-Polymer.PaperRippleBehavior = {
-  properties: {
-    noink: {
-      type: Boolean,
-      observer: '_noinkChanged'
-    },
-    _rippleContainer: {
-      type: Object
-    }
-  },
-  _buttonStateChanged: function() {
-    if (this.focused) {
-      this.ensureRipple();
-    }
-  },
-  _downHandler: function(event) {
-    Polymer.IronButtonStateImpl._downHandler.call(this, event);
-    if (this.pressed) {
-      this.ensureRipple(event);
-    }
-  },
-  ensureRipple: function(optTriggeringEvent) {
-    if (!this.hasRipple()) {
-      this._ripple = this._createRipple();
-      this._ripple.noink = this.noink;
-      var rippleContainer = this._rippleContainer || this.root;
-      if (rippleContainer) {
-        Polymer.dom(rippleContainer).appendChild(this._ripple);
-      }
-      if (optTriggeringEvent) {
-        var domContainer = Polymer.dom(this._rippleContainer || this);
-        var target = Polymer.dom(optTriggeringEvent).rootTarget;
-        if (domContainer.deepContains(target)) {
-          this._ripple.uiDownAction(optTriggeringEvent);
-        }
-      }
-    }
-  },
-  getRipple: function() {
-    this.ensureRipple();
-    return this._ripple;
-  },
-  hasRipple: function() {
-    return Boolean(this._ripple);
-  },
-  _createRipple: function() {
-    return document.createElement('paper-ripple');
-  },
-  _noinkChanged: function(noink) {
-    if (this.hasRipple()) {
-      this._ripple.noink = noink;
-    }
+Polymer.IronOverlayManagerClass = function() {
+  this._overlays = [];
+  this._minimumZ = 101;
+  this._backdropElement = null;
+  Polymer.Gestures.add(document, 'tap', this._onCaptureClick.bind(this));
+  document.addEventListener('focus', this._onCaptureFocus.bind(this), true);
+  document.addEventListener('keydown', this._onCaptureKeyDown.bind(this), true);
+};
+
+Polymer.IronOverlayManagerClass.prototype = {
+  constructor: Polymer.IronOverlayManagerClass,
+  get backdropElement() {
+    if (!this._backdropElement) {
+      this._backdropElement = document.createElement('iron-overlay-backdrop');
+    }
+    return this._backdropElement;
+  },
+  get deepActiveElement() {
+    var active = document.activeElement || document.body;
+    while (active.root && Polymer.dom(active.root).activeElement) {
+      active = Polymer.dom(active.root).activeElement;
+    }
+    return active;
+  },
+  _bringOverlayAtIndexToFront: function(i) {
+    var overlay = this._overlays[i];
+    if (!overlay) {
+      return;
+    }
+    var lastI = this._overlays.length - 1;
+    var currentOverlay = this._overlays[lastI];
+    if (currentOverlay && this._shouldBeBehindOverlay(overlay, currentOverlay)) {
+      lastI--;
+    }
+    if (i >= lastI) {
+      return;
+    }
+    var minimumZ = Math.max(this.currentOverlayZ(), this._minimumZ);
+    if (this._getZ(overlay) <= minimumZ) {
+      this._applyOverlayZ(overlay, minimumZ);
+    }
+    while (i < lastI) {
+      this._overlays[i] = this._overlays[i + 1];
+      i++;
+    }
+    this._overlays[lastI] = overlay;
+  },
+  addOrRemoveOverlay: function(overlay) {
+    if (overlay.opened) {
+      this.addOverlay(overlay);
+    } else {
+      this.removeOverlay(overlay);
+    }
+  },
+  addOverlay: function(overlay) {
+    var i = this._overlays.indexOf(overlay);
+    if (i >= 0) {
+      this._bringOverlayAtIndexToFront(i);
+      this.trackBackdrop();
+      return;
+    }
+    var insertionIndex = this._overlays.length;
+    var currentOverlay = this._overlays[insertionIndex - 1];
+    var minimumZ = Math.max(this._getZ(currentOverlay), this._minimumZ);
+    var newZ = this._getZ(overlay);
+    if (currentOverlay && this._shouldBeBehindOverlay(overlay, currentOverlay)) {
+      this._applyOverlayZ(currentOverlay, minimumZ);
+      insertionIndex--;
+      var previousOverlay = this._overlays[insertionIndex - 1];
+      minimumZ = Math.max(this._getZ(previousOverlay), this._minimumZ);
+    }
+    if (newZ <= minimumZ) {
+      this._applyOverlayZ(overlay, minimumZ);
+    }
+    this._overlays.splice(insertionIndex, 0, overlay);
+    this.trackBackdrop();
+  },
+  removeOverlay: function(overlay) {
+    var i = this._overlays.indexOf(overlay);
+    if (i === -1) {
+      return;
+    }
+    this._overlays.splice(i, 1);
+    this.trackBackdrop();
+  },
+  currentOverlay: function() {
+    var i = this._overlays.length - 1;
+    return this._overlays[i];
+  },
+  currentOverlayZ: function() {
+    return this._getZ(this.currentOverlay());
+  },
+  ensureMinimumZ: function(minimumZ) {
+    this._minimumZ = Math.max(this._minimumZ, minimumZ);
+  },
+  focusOverlay: function() {
+    var current = this.currentOverlay();
+    if (current) {
+      current._applyFocus();
+    }
+  },
+  trackBackdrop: function() {
+    var overlay = this._overlayWithBackdrop();
+    if (!overlay && !this._backdropElement) {
+      return;
+    }
+    this.backdropElement.style.zIndex = this._getZ(overlay) - 1;
+    this.backdropElement.opened = !!overlay;
+  },
+  getBackdrops: function() {
+    var backdrops = [];
+    for (var i = 0; i < this._overlays.length; i++) {
+      if (this._overlays[i].withBackdrop) {
+        backdrops.push(this._overlays[i]);
+      }
+    }
+    return backdrops;
+  },
+  backdropZ: function() {
+    return this._getZ(this._overlayWithBackdrop()) - 1;
+  },
+  _overlayWithBackdrop: function() {
+    for (var i = 0; i < this._overlays.length; i++) {
+      if (this._overlays[i].withBackdrop) {
+        return this._overlays[i];
+      }
+    }
+  },
+  _getZ: function(overlay) {
+    var z = this._minimumZ;
+    if (overlay) {
+      var z1 = Number(overlay.style.zIndex || window.getComputedStyle(overlay).zIndex);
+      if (z1 === z1) {
+        z = z1;
+      }
+    }
+    return z;
+  },
+  _setZ: function(element, z) {
+    element.style.zIndex = z;
+  },
+  _applyOverlayZ: function(overlay, aboveZ) {
+    this._setZ(overlay, aboveZ + 2);
+  },
+  _overlayInPath: function(path) {
+    path = path || [];
+    for (var i = 0; i < path.length; i++) {
+      if (path[i]._manager === this) {
+        return path[i];
+      }
+    }
+  },
+  _onCaptureClick: function(event) {
+    var overlay = this.currentOverlay();
+    if (overlay && this._overlayInPath(Polymer.dom(event).path) !== overlay) {
+      overlay._onCaptureClick(event);
+    }
+  },
+  _onCaptureFocus: function(event) {
+    var overlay = this.currentOverlay();
+    if (overlay) {
+      overlay._onCaptureFocus(event);
+    }
+  },
+  _onCaptureKeyDown: function(event) {
+    var overlay = this.currentOverlay();
+    if (overlay) {
+      if (Polymer.IronA11yKeysBehavior.keyboardEventMatchesKeys(event, 'esc')) {
+        overlay._onCaptureEsc(event);
+      } else if (Polymer.IronA11yKeysBehavior.keyboardEventMatchesKeys(event, 'tab')) {
+        overlay._onCaptureTab(event);
+      }
+    }
+  },
+  _shouldBeBehindOverlay: function(overlay1, overlay2) {
+    return !overlay1.alwaysOnTop && overlay2.alwaysOnTop;
   }
 };
 
-Polymer.PaperButtonBehaviorImpl = {
-  properties: {
-    elevation: {
-      type: Number,
-      reflectToAttribute: true,
-      readOnly: true
-    }
-  },
-  observers: [ '_calculateElevation(focused, disabled, active, pressed, receivedFocusFromKeyboard)', '_computeKeyboardClass(receivedFocusFromKeyboard)' ],
-  hostAttributes: {
-    role: 'button',
-    tabindex: '0',
-    animated: true
-  },
-  _calculateElevation: function() {
-    var e = 1;
-    if (this.disabled) {
-      e = 0;
-    } else if (this.active || this.pressed) {
-      e = 4;
-    } else if (this.receivedFocusFromKeyboard) {
-      e = 3;
-    }
-    this._setElevation(e);
-  },
-  _computeKeyboardClass: function(receivedFocusFromKeyboard) {
-    this.toggleClass('keyboard-focus', receivedFocusFromKeyboard);
-  },
-  _spaceKeyDownHandler: function(event) {
-    Polymer.IronButtonStateImpl._spaceKeyDownHandler.call(this, event);
-    if (this.hasRipple() && this.getRipple().ripples.length < 1) {
-      this._ripple.uiDownAction();
-    }
-  },
-  _spaceKeyUpHandler: function(event) {
-    Polymer.IronButtonStateImpl._spaceKeyUpHandler.call(this, event);
-    if (this.hasRipple()) {
-      this._ripple.uiUpAction();
-    }
-  }
-};
+Polymer.IronOverlayManager = new Polymer.IronOverlayManagerClass();
 
-Polymer.PaperButtonBehavior = [ Polymer.IronButtonState, Polymer.IronControlState, Polymer.PaperRippleBehavior, Polymer.PaperButtonBehaviorImpl ];
-
-Polymer({
-  is: 'paper-button',
-  behaviors: [ Polymer.PaperButtonBehavior ],
-  properties: {
-    raised: {
-      type: Boolean,
-      reflectToAttribute: true,
-      value: false,
-      observer: '_calculateElevation'
-    }
-  },
-  _calculateElevation: function() {
-    if (!this.raised) {
-      this._setElevation(0);
-    } else {
-      Polymer.PaperButtonBehaviorImpl._calculateElevation.apply(this);
-    }
-  }
-});
+(function() {
+  'use strict';
+  Polymer.IronOverlayBehaviorImpl = {
+    properties: {
+      opened: {
+        observer: '_openedChanged',
+        type: Boolean,
+        value: false,
+        notify: true
+      },
+      canceled: {
+        observer: '_canceledChanged',
+        readOnly: true,
+        type: Boolean,
+        value: false
+      },
+      withBackdrop: {
+        observer: '_withBackdropChanged',
+        type: Boolean
+      },
+      noAutoFocus: {
+        type: Boolean,
+        value: false
+      },
+      noCancelOnEscKey: {
+        type: Boolean,
+        value: false
+      },
+      noCancelOnOutsideClick: {
+        type: Boolean,
+        value: false
+      },
+      closingReason: {
+        type: Object
+      },
+      restoreFocusOnClose: {
+        type: Boolean,
+        value: false
+      },
+      alwaysOnTop: {
+        type: Boolean
+      },
+      _manager: {
+        type: Object,
+        value: Polymer.IronOverlayManager
+      },
+      _focusedChild: {
+        type: Object
+      }
+    },
+    listeners: {
+      'iron-resize': '_onIronResize'
+    },
+    get backdropElement() {
+      return this._manager.backdropElement;
+    },
+    get _focusNode() {
+      return this._focusedChild || Polymer.dom(this).querySelector('[autofocus]') || this;
+    },
+    get _focusableNodes() {
+      var FOCUSABLE_WITH_DISABLED = [ 'a[href]', 'area[href]', 'iframe', '[tabindex]', '[contentEditable=true]' ];
+      var FOCUSABLE_WITHOUT_DISABLED = [ 'input', 'select', 'textarea', 'button' ];
+      var selector = FOCUSABLE_WITH_DISABLED.join(':not([tabindex="-1"]),') + ':not([tabindex="-1"]),' + FOCUSABLE_WITHOUT_DISABLED.join(':not([disabled]):not([tabindex="-1"]),') + ':not([disabled]):not([tabindex="-1"])';
+      var focusables = Polymer.dom(this).querySelectorAll(selector);
+      if (this.tabIndex >= 0) {
+        focusables.splice(0, 0, this);
+      }
+      return focusables.sort(function(a, b) {
+        if (a.tabIndex === b.tabIndex) {
+          return 0;
+        }
+        if (a.tabIndex === 0 || a.tabIndex > b.tabIndex) {
+          return 1;
+        }
+        return -1;
+      });
+    },
+    ready: function() {
+      this.__isAnimating = false;
+      this.__shouldRemoveTabIndex = false;
+      this.__firstFocusableNode = this.__lastFocusableNode = null;
+      this.__raf = null;
+      this.__restoreFocusNode = null;
+      this._ensureSetup();
+    },
+    attached: function() {
+      if (this.opened) {
+        this._openedChanged(this.opened);
+      }
+      this._observer = Polymer.dom(this).observeNodes(this._onNodesChange);
+    },
+    detached: function() {
+      Polymer.dom(this).unobserveNodes(this._observer);
+      this._observer = null;
+      if (this.__raf) {
+        window.cancelAnimationFrame(this.__raf);
+        this.__raf = null;
+      }
+      this._manager.removeOverlay(this);
+    },
+    toggle: function() {
+      this._setCanceled(false);
+      this.opened = !this.opened;
+    },
+    open: function() {
+      this._setCanceled(false);
+      this.opened = true;
+    },
+    close: function() {
+      this._setCanceled(false);
+      this.opened = false;
+    },
+    cancel: function(event) {
+      var cancelEvent = this.fire('iron-overlay-canceled', event, {
+        cancelable: true
+      });
+      if (cancelEvent.defaultPrevented) {
+        return;
+      }
+      this._setCanceled(true);
+      this.opened = false;
+    },
+    _ensureSetup: function() {
+      if (this._overlaySetup) {
+        return;
+      }
+      this._overlaySetup = true;
+      this.style.outline = 'none';
+      this.style.display = 'none';
+    },
+    _openedChanged: function(opened) {
+      if (opened) {
+        this.removeAttribute('aria-hidden');
+      } else {
+        this.setAttribute('aria-hidden', 'true');
+      }
+      if (!this.isAttached) {
+        return;
+      }
+      this.__isAnimating = true;
+      this.__onNextAnimationFrame(this.__openedChanged);
+    },
+    _canceledChanged: function() {
+      this.closingReason = this.closingReason || {};
+      this.closingReason.canceled = this.canceled;
+    },
+    _withBackdropChanged: function() {
+      if (this.withBackdrop && !this.hasAttribute('tabindex')) {
+        this.setAttribute('tabindex', '-1');
+        this.__shouldRemoveTabIndex = true;
+      } else if (this.__shouldRemoveTabIndex) {
+        this.removeAttribute('tabindex');
+        this.__shouldRemoveTabIndex = false;
+      }
+      if (this.opened && this.isAttached) {
+        this._manager.trackBackdrop();
+      }
+    },
+    _prepareRenderOpened: function() {
+      this.__restoreFocusNode = this._manager.deepActiveElement;
+      this._preparePositioning();
+      this.refit();
+      this._finishPositioning();
+      if (this.noAutoFocus && document.activeElement === this._focusNode) {
+        this._focusNode.blur();
+        this.__restoreFocusNode.focus();
+      }
+    },
+    _renderOpened: function() {
+      this._finishRenderOpened();
+    },
+    _renderClosed: function() {
+      this._finishRenderClosed();
+    },
+    _finishRenderOpened: function() {
+      this.notifyResize();
+      this.__isAnimating = false;
+      var focusableNodes = this._focusableNodes;
+      this.__firstFocusableNode = focusableNodes[0];
+      this.__lastFocusableNode = focusableNodes[focusableNodes.length - 1];
+      this.fire('iron-overlay-opened');
+    },
+    _finishRenderClosed: function() {
+      this.style.display = 'none';
+      this.style.zIndex = '';
+      this.notifyResize();
+      this.__isAnimating = false;
+      this.fire('iron-overlay-closed', this.closingReason);
+    },
+    _preparePositioning: function() {
+      this.style.transition = this.style.webkitTransition = 'none';
+      this.style.transform = this.style.webkitTransform = 'none';
+      this.style.display = '';
+    },
+    _finishPositioning: function() {
+      this.style.display = 'none';
+      this.scrollTop = this.scrollTop;
+      this.style.transition = this.style.webkitTransition = '';
+      this.style.transform = this.style.webkitTransform = '';
+      this.style.display = '';
+      this.scrollTop = this.scrollTop;
+    },
+    _applyFocus: function() {
+      if (this.opened) {
+        if (!this.noAutoFocus) {
+          this._focusNode.focus();
+        }
+      } else {
+        this._focusNode.blur();
+        this._focusedChild = null;
+        if (this.restoreFocusOnClose && this.__restoreFocusNode) {
+          this.__restoreFocusNode.focus();
+        }
+        this.__restoreFocusNode = null;
+        var currentOverlay = this._manager.currentOverlay();
+        if (currentOverlay && this !== currentOverlay) {
+          currentOverlay._applyFocus();
+        }
+      }
+    },
+    _onCaptureClick: function(event) {
+      if (!this.noCancelOnOutsideClick) {
+        this.cancel(event);
+      }
+    },
+    _onCaptureFocus: function(event) {
+      if (!this.withBackdrop) {
+        return;
+      }
+      var path = Polymer.dom(event).path;
+      if (path.indexOf(this) === -1) {
+        event.stopPropagation();
+        this._applyFocus();
+      } else {
+        this._focusedChild = path[0];
+      }
+    },
+    _onCaptureEsc: function(event) {
+      if (!this.noCancelOnEscKey) {
+        this.cancel(event);
+      }
+    },
+    _onCaptureTab: function(event) {
+      if (!this.withBackdrop) {
+        return;
+      }
+      var shift = event.shiftKey;
+      var nodeToCheck = shift ? this.__firstFocusableNode : this.__lastFocusableNode;
+      var nodeToSet = shift ? this.__lastFocusableNode : this.__firstFocusableNode;
+      var shouldWrap = false;
+      if (nodeToCheck === nodeToSet) {
+        shouldWrap = true;
+      } else {
+        var focusedNode = this._manager.deepActiveElement;
+        shouldWrap = focusedNode === nodeToCheck || focusedNode === this;
+      }
+      if (shouldWrap) {
+        event.preventDefault();
+        this._focusedChild = nodeToSet;
+        this._applyFocus();
+      }
+    },
+    _onIronResize: function() {
+      if (this.opened && !this.__isAnimating) {
+        this.__onNextAnimationFrame(this.refit);
+      }
+    },
+    _onNodesChange: function() {
+      if (this.opened && !this.__isAnimating) {
+        this.notifyResize();
+      }
+    },
+    __openedChanged: function() {
+      if (this.opened) {
+        this._prepareRenderOpened();
+        this._manager.addOverlay(this);
+        this._applyFocus();
+        this._renderOpened();
+      } else {
+        this._manager.removeOverlay(this);
+        this._applyFocus();
+        this._renderClosed();
+      }
+    },
+    __onNextAnimationFrame: function(callback) {
+      if (this.__raf) {
+        window.cancelAnimationFrame(this.__raf);
+      }
+      var self = this;
+      this.__raf = window.requestAnimationFrame(function nextAnimationFrame() {
+        self.__raf = null;
+        callback.call(self);
+      });
+    }
+  };
+  Polymer.IronOverlayBehavior = [ Polymer.IronFitBehavior, Polymer.IronResizableBehavior, Polymer.IronOverlayBehaviorImpl ];
+})();
 
 (function() {
   var metaDatas = {};
   var metaArrays = {};
   var singleton = null;
   Polymer.IronMeta = Polymer({
     is: 'iron-meta',
     properties: {
       type: {
         type: String,
         value: 'default',
         observer: '_typeChanged'
       },
       key: {
         type: String,
-        observer: '_keyChanged'
-      },
-      value: {
-        type: Object,
-        notify: true,
-        observer: '_valueChanged'
-      },
-      self: {
-        type: Boolean,
-        observer: '_selfChanged'
-      },
-      list: {
-        type: Array,
-        notify: true
-      }
-    },
-    hostAttributes: {
-      hidden: true
-    },
-    factoryImpl: function(config) {
-      if (config) {
-        for (var n in config) {
-          switch (n) {
-           case 'type':
-           case 'key':
-           case 'value':
-            this[n] = config[n];
-            break;
-          }
-        }
-      }
-    },
-    created: function() {
-      this._metaDatas = metaDatas;
-      this._metaArrays = metaArrays;
-    },
-    _keyChanged: function(key, old) {
-      this._resetRegistration(old);
-    },
-    _valueChanged: function(value) {
-      this._resetRegistration(this.key);
-    },
-    _selfChanged: function(self) {
-      if (self) {
-        this.value = this;
-      }
-    },
-    _typeChanged: function(type) {
-      this._unregisterKey(this.key);
-      if (!metaDatas[type]) {
-        metaDatas[type] = {};
-      }
-      this._metaData = metaDatas[type];
-      if (!metaArrays[type]) {
-        metaArrays[type] = [];
-      }
-      this.list = metaArrays[type];
-      this._registerKeyValue(this.key, this.value);
-    },
-    byKey: function(key) {
-      return this._metaData && this._metaData[key];
-    },
-    _resetRegistration: function(oldKey) {
-      this._unregisterKey(oldKey);
-      this._registerKeyValue(this.key, this.value);
-    },
-    _unregisterKey: function(key) {
-      this._unregister(key, this._metaData, this.list);
-    },
-    _registerKeyValue: function(key, value) {
-      this._register(key, value, this._metaData, this.list);
-    },
-    _register: function(key, value, data, list) {
-      if (key && data && value !== undefined) {
-        data[key] = value;
-        list.push(value);
-      }
-    },
-    _unregister: function(key, data, list) {
-      if (key && data) {
-        if (key in data) {
-          var value = data[key];
-          delete data[key];
-          this.arrayDelete(list, value);
-        }
-      }
-    }
-  });
-  Polymer.IronMeta.getIronMeta = function getIronMeta() {
-    if (singleton === null) {
-      singleton = new Polymer.IronMeta();
-    }
-    return singleton;
-  };
-  Polymer.IronMetaQuery = Polymer({
-    is: 'iron-meta-query',
-    properties: {
-      type: {
-        type: String,
-        value: 'default',
-        observer: '_typeChanged'
-      },
-      key: {
-        type: String,
         observer: '_keyChanged'
       },
       value: {
         type: Object,
         notify: true,
-        readOnly: true
+        observer: '_valueChanged'
+      },
+      self: {
+        type: Boolean,
+        observer: '_selfChanged'
       },
       list: {
         type: Array,
         notify: true
       }
     },
+    hostAttributes: {
+      hidden: true
+    },
     factoryImpl: function(config) {
       if (config) {
         for (var n in config) {
           switch (n) {
            case 'type':
            case 'key':
+           case 'value':
             this[n] = config[n];
             break;
           }
         }
       }
     },
     created: function() {
       this._metaDatas = metaDatas;
       this._metaArrays = metaArrays;
     },
+    _keyChanged: function(key, old) {
+      this._resetRegistration(old);
+    },
+    _valueChanged: function(value) {
+      this._resetRegistration(this.key);
+    },
+    _selfChanged: function(self) {
+      if (self) {
+        this.value = this;
+      }
+    },
+    _typeChanged: function(type) {
+      this._unregisterKey(this.key);
+      if (!metaDatas[type]) {
+        metaDatas[type] = {};
+      }
+      this._metaData = metaDatas[type];
+      if (!metaArrays[type]) {
+        metaArrays[type] = [];
+      }
+      this.list = metaArrays[type];
+      this._registerKeyValue(this.key, this.value);
+    },
+    byKey: function(key) {
+      return this._metaData && this._metaData[key];
+    },
+    _resetRegistration: function(oldKey) {
+      this._unregisterKey(oldKey);
+      this._registerKeyValue(this.key, this.value);
+    },
+    _unregisterKey: function(key) {
+      this._unregister(key, this._metaData, this.list);
+    },
+    _registerKeyValue: function(key, value) {
+      this._register(key, value, this._metaData, this.list);
+    },
+    _register: function(key, value, data, list) {
+      if (key && data && value !== undefined) {
+        data[key] = value;
+        list.push(value);
+      }
+    },
+    _unregister: function(key, data, list) {
+      if (key && data) {
+        if (key in data) {
+          var value = data[key];
+          delete data[key];
+          this.arrayDelete(list, value);
+        }
+      }
+    }
+  });
+  Polymer.IronMeta.getIronMeta = function getIronMeta() {
+    if (singleton === null) {
+      singleton = new Polymer.IronMeta();
+    }
+    return singleton;
+  };
+  Polymer.IronMetaQuery = Polymer({
+    is: 'iron-meta-query',
+    properties: {
+      type: {
+        type: String,
+        value: 'default',
+        observer: '_typeChanged'
+      },
+      key: {
+        type: String,
+        observer: '_keyChanged'
+      },
+      value: {
+        type: Object,
+        notify: true,
+        readOnly: true
+      },
+      list: {
+        type: Array,
+        notify: true
+      }
+    },
+    factoryImpl: function(config) {
+      if (config) {
+        for (var n in config) {
+          switch (n) {
+           case 'type':
+           case 'key':
+            this[n] = config[n];
+            break;
+          }
+        }
+      }
+    },
+    created: function() {
+      this._metaDatas = metaDatas;
+      this._metaArrays = metaArrays;
+    },
     _keyChanged: function(key) {
       this._setValue(this._metaData && this._metaData[key]);
     },
     _typeChanged: function(type) {
       this._metaData = metaDatas[type];
       this.list = metaArrays[type];
       if (this.key) {
         this._keyChanged(this.key);
       }
     },
     byKey: function(key) {
       return this._metaData && this._metaData[key];
     }
   });
 })();
 
-Polymer({
-  is: 'iron-icon',
-  properties: {
-    icon: {
-      type: String,
-      observer: '_iconChanged'
-    },
-    theme: {
-      type: String,
-      observer: '_updateIcon'
-    },
-    src: {
-      type: String,
-      observer: '_srcChanged'
-    },
-    _meta: {
-      value: Polymer.Base.create('iron-meta', {
-        type: 'iconset'
-      }),
-      observer: '_updateIcon'
-    }
-  },
-  _DEFAULT_ICONSET: 'icons',
-  _iconChanged: function(icon) {
-    var parts = (icon || '').split(':');
-    this._iconName = parts.pop();
-    this._iconsetName = parts.pop() || this._DEFAULT_ICONSET;
-    this._updateIcon();
-  },
-  _srcChanged: function(src) {
-    this._updateIcon();
-  },
-  _usesIconset: function() {
-    return this.icon || !this.src;
-  },
-  _updateIcon: function() {
-    if (this._usesIconset()) {
-      if (this._img && this._img.parentNode) {
-        Polymer.dom(this.root).removeChild(this._img);
-      }
-      if (this._iconName === "") {
-        if (this._iconset) {
-          this._iconset.removeIcon(this);
-        }
-      } else if (this._iconsetName && this._meta) {
-        this._iconset = this._meta.byKey(this._iconsetName);
-        if (this._iconset) {
-          this._iconset.applyIcon(this, this._iconName, this.theme);
-          this.unlisten(window, 'iron-iconset-added', '_updateIcon');
-        } else {
-          this.listen(window, 'iron-iconset-added', '_updateIcon');
-        }
-      }
-    } else {
-      if (this._iconset) {
-        this._iconset.removeIcon(this);
-      }
-      if (!this._img) {
-        this._img = document.createElement('img');
-        this._img.style.width = '100%';
-        this._img.style.height = '100%';
-        this._img.draggable = false;
-      }
-      this._img.src = this.src;
-      Polymer.dom(this.root).appendChild(this._img);
-    }
-  }
-});
-
-Polymer.PaperInkyFocusBehaviorImpl = {
-  observers: [ '_focusedChanged(receivedFocusFromKeyboard)' ],
-  _focusedChanged: function(receivedFocusFromKeyboard) {
-    if (receivedFocusFromKeyboard) {
-      this.ensureRipple();
-    }
-    if (this.hasRipple()) {
-      this._ripple.holdDown = receivedFocusFromKeyboard;
-    }
-  },
-  _createRipple: function() {
-    var ripple = Polymer.PaperRippleBehavior._createRipple();
-    ripple.id = 'ink';
-    ripple.setAttribute('center', '');
-    ripple.classList.add('circle');
-    return ripple;
-  }
-};
-
-Polymer.PaperInkyFocusBehavior = [ Polymer.IronButtonState, Polymer.IronControlState, Polymer.PaperRippleBehavior, Polymer.PaperInkyFocusBehaviorImpl ];
-
-Polymer({
-  is: 'paper-icon-button',
-  hostAttributes: {
-    role: 'button',
-    tabindex: '0'
-  },
-  behaviors: [ Polymer.PaperInkyFocusBehavior ],
-  properties: {
-    src: {
-      type: String
-    },
-    icon: {
-      type: String
-    },
-    alt: {
-      type: String,
-      observer: "_altChanged"
-    }
-  },
-  _altChanged: function(newValue, oldValue) {
-    var label = this.getAttribute('aria-label');
-    if (!label || oldValue == label) {
-      this.setAttribute('aria-label', newValue);
-    }
-  }
-});
-
-Polymer({
-  is: 'paper-tab',
-  behaviors: [ Polymer.IronControlState, Polymer.IronButtonState, Polymer.PaperRippleBehavior ],
-  properties: {
-    link: {
-      type: Boolean,
-      value: false,
-      reflectToAttribute: true
-    }
-  },
-  hostAttributes: {
-    role: 'tab'
-  },
-  listeners: {
-    down: '_updateNoink',
-    tap: '_onTap'
-  },
-  attached: function() {
-    this._updateNoink();
-  },
-  get _parentNoink() {
-    var parent = Polymer.dom(this).parentNode;
-    return !!parent && !!parent.noink;
-  },
-  _updateNoink: function() {
-    this.noink = !!this.noink || !!this._parentNoink;
-  },
-  _onTap: function(event) {
-    if (this.link) {
-      var anchor = this.queryEffectiveChildren('a');
-      if (!anchor) {
-        return;
-      }
-      if (event.target === anchor) {
-        return;
-      }
-      anchor.click();
-    }
-  }
-});
-
-Polymer.IronMultiSelectableBehaviorImpl = {
-  properties: {
-    multi: {
-      type: Boolean,
-      value: false,
-      observer: 'multiChanged'
-    },
-    selectedValues: {
-      type: Array,
-      notify: true
-    },
-    selectedItems: {
-      type: Array,
-      readOnly: true,
-      notify: true
-    }
-  },
-  observers: [ '_updateSelected(selectedValues.splices)' ],
-  select: function(value) {
-    if (this.multi) {
-      if (this.selectedValues) {
-        this._toggleSelected(value);
-      } else {
-        this.selectedValues = [ value ];
-      }
-    } else {
-      this.selected = value;
-    }
-  },
-  multiChanged: function(multi) {
-    this._selection.multi = multi;
-  },
-  get _shouldUpdateSelection() {
-    return this.selected != null || this.selectedValues != null && this.selectedValues.length;
-  },
-  _updateAttrForSelected: function() {
-    if (!this.multi) {
-      Polymer.IronSelectableBehavior._updateAttrForSelected.apply(this);
-    } else if (this._shouldUpdateSelection) {
-      this.selectedValues = this.selectedItems.map(function(selectedItem) {
-        return this._indexToValue(this.indexOf(selectedItem));
-      }, this).filter(function(unfilteredValue) {
-        return unfilteredValue != null;
-      }, this);
-    }
-  },
-  _updateSelected: function() {
-    if (this.multi) {
-      this._selectMulti(this.selectedValues);
-    } else {
-      this._selectSelected(this.selected);
-    }
-  },
-  _selectMulti: function(values) {
-    if (values) {
-      var selectedItems = this._valuesToItems(values);
-      this._selection.clear(selectedItems);
-      for (var i = 0; i < selectedItems.length; i++) {
-        this._selection.setItemSelected(selectedItems[i], true);
-      }
-      if (this.fallbackSelection && this.items.length && !this._selection.get().length) {
-        var fallback = this._valueToItem(this.fallbackSelection);
-        if (fallback) {
-          this.selectedValues = [ this.fallbackSelection ];
-        }
-      }
-    } else {
-      this._selection.clear();
-    }
-  },
-  _selectionChange: function() {
-    var s = this._selection.get();
-    if (this.multi) {
-      this._setSelectedItems(s);
-    } else {
-      this._setSelectedItems([ s ]);
-      this._setSelectedItem(s);
-    }
-  },
-  _toggleSelected: function(value) {
-    var i = this.selectedValues.indexOf(value);
-    var unselected = i < 0;
-    if (unselected) {
-      this.push('selectedValues', value);
-    } else {
-      this.splice('selectedValues', i, 1);
-    }
-  },
-  _valuesToItems: function(values) {
-    return values == null ? null : values.map(function(value) {
-      return this._valueToItem(value);
-    }, this);
-  }
-};
-
-Polymer.IronMultiSelectableBehavior = [ Polymer.IronSelectableBehavior, Polymer.IronMultiSelectableBehaviorImpl ];
-
-Polymer.IronMenuBehaviorImpl = {
-  properties: {
-    focusedItem: {
-      observer: '_focusedItemChanged',
-      readOnly: true,
-      type: Object
-    },
-    attrForItemTitle: {
-      type: String
-    }
-  },
-  hostAttributes: {
-    role: 'menu',
-    tabindex: '0'
-  },
-  observers: [ '_updateMultiselectable(multi)' ],
-  listeners: {
-    focus: '_onFocus',
-    keydown: '_onKeydown',
-    'iron-items-changed': '_onIronItemsChanged'
-  },
-  keyBindings: {
-    up: '_onUpKey',
-    down: '_onDownKey',
-    esc: '_onEscKey',
-    'shift+tab:keydown': '_onShiftTabDown'
-  },
-  attached: function() {
-    this._resetTabindices();
-  },
-  select: function(value) {
-    if (this._defaultFocusAsync) {
-      this.cancelAsync(this._defaultFocusAsync);
-      this._defaultFocusAsync = null;
-    }
-    var item = this._valueToItem(value);
-    if (item && item.hasAttribute('disabled')) return;
-    this._setFocusedItem(item);
-    Polymer.IronMultiSelectableBehaviorImpl.select.apply(this, arguments);
-  },
-  _resetTabindices: function() {
-    var selectedItem = this.multi ? this.selectedItems && this.selectedItems[0] : this.selectedItem;
-    this.items.forEach(function(item) {
-      item.setAttribute('tabindex', item === selectedItem ? '0' : '-1');
-    }, this);
-  },
-  _updateMultiselectable: function(multi) {
-    if (multi) {
-      this.setAttribute('aria-multiselectable', 'true');
-    } else {
-      this.removeAttribute('aria-multiselectable');
-    }
-  },
-  _focusWithKeyboardEvent: function(event) {
-    for (var i = 0, item; item = this.items[i]; i++) {
-      var attr = this.attrForItemTitle || 'textContent';
-      var title = item[attr] || item.getAttribute(attr);
-      if (!item.hasAttribute('disabled') && title && title.trim().charAt(0).toLowerCase() === String.fromCharCode(event.keyCode).toLowerCase()) {
-        this._setFocusedItem(item);
-        break;
-      }
-    }
-  },
-  _focusPrevious: function() {
-    var length = this.items.length;
-    var curFocusIndex = Number(this.indexOf(this.focusedItem));
-    for (var i = 1; i < length + 1; i++) {
-      var item = this.items[(curFocusIndex - i + length) % length];
-      if (!item.hasAttribute('disabled')) {
-        this._setFocusedItem(item);
-        return;
-      }
-    }
-  },
-  _focusNext: function() {
-    var length = this.items.length;
-    var curFocusIndex = Number(this.indexOf(this.focusedItem));
-    for (var i = 1; i < length + 1; i++) {
-      var item = this.items[(curFocusIndex + i) % length];
-      if (!item.hasAttribute('disabled')) {
-        this._setFocusedItem(item);
-        return;
-      }
-    }
-  },
-  _applySelection: function(item, isSelected) {
-    if (isSelected) {
-      item.setAttribute('aria-selected', 'true');
-    } else {
-      item.removeAttribute('aria-selected');
-    }
-    Polymer.IronSelectableBehavior._applySelection.apply(this, arguments);
-  },
-  _focusedItemChanged: function(focusedItem, old) {
-    old && old.setAttribute('tabindex', '-1');
-    if (focusedItem) {
-      focusedItem.setAttribute('tabindex', '0');
-      focusedItem.focus();
-    }
-  },
-  _onIronItemsChanged: function(event) {
-    if (event.detail.addedNodes.length) {
-      this._resetTabindices();
-    }
-  },
-  _onShiftTabDown: function(event) {
-    var oldTabIndex = this.getAttribute('tabindex');
-    Polymer.IronMenuBehaviorImpl._shiftTabPressed = true;
-    this._setFocusedItem(null);
-    this.setAttribute('tabindex', '-1');
-    this.async(function() {
-      this.setAttribute('tabindex', oldTabIndex);
-      Polymer.IronMenuBehaviorImpl._shiftTabPressed = false;
-    }, 1);
-  },
-  _onFocus: function(event) {
-    if (Polymer.IronMenuBehaviorImpl._shiftTabPressed) {
-      return;
-    }
-    var rootTarget = Polymer.dom(event).rootTarget;
-    if (rootTarget !== this && typeof rootTarget.tabIndex !== "undefined" && !this.isLightDescendant(rootTarget)) {
-      return;
-    }
-    this._defaultFocusAsync = this.async(function() {
-      var selectedItem = this.multi ? this.selectedItems && this.selectedItems[0] : this.selectedItem;
-      this._setFocusedItem(null);
-      if (selectedItem) {
-        this._setFocusedItem(selectedItem);
-      } else if (this.items[0]) {
-        this._focusNext();
-      }
-    });
-  },
-  _onUpKey: function(event) {
-    this._focusPrevious();
-    event.detail.keyboardEvent.preventDefault();
-  },
-  _onDownKey: function(event) {
-    this._focusNext();
-    event.detail.keyboardEvent.preventDefault();
-  },
-  _onEscKey: function(event) {
-    this.focusedItem.blur();
-  },
-  _onKeydown: function(event) {
-    if (!this.keyboardEventMatchesKeys(event, 'up down esc')) {
-      this._focusWithKeyboardEvent(event);
-    }
-    event.stopPropagation();
-  },
-  _activateHandler: function(event) {
-    Polymer.IronSelectableBehavior._activateHandler.call(this, event);
-    event.stopPropagation();
-  }
-};
-
-Polymer.IronMenuBehaviorImpl._shiftTabPressed = false;
-
-Polymer.IronMenuBehavior = [ Polymer.IronMultiSelectableBehavior, Polymer.IronA11yKeysBehavior, Polymer.IronMenuBehaviorImpl ];
-
-Polymer.IronMenubarBehaviorImpl = {
-  hostAttributes: {
-    role: 'menubar'
-  },
-  keyBindings: {
-    left: '_onLeftKey',
-    right: '_onRightKey'
-  },
-  _onUpKey: function(event) {
-    this.focusedItem.click();
-    event.detail.keyboardEvent.preventDefault();
-  },
-  _onDownKey: function(event) {
-    this.focusedItem.click();
-    event.detail.keyboardEvent.preventDefault();
-  },
-  get _isRTL() {
-    return window.getComputedStyle(this)['direction'] === 'rtl';
-  },
-  _onLeftKey: function(event) {
-    if (this._isRTL) {
-      this._focusNext();
-    } else {
-      this._focusPrevious();
-    }
-    event.detail.keyboardEvent.preventDefault();
-  },
-  _onRightKey: function(event) {
-    if (this._isRTL) {
-      this._focusPrevious();
-    } else {
-      this._focusNext();
-    }
-    event.detail.keyboardEvent.preventDefault();
-  },
-  _onKeydown: function(event) {
-    if (this.keyboardEventMatchesKeys(event, 'up down left right esc')) {
-      return;
-    }
-    this._focusWithKeyboardEvent(event);
-  }
-};
-
-Polymer.IronMenubarBehavior = [ Polymer.IronMenuBehavior, Polymer.IronMenubarBehaviorImpl ];
-
-Polymer({
-  is: 'iron-iconset-svg',
-  properties: {
-    name: {
-      type: String,
-      observer: '_nameChanged'
-    },
-    size: {
-      type: Number,
-      value: 24
-    }
-  },
-  attached: function() {
-    this.style.display = 'none';
-  },
-  getIconNames: function() {
-    this._icons = this._createIconMap();
-    return Object.keys(this._icons).map(function(n) {
-      return this.name + ':' + n;
-    }, this);
-  },
-  applyIcon: function(element, iconName) {
-    element = element.root || element;
-    this.removeIcon(element);
-    var svg = this._cloneIcon(iconName);
-    if (svg) {
-      var pde = Polymer.dom(element);
-      pde.insertBefore(svg, pde.childNodes[0]);
-      return element._svgIcon = svg;
-    }
-    return null;
-  },
-  removeIcon: function(element) {
-    if (element._svgIcon) {
-      Polymer.dom(element).removeChild(element._svgIcon);
-      element._svgIcon = null;
-    }
-  },
-  _nameChanged: function() {
-    new Polymer.IronMeta({
-      type: 'iconset',
-      key: this.name,
-      value: this
-    });
-    this.async(function() {
-      this.fire('iron-iconset-added', this, {
-        node: window
-      });
-    });
-  },
-  _createIconMap: function() {
-    var icons = Object.create(null);
-    Polymer.dom(this).querySelectorAll('[id]').forEach(function(icon) {
-      icons[icon.id] = icon;
-    });
-    return icons;
-  },
-  _cloneIcon: function(id) {
-    this._icons = this._icons || this._createIconMap();
-    return this._prepareSvgClone(this._icons[id], this.size);
-  },
-  _prepareSvgClone: function(sourceSvg, size) {
-    if (sourceSvg) {
-      var content = sourceSvg.cloneNode(true), svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg'), viewBox = content.getAttribute('viewBox') || '0 0 ' + size + ' ' + size;
-      svg.setAttribute('viewBox', viewBox);
-      svg.setAttribute('preserveAspectRatio', 'xMidYMid meet');
-      svg.style.cssText = 'pointer-events: none; display: block; width: 100%; height: 100%;';
-      svg.appendChild(content).removeAttribute('id');
-      return svg;
-    }
-    return null;
-  }
-});
-
-Polymer({
-  is: 'paper-tabs',
-  behaviors: [ Polymer.IronResizableBehavior, Polymer.IronMenubarBehavior ],
-  properties: {
-    noink: {
-      type: Boolean,
-      value: false,
-      observer: '_noinkChanged'
-    },
-    noBar: {
-      type: Boolean,
-      value: false
-    },
-    noSlide: {
-      type: Boolean,
-      value: false
-    },
-    scrollable: {
-      type: Boolean,
-      value: false
-    },
-    fitContainer: {
-      type: Boolean,
-      value: false
-    },
-    disableDrag: {
-      type: Boolean,
-      value: false
-    },
-    hideScrollButtons: {
-      type: Boolean,
-      value: false
-    },
-    alignBottom: {
-      type: Boolean,
-      value: false
-    },
-    selectable: {
-      type: String,
-      value: 'paper-tab'
-    },
-    autoselect: {
-      type: Boolean,
-      value: false
-    },
-    autoselectDelay: {
-      type: Number,
-      value: 0
-    },
-    _step: {
-      type: Number,
-      value: 10
-    },
-    _holdDelay: {
-      type: Number,
-      value: 1
-    },
-    _leftHidden: {
-      type: Boolean,
-      value: false
-    },
-    _rightHidden: {
-      type: Boolean,
-      value: false
-    },
-    _previousTab: {
-      type: Object
-    }
-  },
-  hostAttributes: {
-    role: 'tablist'
-  },
-  listeners: {
-    'iron-resize': '_onTabSizingChanged',
-    'iron-items-changed': '_onTabSizingChanged',
-    'iron-select': '_onIronSelect',
-    'iron-deselect': '_onIronDeselect'
-  },
-  keyBindings: {
-    'left:keyup right:keyup': '_onArrowKeyup'
-  },
-  created: function() {
-    this._holdJob = null;
-    this._pendingActivationItem = undefined;
-    this._pendingActivationTimeout = undefined;
-    this._bindDelayedActivationHandler = this._delayedActivationHandler.bind(this);
-    this.addEventListener('blur', this._onBlurCapture.bind(this), true);
-  },
-  ready: function() {
-    this.setScrollDirection('y', this.$.tabsContainer);
-  },
-  detached: function() {
-    this._cancelPendingActivation();
-  },
-  _noinkChanged: function(noink) {
-    var childTabs = Polymer.dom(this).querySelectorAll('paper-tab');
-    childTabs.forEach(noink ? this._setNoinkAttribute : this._removeNoinkAttribute);
-  },
-  _setNoinkAttribute: function(element) {
-    element.setAttribute('noink', '');
-  },
-  _removeNoinkAttribute: function(element) {
-    element.removeAttribute('noink');
-  },
-  _computeScrollButtonClass: function(hideThisButton, scrollable, hideScrollButtons) {
-    if (!scrollable || hideScrollButtons) {
-      return 'hidden';
-    }
-    if (hideThisButton) {
-      return 'not-visible';
-    }
-    return '';
-  },
-  _computeTabsContentClass: function(scrollable, fitContainer) {
-    return scrollable ? 'scrollable' + (fitContainer ? ' fit-container' : '') : ' fit-container';
-  },
-  _computeSelectionBarClass: function(noBar, alignBottom) {
-    if (noBar) {
-      return 'hidden';
-    } else if (alignBottom) {
-      return 'align-bottom';
-    }
-    return '';
-  },
-  _onTabSizingChanged: function() {
-    this.debounce('_onTabSizingChanged', function() {
-      this._scroll();
-      this._tabChanged(this.selectedItem);
-    }, 10);
-  },
-  _onIronSelect: function(event) {
-    this._tabChanged(event.detail.item, this._previousTab);
-    this._previousTab = event.detail.item;
-    this.cancelDebouncer('tab-changed');
-  },
-  _onIronDeselect: function(event) {
-    this.debounce('tab-changed', function() {
-      this._tabChanged(null, this._previousTab);
-      this._previousTab = null;
-    }, 1);
-  },
-  _activateHandler: function() {
-    this._cancelPendingActivation();
-    Polymer.IronMenuBehaviorImpl._activateHandler.apply(this, arguments);
-  },
-  _scheduleActivation: function(item, delay) {
-    this._pendingActivationItem = item;
-    this._pendingActivationTimeout = this.async(this._bindDelayedActivationHandler, delay);
-  },
-  _delayedActivationHandler: function() {
-    var item = this._pendingActivationItem;
-    this._pendingActivationItem = undefined;
-    this._pendingActivationTimeout = undefined;
-    item.fire(this.activateEvent, null, {
-      bubbles: true,
-      cancelable: true
-    });
-  },
-  _cancelPendingActivation: function() {
-    if (this._pendingActivationTimeout !== undefined) {
-      this.cancelAsync(this._pendingActivationTimeout);
-      this._pendingActivationItem = undefined;
-      this._pendingActivationTimeout = undefined;
-    }
-  },
-  _onArrowKeyup: function(event) {
-    if (this.autoselect) {
-      this._scheduleActivation(this.focusedItem, this.autoselectDelay);
-    }
-  },
-  _onBlurCapture: function(event) {
-    if (event.target === this._pendingActivationItem) {
-      this._cancelPendingActivation();
-    }
-  },
-  get _tabContainerScrollSize() {
-    return Math.max(0, this.$.tabsContainer.scrollWidth - this.$.tabsContainer.offsetWidth);
-  },
-  _scroll: function(e, detail) {
-    if (!this.scrollable) {
-      return;
-    }
-    var ddx = detail && -detail.ddx || 0;
-    this._affectScroll(ddx);
-  },
-  _down: function(e) {
-    this.async(function() {
-      if (this._defaultFocusAsync) {
-        this.cancelAsync(this._defaultFocusAsync);
-        this._defaultFocusAsync = null;
-      }
-    }, 1);
-  },
-  _affectScroll: function(dx) {
-    this.$.tabsContainer.scrollLeft += dx;
-    var scrollLeft = this.$.tabsContainer.scrollLeft;
-    this._leftHidden = scrollLeft === 0;
-    this._rightHidden = scrollLeft === this._tabContainerScrollSize;
-  },
-  _onLeftScrollButtonDown: function() {
-    this._scrollToLeft();
-    this._holdJob = setInterval(this._scrollToLeft.bind(this), this._holdDelay);
-  },
-  _onRightScrollButtonDown: function() {
-    this._scrollToRight();
-    this._holdJob = setInterval(this._scrollToRight.bind(this), this._holdDelay);
-  },
-  _onScrollButtonUp: function() {
-    clearInterval(this._holdJob);
-    this._holdJob = null;
-  },
-  _scrollToLeft: function() {
-    this._affectScroll(-this._step);
-  },
-  _scrollToRight: function() {
-    this._affectScroll(this._step);
-  },
-  _tabChanged: function(tab, old) {
-    if (!tab) {
-      this.$.selectionBar.classList.remove('expand');
-      this.$.selectionBar.classList.remove('contract');
-      this._positionBar(0, 0);
-      return;
-    }
-    var r = this.$.tabsContent.getBoundingClientRect();
-    var w = r.width;
-    var tabRect = tab.getBoundingClientRect();
-    var tabOffsetLeft = tabRect.left - r.left;
-    this._pos = {
-      width: this._calcPercent(tabRect.width, w),
-      left: this._calcPercent(tabOffsetLeft, w)
-    };
-    if (this.noSlide || old == null) {
-      this.$.selectionBar.classList.remove('expand');
-      this.$.selectionBar.classList.remove('contract');
-      this._positionBar(this._pos.width, this._pos.left);
-      return;
-    }
-    var oldRect = old.getBoundingClientRect();
-    var oldIndex = this.items.indexOf(old);
-    var index = this.items.indexOf(tab);
-    var m = 5;
-    this.$.selectionBar.classList.add('expand');
-    var moveRight = oldIndex < index;
-    var isRTL = this._isRTL;
-    if (isRTL) {
-      moveRight = !moveRight;
-    }
-    if (moveRight) {
-      this._positionBar(this._calcPercent(tabRect.left + tabRect.width - oldRect.left, w) - m, this._left);
-    } else {
-      this._positionBar(this._calcPercent(oldRect.left + oldRect.width - tabRect.left, w) - m, this._calcPercent(tabOffsetLeft, w) + m);
-    }
-    if (this.scrollable) {
-      this._scrollToSelectedIfNeeded(tabRect.width, tabOffsetLeft);
-    }
-  },
-  _scrollToSelectedIfNeeded: function(tabWidth, tabOffsetLeft) {
-    var l = tabOffsetLeft - this.$.tabsContainer.scrollLeft;
-    if (l < 0) {
-      this.$.tabsContainer.scrollLeft += l;
-    } else {
-      l += tabWidth - this.$.tabsContainer.offsetWidth;
-      if (l > 0) {
-        this.$.tabsContainer.scrollLeft += l;
-      }
-    }
-  },
-  _calcPercent: function(w, w0) {
-    return 100 * w / w0;
-  },
-  _positionBar: function(width, left) {
-    width = width || 0;
-    left = left || 0;
-    this._width = width;
-    this._left = left;
-    this.transform('translateX(' + left + '%) scaleX(' + width / 100 + ')', this.$.selectionBar);
-  },
-  _onBarTransitionEnd: function(e) {
-    var cl = this.$.selectionBar.classList;
-    if (cl.contains('expand')) {
-      cl.remove('expand');
-      cl.add('contract');
-      this._positionBar(this._pos.width, this._pos.left);
-    } else if (cl.contains('contract')) {
-      cl.remove('contract');
-    }
-  }
-});
-
-(function() {
-  'use strict';
-  Polymer.IronA11yAnnouncer = Polymer({
-    is: 'iron-a11y-announcer',
-    properties: {
-      mode: {
-        type: String,
-        value: 'polite'
-      },
-      _text: {
-        type: String,
-        value: ''
-      }
-    },
-    created: function() {
-      if (!Polymer.IronA11yAnnouncer.instance) {
-        Polymer.IronA11yAnnouncer.instance = this;
-      }
-      document.body.addEventListener('iron-announce', this._onIronAnnounce.bind(this));
-    },
-    announce: function(text) {
-      this._text = '';
-      this.async(function() {
-        this._text = text;
-      }, 100);
-    },
-    _onIronAnnounce: function(event) {
-      if (event.detail && event.detail.text) {
-        this.announce(event.detail.text);
-      }
-    }
-  });
-  Polymer.IronA11yAnnouncer.instance = null;
-  Polymer.IronA11yAnnouncer.requestAvailability = function() {
-    if (!Polymer.IronA11yAnnouncer.instance) {
-      Polymer.IronA11yAnnouncer.instance = document.createElement('iron-a11y-announcer');
-    }
-    document.body.appendChild(Polymer.IronA11yAnnouncer.instance);
-  };
-})();
-
-Polymer.IronValidatableBehaviorMeta = null;
-
-Polymer.IronValidatableBehavior = {
-  properties: {
-    validator: {
-      type: String
-    },
-    invalid: {
-      notify: true,
-      reflectToAttribute: true,
-      type: Boolean,
-      value: false
-    },
-    _validatorMeta: {
-      type: Object
-    },
-    validatorType: {
-      type: String,
-      value: 'validator'
-    },
-    _validator: {
-      type: Object,
-      computed: '__computeValidator(validator)'
-    }
-  },
-  observers: [ '_invalidChanged(invalid)' ],
-  registered: function() {
-    Polymer.IronValidatableBehaviorMeta = new Polymer.IronMeta({
-      type: 'validator'
-    });
-  },
-  _invalidChanged: function() {
-    if (this.invalid) {
-      this.setAttribute('aria-invalid', 'true');
-    } else {
-      this.removeAttribute('aria-invalid');
-    }
-  },
-  hasValidator: function() {
-    return this._validator != null;
-  },
-  validate: function(value) {
-    this.invalid = !this._getValidity(value);
-    return !this.invalid;
-  },
-  _getValidity: function(value) {
-    if (this.hasValidator()) {
-      return this._validator.validate(value);
-    }
-    return true;
-  },
-  __computeValidator: function() {
-    return Polymer.IronValidatableBehaviorMeta && Polymer.IronValidatableBehaviorMeta.byKey(this.validator);
-  }
-};
-
-Polymer({
-  is: 'iron-input',
-  "extends": 'input',
-  behaviors: [ Polymer.IronValidatableBehavior ],
-  properties: {
-    bindValue: {
-      observer: '_bindValueChanged',
-      type: String
-    },
-    preventInvalidInput: {
-      type: Boolean
-    },
-    allowedPattern: {
-      type: String,
-      observer: "_allowedPatternChanged"
-    },
-    _previousValidInput: {
-      type: String,
-      value: ''
-    },
-    _patternAlreadyChecked: {
-      type: Boolean,
-      value: false
-    }
-  },
-  listeners: {
-    input: '_onInput',
-    keypress: '_onKeypress'
-  },
-  registered: function() {
-    if (!this._canDispatchEventOnDisabled()) {
-      this._origDispatchEvent = this.dispatchEvent;
-      this.dispatchEvent = this._dispatchEventFirefoxIE;
-    }
-  },
-  created: function() {
-    Polymer.IronA11yAnnouncer.requestAvailability();
-  },
-  _canDispatchEventOnDisabled: function() {
-    var input = document.createElement('input');
-    var canDispatch = false;
-    input.disabled = true;
-    input.addEventListener('feature-check-dispatch-event', function() {
-      canDispatch = true;
-    });
-    try {
-      input.dispatchEvent(new Event('feature-check-dispatch-event'));
-    } catch (e) {}
-    return canDispatch;
-  },
-  _dispatchEventFirefoxIE: function() {
-    var disabled = this.disabled;
-    this.disabled = false;
-    this._origDispatchEvent.apply(this, arguments);
-    this.disabled = disabled;
-  },
-  get _patternRegExp() {
-    var pattern;
-    if (this.allowedPattern) {
-      pattern = new RegExp(this.allowedPattern);
-    } else {
-      switch (this.type) {
-       case 'number':
-        pattern = /[0-9.,e-]/;
-        break;
-      }
-    }
-    return pattern;
-  },
-  ready: function() {
-    this.bindValue = this.value;
-  },
-  _bindValueChanged: function() {
-    if (this.value !== this.bindValue) {
-      this.value = !(this.bindValue || this.bindValue === 0 || this.bindValue === false) ? '' : this.bindValue;
-    }
-    this.fire('bind-value-changed', {
-      value: this.bindValue
-    });
-  },
-  _allowedPatternChanged: function() {
-    this.preventInvalidInput = this.allowedPattern ? true : false;
-  },
-  _onInput: function() {
-    if (this.preventInvalidInput && !this._patternAlreadyChecked) {
-      var valid = this._checkPatternValidity();
-      if (!valid) {
-        this._announceInvalidCharacter('Invalid string of characters not entered.');
-        this.value = this._previousValidInput;
-      }
-    }
-    this.bindValue = this.value;
-    this._previousValidInput = this.value;
-    this._patternAlreadyChecked = false;
-  },
-  _isPrintable: function(event) {
-    var anyNonPrintable = event.keyCode == 8 || event.keyCode == 9 || event.keyCode == 13 || event.keyCode == 27;
-    var mozNonPrintable = event.keyCode == 19 || event.keyCode == 20 || event.keyCode == 45 || event.keyCode == 46 || event.keyCode == 144 || event.keyCode == 145 || event.keyCode > 32 && event.keyCode < 41 || event.keyCode > 111 && event.keyCode < 124;
-    return !anyNonPrintable && !(event.charCode == 0 && mozNonPrintable);
-  },
-  _onKeypress: function(event) {
-    if (!this.preventInvalidInput && this.type !== 'number') {
-      return;
-    }
-    var regexp = this._patternRegExp;
-    if (!regexp) {
-      return;
-    }
-    if (event.metaKey || event.ctrlKey || event.altKey) return;
-    this._patternAlreadyChecked = true;
-    var thisChar = String.fromCharCode(event.charCode);
-    if (this._isPrintable(event) && !regexp.test(thisChar)) {
-      event.preventDefault();
-      this._announceInvalidCharacter('Invalid character ' + thisChar + ' not entered.');
-    }
-  },
-  _checkPatternValidity: function() {
-    var regexp = this._patternRegExp;
-    if (!regexp) {
-      return true;
-    }
-    for (var i = 0; i < this.value.length; i++) {
-      if (!regexp.test(this.value[i])) {
-        return false;
-      }
-    }
-    return true;
-  },
-  validate: function() {
-    var valid = this.checkValidity();
-    if (valid) {
-      if (this.required && this.value === '') {
-        valid = false;
-      } else if (this.hasValidator()) {
-        valid = Polymer.IronValidatableBehavior.validate.call(this, this.value);
-      }
-    }
-    this.invalid = !valid;
-    this.fire('iron-input-validate');
-    return valid;
-  },
-  _announceInvalidCharacter: function(message) {
-    this.fire('iron-announce', {
-      text: message
-    });
-  }
-});
-
-Polymer({
-  is: 'paper-input-container',
-  properties: {
-    noLabelFloat: {
-      type: Boolean,
-      value: false
-    },
-    alwaysFloatLabel: {
-      type: Boolean,
-      value: false
-    },
-    attrForValue: {
-      type: String,
-      value: 'bind-value'
-    },
-    autoValidate: {
-      type: Boolean,
-      value: false
-    },
-    invalid: {
-      observer: '_invalidChanged',
-      type: Boolean,
-      value: false
-    },
-    focused: {
-      readOnly: true,
-      type: Boolean,
-      value: false,
-      notify: true
-    },
-    _addons: {
-      type: Array
-    },
-    _inputHasContent: {
-      type: Boolean,
-      value: false
-    },
-    _inputSelector: {
-      type: String,
-      value: 'input,textarea,.paper-input-input'
-    },
-    _boundOnFocus: {
-      type: Function,
-      value: function() {
-        return this._onFocus.bind(this);
-      }
-    },
-    _boundOnBlur: {
-      type: Function,
-      value: function() {
-        return this._onBlur.bind(this);
-      }
-    },
-    _boundOnInput: {
-      type: Function,
-      value: function() {
-        return this._onInput.bind(this);
-      }
-    },
-    _boundValueChanged: {
-      type: Function,
-      value: function() {
-        return this._onValueChanged.bind(this);
-      }
-    }
-  },
-  listeners: {
-    'addon-attached': '_onAddonAttached',
-    'iron-input-validate': '_onIronInputValidate'
-  },
-  get _valueChangedEvent() {
-    return this.attrForValue + '-changed';
-  },
-  get _propertyForValue() {
-    return Polymer.CaseMap.dashToCamelCase(this.attrForValue);
-  },
-  get _inputElement() {
-    return Polymer.dom(this).querySelector(this._inputSelector);
-  },
-  get _inputElementValue() {
-    return this._inputElement[this._propertyForValue] || this._inputElement.value;
-  },
-  ready: function() {
-    if (!this._addons) {
-      this._addons = [];
-    }
-    this.addEventListener('focus', this._boundOnFocus, true);
-    this.addEventListener('blur', this._boundOnBlur, true);
-  },
-  attached: function() {
-    if (this.attrForValue) {
-      this._inputElement.addEventListener(this._valueChangedEvent, this._boundValueChanged);
-    } else {
-      this.addEventListener('input', this._onInput);
-    }
-    if (this._inputElementValue != '') {
-      this._handleValueAndAutoValidate(this._inputElement);
-    } else {
-      this._handleValue(this._inputElement);
-    }
-  },
-  _onAddonAttached: function(event) {
-    if (!this._addons) {
-      this._addons = [];
-    }
-    var target = event.target;
-    if (this._addons.indexOf(target) === -1) {
-      this._addons.push(target);
-      if (this.isAttached) {
-        this._handleValue(this._inputElement);
-      }
-    }
-  },
-  _onFocus: function() {
-    this._setFocused(true);
-  },
-  _onBlur: function() {
-    this._setFocused(false);
-    this._handleValueAndAutoValidate(this._inputElement);
-  },
-  _onInput: function(event) {
-    this._handleValueAndAutoValidate(event.target);
-  },
-  _onValueChanged: function(event) {
-    this._handleValueAndAutoValidate(event.target);
-  },
-  _handleValue: function(inputElement) {
-    var value = this._inputElementValue;
-    if (value || value === 0 || inputElement.type === 'number' && !inputElement.checkValidity()) {
-      this._inputHasContent = true;
-    } else {
-      this._inputHasContent = false;
-    }
-    this.updateAddons({
-      inputElement: inputElement,
-      value: value,
-      invalid: this.invalid
-    });
-  },
-  _handleValueAndAutoValidate: function(inputElement) {
-    if (this.autoValidate) {
-      var valid;
-      if (inputElement.validate) {
-        valid = inputElement.validate(this._inputElementValue);
-      } else {
-        valid = inputElement.checkValidity();
-      }
-      this.invalid = !valid;
-    }
-    this._handleValue(inputElement);
-  },
-  _onIronInputValidate: function(event) {
-    this.invalid = this._inputElement.invalid;
-  },
-  _invalidChanged: function() {
-    if (this._addons) {
-      this.updateAddons({
-        invalid: this.invalid
-      });
-    }
-  },
-  updateAddons: function(state) {
-    for (var addon, index = 0; addon = this._addons[index]; index++) {
-      addon.update(state);
-    }
-  },
-  _computeInputContentClass: function(noLabelFloat, alwaysFloatLabel, focused, invalid, _inputHasContent) {
-    var cls = 'input-content';
-    if (!noLabelFloat) {
-      var label = this.querySelector('label');
-      if (alwaysFloatLabel || _inputHasContent) {
-        cls += ' label-is-floating';
-        this.$.labelAndInputContainer.style.position = 'static';
-        if (invalid) {
-          cls += ' is-invalid';
-        } else if (focused) {
-          cls += " label-is-highlighted";
-        }
-      } else {
-        if (label) {
-          this.$.labelAndInputContainer.style.position = 'relative';
-        }
-      }
-    } else {
-      if (_inputHasContent) {
-        cls += ' label-is-hidden';
-      }
-    }
-    return cls;
-  },
-  _computeUnderlineClass: function(focused, invalid) {
-    var cls = 'underline';
-    if (invalid) {
-      cls += ' is-invalid';
-    } else if (focused) {
-      cls += ' is-highlighted';
-    }
-    return cls;
-  },
-  _computeAddOnContentClass: function(focused, invalid) {
-    var cls = 'add-on-content';
-    if (invalid) {
-      cls += ' is-invalid';
-    } else if (focused) {
-      cls += ' is-highlighted';
-    }
-    return cls;
-  }
-});
-
-Polymer.PaperSpinnerBehavior = {
-  listeners: {
-    animationend: '__reset',
-    webkitAnimationEnd: '__reset'
-  },
-  properties: {
-    active: {
-      type: Boolean,
-      value: false,
-      reflectToAttribute: true,
-      observer: '__activeChanged'
-    },
-    alt: {
-      type: String,
-      value: 'loading',
-      observer: '__altChanged'
-    },
-    __coolingDown: {
-      type: Boolean,
-      value: false
-    }
-  },
-  __computeContainerClasses: function(active, coolingDown) {
-    return [ active || coolingDown ? 'active' : '', coolingDown ? 'cooldown' : '' ].join(' ');
-  },
-  __activeChanged: function(active, old) {
-    this.__setAriaHidden(!active);
-    this.__coolingDown = !active && old;
-  },
-  __altChanged: function(alt) {
-    if (alt === this.getPropertyInfo('alt').value) {
-      this.alt = this.getAttribute('aria-label') || alt;
-    } else {
-      this.__setAriaHidden(alt === '');
-      this.setAttribute('aria-label', alt);
-    }
-  },
-  __setAriaHidden: function(hidden) {
-    var attr = 'aria-hidden';
-    if (hidden) {
-      this.setAttribute(attr, 'true');
-    } else {
-      this.removeAttribute(attr);
-    }
-  },
-  __reset: function() {
-    this.active = false;
-    this.__coolingDown = false;
-  }
-};
-
-Polymer({
-  is: 'paper-spinner-lite',
-  behaviors: [ Polymer.PaperSpinnerBehavior ]
-});
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-var CrSearchFieldBehavior = {
-  properties: {
-    label: {
-      type: String,
-      value: ''
-    },
-    clearLabel: {
-      type: String,
-      value: ''
-    },
-    showingSearch: {
-      type: Boolean,
-      value: false,
-      notify: true,
-      observer: 'showingSearchChanged_',
-      reflectToAttribute: true
-    },
-    lastValue_: {
-      type: String,
-      value: ''
-    }
-  },
-  getSearchInput: function() {},
-  getValue: function() {
-    return this.getSearchInput().value;
-  },
-  setValue: function(value) {
-    this.getSearchInput().bindValue = value;
-    this.onValueChanged_(value);
-  },
-  showAndFocus: function() {
-    this.showingSearch = true;
-    this.focus_();
-  },
-  focus_: function() {
-    this.getSearchInput().focus();
-  },
-  onSearchTermSearch: function() {
-    this.onValueChanged_(this.getValue());
-  },
-  onValueChanged_: function(newValue) {
-    if (newValue == this.lastValue_) return;
-    this.fire('search-changed', newValue);
-    this.lastValue_ = newValue;
-  },
-  onSearchTermKeydown: function(e) {
-    if (e.key == 'Escape') this.showingSearch = false;
-  },
-  showingSearchChanged_: function() {
-    if (this.showingSearch) {
-      this.focus_();
-      return;
-    }
-    this.setValue('');
-    this.getSearchInput().blur();
-  }
-};
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-Polymer({
-  is: 'cr-toolbar-search-field',
-  behaviors: [ CrSearchFieldBehavior ],
-  properties: {
-    narrow: {
-      type: Boolean,
-      reflectToAttribute: true
-    },
-    label: String,
-    clearLabel: String,
-    spinnerActive: {
-      type: Boolean,
-      reflectToAttribute: true
-    },
-    hasSearchText_: Boolean
-  },
-  listeners: {
-    tap: 'showSearch_',
-    'searchInput.bind-value-changed': 'onBindValueChanged_'
-  },
-  getSearchInput: function() {
-    return this.$.searchInput;
-  },
-  isSearchFocused: function() {
-    return this.$.searchTerm.focused;
-  },
-  computeIconTabIndex_: function(narrow) {
-    return narrow ? 0 : -1;
-  },
-  isSpinnerShown_: function(spinnerActive, showingSearch) {
-    return spinnerActive && showingSearch;
-  },
-  onInputBlur_: function() {
-    if (!this.hasSearchText_) this.showingSearch = false;
-  },
-  onBindValueChanged_: function() {
-    var newValue = this.$.searchInput.bindValue;
-    this.hasSearchText_ = newValue != '';
-    if (newValue != '') this.showingSearch = true;
-  },
-  showSearch_: function(e) {
-    if (e.target != this.$.clearSearch) this.showingSearch = true;
-  },
-  hideSearch_: function(e) {
-    this.showingSearch = false;
-    e.stopPropagation();
-  }
-});
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-Polymer({
-  is: 'cr-toolbar',
-  properties: {
-    pageName: String,
-    searchPrompt: String,
-    clearLabel: String,
-    menuLabel: String,
-    spinnerActive: Boolean,
-    showMenu: {
-      type: Boolean,
-      value: false
-    },
-    narrow_: {
-      type: Boolean,
-      reflectToAttribute: true
-    },
-    showingSearch_: {
-      type: Boolean,
-      reflectToAttribute: true
-    }
-  },
-  getSearchField: function() {
-    return this.$.search;
-  },
-  onMenuTap_: function(e) {
-    this.fire('cr-menu-tap');
-  }
-});
-
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-Polymer({
-  is: 'history-toolbar',
-  properties: {
-    count: {
-      type: Number,
-      value: 0,
-      observer: 'changeToolbarView_'
-    },
-    itemsSelected_: {
-      type: Boolean,
-      value: false,
-      reflectToAttribute: true
-    },
-    searchTerm: {
-      type: String,
-      notify: true
-    },
-    spinnerActive: {
-      type: Boolean,
-      value: false
-    },
-    hasDrawer: {
-      type: Boolean,
-      observer: 'hasDrawerChanged_',
-      reflectToAttribute: true
-    },
-    isGroupedMode: {
-      type: Boolean,
-      reflectToAttribute: true
-    },
-    groupedRange: {
-      type: Number,
-      value: 0,
-      reflectToAttribute: true,
-      notify: true
-    },
-    queryStartTime: String,
-    queryEndTime: String
-  },
-  changeToolbarView_: function() {
-    this.itemsSelected_ = this.count > 0;
-  },
-  setSearchTerm: function(search) {
-    if (this.searchTerm == search) return;
-    this.searchTerm = search;
-    var searchField = this.$['main-toolbar'].getSearchField();
-    searchField.showAndFocus();
-    searchField.setValue(search);
-  },
-  onSearchChanged_: function(event) {
-    this.searchTerm = event.detail;
-  },
-  onClearSelectionTap_: function() {
-    this.fire('unselect-all');
-  },
-  onDeleteTap_: function() {
-    this.fire('delete-selected');
-  },
-  get searchBar() {
-    return this.$['main-toolbar'].getSearchField();
-  },
-  showSearchField: function() {
-    this.$['main-toolbar'].getSearchField().showAndFocus();
-  },
-  deletingAllowed_: function() {
-    return loadTimeData.getBoolean('allowDeletingHistory');
-  },
-  numberOfItemsSelected_: function(count) {
-    return count > 0 ? loadTimeData.getStringF('itemsSelected', count) : '';
-  },
-  getHistoryInterval_: function(queryStartTime, queryEndTime) {
-    return loadTimeData.getStringF('historyInterval', queryStartTime, queryEndTime);
-  },
-  hasDrawerChanged_: function() {
-    this.updateStyles();
-  }
-});
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-Polymer({
-  is: 'cr-dialog',
-  "extends": 'dialog',
-  created: function() {
-    window.addEventListener('popstate', function() {
-      if (this.open) this.cancel();
-    }.bind(this));
-  },
-  cancel: function() {
-    this.fire('cancel');
-    HTMLDialogElement.prototype.close.call(this, '');
-  },
-  close: function(opt_returnValue) {
-    HTMLDialogElement.prototype.close.call(this, 'success');
-  },
-  getCloseButton: function() {
-    return this.$.close;
-  }
-});
-
-Polymer.IronFitBehavior = {
-  properties: {
-    sizingTarget: {
-      type: Object,
-      value: function() {
-        return this;
-      }
-    },
-    fitInto: {
-      type: Object,
-      value: window
-    },
-    noOverlap: {
-      type: Boolean
-    },
-    positionTarget: {
-      type: Element
-    },
-    horizontalAlign: {
-      type: String
-    },
-    verticalAlign: {
-      type: String
-    },
-    dynamicAlign: {
-      type: Boolean
-    },
-    horizontalOffset: {
-      type: Number,
-      value: 0,
-      notify: true
-    },
-    verticalOffset: {
-      type: Number,
-      value: 0,
-      notify: true
-    },
-    autoFitOnAttach: {
-      type: Boolean,
-      value: false
-    },
-    _fitInfo: {
-      type: Object
-    }
-  },
-  get _fitWidth() {
-    var fitWidth;
-    if (this.fitInto === window) {
-      fitWidth = this.fitInto.innerWidth;
-    } else {
-      fitWidth = this.fitInto.getBoundingClientRect().width;
-    }
-    return fitWidth;
-  },
-  get _fitHeight() {
-    var fitHeight;
-    if (this.fitInto === window) {
-      fitHeight = this.fitInto.innerHeight;
-    } else {
-      fitHeight = this.fitInto.getBoundingClientRect().height;
-    }
-    return fitHeight;
-  },
-  get _fitLeft() {
-    var fitLeft;
-    if (this.fitInto === window) {
-      fitLeft = 0;
-    } else {
-      fitLeft = this.fitInto.getBoundingClientRect().left;
-    }
-    return fitLeft;
-  },
-  get _fitTop() {
-    var fitTop;
-    if (this.fitInto === window) {
-      fitTop = 0;
-    } else {
-      fitTop = this.fitInto.getBoundingClientRect().top;
-    }
-    return fitTop;
-  },
-  get _defaultPositionTarget() {
-    var parent = Polymer.dom(this).parentNode;
-    if (parent && parent.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
-      parent = parent.host;
-    }
-    return parent;
-  },
-  get _localeHorizontalAlign() {
-    if (this._isRTL) {
-      if (this.horizontalAlign === 'right') {
-        return 'left';
-      }
-      if (this.horizontalAlign === 'left') {
-        return 'right';
-      }
-    }
-    return this.horizontalAlign;
-  },
-  attached: function() {
-    this._isRTL = window.getComputedStyle(this).direction == 'rtl';
-    this.positionTarget = this.positionTarget || this._defaultPositionTarget;
-    if (this.autoFitOnAttach) {
-      if (window.getComputedStyle(this).display === 'none') {
-        setTimeout(function() {
-          this.fit();
-        }.bind(this));
-      } else {
-        this.fit();
-      }
-    }
-  },
-  fit: function() {
-    this.position();
-    this.constrain();
-    this.center();
-  },
-  _discoverInfo: function() {
-    if (this._fitInfo) {
-      return;
-    }
-    var target = window.getComputedStyle(this);
-    var sizer = window.getComputedStyle(this.sizingTarget);
-    this._fitInfo = {
-      inlineStyle: {
-        top: this.style.top || '',
-        left: this.style.left || '',
-        position: this.style.position || ''
-      },
-      sizerInlineStyle: {
-        maxWidth: this.sizingTarget.style.maxWidth || '',
-        maxHeight: this.sizingTarget.style.maxHeight || '',
-        boxSizing: this.sizingTarget.style.boxSizing || ''
-      },
-      positionedBy: {
-        vertically: target.top !== 'auto' ? 'top' : target.bottom !== 'auto' ? 'bottom' : null,
-        horizontally: target.left !== 'auto' ? 'left' : target.right !== 'auto' ? 'right' : null
-      },
-      sizedBy: {
-        height: sizer.maxHeight !== 'none',
-        width: sizer.maxWidth !== 'none',
-        minWidth: parseInt(sizer.minWidth, 10) || 0,
-        minHeight: parseInt(sizer.minHeight, 10) || 0
-      },
-      margin: {
-        top: parseInt(target.marginTop, 10) || 0,
-        right: parseInt(target.marginRight, 10) || 0,
-        bottom: parseInt(target.marginBottom, 10) || 0,
-        left: parseInt(target.marginLeft, 10) || 0
-      }
-    };
-    if (this.verticalOffset) {
-      this._fitInfo.margin.top = this._fitInfo.margin.bottom = this.verticalOffset;
-      this._fitInfo.inlineStyle.marginTop = this.style.marginTop || '';
-      this._fitInfo.inlineStyle.marginBottom = this.style.marginBottom || '';
-      this.style.marginTop = this.style.marginBottom = this.verticalOffset + 'px';
-    }
-    if (this.horizontalOffset) {
-      this._fitInfo.margin.left = this._fitInfo.margin.right = this.horizontalOffset;
-      this._fitInfo.inlineStyle.marginLeft = this.style.marginLeft || '';
-      this._fitInfo.inlineStyle.marginRight = this.style.marginRight || '';
-      this.style.marginLeft = this.style.marginRight = this.horizontalOffset + 'px';
-    }
-  },
-  resetFit: function() {
-    var info = this._fitInfo || {};
-    for (var property in info.sizerInlineStyle) {
-      this.sizingTarget.style[property] = info.sizerInlineStyle[property];
-    }
-    for (var property in info.inlineStyle) {
-      this.style[property] = info.inlineStyle[property];
-    }
-    this._fitInfo = null;
-  },
-  refit: function() {
-    var scrollLeft = this.sizingTarget.scrollLeft;
-    var scrollTop = this.sizingTarget.scrollTop;
-    this.resetFit();
-    this.fit();
-    this.sizingTarget.scrollLeft = scrollLeft;
-    this.sizingTarget.scrollTop = scrollTop;
-  },
-  position: function() {
-    if (!this.horizontalAlign && !this.verticalAlign) {
-      return;
-    }
-    this._discoverInfo();
-    this.style.position = 'fixed';
-    this.sizingTarget.style.boxSizing = 'border-box';
-    this.style.left = '0px';
-    this.style.top = '0px';
-    var rect = this.getBoundingClientRect();
-    var positionRect = this.__getNormalizedRect(this.positionTarget);
-    var fitRect = this.__getNormalizedRect(this.fitInto);
-    var margin = this._fitInfo.margin;
-    var size = {
-      width: rect.width + margin.left + margin.right,
-      height: rect.height + margin.top + margin.bottom
-    };
-    var position = this.__getPosition(this._localeHorizontalAlign, this.verticalAlign, size, positionRect, fitRect);
-    var left = position.left + margin.left;
-    var top = position.top + margin.top;
-    var right = Math.min(fitRect.right - margin.right, left + rect.width);
-    var bottom = Math.min(fitRect.bottom - margin.bottom, top + rect.height);
-    var minWidth = this._fitInfo.sizedBy.minWidth;
-    var minHeight = this._fitInfo.sizedBy.minHeight;
-    if (left < margin.left) {
-      left = margin.left;
-      if (right - left < minWidth) {
-        left = right - minWidth;
-      }
-    }
-    if (top < margin.top) {
-      top = margin.top;
-      if (bottom - top < minHeight) {
-        top = bottom - minHeight;
-      }
-    }
-    this.sizingTarget.style.maxWidth = right - left + 'px';
-    this.sizingTarget.style.maxHeight = bottom - top + 'px';
-    this.style.left = left - rect.left + 'px';
-    this.style.top = top - rect.top + 'px';
-  },
-  constrain: function() {
-    if (this.horizontalAlign || this.verticalAlign) {
-      return;
-    }
-    this._discoverInfo();
-    var info = this._fitInfo;
-    if (!info.positionedBy.vertically) {
-      this.style.position = 'fixed';
-      this.style.top = '0px';
-    }
-    if (!info.positionedBy.horizontally) {
-      this.style.position = 'fixed';
-      this.style.left = '0px';
-    }
-    this.sizingTarget.style.boxSizing = 'border-box';
-    var rect = this.getBoundingClientRect();
-    if (!info.sizedBy.height) {
-      this.__sizeDimension(rect, info.positionedBy.vertically, 'top', 'bottom', 'Height');
-    }
-    if (!info.sizedBy.width) {
-      this.__sizeDimension(rect, info.positionedBy.horizontally, 'left', 'right', 'Width');
-    }
-  },
-  _sizeDimension: function(rect, positionedBy, start, end, extent) {
-    this.__sizeDimension(rect, positionedBy, start, end, extent);
-  },
-  __sizeDimension: function(rect, positionedBy, start, end, extent) {
-    var info = this._fitInfo;
-    var fitRect = this.__getNormalizedRect(this.fitInto);
-    var max = extent === 'Width' ? fitRect.width : fitRect.height;
-    var flip = positionedBy === end;
-    var offset = flip ? max - rect[end] : rect[start];
-    var margin = info.margin[flip ? start : end];
-    var offsetExtent = 'offset' + extent;
-    var sizingOffset = this[offsetExtent] - this.sizingTarget[offsetExtent];
-    this.sizingTarget.style['max' + extent] = max - margin - offset - sizingOffset + 'px';
-  },
-  center: function() {
-    if (this.horizontalAlign || this.verticalAlign) {
-      return;
-    }
-    this._discoverInfo();
-    var positionedBy = this._fitInfo.positionedBy;
-    if (positionedBy.vertically && positionedBy.horizontally) {
-      return;
-    }
-    this.style.position = 'fixed';
-    if (!positionedBy.vertically) {
-      this.style.top = '0px';
-    }
-    if (!positionedBy.horizontally) {
-      this.style.left = '0px';
-    }
-    var rect = this.getBoundingClientRect();
-    var fitRect = this.__getNormalizedRect(this.fitInto);
-    if (!positionedBy.vertically) {
-      var top = fitRect.top - rect.top + (fitRect.height - rect.height) / 2;
-      this.style.top = top + 'px';
-    }
-    if (!positionedBy.horizontally) {
-      var left = fitRect.left - rect.left + (fitRect.width - rect.width) / 2;
-      this.style.left = left + 'px';
-    }
-  },
-  __getNormalizedRect: function(target) {
-    if (target === document.documentElement || target === window) {
-      return {
-        top: 0,
-        left: 0,
-        width: window.innerWidth,
-        height: window.innerHeight,
-        right: window.innerWidth,
-        bottom: window.innerHeight
-      };
-    }
-    return target.getBoundingClientRect();
-  },
-  __getCroppedArea: function(position, size, fitRect) {
-    var verticalCrop = Math.min(0, position.top) + Math.min(0, fitRect.bottom - (position.top + size.height));
-    var horizontalCrop = Math.min(0, position.left) + Math.min(0, fitRect.right - (position.left + size.width));
-    return Math.abs(verticalCrop) * size.width + Math.abs(horizontalCrop) * size.height;
-  },
-  __getPosition: function(hAlign, vAlign, size, positionRect, fitRect) {
-    var positions = [ {
-      verticalAlign: 'top',
-      horizontalAlign: 'left',
-      top: positionRect.top,
-      left: positionRect.left
-    }, {
-      verticalAlign: 'top',
-      horizontalAlign: 'right',
-      top: positionRect.top,
-      left: positionRect.right - size.width
-    }, {
-      verticalAlign: 'bottom',
-      horizontalAlign: 'left',
-      top: positionRect.bottom - size.height,
-      left: positionRect.left
-    }, {
-      verticalAlign: 'bottom',
-      horizontalAlign: 'right',
-      top: positionRect.bottom - size.height,
-      left: positionRect.right - size.width
-    } ];
-    if (this.noOverlap) {
-      for (var i = 0, l = positions.length; i < l; i++) {
-        var copy = {};
-        for (var key in positions[i]) {
-          copy[key] = positions[i][key];
-        }
-        positions.push(copy);
-      }
-      positions[0].top = positions[1].top += positionRect.height;
-      positions[2].top = positions[3].top -= positionRect.height;
-      positions[4].left = positions[6].left += positionRect.width;
-      positions[5].left = positions[7].left -= positionRect.width;
-    }
-    vAlign = vAlign === 'auto' ? null : vAlign;
-    hAlign = hAlign === 'auto' ? null : hAlign;
-    var position;
-    for (var i = 0; i < positions.length; i++) {
-      var pos = positions[i];
-      if (!this.dynamicAlign && !this.noOverlap && pos.verticalAlign === vAlign && pos.horizontalAlign === hAlign) {
-        position = pos;
-        break;
-      }
-      var alignOk = (!vAlign || pos.verticalAlign === vAlign) && (!hAlign || pos.horizontalAlign === hAlign);
-      if (!this.dynamicAlign && !alignOk) {
-        continue;
-      }
-      position = position || pos;
-      pos.croppedArea = this.__getCroppedArea(pos, size, fitRect);
-      var diff = pos.croppedArea - position.croppedArea;
-      if (diff < 0 || diff === 0 && alignOk) {
-        position = pos;
-      }
-      if (position.croppedArea === 0 && alignOk) {
-        break;
-      }
-    }
-    return position;
-  }
-};
-
-(function() {
-  'use strict';
-  Polymer({
-    is: 'iron-overlay-backdrop',
-    properties: {
-      opened: {
-        reflectToAttribute: true,
-        type: Boolean,
-        value: false,
-        observer: '_openedChanged'
-      }
-    },
-    listeners: {
-      transitionend: '_onTransitionend'
-    },
-    created: function() {
-      this.__openedRaf = null;
-    },
-    attached: function() {
-      this.opened && this._openedChanged(this.opened);
-    },
-    prepare: function() {
-      if (this.opened && !this.parentNode) {
-        Polymer.dom(document.body).appendChild(this);
-      }
-    },
-    open: function() {
-      this.opened = true;
-    },
-    close: function() {
-      this.opened = false;
-    },
-    complete: function() {
-      if (!this.opened && this.parentNode === document.body) {
-        Polymer.dom(this.parentNode).removeChild(this);
-      }
-    },
-    _onTransitionend: function(event) {
-      if (event && event.target === this) {
-        this.complete();
-      }
-    },
-    _openedChanged: function(opened) {
-      if (opened) {
-        this.prepare();
-      } else {
-        var cs = window.getComputedStyle(this);
-        if (cs.transitionDuration === '0s' || cs.opacity == 0) {
-          this.complete();
-        }
-      }
-      if (!this.isAttached) {
-        return;
-      }
-      if (this.__openedRaf) {
-        window.cancelAnimationFrame(this.__openedRaf);
-        this.__openedRaf = null;
-      }
-      this.scrollTop = this.scrollTop;
-      this.__openedRaf = window.requestAnimationFrame(function() {
-        this.__openedRaf = null;
-        this.toggleClass('opened', this.opened);
-      }.bind(this));
-    }
-  });
-})();
-
-Polymer.IronOverlayManagerClass = function() {
-  this._overlays = [];
-  this._minimumZ = 101;
-  this._backdropElement = null;
-  Polymer.Gestures.add(document, 'tap', this._onCaptureClick.bind(this));
-  document.addEventListener('focus', this._onCaptureFocus.bind(this), true);
-  document.addEventListener('keydown', this._onCaptureKeyDown.bind(this), true);
-};
-
-Polymer.IronOverlayManagerClass.prototype = {
-  constructor: Polymer.IronOverlayManagerClass,
-  get backdropElement() {
-    if (!this._backdropElement) {
-      this._backdropElement = document.createElement('iron-overlay-backdrop');
-    }
-    return this._backdropElement;
-  },
-  get deepActiveElement() {
-    var active = document.activeElement || document.body;
-    while (active.root && Polymer.dom(active.root).activeElement) {
-      active = Polymer.dom(active.root).activeElement;
-    }
-    return active;
-  },
-  _bringOverlayAtIndexToFront: function(i) {
-    var overlay = this._overlays[i];
-    if (!overlay) {
-      return;
-    }
-    var lastI = this._overlays.length - 1;
-    var currentOverlay = this._overlays[lastI];
-    if (currentOverlay && this._shouldBeBehindOverlay(overlay, currentOverlay)) {
-      lastI--;
-    }
-    if (i >= lastI) {
-      return;
-    }
-    var minimumZ = Math.max(this.currentOverlayZ(), this._minimumZ);
-    if (this._getZ(overlay) <= minimumZ) {
-      this._applyOverlayZ(overlay, minimumZ);
-    }
-    while (i < lastI) {
-      this._overlays[i] = this._overlays[i + 1];
-      i++;
-    }
-    this._overlays[lastI] = overlay;
-  },
-  addOrRemoveOverlay: function(overlay) {
-    if (overlay.opened) {
-      this.addOverlay(overlay);
-    } else {
-      this.removeOverlay(overlay);
-    }
-  },
-  addOverlay: function(overlay) {
-    var i = this._overlays.indexOf(overlay);
-    if (i >= 0) {
-      this._bringOverlayAtIndexToFront(i);
-      this.trackBackdrop();
-      return;
-    }
-    var insertionIndex = this._overlays.length;
-    var currentOverlay = this._overlays[insertionIndex - 1];
-    var minimumZ = Math.max(this._getZ(currentOverlay), this._minimumZ);
-    var newZ = this._getZ(overlay);
-    if (currentOverlay && this._shouldBeBehindOverlay(overlay, currentOverlay)) {
-      this._applyOverlayZ(currentOverlay, minimumZ);
-      insertionIndex--;
-      var previousOverlay = this._overlays[insertionIndex - 1];
-      minimumZ = Math.max(this._getZ(previousOverlay), this._minimumZ);
-    }
-    if (newZ <= minimumZ) {
-      this._applyOverlayZ(overlay, minimumZ);
-    }
-    this._overlays.splice(insertionIndex, 0, overlay);
-    this.trackBackdrop();
-  },
-  removeOverlay: function(overlay) {
-    var i = this._overlays.indexOf(overlay);
-    if (i === -1) {
-      return;
-    }
-    this._overlays.splice(i, 1);
-    this.trackBackdrop();
-  },
-  currentOverlay: function() {
-    var i = this._overlays.length - 1;
-    return this._overlays[i];
-  },
-  currentOverlayZ: function() {
-    return this._getZ(this.currentOverlay());
-  },
-  ensureMinimumZ: function(minimumZ) {
-    this._minimumZ = Math.max(this._minimumZ, minimumZ);
-  },
-  focusOverlay: function() {
-    var current = this.currentOverlay();
-    if (current) {
-      current._applyFocus();
-    }
-  },
-  trackBackdrop: function() {
-    var overlay = this._overlayWithBackdrop();
-    if (!overlay && !this._backdropElement) {
-      return;
-    }
-    this.backdropElement.style.zIndex = this._getZ(overlay) - 1;
-    this.backdropElement.opened = !!overlay;
-  },
-  getBackdrops: function() {
-    var backdrops = [];
-    for (var i = 0; i < this._overlays.length; i++) {
-      if (this._overlays[i].withBackdrop) {
-        backdrops.push(this._overlays[i]);
-      }
-    }
-    return backdrops;
-  },
-  backdropZ: function() {
-    return this._getZ(this._overlayWithBackdrop()) - 1;
-  },
-  _overlayWithBackdrop: function() {
-    for (var i = 0; i < this._overlays.length; i++) {
-      if (this._overlays[i].withBackdrop) {
-        return this._overlays[i];
-      }
-    }
-  },
-  _getZ: function(overlay) {
-    var z = this._minimumZ;
-    if (overlay) {
-      var z1 = Number(overlay.style.zIndex || window.getComputedStyle(overlay).zIndex);
-      if (z1 === z1) {
-        z = z1;
-      }
-    }
-    return z;
-  },
-  _setZ: function(element, z) {
-    element.style.zIndex = z;
-  },
-  _applyOverlayZ: function(overlay, aboveZ) {
-    this._setZ(overlay, aboveZ + 2);
-  },
-  _overlayInPath: function(path) {
-    path = path || [];
-    for (var i = 0; i < path.length; i++) {
-      if (path[i]._manager === this) {
-        return path[i];
-      }
-    }
-  },
-  _onCaptureClick: function(event) {
-    var overlay = this.currentOverlay();
-    if (overlay && this._overlayInPath(Polymer.dom(event).path) !== overlay) {
-      overlay._onCaptureClick(event);
-    }
-  },
-  _onCaptureFocus: function(event) {
-    var overlay = this.currentOverlay();
-    if (overlay) {
-      overlay._onCaptureFocus(event);
-    }
-  },
-  _onCaptureKeyDown: function(event) {
-    var overlay = this.currentOverlay();
-    if (overlay) {
-      if (Polymer.IronA11yKeysBehavior.keyboardEventMatchesKeys(event, 'esc')) {
-        overlay._onCaptureEsc(event);
-      } else if (Polymer.IronA11yKeysBehavior.keyboardEventMatchesKeys(event, 'tab')) {
-        overlay._onCaptureTab(event);
-      }
-    }
-  },
-  _shouldBeBehindOverlay: function(overlay1, overlay2) {
-    return !overlay1.alwaysOnTop && overlay2.alwaysOnTop;
-  }
-};
-
-Polymer.IronOverlayManager = new Polymer.IronOverlayManagerClass();
-
-(function() {
-  'use strict';
-  Polymer.IronOverlayBehaviorImpl = {
-    properties: {
-      opened: {
-        observer: '_openedChanged',
-        type: Boolean,
-        value: false,
-        notify: true
-      },
-      canceled: {
-        observer: '_canceledChanged',
-        readOnly: true,
-        type: Boolean,
-        value: false
-      },
-      withBackdrop: {
-        observer: '_withBackdropChanged',
-        type: Boolean
-      },
-      noAutoFocus: {
-        type: Boolean,
-        value: false
-      },
-      noCancelOnEscKey: {
-        type: Boolean,
-        value: false
-      },
-      noCancelOnOutsideClick: {
-        type: Boolean,
-        value: false
-      },
-      closingReason: {
-        type: Object
-      },
-      restoreFocusOnClose: {
-        type: Boolean,
-        value: false
-      },
-      alwaysOnTop: {
-        type: Boolean
-      },
-      _manager: {
-        type: Object,
-        value: Polymer.IronOverlayManager
-      },
-      _focusedChild: {
-        type: Object
-      }
-    },
-    listeners: {
-      'iron-resize': '_onIronResize'
-    },
-    get backdropElement() {
-      return this._manager.backdropElement;
-    },
-    get _focusNode() {
-      return this._focusedChild || Polymer.dom(this).querySelector('[autofocus]') || this;
-    },
-    get _focusableNodes() {
-      var FOCUSABLE_WITH_DISABLED = [ 'a[href]', 'area[href]', 'iframe', '[tabindex]', '[contentEditable=true]' ];
-      var FOCUSABLE_WITHOUT_DISABLED = [ 'input', 'select', 'textarea', 'button' ];
-      var selector = FOCUSABLE_WITH_DISABLED.join(':not([tabindex="-1"]),') + ':not([tabindex="-1"]),' + FOCUSABLE_WITHOUT_DISABLED.join(':not([disabled]):not([tabindex="-1"]),') + ':not([disabled]):not([tabindex="-1"])';
-      var focusables = Polymer.dom(this).querySelectorAll(selector);
-      if (this.tabIndex >= 0) {
-        focusables.splice(0, 0, this);
-      }
-      return focusables.sort(function(a, b) {
-        if (a.tabIndex === b.tabIndex) {
-          return 0;
-        }
-        if (a.tabIndex === 0 || a.tabIndex > b.tabIndex) {
-          return 1;
-        }
-        return -1;
-      });
-    },
-    ready: function() {
-      this.__isAnimating = false;
-      this.__shouldRemoveTabIndex = false;
-      this.__firstFocusableNode = this.__lastFocusableNode = null;
-      this.__raf = null;
-      this.__restoreFocusNode = null;
-      this._ensureSetup();
-    },
-    attached: function() {
-      if (this.opened) {
-        this._openedChanged(this.opened);
-      }
-      this._observer = Polymer.dom(this).observeNodes(this._onNodesChange);
-    },
-    detached: function() {
-      Polymer.dom(this).unobserveNodes(this._observer);
-      this._observer = null;
-      if (this.__raf) {
-        window.cancelAnimationFrame(this.__raf);
-        this.__raf = null;
-      }
-      this._manager.removeOverlay(this);
-    },
-    toggle: function() {
-      this._setCanceled(false);
-      this.opened = !this.opened;
-    },
-    open: function() {
-      this._setCanceled(false);
-      this.opened = true;
-    },
-    close: function() {
-      this._setCanceled(false);
-      this.opened = false;
-    },
-    cancel: function(event) {
-      var cancelEvent = this.fire('iron-overlay-canceled', event, {
-        cancelable: true
-      });
-      if (cancelEvent.defaultPrevented) {
-        return;
-      }
-      this._setCanceled(true);
-      this.opened = false;
-    },
-    _ensureSetup: function() {
-      if (this._overlaySetup) {
-        return;
-      }
-      this._overlaySetup = true;
-      this.style.outline = 'none';
-      this.style.display = 'none';
-    },
-    _openedChanged: function(opened) {
-      if (opened) {
-        this.removeAttribute('aria-hidden');
-      } else {
-        this.setAttribute('aria-hidden', 'true');
-      }
-      if (!this.isAttached) {
-        return;
-      }
-      this.__isAnimating = true;
-      this.__onNextAnimationFrame(this.__openedChanged);
-    },
-    _canceledChanged: function() {
-      this.closingReason = this.closingReason || {};
-      this.closingReason.canceled = this.canceled;
-    },
-    _withBackdropChanged: function() {
-      if (this.withBackdrop && !this.hasAttribute('tabindex')) {
-        this.setAttribute('tabindex', '-1');
-        this.__shouldRemoveTabIndex = true;
-      } else if (this.__shouldRemoveTabIndex) {
-        this.removeAttribute('tabindex');
-        this.__shouldRemoveTabIndex = false;
-      }
-      if (this.opened && this.isAttached) {
-        this._manager.trackBackdrop();
-      }
-    },
-    _prepareRenderOpened: function() {
-      this.__restoreFocusNode = this._manager.deepActiveElement;
-      this._preparePositioning();
-      this.refit();
-      this._finishPositioning();
-      if (this.noAutoFocus && document.activeElement === this._focusNode) {
-        this._focusNode.blur();
-        this.__restoreFocusNode.focus();
-      }
-    },
-    _renderOpened: function() {
-      this._finishRenderOpened();
-    },
-    _renderClosed: function() {
-      this._finishRenderClosed();
-    },
-    _finishRenderOpened: function() {
-      this.notifyResize();
-      this.__isAnimating = false;
-      var focusableNodes = this._focusableNodes;
-      this.__firstFocusableNode = focusableNodes[0];
-      this.__lastFocusableNode = focusableNodes[focusableNodes.length - 1];
-      this.fire('iron-overlay-opened');
-    },
-    _finishRenderClosed: function() {
-      this.style.display = 'none';
-      this.style.zIndex = '';
-      this.notifyResize();
-      this.__isAnimating = false;
-      this.fire('iron-overlay-closed', this.closingReason);
-    },
-    _preparePositioning: function() {
-      this.style.transition = this.style.webkitTransition = 'none';
-      this.style.transform = this.style.webkitTransform = 'none';
-      this.style.display = '';
-    },
-    _finishPositioning: function() {
-      this.style.display = 'none';
-      this.scrollTop = this.scrollTop;
-      this.style.transition = this.style.webkitTransition = '';
-      this.style.transform = this.style.webkitTransform = '';
-      this.style.display = '';
-      this.scrollTop = this.scrollTop;
-    },
-    _applyFocus: function() {
-      if (this.opened) {
-        if (!this.noAutoFocus) {
-          this._focusNode.focus();
-        }
-      } else {
-        this._focusNode.blur();
-        this._focusedChild = null;
-        if (this.restoreFocusOnClose && this.__restoreFocusNode) {
-          this.__restoreFocusNode.focus();
-        }
-        this.__restoreFocusNode = null;
-        var currentOverlay = this._manager.currentOverlay();
-        if (currentOverlay && this !== currentOverlay) {
-          currentOverlay._applyFocus();
-        }
-      }
-    },
-    _onCaptureClick: function(event) {
-      if (!this.noCancelOnOutsideClick) {
-        this.cancel(event);
-      }
-    },
-    _onCaptureFocus: function(event) {
-      if (!this.withBackdrop) {
-        return;
-      }
-      var path = Polymer.dom(event).path;
-      if (path.indexOf(this) === -1) {
-        event.stopPropagation();
-        this._applyFocus();
-      } else {
-        this._focusedChild = path[0];
-      }
-    },
-    _onCaptureEsc: function(event) {
-      if (!this.noCancelOnEscKey) {
-        this.cancel(event);
-      }
-    },
-    _onCaptureTab: function(event) {
-      if (!this.withBackdrop) {
-        return;
-      }
-      var shift = event.shiftKey;
-      var nodeToCheck = shift ? this.__firstFocusableNode : this.__lastFocusableNode;
-      var nodeToSet = shift ? this.__lastFocusableNode : this.__firstFocusableNode;
-      var shouldWrap = false;
-      if (nodeToCheck === nodeToSet) {
-        shouldWrap = true;
-      } else {
-        var focusedNode = this._manager.deepActiveElement;
-        shouldWrap = focusedNode === nodeToCheck || focusedNode === this;
-      }
-      if (shouldWrap) {
-        event.preventDefault();
-        this._focusedChild = nodeToSet;
-        this._applyFocus();
-      }
-    },
-    _onIronResize: function() {
-      if (this.opened && !this.__isAnimating) {
-        this.__onNextAnimationFrame(this.refit);
-      }
-    },
-    _onNodesChange: function() {
-      if (this.opened && !this.__isAnimating) {
-        this.notifyResize();
-      }
-    },
-    __openedChanged: function() {
-      if (this.opened) {
-        this._prepareRenderOpened();
-        this._manager.addOverlay(this);
-        this._applyFocus();
-        this._renderOpened();
-      } else {
-        this._manager.removeOverlay(this);
-        this._applyFocus();
-        this._renderClosed();
-      }
-    },
-    __onNextAnimationFrame: function(callback) {
-      if (this.__raf) {
-        window.cancelAnimationFrame(this.__raf);
-      }
-      var self = this;
-      this.__raf = window.requestAnimationFrame(function nextAnimationFrame() {
-        self.__raf = null;
-        callback.call(self);
-      });
-    }
-  };
-  Polymer.IronOverlayBehavior = [ Polymer.IronFitBehavior, Polymer.IronResizableBehavior, Polymer.IronOverlayBehaviorImpl ];
-})();
-
 Polymer.NeonAnimatableBehavior = {
   properties: {
     animationConfig: {
       type: Object
     },
     entryAnimation: {
       observer: '_entryAnimationChanged',
       type: String
     },
     exitAnimation: {
@@ skipping 548 matching lines @@
       if (focusTarget && this.opened && !this.noAutoFocus) {
         focusTarget.focus();
       } else {
         Polymer.IronOverlayBehaviorImpl._applyFocus.apply(this, arguments);
       }
     }
   });
 })();
 
 Polymer({
+  is: 'iron-icon',
+  properties: {
+    icon: {
+      type: String,
+      observer: '_iconChanged'
+    },
+    theme: {
+      type: String,
+      observer: '_updateIcon'
+    },
+    src: {
+      type: String,
+      observer: '_srcChanged'
+    },
+    _meta: {
+      value: Polymer.Base.create('iron-meta', {
+        type: 'iconset'
+      }),
+      observer: '_updateIcon'
+    }
+  },
+  _DEFAULT_ICONSET: 'icons',
+  _iconChanged: function(icon) {
+    var parts = (icon || '').split(':');
+    this._iconName = parts.pop();
+    this._iconsetName = parts.pop() || this._DEFAULT_ICONSET;
+    this._updateIcon();
+  },
+  _srcChanged: function(src) {
+    this._updateIcon();
+  },
+  _usesIconset: function() {
+    return this.icon || !this.src;
+  },
+  _updateIcon: function() {
+    if (this._usesIconset()) {
+      if (this._img && this._img.parentNode) {
+        Polymer.dom(this.root).removeChild(this._img);
+      }
+      if (this._iconName === "") {
+        if (this._iconset) {
+          this._iconset.removeIcon(this);
+        }
+      } else if (this._iconsetName && this._meta) {
+        this._iconset = this._meta.byKey(this._iconsetName);
+        if (this._iconset) {
+          this._iconset.applyIcon(this, this._iconName, this.theme);
+          this.unlisten(window, 'iron-iconset-added', '_updateIcon');
+        } else {
+          this.listen(window, 'iron-iconset-added', '_updateIcon');
+        }
+      }
+    } else {
+      if (this._iconset) {
+        this._iconset.removeIcon(this);
+      }
+      if (!this._img) {
+        this._img = document.createElement('img');
+        this._img.style.width = '100%';
+        this._img.style.height = '100%';
+        this._img.draggable = false;
+      }
+      this._img.src = this.src;
+      Polymer.dom(this.root).appendChild(this._img);
+    }
+  }
+});
+
+Polymer.IronButtonStateImpl = {
+  properties: {
+    pressed: {
+      type: Boolean,
+      readOnly: true,
+      value: false,
+      reflectToAttribute: true,
+      observer: '_pressedChanged'
+    },
+    toggles: {
+      type: Boolean,
+      value: false,
+      reflectToAttribute: true
+    },
+    active: {
+      type: Boolean,
+      value: false,
+      notify: true,
+      reflectToAttribute: true
+    },
+    pointerDown: {
+      type: Boolean,
+      readOnly: true,
+      value: false
+    },
+    receivedFocusFromKeyboard: {
+      type: Boolean,
+      readOnly: true
+    },
+    ariaActiveAttribute: {
+      type: String,
+      value: 'aria-pressed',
+      observer: '_ariaActiveAttributeChanged'
+    }
+  },
+  listeners: {
+    down: '_downHandler',
+    up: '_upHandler',
+    tap: '_tapHandler'
+  },
+  observers: [ '_detectKeyboardFocus(focused)', '_activeChanged(active, ariaActiveAttribute)' ],
+  keyBindings: {
+    'enter:keydown': '_asyncClick',
+    'space:keydown': '_spaceKeyDownHandler',
+    'space:keyup': '_spaceKeyUpHandler'
+  },
+  _mouseEventRe: /^mouse/,
+  _tapHandler: function() {
+    if (this.toggles) {
+      this._userActivate(!this.active);
+    } else {
+      this.active = false;
+    }
+  },
+  _detectKeyboardFocus: function(focused) {
+    this._setReceivedFocusFromKeyboard(!this.pointerDown && focused);
+  },
+  _userActivate: function(active) {
+    if (this.active !== active) {
+      this.active = active;
+      this.fire('change');
+    }
+  },
+  _downHandler: function(event) {
+    this._setPointerDown(true);
+    this._setPressed(true);
+    this._setReceivedFocusFromKeyboard(false);
+  },
+  _upHandler: function() {
+    this._setPointerDown(false);
+    this._setPressed(false);
+  },
+  _spaceKeyDownHandler: function(event) {
+    var keyboardEvent = event.detail.keyboardEvent;
+    var target = Polymer.dom(keyboardEvent).localTarget;
+    if (this.isLightDescendant(target)) return;
+    keyboardEvent.preventDefault();
+    keyboardEvent.stopImmediatePropagation();
+    this._setPressed(true);
+  },
+  _spaceKeyUpHandler: function(event) {
+    var keyboardEvent = event.detail.keyboardEvent;
+    var target = Polymer.dom(keyboardEvent).localTarget;
+    if (this.isLightDescendant(target)) return;
+    if (this.pressed) {
+      this._asyncClick();
+    }
+    this._setPressed(false);
+  },
+  _asyncClick: function() {
+    this.async(function() {
+      this.click();
+    }, 1);
+  },
+  _pressedChanged: function(pressed) {
+    this._changedButtonState();
+  },
+  _ariaActiveAttributeChanged: function(value, oldValue) {
+    if (oldValue && oldValue != value && this.hasAttribute(oldValue)) {
+      this.removeAttribute(oldValue);
+    }
+  },
+  _activeChanged: function(active, ariaActiveAttribute) {
+    if (this.toggles) {
+      this.setAttribute(this.ariaActiveAttribute, active ? 'true' : 'false');
+    } else {
+      this.removeAttribute(this.ariaActiveAttribute);
+    }
+    this._changedButtonState();
+  },
+  _controlStateChanged: function() {
+    if (this.disabled) {
+      this._setPressed(false);
+    } else {
+      this._changedButtonState();
+    }
+  },
+  _changedButtonState: function() {
+    if (this._buttonStateChanged) {
+      this._buttonStateChanged();
+    }
+  }
+};
+
+Polymer.IronButtonState = [ Polymer.IronA11yKeysBehavior, Polymer.IronButtonStateImpl ];
+
+(function() {
+  var Utility = {
+    distance: function(x1, y1, x2, y2) {
+      var xDelta = x1 - x2;
+      var yDelta = y1 - y2;
+      return Math.sqrt(xDelta * xDelta + yDelta * yDelta);
+    },
+    now: window.performance && window.performance.now ? window.performance.now.bind(window.performance) : Date.now
+  };
+  function ElementMetrics(element) {
+    this.element = element;
+    this.width = this.boundingRect.width;
+    this.height = this.boundingRect.height;
+    this.size = Math.max(this.width, this.height);
+  }
+  ElementMetrics.prototype = {
+    get boundingRect() {
+      return this.element.getBoundingClientRect();
+    },
+    furthestCornerDistanceFrom: function(x, y) {
+      var topLeft = Utility.distance(x, y, 0, 0);
+      var topRight = Utility.distance(x, y, this.width, 0);
+      var bottomLeft = Utility.distance(x, y, 0, this.height);
+      var bottomRight = Utility.distance(x, y, this.width, this.height);
+      return Math.max(topLeft, topRight, bottomLeft, bottomRight);
+    }
+  };
+  function Ripple(element) {
+    this.element = element;
+    this.color = window.getComputedStyle(element).color;
+    this.wave = document.createElement('div');
+    this.waveContainer = document.createElement('div');
+    this.wave.style.backgroundColor = this.color;
+    this.wave.classList.add('wave');
+    this.waveContainer.classList.add('wave-container');
+    Polymer.dom(this.waveContainer).appendChild(this.wave);
+    this.resetInteractionState();
+  }
+  Ripple.MAX_RADIUS = 300;
+  Ripple.prototype = {
+    get recenters() {
+      return this.element.recenters;
+    },
+    get center() {
+      return this.element.center;
+    },
+    get mouseDownElapsed() {
+      var elapsed;
+      if (!this.mouseDownStart) {
+        return 0;
+      }
+      elapsed = Utility.now() - this.mouseDownStart;
+      if (this.mouseUpStart) {
+        elapsed -= this.mouseUpElapsed;
+      }
+      return elapsed;
+    },
+    get mouseUpElapsed() {
+      return this.mouseUpStart ? Utility.now() - this.mouseUpStart : 0;
+    },
+    get mouseDownElapsedSeconds() {
+      return this.mouseDownElapsed / 1e3;
+    },
+    get mouseUpElapsedSeconds() {
+      return this.mouseUpElapsed / 1e3;
+    },
+    get mouseInteractionSeconds() {
+      return this.mouseDownElapsedSeconds + this.mouseUpElapsedSeconds;
+    },
+    get initialOpacity() {
+      return this.element.initialOpacity;
+    },
+    get opacityDecayVelocity() {
+      return this.element.opacityDecayVelocity;
+    },
+    get radius() {
+      var width2 = this.containerMetrics.width * this.containerMetrics.width;
+      var height2 = this.containerMetrics.height * this.containerMetrics.height;
+      var waveRadius = Math.min(Math.sqrt(width2 + height2), Ripple.MAX_RADIUS) * 1.1 + 5;
+      var duration = 1.1 - .2 * (waveRadius / Ripple.MAX_RADIUS);
+      var timeNow = this.mouseInteractionSeconds / duration;
+      var size = waveRadius * (1 - Math.pow(80, -timeNow));
+      return Math.abs(size);
+    },
+    get opacity() {
+      if (!this.mouseUpStart) {
+        return this.initialOpacity;
+      }
+      return Math.max(0, this.initialOpacity - this.mouseUpElapsedSeconds * this.opacityDecayVelocity);
+    },
+    get outerOpacity() {
+      var outerOpacity = this.mouseUpElapsedSeconds * .3;
+      var waveOpacity = this.opacity;
+      return Math.max(0, Math.min(outerOpacity, waveOpacity));
+    },
+    get isOpacityFullyDecayed() {
+      return this.opacity < .01 && this.radius >= Math.min(this.maxRadius, Ripple.MAX_RADIUS);
+    },
+    get isRestingAtMaxRadius() {
+      return this.opacity >= this.initialOpacity && this.radius >= Math.min(this.maxRadius, Ripple.MAX_RADIUS);
+    },
+    get isAnimationComplete() {
+      return this.mouseUpStart ? this.isOpacityFullyDecayed : this.isRestingAtMaxRadius;
+    },
+    get translationFraction() {
+      return Math.min(1, this.radius / this.containerMetrics.size * 2 / Math.sqrt(2));
+    },
+    get xNow() {
+      if (this.xEnd) {
+        return this.xStart + this.translationFraction * (this.xEnd - this.xStart);
+      }
+      return this.xStart;
+    },
+    get yNow() {
+      if (this.yEnd) {
+        return this.yStart + this.translationFraction * (this.yEnd - this.yStart);
+      }
+      return this.yStart;
+    },
+    get isMouseDown() {
+      return this.mouseDownStart && !this.mouseUpStart;
+    },
+    resetInteractionState: function() {
+      this.maxRadius = 0;
+      this.mouseDownStart = 0;
+      this.mouseUpStart = 0;
+      this.xStart = 0;
+      this.yStart = 0;
+      this.xEnd = 0;
+      this.yEnd = 0;
+      this.slideDistance = 0;
+      this.containerMetrics = new ElementMetrics(this.element);
+    },
+    draw: function() {
+      var scale;
+      var translateString;
+      var dx;
+      var dy;
+      this.wave.style.opacity = this.opacity;
+      scale = this.radius / (this.containerMetrics.size / 2);
+      dx = this.xNow - this.containerMetrics.width / 2;
+      dy = this.yNow - this.containerMetrics.height / 2;
+      this.waveContainer.style.webkitTransform = 'translate(' + dx + 'px, ' + dy + 'px)';
+      this.waveContainer.style.transform = 'translate3d(' + dx + 'px, ' + dy + 'px, 0)';
+      this.wave.style.webkitTransform = 'scale(' + scale + ',' + scale + ')';
+      this.wave.style.transform = 'scale3d(' + scale + ',' + scale + ',1)';
+    },
+    downAction: function(event) {
+      var xCenter = this.containerMetrics.width / 2;
+      var yCenter = this.containerMetrics.height / 2;
+      this.resetInteractionState();
+      this.mouseDownStart = Utility.now();
+      if (this.center) {
+        this.xStart = xCenter;
+        this.yStart = yCenter;
+        this.slideDistance = Utility.distance(this.xStart, this.yStart, this.xEnd, this.yEnd);
+      } else {
+        this.xStart = event ? event.detail.x - this.containerMetrics.boundingRect.left : this.containerMetrics.width / 2;
+        this.yStart = event ? event.detail.y - this.containerMetrics.boundingRect.top : this.containerMetrics.height / 2;
+      }
+      if (this.recenters) {
+        this.xEnd = xCenter;
+        this.yEnd = yCenter;
+        this.slideDistance = Utility.distance(this.xStart, this.yStart, this.xEnd, this.yEnd);
+      }
+      this.maxRadius = this.containerMetrics.furthestCornerDistanceFrom(this.xStart, this.yStart);
+      this.waveContainer.style.top = (this.containerMetrics.height - this.containerMetrics.size) / 2 + 'px';
+      this.waveContainer.style.left = (this.containerMetrics.width - this.containerMetrics.size) / 2 + 'px';
+      this.waveContainer.style.width = this.containerMetrics.size + 'px';
+      this.waveContainer.style.height = this.containerMetrics.size + 'px';
+    },
+    upAction: function(event) {
+      if (!this.isMouseDown) {
+        return;
+      }
+      this.mouseUpStart = Utility.now();
+    },
+    remove: function() {
+      Polymer.dom(this.waveContainer.parentNode).removeChild(this.waveContainer);
+    }
+  };
+  Polymer({
+    is: 'paper-ripple',
+    behaviors: [ Polymer.IronA11yKeysBehavior ],
+    properties: {
+      initialOpacity: {
+        type: Number,
+        value: .25
+      },
+      opacityDecayVelocity: {
+        type: Number,
+        value: .8
+      },
+      recenters: {
+        type: Boolean,
+        value: false
+      },
+      center: {
+        type: Boolean,
+        value: false
+      },
+      ripples: {
+        type: Array,
+        value: function() {
+          return [];
+        }
+      },
+      animating: {
+        type: Boolean,
+        readOnly: true,
+        reflectToAttribute: true,
+        value: false
+      },
+      holdDown: {
+        type: Boolean,
+        value: false,
+        observer: '_holdDownChanged'
+      },
+      noink: {
+        type: Boolean,
+        value: false
+      },
+      _animating: {
+        type: Boolean
+      },
+      _boundAnimate: {
+        type: Function,
+        value: function() {
+          return this.animate.bind(this);
+        }
+      }
+    },
+    get target() {
+      return this.keyEventTarget;
+    },
+    keyBindings: {
+      'enter:keydown': '_onEnterKeydown',
+      'space:keydown': '_onSpaceKeydown',
+      'space:keyup': '_onSpaceKeyup'
+    },
+    attached: function() {
+      if (this.parentNode.nodeType == 11) {
+        this.keyEventTarget = Polymer.dom(this).getOwnerRoot().host;
+      } else {
+        this.keyEventTarget = this.parentNode;
+      }
+      var keyEventTarget = this.keyEventTarget;
+      this.listen(keyEventTarget, 'up', 'uiUpAction');
+      this.listen(keyEventTarget, 'down', 'uiDownAction');
+    },
+    detached: function() {
+      this.unlisten(this.keyEventTarget, 'up', 'uiUpAction');
+      this.unlisten(this.keyEventTarget, 'down', 'uiDownAction');
+      this.keyEventTarget = null;
+    },
+    get shouldKeepAnimating() {
+      for (var index = 0; index < this.ripples.length; ++index) {
+        if (!this.ripples[index].isAnimationComplete) {
+          return true;
+        }
+      }
+      return false;
+    },
+    simulatedRipple: function() {
+      this.downAction(null);
+      this.async(function() {
+        this.upAction();
+      }, 1);
+    },
+    uiDownAction: function(event) {
+      if (!this.noink) {
+        this.downAction(event);
+      }
+    },
+    downAction: function(event) {
+      if (this.holdDown && this.ripples.length > 0) {
+        return;
+      }
+      var ripple = this.addRipple();
+      ripple.downAction(event);
+      if (!this._animating) {
+        this._animating = true;
+        this.animate();
+      }
+    },
+    uiUpAction: function(event) {
+      if (!this.noink) {
+        this.upAction(event);
+      }
+    },
+    upAction: function(event) {
+      if (this.holdDown) {
+        return;
+      }
+      this.ripples.forEach(function(ripple) {
+        ripple.upAction(event);
+      });
+      this._animating = true;
+      this.animate();
+    },
+    onAnimationComplete: function() {
+      this._animating = false;
+      this.$.background.style.backgroundColor = null;
+      this.fire('transitionend');
+    },
+    addRipple: function() {
+      var ripple = new Ripple(this);
+      Polymer.dom(this.$.waves).appendChild(ripple.waveContainer);
+      this.$.background.style.backgroundColor = ripple.color;
+      this.ripples.push(ripple);
+      this._setAnimating(true);
+      return ripple;
+    },
+    removeRipple: function(ripple) {
+      var rippleIndex = this.ripples.indexOf(ripple);
+      if (rippleIndex < 0) {
+        return;
+      }
+      this.ripples.splice(rippleIndex, 1);
+      ripple.remove();
+      if (!this.ripples.length) {
+        this._setAnimating(false);
+      }
+    },
+    animate: function() {
+      if (!this._animating) {
+        return;
+      }
+      var index;
+      var ripple;
+      for (index = 0; index < this.ripples.length; ++index) {
+        ripple = this.ripples[index];
+        ripple.draw();
+        this.$.background.style.opacity = ripple.outerOpacity;
+        if (ripple.isOpacityFullyDecayed && !ripple.isRestingAtMaxRadius) {
+          this.removeRipple(ripple);
+        }
+      }
+      if (!this.shouldKeepAnimating && this.ripples.length === 0) {
+        this.onAnimationComplete();
+      } else {
+        window.requestAnimationFrame(this._boundAnimate);
+      }
+    },
+    _onEnterKeydown: function() {
+      this.uiDownAction();
+      this.async(this.uiUpAction, 1);
+    },
+    _onSpaceKeydown: function() {
+      this.uiDownAction();
+    },
+    _onSpaceKeyup: function() {
+      this.uiUpAction();
+    },
+    _holdDownChanged: function(newVal, oldVal) {
+      if (oldVal === undefined) {
+        return;
+      }
+      if (newVal) {
+        this.downAction();
+      } else {
+        this.upAction();
+      }
+    }
+  });
+})();
+
+Polymer.PaperRippleBehavior = {
+  properties: {
+    noink: {
+      type: Boolean,
+      observer: '_noinkChanged'
+    },
+    _rippleContainer: {
+      type: Object
+    }
+  },
+  _buttonStateChanged: function() {
+    if (this.focused) {
+      this.ensureRipple();
+    }
+  },
+  _downHandler: function(event) {
+    Polymer.IronButtonStateImpl._downHandler.call(this, event);
+    if (this.pressed) {
+      this.ensureRipple(event);
+    }
+  },
+  ensureRipple: function(optTriggeringEvent) {
+    if (!this.hasRipple()) {
+      this._ripple = this._createRipple();
+      this._ripple.noink = this.noink;
+      var rippleContainer = this._rippleContainer || this.root;
+      if (rippleContainer) {
+        Polymer.dom(rippleContainer).appendChild(this._ripple);
+      }
+      if (optTriggeringEvent) {
+        var domContainer = Polymer.dom(this._rippleContainer || this);
+        var target = Polymer.dom(optTriggeringEvent).rootTarget;
+        if (domContainer.deepContains(target)) {
+          this._ripple.uiDownAction(optTriggeringEvent);
+        }
+      }
+    }
+  },
+  getRipple: function() {
+    this.ensureRipple();
+    return this._ripple;
+  },
+  hasRipple: function() {
+    return Boolean(this._ripple);
+  },
+  _createRipple: function() {
+    return document.createElement('paper-ripple');
+  },
+  _noinkChanged: function(noink) {
+    if (this.hasRipple()) {
+      this._ripple.noink = noink;
+    }
+  }
+};
+
+Polymer.PaperButtonBehaviorImpl = {
+  properties: {
+    elevation: {
+      type: Number,
+      reflectToAttribute: true,
+      readOnly: true
+    }
+  },
+  observers: [ '_calculateElevation(focused, disabled, active, pressed, receivedFocusFromKeyboard)', '_computeKeyboardClass(receivedFocusFromKeyboard)' ],
+  hostAttributes: {
+    role: 'button',
+    tabindex: '0',
+    animated: true
+  },
+  _calculateElevation: function() {
+    var e = 1;
+    if (this.disabled) {
+      e = 0;
+    } else if (this.active || this.pressed) {
+      e = 4;
+    } else if (this.receivedFocusFromKeyboard) {
+      e = 3;
+    }
+    this._setElevation(e);
+  },
+  _computeKeyboardClass: function(receivedFocusFromKeyboard) {
+    this.toggleClass('keyboard-focus', receivedFocusFromKeyboard);
+  },
+  _spaceKeyDownHandler: function(event) {
+    Polymer.IronButtonStateImpl._spaceKeyDownHandler.call(this, event);
+    if (this.hasRipple() && this.getRipple().ripples.length < 1) {
+      this._ripple.uiDownAction();
+    }
+  },
+  _spaceKeyUpHandler: function(event) {
+    Polymer.IronButtonStateImpl._spaceKeyUpHandler.call(this, event);
+    if (this.hasRipple()) {
+      this._ripple.uiUpAction();
+    }
+  }
+};
+
+Polymer.PaperButtonBehavior = [ Polymer.IronButtonState, Polymer.IronControlState, Polymer.PaperRippleBehavior, Polymer.PaperButtonBehaviorImpl ];
+
+Polymer({
+  is: 'paper-button',
+  behaviors: [ Polymer.PaperButtonBehavior ],
+  properties: {
+    raised: {
+      type: Boolean,
+      reflectToAttribute: true,
+      value: false,
+      observer: '_calculateElevation'
+    }
+  },
+  _calculateElevation: function() {
+    if (!this.raised) {
+      this._setElevation(0);
+    } else {
+      Polymer.PaperButtonBehaviorImpl._calculateElevation.apply(this);
+    }
+  }
+});
+
+Polymer({
+  is: 'paper-icon-button-light',
+  "extends": 'button',
+  behaviors: [ Polymer.PaperRippleBehavior ],
+  listeners: {
+    down: '_rippleDown',
+    up: '_rippleUp',
+    focus: '_rippleDown',
+    blur: '_rippleUp'
+  },
+  _rippleDown: function() {
+    this.getRipple().downAction();
+  },
+  _rippleUp: function() {
+    this.getRipple().upAction();
+  },
+  ensureRipple: function(var_args) {
+    var lastRipple = this._ripple;
+    Polymer.PaperRippleBehavior.ensureRipple.apply(this, arguments);
+    if (this._ripple && this._ripple !== lastRipple) {
+      this._ripple.center = true;
+      this._ripple.classList.add('circle');
+    }
+  }
+});
+
+Polymer.PaperInkyFocusBehaviorImpl = {
+  observers: [ '_focusedChanged(receivedFocusFromKeyboard)' ],
+  _focusedChanged: function(receivedFocusFromKeyboard) {
+    if (receivedFocusFromKeyboard) {
+      this.ensureRipple();
+    }
+    if (this.hasRipple()) {
+      this._ripple.holdDown = receivedFocusFromKeyboard;
+    }
+  },
+  _createRipple: function() {
+    var ripple = Polymer.PaperRippleBehavior._createRipple();
+    ripple.id = 'ink';
+    ripple.setAttribute('center', '');
+    ripple.classList.add('circle');
+    return ripple;
+  }
+};
+
+Polymer.PaperInkyFocusBehavior = [ Polymer.IronButtonState, Polymer.IronControlState, Polymer.PaperRippleBehavior, Polymer.PaperInkyFocusBehaviorImpl ];
+
+Polymer({
+  is: 'paper-icon-button',
+  hostAttributes: {
+    role: 'button',
+    tabindex: '0'
+  },
+  behaviors: [ Polymer.PaperInkyFocusBehavior ],
+  properties: {
+    src: {
+      type: String
+    },
+    icon: {
+      type: String
+    },
+    alt: {
+      type: String,
+      observer: "_altChanged"
+    }
+  },
+  _altChanged: function(newValue, oldValue) {
+    var label = this.getAttribute('aria-label');
+    if (!label || oldValue == label) {
+      this.setAttribute('aria-label', newValue);
+    }
+  }
+});
+
+Polymer({
+  is: 'paper-tab',
+  behaviors: [ Polymer.IronControlState, Polymer.IronButtonState, Polymer.PaperRippleBehavior ],
+  properties: {
+    link: {
+      type: Boolean,
+      value: false,
+      reflectToAttribute: true
+    }
+  },
+  hostAttributes: {
+    role: 'tab'
+  },
+  listeners: {
+    down: '_updateNoink',
+    tap: '_onTap'
+  },
+  attached: function() {
+    this._updateNoink();
+  },
+  get _parentNoink() {
+    var parent = Polymer.dom(this).parentNode;
+    return !!parent && !!parent.noink;
+  },
+  _updateNoink: function() {
+    this.noink = !!this.noink || !!this._parentNoink;
+  },
+  _onTap: function(event) {
+    if (this.link) {
+      var anchor = this.queryEffectiveChildren('a');
+      if (!anchor) {
+        return;
+      }
+      if (event.target === anchor) {
+        return;
+      }
+      anchor.click();
+    }
+  }
+});
+
+Polymer.IronMultiSelectableBehaviorImpl = {
+  properties: {
+    multi: {
+      type: Boolean,
+      value: false,
+      observer: 'multiChanged'
+    },
+    selectedValues: {
+      type: Array,
+      notify: true
+    },
+    selectedItems: {
+      type: Array,
+      readOnly: true,
+      notify: true
+    }
+  },
+  observers: [ '_updateSelected(selectedValues.splices)' ],
+  select: function(value) {
+    if (this.multi) {
+      if (this.selectedValues) {
+        this._toggleSelected(value);
+      } else {
+        this.selectedValues = [ value ];
+      }
+    } else {
+      this.selected = value;
+    }
+  },
+  multiChanged: function(multi) {
+    this._selection.multi = multi;
+  },
+  get _shouldUpdateSelection() {
+    return this.selected != null || this.selectedValues != null && this.selectedValues.length;
+  },
+  _updateAttrForSelected: function() {
+    if (!this.multi) {
+      Polymer.IronSelectableBehavior._updateAttrForSelected.apply(this);
+    } else if (this._shouldUpdateSelection) {
+      this.selectedValues = this.selectedItems.map(function(selectedItem) {
+        return this._indexToValue(this.indexOf(selectedItem));
+      }, this).filter(function(unfilteredValue) {
+        return unfilteredValue != null;
+      }, this);
+    }
+  },
+  _updateSelected: function() {
+    if (this.multi) {
+      this._selectMulti(this.selectedValues);
+    } else {
+      this._selectSelected(this.selected);
+    }
+  },
+  _selectMulti: function(values) {
+    if (values) {
+      var selectedItems = this._valuesToItems(values);
+      this._selection.clear(selectedItems);
+      for (var i = 0; i < selectedItems.length; i++) {
+        this._selection.setItemSelected(selectedItems[i], true);
+      }
+      if (this.fallbackSelection && this.items.length && !this._selection.get().length) {
+        var fallback = this._valueToItem(this.fallbackSelection);
+        if (fallback) {
+          this.selectedValues = [ this.fallbackSelection ];
+        }
+      }
+    } else {
+      this._selection.clear();
+    }
+  },
+  _selectionChange: function() {
+    var s = this._selection.get();
+    if (this.multi) {
+      this._setSelectedItems(s);
+    } else {
+      this._setSelectedItems([ s ]);
+      this._setSelectedItem(s);
+    }
+  },
+  _toggleSelected: function(value) {
+    var i = this.selectedValues.indexOf(value);
+    var unselected = i < 0;
+    if (unselected) {
+      this.push('selectedValues', value);
+    } else {
+      this.splice('selectedValues', i, 1);
+    }
+  },
+  _valuesToItems: function(values) {
+    return values == null ? null : values.map(function(value) {
+      return this._valueToItem(value);
+    }, this);
+  }
+};
+
+Polymer.IronMultiSelectableBehavior = [ Polymer.IronSelectableBehavior, Polymer.IronMultiSelectableBehaviorImpl ];
+
+Polymer.IronMenuBehaviorImpl = {
+  properties: {
+    focusedItem: {
+      observer: '_focusedItemChanged',
+      readOnly: true,
+      type: Object
+    },
+    attrForItemTitle: {
+      type: String
+    }
+  },
+  hostAttributes: {
+    role: 'menu',
+    tabindex: '0'
+  },
+  observers: [ '_updateMultiselectable(multi)' ],
+  listeners: {
+    focus: '_onFocus',
+    keydown: '_onKeydown',
+    'iron-items-changed': '_onIronItemsChanged'
+  },
+  keyBindings: {
+    up: '_onUpKey',
+    down: '_onDownKey',
+    esc: '_onEscKey',
+    'shift+tab:keydown': '_onShiftTabDown'
+  },
+  attached: function() {
+    this._resetTabindices();
+  },
+  select: function(value) {
+    if (this._defaultFocusAsync) {
+      this.cancelAsync(this._defaultFocusAsync);
+      this._defaultFocusAsync = null;
+    }
+    var item = this._valueToItem(value);
+    if (item && item.hasAttribute('disabled')) return;
+    this._setFocusedItem(item);
+    Polymer.IronMultiSelectableBehaviorImpl.select.apply(this, arguments);
+  },
+  _resetTabindices: function() {
+    var selectedItem = this.multi ? this.selectedItems && this.selectedItems[0] : this.selectedItem;
+    this.items.forEach(function(item) {
+      item.setAttribute('tabindex', item === selectedItem ? '0' : '-1');
+    }, this);
+  },
+  _updateMultiselectable: function(multi) {
+    if (multi) {
+      this.setAttribute('aria-multiselectable', 'true');
+    } else {
+      this.removeAttribute('aria-multiselectable');
+    }
+  },
+  _focusWithKeyboardEvent: function(event) {
+    for (var i = 0, item; item = this.items[i]; i++) {
+      var attr = this.attrForItemTitle || 'textContent';
+      var title = item[attr] || item.getAttribute(attr);
+      if (!item.hasAttribute('disabled') && title && title.trim().charAt(0).toLowerCase() === String.fromCharCode(event.keyCode).toLowerCase()) {
+        this._setFocusedItem(item);
+        break;
+      }
+    }
+  },
+  _focusPrevious: function() {
+    var length = this.items.length;
+    var curFocusIndex = Number(this.indexOf(this.focusedItem));
+    for (var i = 1; i < length + 1; i++) {
+      var item = this.items[(curFocusIndex - i + length) % length];
+      if (!item.hasAttribute('disabled')) {
+        this._setFocusedItem(item);
+        return;
+      }
+    }
+  },
+  _focusNext: function() {
+    var length = this.items.length;
+    var curFocusIndex = Number(this.indexOf(this.focusedItem));
+    for (var i = 1; i < length + 1; i++) {
+      var item = this.items[(curFocusIndex + i) % length];
+      if (!item.hasAttribute('disabled')) {
+        this._setFocusedItem(item);
+        return;
+      }
+    }
+  },
+  _applySelection: function(item, isSelected) {
+    if (isSelected) {
+      item.setAttribute('aria-selected', 'true');
+    } else {
+      item.removeAttribute('aria-selected');
+    }
+    Polymer.IronSelectableBehavior._applySelection.apply(this, arguments);
+  },
+  _focusedItemChanged: function(focusedItem, old) {
+    old && old.setAttribute('tabindex', '-1');
+    if (focusedItem) {
+      focusedItem.setAttribute('tabindex', '0');
+      focusedItem.focus();
+    }
+  },
+  _onIronItemsChanged: function(event) {
+    if (event.detail.addedNodes.length) {
+      this._resetTabindices();
+    }
+  },
+  _onShiftTabDown: function(event) {
+    var oldTabIndex = this.getAttribute('tabindex');
+    Polymer.IronMenuBehaviorImpl._shiftTabPressed = true;
+    this._setFocusedItem(null);
+    this.setAttribute('tabindex', '-1');
+    this.async(function() {
+      this.setAttribute('tabindex', oldTabIndex);
+      Polymer.IronMenuBehaviorImpl._shiftTabPressed = false;
+    }, 1);
+  },
+  _onFocus: function(event) {
+    if (Polymer.IronMenuBehaviorImpl._shiftTabPressed) {
+      return;
+    }
+    var rootTarget = Polymer.dom(event).rootTarget;
+    if (rootTarget !== this && typeof rootTarget.tabIndex !== "undefined" && !this.isLightDescendant(rootTarget)) {
+      return;
+    }
+    this._defaultFocusAsync = this.async(function() {
+      var selectedItem = this.multi ? this.selectedItems && this.selectedItems[0] : this.selectedItem;
+      this._setFocusedItem(null);
+      if (selectedItem) {
+        this._setFocusedItem(selectedItem);
+      } else if (this.items[0]) {
+        this._focusNext();
+      }
+    });
+  },
+  _onUpKey: function(event) {
+    this._focusPrevious();
+    event.detail.keyboardEvent.preventDefault();
+  },
+  _onDownKey: function(event) {
+    this._focusNext();
+    event.detail.keyboardEvent.preventDefault();
+  },
+  _onEscKey: function(event) {
+    this.focusedItem.blur();
+  },
+  _onKeydown: function(event) {
+    if (!this.keyboardEventMatchesKeys(event, 'up down esc')) {
+      this._focusWithKeyboardEvent(event);
+    }
+    event.stopPropagation();
+  },
+  _activateHandler: function(event) {
+    Polymer.IronSelectableBehavior._activateHandler.call(this, event);
+    event.stopPropagation();
+  }
+};
+
+Polymer.IronMenuBehaviorImpl._shiftTabPressed = false;
+
+Polymer.IronMenuBehavior = [ Polymer.IronMultiSelectableBehavior, Polymer.IronA11yKeysBehavior, Polymer.IronMenuBehaviorImpl ];
+
+Polymer.IronMenubarBehaviorImpl = {
+  hostAttributes: {
+    role: 'menubar'
+  },
+  keyBindings: {
+    left: '_onLeftKey',
+    right: '_onRightKey'
+  },
+  _onUpKey: function(event) {
+    this.focusedItem.click();
+    event.detail.keyboardEvent.preventDefault();
+  },
+  _onDownKey: function(event) {
+    this.focusedItem.click();
+    event.detail.keyboardEvent.preventDefault();
+  },
+  get _isRTL() {
+    return window.getComputedStyle(this)['direction'] === 'rtl';
+  },
+  _onLeftKey: function(event) {
+    if (this._isRTL) {
+      this._focusNext();
+    } else {
+      this._focusPrevious();
+    }
+    event.detail.keyboardEvent.preventDefault();
+  },
+  _onRightKey: function(event) {
+    if (this._isRTL) {
+      this._focusPrevious();
+    } else {
+      this._focusNext();
+    }
+    event.detail.keyboardEvent.preventDefault();
+  },
+  _onKeydown: function(event) {
+    if (this.keyboardEventMatchesKeys(event, 'up down left right esc')) {
+      return;
+    }
+    this._focusWithKeyboardEvent(event);
+  }
+};
+
+Polymer.IronMenubarBehavior = [ Polymer.IronMenuBehavior, Polymer.IronMenubarBehaviorImpl ];
+
+Polymer({
+  is: 'iron-iconset-svg',
+  properties: {
+    name: {
+      type: String,
+      observer: '_nameChanged'
+    },
+    size: {
+      type: Number,
+      value: 24
+    }
+  },
+  attached: function() {
+    this.style.display = 'none';
+  },
+  getIconNames: function() {
+    this._icons = this._createIconMap();
+    return Object.keys(this._icons).map(function(n) {
+      return this.name + ':' + n;
+    }, this);
+  },
+  applyIcon: function(element, iconName) {
+    element = element.root || element;
+    this.removeIcon(element);
+    var svg = this._cloneIcon(iconName);
+    if (svg) {
+      var pde = Polymer.dom(element);
+      pde.insertBefore(svg, pde.childNodes[0]);
+      return element._svgIcon = svg;
+    }
+    return null;
+  },
+  removeIcon: function(element) {
+    if (element._svgIcon) {
+      Polymer.dom(element).removeChild(element._svgIcon);
+      element._svgIcon = null;
+    }
+  },
+  _nameChanged: function() {
+    new Polymer.IronMeta({
+      type: 'iconset',
+      key: this.name,
+      value: this
+    });
+    this.async(function() {
+      this.fire('iron-iconset-added', this, {
+        node: window
+      });
+    });
+  },
+  _createIconMap: function() {
+    var icons = Object.create(null);
+    Polymer.dom(this).querySelectorAll('[id]').forEach(function(icon) {
+      icons[icon.id] = icon;
+    });
+    return icons;
+  },
+  _cloneIcon: function(id) {
+    this._icons = this._icons || this._createIconMap();
+    return this._prepareSvgClone(this._icons[id], this.size);
+  },
+  _prepareSvgClone: function(sourceSvg, size) {
+    if (sourceSvg) {
+      var content = sourceSvg.cloneNode(true), svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg'), viewBox = content.getAttribute('viewBox') || '0 0 ' + size + ' ' + size;
+      svg.setAttribute('viewBox', viewBox);
+      svg.setAttribute('preserveAspectRatio', 'xMidYMid meet');
+      svg.style.cssText = 'pointer-events: none; display: block; width: 100%; height: 100%;';
+      svg.appendChild(content).removeAttribute('id');
+      return svg;
+    }
+    return null;
+  }
+});
+
+Polymer({
+  is: 'paper-tabs',
+  behaviors: [ Polymer.IronResizableBehavior, Polymer.IronMenubarBehavior ],
+  properties: {
+    noink: {
+      type: Boolean,
+      value: false,
+      observer: '_noinkChanged'
+    },
+    noBar: {
+      type: Boolean,
+      value: false
+    },
+    noSlide: {
+      type: Boolean,
+      value: false
+    },
+    scrollable: {
+      type: Boolean,
+      value: false
+    },
+    fitContainer: {
+      type: Boolean,
+      value: false
+    },
+    disableDrag: {
+      type: Boolean,
+      value: false
+    },
+    hideScrollButtons: {
+      type: Boolean,
+      value: false
+    },
+    alignBottom: {
+      type: Boolean,
+      value: false
+    },
+    selectable: {
+      type: String,
+      value: 'paper-tab'
+    },
+    autoselect: {
+      type: Boolean,
+      value: false
+    },
+    autoselectDelay: {
+      type: Number,
+      value: 0
+    },
+    _step: {
+      type: Number,
+      value: 10
+    },
+    _holdDelay: {
+      type: Number,
+      value: 1
+    },
+    _leftHidden: {
+      type: Boolean,
+      value: false
+    },
+    _rightHidden: {
+      type: Boolean,
+      value: false
+    },
+    _previousTab: {
+      type: Object
+    }
+  },
+  hostAttributes: {
+    role: 'tablist'
+  },
+  listeners: {
+    'iron-resize': '_onTabSizingChanged',
+    'iron-items-changed': '_onTabSizingChanged',
+    'iron-select': '_onIronSelect',
+    'iron-deselect': '_onIronDeselect'
+  },
+  keyBindings: {
+    'left:keyup right:keyup': '_onArrowKeyup'
+  },
+  created: function() {
+    this._holdJob = null;
+    this._pendingActivationItem = undefined;
+    this._pendingActivationTimeout = undefined;
+    this._bindDelayedActivationHandler = this._delayedActivationHandler.bind(this);
+    this.addEventListener('blur', this._onBlurCapture.bind(this), true);
+  },
+  ready: function() {
+    this.setScrollDirection('y', this.$.tabsContainer);
+  },
+  detached: function() {
+    this._cancelPendingActivation();
+  },
+  _noinkChanged: function(noink) {
+    var childTabs = Polymer.dom(this).querySelectorAll('paper-tab');
+    childTabs.forEach(noink ? this._setNoinkAttribute : this._removeNoinkAttribute);
+  },
+  _setNoinkAttribute: function(element) {
+    element.setAttribute('noink', '');
+  },
+  _removeNoinkAttribute: function(element) {
+    element.removeAttribute('noink');
+  },
+  _computeScrollButtonClass: function(hideThisButton, scrollable, hideScrollButtons) {
+    if (!scrollable || hideScrollButtons) {
+      return 'hidden';
+    }
+    if (hideThisButton) {
+      return 'not-visible';
+    }
+    return '';
+  },
+  _computeTabsContentClass: function(scrollable, fitContainer) {
+    return scrollable ? 'scrollable' + (fitContainer ? ' fit-container' : '') : ' fit-container';
+  },
+  _computeSelectionBarClass: function(noBar, alignBottom) {
+    if (noBar) {
+      return 'hidden';
+    } else if (alignBottom) {
+      return 'align-bottom';
+    }
+    return '';
+  },
+  _onTabSizingChanged: function() {
+    this.debounce('_onTabSizingChanged', function() {
+      this._scroll();
+      this._tabChanged(this.selectedItem);
+    }, 10);
+  },
+  _onIronSelect: function(event) {
+    this._tabChanged(event.detail.item, this._previousTab);
+    this._previousTab = event.detail.item;
+    this.cancelDebouncer('tab-changed');
+  },
+  _onIronDeselect: function(event) {
+    this.debounce('tab-changed', function() {
+      this._tabChanged(null, this._previousTab);
+      this._previousTab = null;
+    }, 1);
+  },
+  _activateHandler: function() {
+    this._cancelPendingActivation();
+    Polymer.IronMenuBehaviorImpl._activateHandler.apply(this, arguments);
+  },
+  _scheduleActivation: function(item, delay) {
+    this._pendingActivationItem = item;
+    this._pendingActivationTimeout = this.async(this._bindDelayedActivationHandler, delay);
+  },
+  _delayedActivationHandler: function() {
+    var item = this._pendingActivationItem;
+    this._pendingActivationItem = undefined;
+    this._pendingActivationTimeout = undefined;
+    item.fire(this.activateEvent, null, {
+      bubbles: true,
+      cancelable: true
+    });
+  },
+  _cancelPendingActivation: function() {
+    if (this._pendingActivationTimeout !== undefined) {
+      this.cancelAsync(this._pendingActivationTimeout);
+      this._pendingActivationItem = undefined;
+      this._pendingActivationTimeout = undefined;
+    }
+  },
+  _onArrowKeyup: function(event) {
+    if (this.autoselect) {
+      this._scheduleActivation(this.focusedItem, this.autoselectDelay);
+    }
+  },
+  _onBlurCapture: function(event) {
+    if (event.target === this._pendingActivationItem) {
+      this._cancelPendingActivation();
+    }
+  },
+  get _tabContainerScrollSize() {
+    return Math.max(0, this.$.tabsContainer.scrollWidth - this.$.tabsContainer.offsetWidth);
+  },
+  _scroll: function(e, detail) {
+    if (!this.scrollable) {
+      return;
+    }
+    var ddx = detail && -detail.ddx || 0;
+    this._affectScroll(ddx);
+  },
+  _down: function(e) {
+    this.async(function() {
+      if (this._defaultFocusAsync) {
+        this.cancelAsync(this._defaultFocusAsync);
+        this._defaultFocusAsync = null;
+      }
+    }, 1);
+  },
+  _affectScroll: function(dx) {
+    this.$.tabsContainer.scrollLeft += dx;
+    var scrollLeft = this.$.tabsContainer.scrollLeft;
+    this._leftHidden = scrollLeft === 0;
+    this._rightHidden = scrollLeft === this._tabContainerScrollSize;
+  },
+  _onLeftScrollButtonDown: function() {
+    this._scrollToLeft();
+    this._holdJob = setInterval(this._scrollToLeft.bind(this), this._holdDelay);
+  },
+  _onRightScrollButtonDown: function() {
+    this._scrollToRight();
+    this._holdJob = setInterval(this._scrollToRight.bind(this), this._holdDelay);
+  },
+  _onScrollButtonUp: function() {
+    clearInterval(this._holdJob);
+    this._holdJob = null;
+  },
+  _scrollToLeft: function() {
+    this._affectScroll(-this._step);
+  },
+  _scrollToRight: function() {
+    this._affectScroll(this._step);
+  },
+  _tabChanged: function(tab, old) {
+    if (!tab) {
+      this.$.selectionBar.classList.remove('expand');
+      this.$.selectionBar.classList.remove('contract');
+      this._positionBar(0, 0);
+      return;
+    }
+    var r = this.$.tabsContent.getBoundingClientRect();
+    var w = r.width;
+    var tabRect = tab.getBoundingClientRect();
+    var tabOffsetLeft = tabRect.left - r.left;
+    this._pos = {
+      width: this._calcPercent(tabRect.width, w),
+      left: this._calcPercent(tabOffsetLeft, w)
+    };
+    if (this.noSlide || old == null) {
+      this.$.selectionBar.classList.remove('expand');
+      this.$.selectionBar.classList.remove('contract');
+      this._positionBar(this._pos.width, this._pos.left);
+      return;
+    }
+    var oldRect = old.getBoundingClientRect();
+    var oldIndex = this.items.indexOf(old);
+    var index = this.items.indexOf(tab);
+    var m = 5;
+    this.$.selectionBar.classList.add('expand');
+    var moveRight = oldIndex < index;
+    var isRTL = this._isRTL;
+    if (isRTL) {
+      moveRight = !moveRight;
+    }
+    if (moveRight) {
+      this._positionBar(this._calcPercent(tabRect.left + tabRect.width - oldRect.left, w) - m, this._left);
+    } else {
+      this._positionBar(this._calcPercent(oldRect.left + oldRect.width - tabRect.left, w) - m, this._calcPercent(tabOffsetLeft, w) + m);
+    }
+    if (this.scrollable) {
+      this._scrollToSelectedIfNeeded(tabRect.width, tabOffsetLeft);
+    }
+  },
+  _scrollToSelectedIfNeeded: function(tabWidth, tabOffsetLeft) {
+    var l = tabOffsetLeft - this.$.tabsContainer.scrollLeft;
+    if (l < 0) {
+      this.$.tabsContainer.scrollLeft += l;
+    } else {
+      l += tabWidth - this.$.tabsContainer.offsetWidth;
+      if (l > 0) {
+        this.$.tabsContainer.scrollLeft += l;
+      }
+    }
+  },
+  _calcPercent: function(w, w0) {
+    return 100 * w / w0;
+  },
+  _positionBar: function(width, left) {
+    width = width || 0;
+    left = left || 0;
+    this._width = width;
+    this._left = left;
+    this.transform('translateX(' + left + '%) scaleX(' + width / 100 + ')', this.$.selectionBar);
+  },
+  _onBarTransitionEnd: function(e) {
+    var cl = this.$.selectionBar.classList;
+    if (cl.contains('expand')) {
+      cl.remove('expand');
+      cl.add('contract');
+      this._positionBar(this._pos.width, this._pos.left);
+    } else if (cl.contains('contract')) {
+      cl.remove('contract');
+    }
+  }
+});
+
+(function() {
+  'use strict';
+  Polymer.IronA11yAnnouncer = Polymer({
+    is: 'iron-a11y-announcer',
+    properties: {
+      mode: {
+        type: String,
+        value: 'polite'
+      },
+      _text: {
+        type: String,
+        value: ''
+      }
+    },
+    created: function() {
+      if (!Polymer.IronA11yAnnouncer.instance) {
+        Polymer.IronA11yAnnouncer.instance = this;
+      }
+      document.body.addEventListener('iron-announce', this._onIronAnnounce.bind(this));
+    },
+    announce: function(text) {
+      this._text = '';
+      this.async(function() {
+        this._text = text;
+      }, 100);
+    },
+    _onIronAnnounce: function(event) {
+      if (event.detail && event.detail.text) {
+        this.announce(event.detail.text);
+      }
+    }
+  });
+  Polymer.IronA11yAnnouncer.instance = null;
+  Polymer.IronA11yAnnouncer.requestAvailability = function() {
+    if (!Polymer.IronA11yAnnouncer.instance) {
+      Polymer.IronA11yAnnouncer.instance = document.createElement('iron-a11y-announcer');
+    }
+    document.body.appendChild(Polymer.IronA11yAnnouncer.instance);
+  };
+})();
+
+Polymer.IronValidatableBehaviorMeta = null;
+
+Polymer.IronValidatableBehavior = {
+  properties: {
+    validator: {
+      type: String
+    },
+    invalid: {
+      notify: true,
+      reflectToAttribute: true,
+      type: Boolean,
+      value: false
+    },
+    _validatorMeta: {
+      type: Object
+    },
+    validatorType: {
+      type: String,
+      value: 'validator'
+    },
+    _validator: {
+      type: Object,
+      computed: '__computeValidator(validator)'
+    }
+  },
+  observers: [ '_invalidChanged(invalid)' ],
+  registered: function() {
+    Polymer.IronValidatableBehaviorMeta = new Polymer.IronMeta({
+      type: 'validator'
+    });
+  },
+  _invalidChanged: function() {
+    if (this.invalid) {
+      this.setAttribute('aria-invalid', 'true');
+    } else {
+      this.removeAttribute('aria-invalid');
+    }
+  },
+  hasValidator: function() {
+    return this._validator != null;
+  },
+  validate: function(value) {
+    this.invalid = !this._getValidity(value);
+    return !this.invalid;
+  },
+  _getValidity: function(value) {
+    if (this.hasValidator()) {
+      return this._validator.validate(value);
+    }
+    return true;
+  },
+  __computeValidator: function() {
+    return Polymer.IronValidatableBehaviorMeta && Polymer.IronValidatableBehaviorMeta.byKey(this.validator);
+  }
+};
+
+Polymer({
+  is: 'iron-input',
+  "extends": 'input',
+  behaviors: [ Polymer.IronValidatableBehavior ],
+  properties: {
+    bindValue: {
+      observer: '_bindValueChanged',
+      type: String
+    },
+    preventInvalidInput: {
+      type: Boolean
+    },
+    allowedPattern: {
+      type: String,
+      observer: "_allowedPatternChanged"
+    },
+    _previousValidInput: {
+      type: String,
+      value: ''
+    },
+    _patternAlreadyChecked: {
+      type: Boolean,
+      value: false
+    }
+  },
+  listeners: {
+    input: '_onInput',
+    keypress: '_onKeypress'
+  },
+  registered: function() {
+    if (!this._canDispatchEventOnDisabled()) {
+      this._origDispatchEvent = this.dispatchEvent;
+      this.dispatchEvent = this._dispatchEventFirefoxIE;
+    }
+  },
+  created: function() {
+    Polymer.IronA11yAnnouncer.requestAvailability();
+  },
+  _canDispatchEventOnDisabled: function() {
+    var input = document.createElement('input');
+    var canDispatch = false;
+    input.disabled = true;
+    input.addEventListener('feature-check-dispatch-event', function() {
+      canDispatch = true;
+    });
+    try {
+      input.dispatchEvent(new Event('feature-check-dispatch-event'));
+    } catch (e) {}
+    return canDispatch;
+  },
+  _dispatchEventFirefoxIE: function() {
+    var disabled = this.disabled;
+    this.disabled = false;
+    this._origDispatchEvent.apply(this, arguments);
+    this.disabled = disabled;
+  },
+  get _patternRegExp() {
+    var pattern;
+    if (this.allowedPattern) {
+      pattern = new RegExp(this.allowedPattern);
+    } else {
+      switch (this.type) {
+       case 'number':
+        pattern = /[0-9.,e-]/;
+        break;
+      }
+    }
+    return pattern;
+  },
+  ready: function() {
+    this.bindValue = this.value;
+  },
+  _bindValueChanged: function() {
+    if (this.value !== this.bindValue) {
+      this.value = !(this.bindValue || this.bindValue === 0 || this.bindValue === false) ? '' : this.bindValue;
+    }
+    this.fire('bind-value-changed', {
+      value: this.bindValue
+    });
+  },
+  _allowedPatternChanged: function() {
+    this.preventInvalidInput = this.allowedPattern ? true : false;
+  },
+  _onInput: function() {
+    if (this.preventInvalidInput && !this._patternAlreadyChecked) {
+      var valid = this._checkPatternValidity();
+      if (!valid) {
+        this._announceInvalidCharacter('Invalid string of characters not entered.');
+        this.value = this._previousValidInput;
+      }
+    }
+    this.bindValue = this.value;
+    this._previousValidInput = this.value;
+    this._patternAlreadyChecked = false;
+  },
+  _isPrintable: function(event) {
+    var anyNonPrintable = event.keyCode == 8 || event.keyCode == 9 || event.keyCode == 13 || event.keyCode == 27;
+    var mozNonPrintable = event.keyCode == 19 || event.keyCode == 20 || event.keyCode == 45 || event.keyCode == 46 || event.keyCode == 144 || event.keyCode == 145 || event.keyCode > 32 && event.keyCode < 41 || event.keyCode > 111 && event.keyCode < 124;
+    return !anyNonPrintable && !(event.charCode == 0 && mozNonPrintable);
+  },
+  _onKeypress: function(event) {
+    if (!this.preventInvalidInput && this.type !== 'number') {
+      return;
+    }
+    var regexp = this._patternRegExp;
+    if (!regexp) {
+      return;
+    }
+    if (event.metaKey || event.ctrlKey || event.altKey) return;
+    this._patternAlreadyChecked = true;
+    var thisChar = String.fromCharCode(event.charCode);
+    if (this._isPrintable(event) && !regexp.test(thisChar)) {
+      event.preventDefault();
+      this._announceInvalidCharacter('Invalid character ' + thisChar + ' not entered.');
+    }
+  },
+  _checkPatternValidity: function() {
+    var regexp = this._patternRegExp;
+    if (!regexp) {
+      return true;
+    }
+    for (var i = 0; i < this.value.length; i++) {
+      if (!regexp.test(this.value[i])) {
+        return false;
+      }
+    }
+    return true;
+  },
+  validate: function() {
+    var valid = this.checkValidity();
+    if (valid) {
+      if (this.required && this.value === '') {
+        valid = false;
+      } else if (this.hasValidator()) {
+        valid = Polymer.IronValidatableBehavior.validate.call(this, this.value);
+      }
+    }
+    this.invalid = !valid;
+    this.fire('iron-input-validate');
+    return valid;
+  },
+  _announceInvalidCharacter: function(message) {
+    this.fire('iron-announce', {
+      text: message
+    });
+  }
+});
+
+Polymer({
+  is: 'paper-input-container',
+  properties: {
+    noLabelFloat: {
+      type: Boolean,
+      value: false
+    },
+    alwaysFloatLabel: {
+      type: Boolean,
+      value: false
+    },
+    attrForValue: {
+      type: String,
+      value: 'bind-value'
+    },
+    autoValidate: {
+      type: Boolean,
+      value: false
+    },
+    invalid: {
+      observer: '_invalidChanged',
+      type: Boolean,
+      value: false
+    },
+    focused: {
+      readOnly: true,
+      type: Boolean,
+      value: false,
+      notify: true
+    },
+    _addons: {
+      type: Array
+    },
+    _inputHasContent: {
+      type: Boolean,
+      value: false
+    },
+    _inputSelector: {
+      type: String,
+      value: 'input,textarea,.paper-input-input'
+    },
+    _boundOnFocus: {
+      type: Function,
+      value: function() {
+        return this._onFocus.bind(this);
+      }
+    },
+    _boundOnBlur: {
+      type: Function,
+      value: function() {
+        return this._onBlur.bind(this);
+      }
+    },
+    _boundOnInput: {
+      type: Function,
+      value: function() {
+        return this._onInput.bind(this);
+      }
+    },
+    _boundValueChanged: {
+      type: Function,
+      value: function() {
+        return this._onValueChanged.bind(this);
+      }
+    }
+  },
+  listeners: {
+    'addon-attached': '_onAddonAttached',
+    'iron-input-validate': '_onIronInputValidate'
+  },
+  get _valueChangedEvent() {
+    return this.attrForValue + '-changed';
+  },
+  get _propertyForValue() {
+    return Polymer.CaseMap.dashToCamelCase(this.attrForValue);
+  },
+  get _inputElement() {
+    return Polymer.dom(this).querySelector(this._inputSelector);
+  },
+  get _inputElementValue() {
+    return this._inputElement[this._propertyForValue] || this._inputElement.value;
+  },
+  ready: function() {
+    if (!this._addons) {
+      this._addons = [];
+    }
+    this.addEventListener('focus', this._boundOnFocus, true);
+    this.addEventListener('blur', this._boundOnBlur, true);
+  },
+  attached: function() {
+    if (this.attrForValue) {
+      this._inputElement.addEventListener(this._valueChangedEvent, this._boundValueChanged);
+    } else {
+      this.addEventListener('input', this._onInput);
+    }
+    if (this._inputElementValue != '') {
+      this._handleValueAndAutoValidate(this._inputElement);
+    } else {
+      this._handleValue(this._inputElement);
+    }
+  },
+  _onAddonAttached: function(event) {
+    if (!this._addons) {
+      this._addons = [];
+    }
+    var target = event.target;
+    if (this._addons.indexOf(target) === -1) {
+      this._addons.push(target);
+      if (this.isAttached) {
+        this._handleValue(this._inputElement);
+      }
+    }
+  },
+  _onFocus: function() {
+    this._setFocused(true);
+  },
+  _onBlur: function() {
+    this._setFocused(false);
+    this._handleValueAndAutoValidate(this._inputElement);
+  },
+  _onInput: function(event) {
+    this._handleValueAndAutoValidate(event.target);
+  },
+  _onValueChanged: function(event) {
+    this._handleValueAndAutoValidate(event.target);
+  },
+  _handleValue: function(inputElement) {
+    var value = this._inputElementValue;
+    if (value || value === 0 || inputElement.type === 'number' && !inputElement.checkValidity()) {
+      this._inputHasContent = true;
+    } else {
+      this._inputHasContent = false;
+    }
+    this.updateAddons({
+      inputElement: inputElement,
+      value: value,
+      invalid: this.invalid
+    });
+  },
+  _handleValueAndAutoValidate: function(inputElement) {
+    if (this.autoValidate) {
+      var valid;
+      if (inputElement.validate) {
+        valid = inputElement.validate(this._inputElementValue);
+      } else {
+        valid = inputElement.checkValidity();
+      }
+      this.invalid = !valid;
+    }
+    this._handleValue(inputElement);
+  },
+  _onIronInputValidate: function(event) {
+    this.invalid = this._inputElement.invalid;
+  },
+  _invalidChanged: function() {
+    if (this._addons) {
+      this.updateAddons({
+        invalid: this.invalid
+      });
+    }
+  },
+  updateAddons: function(state) {
+    for (var addon, index = 0; addon = this._addons[index]; index++) {
+      addon.update(state);
+    }
+  },
+  _computeInputContentClass: function(noLabelFloat, alwaysFloatLabel, focused, invalid, _inputHasContent) {
+    var cls = 'input-content';
+    if (!noLabelFloat) {
+      var label = this.querySelector('label');
+      if (alwaysFloatLabel || _inputHasContent) {
+        cls += ' label-is-floating';
+        this.$.labelAndInputContainer.style.position = 'static';
+        if (invalid) {
+          cls += ' is-invalid';
+        } else if (focused) {
+          cls += " label-is-highlighted";
+        }
+      } else {
+        if (label) {
+          this.$.labelAndInputContainer.style.position = 'relative';
+        }
+      }
+    } else {
+      if (_inputHasContent) {
+        cls += ' label-is-hidden';
+      }
+    }
+    return cls;
+  },
+  _computeUnderlineClass: function(focused, invalid) {
+    var cls = 'underline';
+    if (invalid) {
+      cls += ' is-invalid';
+    } else if (focused) {
+      cls += ' is-highlighted';
+    }
+    return cls;
+  },
+  _computeAddOnContentClass: function(focused, invalid) {
+    var cls = 'add-on-content';
+    if (invalid) {
+      cls += ' is-invalid';
+    } else if (focused) {
+      cls += ' is-highlighted';
+    }
+    return cls;
+  }
+});
+
+Polymer.PaperSpinnerBehavior = {
+  listeners: {
+    animationend: '__reset',
+    webkitAnimationEnd: '__reset'
+  },
+  properties: {
+    active: {
+      type: Boolean,
+      value: false,
+      reflectToAttribute: true,
+      observer: '__activeChanged'
+    },
+    alt: {
+      type: String,
+      value: 'loading',
+      observer: '__altChanged'
+    },
+    __coolingDown: {
+      type: Boolean,
+      value: false
+    }
+  },
+  __computeContainerClasses: function(active, coolingDown) {
+    return [ active || coolingDown ? 'active' : '', coolingDown ? 'cooldown' : '' ].join(' ');
+  },
+  __activeChanged: function(active, old) {
+    this.__setAriaHidden(!active);
+    this.__coolingDown = !active && old;
+  },
+  __altChanged: function(alt) {
+    if (alt === this.getPropertyInfo('alt').value) {
+      this.alt = this.getAttribute('aria-label') || alt;
+    } else {
+      this.__setAriaHidden(alt === '');
+      this.setAttribute('aria-label', alt);
+    }
+  },
+  __setAriaHidden: function(hidden) {
+    var attr = 'aria-hidden';
+    if (hidden) {
+      this.setAttribute(attr, 'true');
+    } else {
+      this.removeAttribute(attr);
+    }
+  },
+  __reset: function() {
+    this.active = false;
+    this.__coolingDown = false;
+  }
+};
+
+Polymer({
+  is: 'paper-spinner-lite',
+  behaviors: [ Polymer.PaperSpinnerBehavior ]
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+var CrSearchFieldBehavior = {
+  properties: {
+    label: {
+      type: String,
+      value: ''
+    },
+    clearLabel: {
+      type: String,
+      value: ''
+    },
+    showingSearch: {
+      type: Boolean,
+      value: false,
+      notify: true,
+      observer: 'showingSearchChanged_',
+      reflectToAttribute: true
+    },
+    lastValue_: {
+      type: String,
+      value: ''
+    }
+  },
+  getSearchInput: function() {},
+  getValue: function() {
+    return this.getSearchInput().value;
+  },
+  setValue: function(value) {
+    this.getSearchInput().bindValue = value;
+    this.onValueChanged_(value);
+  },
+  showAndFocus: function() {
+    this.showingSearch = true;
+    this.focus_();
+  },
+  focus_: function() {
+    this.getSearchInput().focus();
+  },
+  onSearchTermSearch: function() {
+    this.onValueChanged_(this.getValue());
+  },
+  onValueChanged_: function(newValue) {
+    if (newValue == this.lastValue_) return;
+    this.fire('search-changed', newValue);
+    this.lastValue_ = newValue;
+  },
+  onSearchTermKeydown: function(e) {
+    if (e.key == 'Escape') this.showingSearch = false;
+  },
+  showingSearchChanged_: function() {
+    if (this.showingSearch) {
+      this.focus_();
+      return;
+    }
+    this.setValue('');
+    this.getSearchInput().blur();
+  }
+};
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Polymer({
+  is: 'cr-toolbar-search-field',
+  behaviors: [ CrSearchFieldBehavior ],
+  properties: {
+    narrow: {
+      type: Boolean,
+      reflectToAttribute: true
+    },
+    label: String,
+    clearLabel: String,
+    spinnerActive: {
+      type: Boolean,
+      reflectToAttribute: true
+    },
+    hasSearchText_: Boolean
+  },
+  listeners: {
+    tap: 'showSearch_',
+    'searchInput.bind-value-changed': 'onBindValueChanged_'
+  },
+  getSearchInput: function() {
+    return this.$.searchInput;
+  },
+  isSearchFocused: function() {
+    return this.$.searchTerm.focused;
+  },
+  computeIconTabIndex_: function(narrow) {
+    return narrow ? 0 : -1;
+  },
+  isSpinnerShown_: function(spinnerActive, showingSearch) {
+    return spinnerActive && showingSearch;
+  },
+  onInputBlur_: function() {
+    if (!this.hasSearchText_) this.showingSearch = false;
+  },
+  onBindValueChanged_: function() {
+    var newValue = this.$.searchInput.bindValue;
+    this.hasSearchText_ = newValue != '';
+    if (newValue != '') this.showingSearch = true;
+  },
+  showSearch_: function(e) {
+    if (e.target != this.$.clearSearch) this.showingSearch = true;
+  },
+  hideSearch_: function(e) {
+    this.showingSearch = false;
+    e.stopPropagation();
+  }
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Polymer({
+  is: 'cr-toolbar',
+  properties: {
+    pageName: String,
+    searchPrompt: String,
+    clearLabel: String,
+    menuLabel: String,
+    spinnerActive: Boolean,
+    showMenu: {
+      type: Boolean,
+      value: false
+    },
+    narrow_: {
+      type: Boolean,
+      reflectToAttribute: true
+    },
+    showingSearch_: {
+      type: Boolean,
+      reflectToAttribute: true
+    }
+  },
+  getSearchField: function() {
+    return this.$.search;
+  },
+  onMenuTap_: function(e) {
+    this.fire('cr-menu-tap');
+  }
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Polymer({
+  is: 'history-lazy-render',
+  "extends": 'template',
+  behaviors: [ Polymer.Templatizer ],
+  _renderPromise: null,
+  _instance: null,
+  get: function() {
+    if (!this._renderPromise) {
+      this._renderPromise = new Promise(function(resolve) {
+        this._debounceTemplate(function() {
+          this._render();
+          this._renderPromise = null;
+          resolve(this.getIfExists());
+        }.bind(this));
+      }.bind(this));
+    }
+    return this._renderPromise;
+  },
+  getIfExists: function() {
+    if (this._instance) {
+      var children = this._instance._children;
+      for (var i = 0; i < children.length; i++) {
+        if (children[i].nodeType == Node.ELEMENT_NODE) return children[i];
+      }
+    }
+    return null;
+  },
+  _render: function() {
+    if (!this.ctor) this.templatize(this);
+    var parentNode = this.parentNode;
+    if (parentNode && !this._instance) {
+      this._instance = this.stamp({});
+      var root = this._instance.root;
+      parentNode.insertBefore(root, this);
+    }
+  },
+  _forwardParentProp: function(prop, value) {
+    if (this._instance) this._instance.__setProperty(prop, value, true);
+  },
+  _forwardParentPath: function(path, value) {
+    if (this._instance) this._instance._notifyPath(path, value, true);
+  }
+});
+
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Polymer({
+  is: 'history-toolbar',
+  properties: {
+    count: {
+      type: Number,
+      value: 0,
+      observer: 'changeToolbarView_'
+    },
+    itemsSelected_: {
+      type: Boolean,
+      value: false,
+      reflectToAttribute: true
+    },
+    searchTerm: {
+      type: String,
+      notify: true
+    },
+    spinnerActive: {
+      type: Boolean,
+      value: false
+    },
+    hasDrawer: {
+      type: Boolean,
+      observer: 'hasDrawerChanged_',
+      reflectToAttribute: true
+    },
+    showSyncNotice: Boolean,
+    isGroupedMode: {
+      type: Boolean,
+      reflectToAttribute: true
+    },
+    groupedRange: {
+      type: Number,
+      value: 0,
+      reflectToAttribute: true,
+      notify: true
+    },
+    queryStartTime: String,
+    queryEndTime: String
+  },
+  changeToolbarView_: function() {
+    this.itemsSelected_ = this.count > 0;
+  },
+  setSearchTerm: function(search) {
+    if (this.searchTerm == search) return;
+    this.searchTerm = search;
+    var searchField = this.$['main-toolbar'].getSearchField();
+    searchField.showAndFocus();
+    searchField.setValue(search);
+  },
+  onSearchChanged_: function(event) {
+    this.searchTerm = event.detail;
+  },
+  onInfoButtonTap_: function() {
+    this.$.syncNotice.get().then(function(dropdown) {
+      dropdown.positionTarget = this.$$('#info-button-icon');
+      if (dropdown.style.display == 'none') dropdown.open();
+    }.bind(this));
+  },
+  onClearSelectionTap_: function() {
+    this.fire('unselect-all');
+  },
+  onDeleteTap_: function() {
+    this.fire('delete-selected');
+  },
+  get searchBar() {
+    return this.$['main-toolbar'].getSearchField();
+  },
+  showSearchField: function() {
+    this.$['main-toolbar'].getSearchField().showAndFocus();
+  },
+  deletingAllowed_: function() {
+    return loadTimeData.getBoolean('allowDeletingHistory');
+  },
+  numberOfItemsSelected_: function(count) {
+    return count > 0 ? loadTimeData.getStringF('itemsSelected', count) : '';
+  },
+  getHistoryInterval_: function(queryStartTime, queryEndTime) {
+    return loadTimeData.getStringF('historyInterval', queryStartTime, queryEndTime);
+  },
+  hasDrawerChanged_: function() {
+    this.updateStyles();
+  }
+});
+
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Polymer({
+  is: 'cr-dialog',
+  "extends": 'dialog',
+  created: function() {
+    window.addEventListener('popstate', function() {
+      if (this.open) this.cancel();
+    }.bind(this));
+  },
+  cancel: function() {
+    this.fire('cancel');
+    HTMLDialogElement.prototype.close.call(this, '');
+  },
+  close: function(opt_returnValue) {
+    HTMLDialogElement.prototype.close.call(this, 'success');
+  },
+  getCloseButton: function() {
+    return this.$.close;
+  }
+});
+
+Polymer({
   is: 'fade-in-animation',
   behaviors: [ Polymer.NeonAnimationBehavior ],
   configure: function(config) {
     var node = config.node;
     this._effect = new KeyframeEffect(node, [ {
       opacity: '0'
     }, {
       opacity: '1'
     } ], this.timingFromConfig(config));
     return this._effect;
@@ skipping 529 matching lines @@
   },
   _computeCheckmarkClass: function(checked) {
     return checked ? '' : 'hidden';
   },
   _createRipple: function() {
     this._rippleContainer = this.$.checkboxContainer;
     return Polymer.PaperInkyFocusBehaviorImpl._createRipple.call(this);
   }
 });
 
-Polymer({
-  is: 'paper-icon-button-light',
-  "extends": 'button',
-  behaviors: [ Polymer.PaperRippleBehavior ],
-  listeners: {
-    down: '_rippleDown',
-    up: '_rippleUp',
-    focus: '_rippleDown',
-    blur: '_rippleUp'
-  },
-  _rippleDown: function() {
-    this.getRipple().downAction();
-  },
-  _rippleUp: function() {
-    this.getRipple().upAction();
-  },
-  ensureRipple: function(var_args) {
-    var lastRipple = this._ripple;
-    Polymer.PaperRippleBehavior.ensureRipple.apply(this, arguments);
-    if (this._ripple && this._ripple !== lastRipple) {
-      this._ripple.center = true;
-      this._ripple.classList.add('circle');
-    }
-  }
-});
-
 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 cr.define('cr.icon', function() {
   function getSupportedScaleFactors() {
     var supportedScaleFactors = [];
+    if (!cr.isIOS) {
+      supportedScaleFactors.push(1);
+    }
     if (cr.isMac || cr.isChromeOS || cr.isWindows || cr.isLinux) {
-      supportedScaleFactors.push(1);
       supportedScaleFactors.push(2);
     } else {
       supportedScaleFactors.push(window.devicePixelRatio);
     }
     return supportedScaleFactors;
   }
-  function getProfileAvatarIcon(path) {
-    var chromeThemePath = 'chrome://theme';
-    var isDefaultAvatar = path.slice(0, chromeThemePath.length) == chromeThemePath;
-    return isDefaultAvatar ? imageset(path + '@scalefactorx') : url(path);
-  }
-  function imageset(path) {
+  function getImageSet(path) {
     var supportedScaleFactors = getSupportedScaleFactors();
     var replaceStartIndex = path.indexOf('scalefactor');
     if (replaceStartIndex < 0) return url(path);
     var s = '';
     for (var i = 0; i < supportedScaleFactors.length; ++i) {
       var scaleFactor = supportedScaleFactors[i];
       var pathWithScaleFactor = path.substr(0, replaceStartIndex) + scaleFactor + path.substr(replaceStartIndex + 'scalefactor'.length);
       s += url(pathWithScaleFactor) + ' ' + scaleFactor + 'x';
       if (i != supportedScaleFactors.length - 1) s += ', ';
     }
     return '-webkit-image-set(' + s + ')';
   }
+  function getImage(path) {
+    var chromeThemePath = 'chrome://theme';
+    var isChromeThemeUrl = path.slice(0, chromeThemePath.length) == chromeThemePath;
+    return isChromeThemeUrl ? getImageSet(path + '@scalefactorx') : url(path);
+  }
   var FAVICON_URL_REGEX = /\.ico$/i;
-  function getFaviconImageSet(url, opt_size, opt_type) {
+  function getFavicon(url, opt_size, opt_type) {
     var size = opt_size || 16;
     var type = opt_type || 'favicon';
-    return imageset('chrome://' + type + '/size/' + size + '@scalefactorx/' + (FAVICON_URL_REGEX.test(url) ? 'iconurl/' : '') + url);
+    return getImageSet('chrome://' + type + '/size/' + size + '@scalefactorx/' + (FAVICON_URL_REGEX.test(url) ? 'iconurl/' : '') + url);
   }
   return {
-    getSupportedScaleFactors: getSupportedScaleFactors,
-    getProfileAvatarIcon: getProfileAvatarIcon,
-    getFaviconImageSet: getFaviconImageSet
+    getImage: getImage,
+    getFavicon: getFavicon
   };
 });
 
 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 Polymer({
   is: 'history-searched-label',
   properties: {
     title: String,
@@ skipping 103 matching lines @@
       if (this.index == undefined) return;
       browserService.recordHistogram('HistoryPage.ClickPosition', this.index, UMA_MAX_BUCKET_VALUE);
       if (this.index <= UMA_MAX_SUBSET_BUCKET_VALUE) {
         browserService.recordHistogram('HistoryPage.ClickPositionSubset', this.index, UMA_MAX_SUBSET_BUCKET_VALUE);
       }
     },
     onLinkRightClick_: function() {
       md_history.BrowserService.getInstance().recordAction('EntryLinkRightClick');
     },
     showIcon_: function() {
-      this.$.icon.style.backgroundImage = cr.icon.getFaviconImageSet(this.item.url);
+      this.$.icon.style.backgroundImage = cr.icon.getFavicon(this.item.url);
     },
     selectionNotAllowed_: function() {
       return !loadTimeData.getBoolean('allowDeletingHistory');
     },
     cardTitle_: function(numberOfItems, historyDate, search) {
       if (!search) return this.item.dateRelativeDay;
       var resultId = numberOfItems == 1 ? 'searchResult' : 'searchResults';
       return loadTimeData.getStringF('foundSearchResults', numberOfItems, loadTimeData.getString(resultId), search);
     },
     cropItemTitle_: function(title) {
@@ skipping 228 matching lines @@
     }, 0);
   },
   needsTimeGap_: function(groupIndex, domainIndex, itemIndex) {
     var visits = this.groupedHistoryData_[groupIndex].domains[domainIndex].visits;
     return md_history.HistoryItem.needsTimeGap(visits, itemIndex, this.searchedTerm);
   },
   pathForItem_: function(groupIndex, domainIndex, itemIndex) {
     return [ 'groupedHistoryData_', groupIndex, 'domains', domainIndex, 'visits', itemIndex ].join('.');
   },
   getWebsiteIconStyle_: function(domain) {
-    return 'background-image: ' + cr.icon.getFaviconImageSet(domain.visits[0].url);
+    return 'background-image: ' + cr.icon.getFavicon(domain.visits[0].url);
   },
   getDropdownIcon_: function(expanded) {
     return expanded ? 'cr:expand-less' : 'cr:expand-more';
   }
 });
 
 (function() {
   var IOS = navigator.userAgent.match(/iP(?:hone|ad;(?: U;)? CPU) OS (\d+)/);
   var IOS_TOUCH_SCROLLING = IOS && IOS[1] >= 8;
   var DEFAULT_PHYSICAL_COUNT = 3;
@@ skipping 1009 matching lines @@
   },
   pathForItem_: function(index) {
     return 'historyData_.' + index;
   }
 });
 
 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 Polymer({
-  is: 'history-lazy-render',
-  "extends": 'template',
-  behaviors: [ Polymer.Templatizer ],
-  _renderPromise: null,
-  _instance: null,
-  get: function() {
-    if (!this._renderPromise) {
-      this._renderPromise = new Promise(function(resolve) {
-        this._debounceTemplate(function() {
-          this._render();
-          this._renderPromise = null;
-          resolve(this.getIfExists());
-        }.bind(this));
-      }.bind(this));
-    }
-    return this._renderPromise;
-  },
-  getIfExists: function() {
-    if (this._instance) {
-      var children = this._instance._children;
-      for (var i = 0; i < children.length; i++) {
-        if (children[i].nodeType == Node.ELEMENT_NODE) return children[i];
-      }
-    }
-    return null;
-  },
-  _render: function() {
-    if (!this.ctor) this.templatize(this);
-    var parentNode = this.parentNode;
-    if (parentNode && !this._instance) {
-      this._instance = this.stamp({});
-      var root = this._instance.root;
-      parentNode.insertBefore(root, this);
-    }
-  },
-  _forwardParentProp: function(prop, value) {
-    if (this._instance) this._instance.__setProperty(prop, value, true);
-  },
-  _forwardParentPath: function(path, value) {
-    if (this._instance) this._instance._notifyPath(path, value, true);
-  }
-});
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-Polymer({
   is: 'history-list-container',
   properties: {
     selectedPage_: String,
     grouped: Boolean,
     groupedRange: {
       type: Number,
       observer: 'groupedRangeChanged_'
     },
     queryState: Object,
     queryResult: Object
@@ skipping 157 matching lines @@
   toggleTabCard: function() {
     var histogramValue = this.$.collapse.opened ? SyncedTabsHistogram.COLLAPSE_SESSION : SyncedTabsHistogram.EXPAND_SESSION;
     md_history.BrowserService.getInstance().recordHistogram(SYNCED_TABS_HISTOGRAM_NAME, histogramValue, SyncedTabsHistogram.LIMIT);
     this.$.collapse.toggle();
     this.$['dropdown-indicator'].icon = this.$.collapse.opened ? 'cr:expand-less' : 'cr:expand-more';
   },
   updateIcons_: function() {
     this.async(function() {
       var icons = Polymer.dom(this.root).querySelectorAll('.website-icon');
       for (var i = 0; i < this.tabs.length; i++) {
-        icons[i].style.backgroundImage = cr.icon.getFaviconImageSet(this.tabs[i].url);
+        icons[i].style.backgroundImage = cr.icon.getFavicon(this.tabs[i].url);
       }
     });
   },
   isWindowSeparatorIndex_: function(index, separatorIndexes) {
     return this.separatorIndexes.indexOf(index) != -1;
   },
   getCollapseIcon_: function(opened) {
     return opened ? 'cr:expand-less' : 'cr:expand-more';
   },
   getCollapseTitle_: function(opened) {
@@ skipping 224 matching lines @@
 });
 
 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 Polymer({
   is: 'history-app',
   behaviors: [ Polymer.IronScrollTargetBehavior ],
   properties: {
     showSidebarFooter: Boolean,
+    hasSyncedResults: Boolean,
     selectedPage_: {
       type: String,
       observer: 'unselectAll'
     },
     grouped_: {
       type: Boolean,
       reflectToAttribute: true
     },
     queryState_: {
       type: Object,
@@ skipping 138 matching lines @@
   },
   updateSignInState: function(isUserSignedIn) {
     this.isUserSignedIn_ = isUserSignedIn;
   },
   syncedTabsSelected_: function(selectedPage) {
     return selectedPage == 'syncedTabs';
   },
   shouldShowSpinner_: function(querying, incremental, searchTerm) {
     return querying && !incremental && searchTerm != '';
   },
+  showSyncNotice_: function(hasSyncedResults, selectedPage) {
+    return hasSyncedResults && selectedPage != 'syncedTabs';
+  },
   routeDataChanged_: function(page) {
     this.selectedPage_ = page;
   },
   selectedPageChanged_: function(selectedPage) {
     this.set('routeData_.page', selectedPage);
     this.historyViewChanged_();
   },
   historyViewChanged_: function() {
     requestAnimationFrame(function() {
       this.scrollTarget = this.$.content.selectedItem.getContentScrollTarget();
@@ skipping 27 matching lines @@
 
        case HistoryRange.MONTH:
         histogramValue = HistoryPageViewHistogram.GROUPED_MONTH;
         break;
       }
       break;
     }
     md_history.BrowserService.getInstance().recordHistogram('History.HistoryPageView', histogramValue, HistoryPageViewHistogram.END);
   }
 });