MD History: Lazily load element files which are not needed for first paint

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 489 matching lines @@
       this.stopPropagation();
       this.preventDefault();
     }
   };
   return {
     Command: Command,
     CanExecuteEvent: CanExecuteEvent
   };
 });
 
-Polymer({
-  is: 'app-drawer',
-  properties: {
-    opened: {
-      type: Boolean,
-      value: false,
-      notify: true,
-      reflectToAttribute: true
-    },
-    persistent: {
-      type: Boolean,
-      value: false,
-      reflectToAttribute: true
-    },
-    align: {
-      type: String,
-      value: 'left'
-    },
-    position: {
-      type: String,
-      readOnly: true,
-      value: 'left',
-      reflectToAttribute: true
-    },
-    swipeOpen: {
-      type: Boolean,
-      value: false,
-      reflectToAttribute: true
-    },
-    noFocusTrap: {
-      type: Boolean,
-      value: false
-    }
-  },
-  observers: [ 'resetLayout(position)', '_resetPosition(align, isAttached)' ],
-  _translateOffset: 0,
-  _trackDetails: null,
-  _drawerState: 0,
-  _boundEscKeydownHandler: null,
-  _firstTabStop: null,
-  _lastTabStop: null,
-  ready: function() {
-    this.setScrollDirection('y');
-    this._setTransitionDuration('0s');
-  },
-  attached: function() {
-    Polymer.RenderStatus.afterNextRender(this, function() {
-      this._setTransitionDuration('');
-      this._boundEscKeydownHandler = this._escKeydownHandler.bind(this);
-      this._resetDrawerState();
-      this.listen(this, 'track', '_track');
-      this.addEventListener('transitionend', this._transitionend.bind(this));
-      this.addEventListener('keydown', this._tabKeydownHandler.bind(this));
-    });
-  },
-  detached: function() {
-    document.removeEventListener('keydown', this._boundEscKeydownHandler);
-  },
-  open: function() {
-    this.opened = true;
-  },
-  close: function() {
-    this.opened = false;
-  },
-  toggle: function() {
-    this.opened = !this.opened;
-  },
-  getWidth: function() {
-    return this.$.contentContainer.offsetWidth;
-  },
-  resetLayout: function() {
-    this.debounce('_resetLayout', function() {
-      this.fire('app-drawer-reset-layout');
-    }, 1);
-  },
-  _isRTL: function() {
-    return window.getComputedStyle(this).direction === 'rtl';
-  },
-  _resetPosition: function() {
-    switch (this.align) {
-     case 'start':
-      this._setPosition(this._isRTL() ? 'right' : 'left');
-      return;
-
-     case 'end':
-      this._setPosition(this._isRTL() ? 'left' : 'right');
-      return;
-    }
-    this._setPosition(this.align);
-  },
-  _escKeydownHandler: function(event) {
-    var ESC_KEYCODE = 27;
-    if (event.keyCode === ESC_KEYCODE) {
-      event.preventDefault();
-      this.close();
-    }
-  },
-  _track: function(event) {
-    if (this.persistent) {
-      return;
-    }
-    event.preventDefault();
-    switch (event.detail.state) {
-     case 'start':
-      this._trackStart(event);
-      break;
-
-     case 'track':
-      this._trackMove(event);
-      break;
-
-     case 'end':
-      this._trackEnd(event);
-      break;
-    }
-  },
-  _trackStart: function(event) {
-    this._drawerState = this._DRAWER_STATE.TRACKING;
-    this._setTransitionDuration('0s');
-    this.style.visibility = 'visible';
-    var rect = this.$.contentContainer.getBoundingClientRect();
-    if (this.position === 'left') {
-      this._translateOffset = rect.left;
-    } else {
-      this._translateOffset = rect.right - window.innerWidth;
-    }
-    this._trackDetails = [];
-  },
-  _trackMove: function(event) {
-    this._translateDrawer(event.detail.dx + this._translateOffset);
-    this._trackDetails.push({
-      dx: event.detail.dx,
-      timeStamp: Date.now()
-    });
-  },
-  _trackEnd: function(event) {
-    var x = event.detail.dx + this._translateOffset;
-    var drawerWidth = this.getWidth();
-    var isPositionLeft = this.position === 'left';
-    var isInEndState = isPositionLeft ? x >= 0 || x <= -drawerWidth : x <= 0 || x >= drawerWidth;
-    if (!isInEndState) {
-      var trackDetails = this._trackDetails;
-      this._trackDetails = null;
-      this._flingDrawer(event, trackDetails);
-      if (this._drawerState === this._DRAWER_STATE.FLINGING) {
-        return;
-      }
-    }
-    var halfWidth = drawerWidth / 2;
-    if (event.detail.dx < -halfWidth) {
-      this.opened = this.position === 'right';
-    } else if (event.detail.dx > halfWidth) {
-      this.opened = this.position === 'left';
-    }
-    if (isInEndState) {
-      this._resetDrawerState();
-    }
-    this._setTransitionDuration('');
-    this._resetDrawerTranslate();
-    this.style.visibility = '';
-  },
-  _calculateVelocity: function(event, trackDetails) {
-    var now = Date.now();
-    var timeLowerBound = now - 100;
-    var trackDetail;
-    var min = 0;
-    var max = trackDetails.length - 1;
-    while (min <= max) {
-      var mid = min + max >> 1;
-      var d = trackDetails[mid];
-      if (d.timeStamp >= timeLowerBound) {
-        trackDetail = d;
-        max = mid - 1;
-      } else {
-        min = mid + 1;
-      }
-    }
-    if (trackDetail) {
-      var dx = event.detail.dx - trackDetail.dx;
-      var dt = now - trackDetail.timeStamp || 1;
-      return dx / dt;
-    }
-    return 0;
-  },
-  _flingDrawer: function(event, trackDetails) {
-    var velocity = this._calculateVelocity(event, trackDetails);
-    if (Math.abs(velocity) < this._MIN_FLING_THRESHOLD) {
-      return;
-    }
-    this._drawerState = this._DRAWER_STATE.FLINGING;
-    var x = event.detail.dx + this._translateOffset;
-    var drawerWidth = this.getWidth();
-    var isPositionLeft = this.position === 'left';
-    var isVelocityPositive = velocity > 0;
-    var isClosingLeft = !isVelocityPositive && isPositionLeft;
-    var isClosingRight = isVelocityPositive && !isPositionLeft;
-    var dx;
-    if (isClosingLeft) {
-      dx = -(x + drawerWidth);
-    } else if (isClosingRight) {
-      dx = drawerWidth - x;
-    } else {
-      dx = -x;
-    }
-    if (isVelocityPositive) {
-      velocity = Math.max(velocity, this._MIN_TRANSITION_VELOCITY);
-      this.opened = this.position === 'left';
-    } else {
-      velocity = Math.min(velocity, -this._MIN_TRANSITION_VELOCITY);
-      this.opened = this.position === 'right';
-    }
-    this._setTransitionDuration(this._FLING_INITIAL_SLOPE * dx / velocity + 'ms');
-    this._setTransitionTimingFunction(this._FLING_TIMING_FUNCTION);
-    this._resetDrawerTranslate();
-  },
-  _transitionend: function(event) {
-    var target = Polymer.dom(event).rootTarget;
-    if (target === this.$.contentContainer || target === this.$.scrim) {
-      if (this._drawerState === this._DRAWER_STATE.FLINGING) {
-        this._setTransitionDuration('');
-        this._setTransitionTimingFunction('');
-        this.style.visibility = '';
-      }
-      this._resetDrawerState();
-    }
-  },
-  _setTransitionDuration: function(duration) {
-    this.$.contentContainer.style.transitionDuration = duration;
-    this.$.scrim.style.transitionDuration = duration;
-  },
-  _setTransitionTimingFunction: function(timingFunction) {
-    this.$.contentContainer.style.transitionTimingFunction = timingFunction;
-    this.$.scrim.style.transitionTimingFunction = timingFunction;
-  },
-  _translateDrawer: function(x) {
-    var drawerWidth = this.getWidth();
-    if (this.position === 'left') {
-      x = Math.max(-drawerWidth, Math.min(x, 0));
-      this.$.scrim.style.opacity = 1 + x / drawerWidth;
-    } else {
-      x = Math.max(0, Math.min(x, drawerWidth));
-      this.$.scrim.style.opacity = 1 - x / drawerWidth;
-    }
-    this.translate3d(x + 'px', '0', '0', this.$.contentContainer);
-  },
-  _resetDrawerTranslate: function() {
-    this.$.scrim.style.opacity = '';
-    this.transform('', this.$.contentContainer);
-  },
-  _resetDrawerState: function() {
-    var oldState = this._drawerState;
-    if (this.opened) {
-      this._drawerState = this.persistent ? this._DRAWER_STATE.OPENED_PERSISTENT : this._DRAWER_STATE.OPENED;
-    } else {
-      this._drawerState = this._DRAWER_STATE.CLOSED;
-    }
-    if (oldState !== this._drawerState) {
-      if (this._drawerState === this._DRAWER_STATE.OPENED) {
-        this._setKeyboardFocusTrap();
-        document.addEventListener('keydown', this._boundEscKeydownHandler);
-        document.body.style.overflow = 'hidden';
-      } else {
-        document.removeEventListener('keydown', this._boundEscKeydownHandler);
-        document.body.style.overflow = '';
-      }
-      if (oldState !== this._DRAWER_STATE.INIT) {
-        this.fire('app-drawer-transitioned');
-      }
-    }
-  },
-  _setKeyboardFocusTrap: function() {
-    if (this.noFocusTrap) {
-      return;
-    }
-    var focusableElementsSelector = [ 'a[href]:not([tabindex="-1"])', 'area[href]:not([tabindex="-1"])', 'input:not([disabled]):not([tabindex="-1"])', 'select:not([disabled]):not([tabindex="-1"])', 'textarea:not([disabled]):not([tabindex="-1"])', 'button:not([disabled]):not([tabindex="-1"])', 'iframe:not([tabindex="-1"])', '[tabindex]:not([tabindex="-1"])', '[contentEditable=true]:not([tabindex="-1"])' ].join(',');
-    var focusableElements = Polymer.dom(this).querySelectorAll(focusableElementsSelector);
-    if (focusableElements.length > 0) {
-      this._firstTabStop = focusableElements[0];
-      this._lastTabStop = focusableElements[focusableElements.length - 1];
-    } else {
-      this._firstTabStop = null;
-      this._lastTabStop = null;
-    }
-    var tabindex = this.getAttribute('tabindex');
-    if (tabindex && parseInt(tabindex, 10) > -1) {
-      this.focus();
-    } else if (this._firstTabStop) {
-      this._firstTabStop.focus();
-    }
-  },
-  _tabKeydownHandler: function(event) {
-    if (this.noFocusTrap) {
-      return;
-    }
-    var TAB_KEYCODE = 9;
-    if (this._drawerState === this._DRAWER_STATE.OPENED && event.keyCode === TAB_KEYCODE) {
-      if (event.shiftKey) {
-        if (this._firstTabStop && Polymer.dom(event).localTarget === this._firstTabStop) {
-          event.preventDefault();
-          this._lastTabStop.focus();
-        }
-      } else {
-        if (this._lastTabStop && Polymer.dom(event).localTarget === this._lastTabStop) {
-          event.preventDefault();
-          this._firstTabStop.focus();
-        }
-      }
-    }
-  },
-  _MIN_FLING_THRESHOLD: .2,
-  _MIN_TRANSITION_VELOCITY: 1.2,
-  _FLING_TIMING_FUNCTION: 'cubic-bezier(0.667, 1, 0.667, 1)',
-  _FLING_INITIAL_SLOPE: 1.5,
-  _DRAWER_STATE: {
-    INIT: 0,
-    OPENED: 1,
-    OPENED_PERSISTENT: 2,
-    CLOSED: 3,
-    TRACKING: 4,
-    FLINGING: 5
-  }
-});
-
 (function() {
   'use strict';
   Polymer({
     is: 'iron-location',
     properties: {
       path: {
         type: String,
         notify: true,
         value: function() {
           return window.decodeURIComponent(window.location.pathname);
@@ skipping 1073 matching lines @@
       return this.scrollTarget === this._doc ? window.innerHeight : this.scrollTarget.offsetHeight;
     }
     return 0;
   },
   _isValidScrollTarget: function() {
     return this.scrollTarget instanceof HTMLElement;
   }
 };
 
 (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
+      },
+      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);
+    }
+  }
+});
+
+(function() {
   'use strict';
   var KEY_IDENTIFIER = {
     'U+0008': 'backspace',
     'U+0009': 'tab',
     'U+001B': 'esc',
     'U+0020': 'space',
     'U+007F': 'del'
   };
   var KEY_CODE = {
     8: 'backspace',
@@ skipping 328 matching lines @@
       this.tabIndex = this._oldTabIndex;
     }
   },
   _changedControlState: function() {
     if (this._controlStateChanged) {
       this._controlStateChanged();
     }
   }
 };
 
-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 ];
-})();
-
-(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
-      },
-      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.NeonAnimatableBehavior = {
-  properties: {
-    animationConfig: {
-      type: Object
-    },
-    entryAnimation: {
-      observer: '_entryAnimationChanged',
-      type: String
-    },
-    exitAnimation: {
-      observer: '_exitAnimationChanged',
-      type: String
-    }
-  },
-  _entryAnimationChanged: function() {
-    this.animationConfig = this.animationConfig || {};
-    this.animationConfig['entry'] = [ {
-      name: this.entryAnimation,
-      node: this
-    } ];
-  },
-  _exitAnimationChanged: function() {
-    this.animationConfig = this.animationConfig || {};
-    this.animationConfig['exit'] = [ {
-      name: this.exitAnimation,
-      node: this
-    } ];
-  },
-  _copyProperties: function(config1, config2) {
-    for (var property in config2) {
-      config1[property] = config2[property];
-    }
-  },
-  _cloneConfig: function(config) {
-    var clone = {
-      isClone: true
-    };
-    this._copyProperties(clone, config);
-    return clone;
-  },
-  _getAnimationConfigRecursive: function(type, map, allConfigs) {
-    if (!this.animationConfig) {
-      return;
-    }
-    if (this.animationConfig.value && typeof this.animationConfig.value === 'function') {
-      this._warn(this._logf('playAnimation', "Please put 'animationConfig' inside of your components 'properties' object instead of outside of it."));
-      return;
-    }
-    var thisConfig;
-    if (type) {
-      thisConfig = this.animationConfig[type];
-    } else {
-      thisConfig = this.animationConfig;
-    }
-    if (!Array.isArray(thisConfig)) {
-      thisConfig = [ thisConfig ];
-    }
-    if (thisConfig) {
-      for (var config, index = 0; config = thisConfig[index]; index++) {
-        if (config.animatable) {
-          config.animatable._getAnimationConfigRecursive(config.type || type, map, allConfigs);
-        } else {
-          if (config.id) {
-            var cachedConfig = map[config.id];
-            if (cachedConfig) {
-              if (!cachedConfig.isClone) {
-                map[config.id] = this._cloneConfig(cachedConfig);
-                cachedConfig = map[config.id];
-              }
-              this._copyProperties(cachedConfig, config);
-            } else {
-              map[config.id] = config;
-            }
-          } else {
-            allConfigs.push(config);
-          }
-        }
-      }
-    }
-  },
-  getAnimationConfig: function(type) {
-    var map = {};
-    var allConfigs = [];
-    this._getAnimationConfigRecursive(type, map, allConfigs);
-    for (var key in map) {
-      allConfigs.push(map[key]);
-    }
-    return allConfigs;
-  }
-};
-
-Polymer.NeonAnimationRunnerBehaviorImpl = {
-  _configureAnimations: function(configs) {
-    var results = [];
-    if (configs.length > 0) {
-      for (var config, index = 0; config = configs[index]; index++) {
-        var neonAnimation = document.createElement(config.name);
-        if (neonAnimation.isNeonAnimation) {
-          var result = null;
-          try {
-            result = neonAnimation.configure(config);
-            if (typeof result.cancel != 'function') {
-              result = document.timeline.play(result);
-            }
-          } catch (e) {
-            result = null;
-            console.warn('Couldnt play', '(', config.name, ').', e);
-          }
-          if (result) {
-            results.push({
-              neonAnimation: neonAnimation,
-              config: config,
-              animation: result
-            });
-          }
-        } else {
-          console.warn(this.is + ':', config.name, 'not found!');
-        }
-      }
-    }
-    return results;
-  },
-  _shouldComplete: function(activeEntries) {
-    var finished = true;
-    for (var i = 0; i < activeEntries.length; i++) {
-      if (activeEntries[i].animation.playState != 'finished') {
-        finished = false;
-        break;
-      }
-    }
-    return finished;
-  },
-  _complete: function(activeEntries) {
-    for (var i = 0; i < activeEntries.length; i++) {
-      activeEntries[i].neonAnimation.complete(activeEntries[i].config);
-    }
-    for (var i = 0; i < activeEntries.length; i++) {
-      activeEntries[i].animation.cancel();
-    }
-  },
-  playAnimation: function(type, cookie) {
-    var configs = this.getAnimationConfig(type);
-    if (!configs) {
-      return;
-    }
-    this._active = this._active || {};
-    if (this._active[type]) {
-      this._complete(this._active[type]);
-      delete this._active[type];
-    }
-    var activeEntries = this._configureAnimations(configs);
-    if (activeEntries.length == 0) {
-      this.fire('neon-animation-finish', cookie, {
-        bubbles: false
-      });
-      return;
-    }
-    this._active[type] = activeEntries;
-    for (var i = 0; i < activeEntries.length; i++) {
-      activeEntries[i].animation.onfinish = function() {
-        if (this._shouldComplete(activeEntries)) {
-          this._complete(activeEntries);
-          delete this._active[type];
-          this.fire('neon-animation-finish', cookie, {
-            bubbles: false
-          });
-        }
-      }.bind(this);
-    }
-  },
-  cancelAnimation: function() {
-    for (var k in this._animations) {
-      this._animations[k].cancel();
-    }
-    this._animations = {};
-  }
-};
-
-Polymer.NeonAnimationRunnerBehavior = [ Polymer.NeonAnimatableBehavior, Polymer.NeonAnimationRunnerBehaviorImpl ];
-
-Polymer.NeonAnimationBehavior = {
-  properties: {
-    animationTiming: {
-      type: Object,
-      value: function() {
-        return {
-          duration: 500,
-          easing: 'cubic-bezier(0.4, 0, 0.2, 1)',
-          fill: 'both'
-        };
-      }
-    }
-  },
-  isNeonAnimation: true,
-  timingFromConfig: function(config) {
-    if (config.timing) {
-      for (var property in config.timing) {
-        this.animationTiming[property] = config.timing[property];
-      }
-    }
-    return this.animationTiming;
-  },
-  setPrefixedProperty: function(node, property, value) {
-    var map = {
-      transform: [ 'webkitTransform' ],
-      transformOrigin: [ 'mozTransformOrigin', 'webkitTransformOrigin' ]
-    };
-    var prefixes = map[property];
-    for (var prefix, index = 0; prefix = prefixes[index]; index++) {
-      node.style[prefix] = value;
-    }
-    node.style[property] = value;
-  },
-  complete: function() {}
-};
-
-Polymer({
-  is: 'opaque-animation',
-  behaviors: [ Polymer.NeonAnimationBehavior ],
-  configure: function(config) {
-    var node = config.node;
-    this._effect = new KeyframeEffect(node, [ {
-      opacity: '1'
-    }, {
-      opacity: '1'
-    } ], this.timingFromConfig(config));
-    node.style.opacity = '0';
-    return this._effect;
-  },
-  complete: function(config) {
-    config.node.style.opacity = '';
-  }
-});
-
-(function() {
-  'use strict';
-  var LAST_TOUCH_POSITION = {
-    pageX: 0,
-    pageY: 0
-  };
-  var ROOT_TARGET = null;
-  var SCROLLABLE_NODES = [];
-  Polymer.IronDropdownScrollManager = {
-    get currentLockingElement() {
-      return this._lockingElements[this._lockingElements.length - 1];
-    },
-    elementIsScrollLocked: function(element) {
-      var currentLockingElement = this.currentLockingElement;
-      if (currentLockingElement === undefined) return false;
-      var scrollLocked;
-      if (this._hasCachedLockedElement(element)) {
-        return true;
-      }
-      if (this._hasCachedUnlockedElement(element)) {
-        return false;
-      }
-      scrollLocked = !!currentLockingElement && currentLockingElement !== element && !this._composedTreeContains(currentLockingElement, element);
-      if (scrollLocked) {
-        this._lockedElementCache.push(element);
-      } else {
-        this._unlockedElementCache.push(element);
-      }
-      return scrollLocked;
-    },
-    pushScrollLock: function(element) {
-      if (this._lockingElements.indexOf(element) >= 0) {
-        return;
-      }
-      if (this._lockingElements.length === 0) {
-        this._lockScrollInteractions();
-      }
-      this._lockingElements.push(element);
-      this._lockedElementCache = [];
-      this._unlockedElementCache = [];
-    },
-    removeScrollLock: function(element) {
-      var index = this._lockingElements.indexOf(element);
-      if (index === -1) {
-        return;
-      }
-      this._lockingElements.splice(index, 1);
-      this._lockedElementCache = [];
-      this._unlockedElementCache = [];
-      if (this._lockingElements.length === 0) {
-        this._unlockScrollInteractions();
-      }
-    },
-    _lockingElements: [],
-    _lockedElementCache: null,
-    _unlockedElementCache: null,
-    _hasCachedLockedElement: function(element) {
-      return this._lockedElementCache.indexOf(element) > -1;
-    },
-    _hasCachedUnlockedElement: function(element) {
-      return this._unlockedElementCache.indexOf(element) > -1;
-    },
-    _composedTreeContains: function(element, child) {
-      var contentElements;
-      var distributedNodes;
-      var contentIndex;
-      var nodeIndex;
-      if (element.contains(child)) {
-        return true;
-      }
-      contentElements = Polymer.dom(element).querySelectorAll('content');
-      for (contentIndex = 0; contentIndex < contentElements.length; ++contentIndex) {
-        distributedNodes = Polymer.dom(contentElements[contentIndex]).getDistributedNodes();
-        for (nodeIndex = 0; nodeIndex < distributedNodes.length; ++nodeIndex) {
-          if (this._composedTreeContains(distributedNodes[nodeIndex], child)) {
-            return true;
-          }
-        }
-      }
-      return false;
-    },
-    _scrollInteractionHandler: function(event) {
-      if (event.cancelable && this._shouldPreventScrolling(event)) {
-        event.preventDefault();
-      }
-      if (event.targetTouches) {
-        var touch = event.targetTouches[0];
-        LAST_TOUCH_POSITION.pageX = touch.pageX;
-        LAST_TOUCH_POSITION.pageY = touch.pageY;
-      }
-    },
-    _lockScrollInteractions: function() {
-      this._boundScrollHandler = this._boundScrollHandler || this._scrollInteractionHandler.bind(this);
-      document.addEventListener('wheel', this._boundScrollHandler, true);
-      document.addEventListener('mousewheel', this._boundScrollHandler, true);
-      document.addEventListener('DOMMouseScroll', this._boundScrollHandler, true);
-      document.addEventListener('touchstart', this._boundScrollHandler, true);
-      document.addEventListener('touchmove', this._boundScrollHandler, true);
-    },
-    _unlockScrollInteractions: function() {
-      document.removeEventListener('wheel', this._boundScrollHandler, true);
-      document.removeEventListener('mousewheel', this._boundScrollHandler, true);
-      document.removeEventListener('DOMMouseScroll', this._boundScrollHandler, true);
-      document.removeEventListener('touchstart', this._boundScrollHandler, true);
-      document.removeEventListener('touchmove', this._boundScrollHandler, true);
-    },
-    _shouldPreventScrolling: function(event) {
-      var target = Polymer.dom(event).rootTarget;
-      if (event.type !== 'touchmove' && ROOT_TARGET !== target) {
-        ROOT_TARGET = target;
-        SCROLLABLE_NODES = this._getScrollableNodes(Polymer.dom(event).path);
-      }
-      if (!SCROLLABLE_NODES.length) {
-        return true;
-      }
-      if (event.type === 'touchstart') {
-        return false;
-      }
-      var info = this._getScrollInfo(event);
-      return !this._getScrollingNode(SCROLLABLE_NODES, info.deltaX, info.deltaY);
-    },
-    _getScrollableNodes: function(nodes) {
-      var scrollables = [];
-      var lockingIndex = nodes.indexOf(this.currentLockingElement);
-      for (var i = 0; i <= lockingIndex; i++) {
-        var node = nodes[i];
-        if (node.nodeType === 11) {
-          continue;
-        }
-        var style = node.style;
-        if (style.overflow !== 'scroll' && style.overflow !== 'auto') {
-          style = window.getComputedStyle(node);
-        }
-        if (style.overflow === 'scroll' || style.overflow === 'auto') {
-          scrollables.push(node);
-        }
-      }
-      return scrollables;
-    },
-    _getScrollingNode: function(nodes, deltaX, deltaY) {
-      if (!deltaX && !deltaY) {
-        return;
-      }
-      var verticalScroll = Math.abs(deltaY) >= Math.abs(deltaX);
-      for (var i = 0; i < nodes.length; i++) {
-        var node = nodes[i];
-        var canScroll = false;
-        if (verticalScroll) {
-          canScroll = deltaY < 0 ? node.scrollTop > 0 : node.scrollTop < node.scrollHeight - node.clientHeight;
-        } else {
-          canScroll = deltaX < 0 ? node.scrollLeft > 0 : node.scrollLeft < node.scrollWidth - node.clientWidth;
-        }
-        if (canScroll) {
-          return node;
-        }
-      }
-    },
-    _getScrollInfo: function(event) {
-      var info = {
-        deltaX: event.deltaX,
-        deltaY: event.deltaY
-      };
-      if ('deltaX' in event) {} else if ('wheelDeltaX' in event) {
-        info.deltaX = -event.wheelDeltaX;
-        info.deltaY = -event.wheelDeltaY;
-      } else if ('axis' in event) {
-        info.deltaX = event.axis === 1 ? event.detail : 0;
-        info.deltaY = event.axis === 2 ? event.detail : 0;
-      } else if (event.targetTouches) {
-        var touch = event.targetTouches[0];
-        info.deltaX = LAST_TOUCH_POSITION.pageX - touch.pageX;
-        info.deltaY = LAST_TOUCH_POSITION.pageY - touch.pageY;
-      }
-      return info;
-    }
-  };
-})();
-
-(function() {
-  'use strict';
-  Polymer({
-    is: 'iron-dropdown',
-    behaviors: [ Polymer.IronControlState, Polymer.IronA11yKeysBehavior, Polymer.IronOverlayBehavior, Polymer.NeonAnimationRunnerBehavior ],
-    properties: {
-      horizontalAlign: {
-        type: String,
-        value: 'left',
-        reflectToAttribute: true
-      },
-      verticalAlign: {
-        type: String,
-        value: 'top',
-        reflectToAttribute: true
-      },
-      openAnimationConfig: {
-        type: Object
-      },
-      closeAnimationConfig: {
-        type: Object
-      },
-      focusTarget: {
-        type: Object
-      },
-      noAnimations: {
-        type: Boolean,
-        value: false
-      },
-      allowOutsideScroll: {
-        type: Boolean,
-        value: false
-      },
-      _boundOnCaptureScroll: {
-        type: Function,
-        value: function() {
-          return this._onCaptureScroll.bind(this);
-        }
-      }
-    },
-    listeners: {
-      'neon-animation-finish': '_onNeonAnimationFinish'
-    },
-    observers: [ '_updateOverlayPosition(positionTarget, verticalAlign, horizontalAlign, verticalOffset, horizontalOffset)' ],
-    get containedElement() {
-      return Polymer.dom(this.$.content).getDistributedNodes()[0];
-    },
-    get _focusTarget() {
-      return this.focusTarget || this.containedElement;
-    },
-    ready: function() {
-      this._scrollTop = 0;
-      this._scrollLeft = 0;
-      this._refitOnScrollRAF = null;
-    },
-    attached: function() {
-      if (!this.sizingTarget || this.sizingTarget === this) {
-        this.sizingTarget = this.containedElement;
-      }
-    },
-    detached: function() {
-      this.cancelAnimation();
-      document.removeEventListener('scroll', this._boundOnCaptureScroll);
-      Polymer.IronDropdownScrollManager.removeScrollLock(this);
-    },
-    _openedChanged: function() {
-      if (this.opened && this.disabled) {
-        this.cancel();
-      } else {
-        this.cancelAnimation();
-        this._updateAnimationConfig();
-        this._saveScrollPosition();
-        if (this.opened) {
-          document.addEventListener('scroll', this._boundOnCaptureScroll);
-          !this.allowOutsideScroll && Polymer.IronDropdownScrollManager.pushScrollLock(this);
-        } else {
-          document.removeEventListener('scroll', this._boundOnCaptureScroll);
-          Polymer.IronDropdownScrollManager.removeScrollLock(this);
-        }
-        Polymer.IronOverlayBehaviorImpl._openedChanged.apply(this, arguments);
-      }
-    },
-    _renderOpened: function() {
-      if (!this.noAnimations && this.animationConfig.open) {
-        this.$.contentWrapper.classList.add('animating');
-        this.playAnimation('open');
-      } else {
-        Polymer.IronOverlayBehaviorImpl._renderOpened.apply(this, arguments);
-      }
-    },
-    _renderClosed: function() {
-      if (!this.noAnimations && this.animationConfig.close) {
-        this.$.contentWrapper.classList.add('animating');
-        this.playAnimation('close');
-      } else {
-        Polymer.IronOverlayBehaviorImpl._renderClosed.apply(this, arguments);
-      }
-    },
-    _onNeonAnimationFinish: function() {
-      this.$.contentWrapper.classList.remove('animating');
-      if (this.opened) {
-        this._finishRenderOpened();
-      } else {
-        this._finishRenderClosed();
-      }
-    },
-    _onCaptureScroll: function() {
-      if (!this.allowOutsideScroll) {
-        this._restoreScrollPosition();
-      } else {
-        this._refitOnScrollRAF && window.cancelAnimationFrame(this._refitOnScrollRAF);
-        this._refitOnScrollRAF = window.requestAnimationFrame(this.refit.bind(this));
-      }
-    },
-    _saveScrollPosition: function() {
-      if (document.scrollingElement) {
-        this._scrollTop = document.scrollingElement.scrollTop;
-        this._scrollLeft = document.scrollingElement.scrollLeft;
-      } else {
-        this._scrollTop = Math.max(document.documentElement.scrollTop, document.body.scrollTop);
-        this._scrollLeft = Math.max(document.documentElement.scrollLeft, document.body.scrollLeft);
-      }
-    },
-    _restoreScrollPosition: function() {
-      if (document.scrollingElement) {
-        document.scrollingElement.scrollTop = this._scrollTop;
-        document.scrollingElement.scrollLeft = this._scrollLeft;
-      } else {
-        document.documentElement.scrollTop = this._scrollTop;
-        document.documentElement.scrollLeft = this._scrollLeft;
-        document.body.scrollTop = this._scrollTop;
-        document.body.scrollLeft = this._scrollLeft;
-      }
-    },
-    _updateAnimationConfig: function() {
-      var animations = (this.openAnimationConfig || []).concat(this.closeAnimationConfig || []);
-      for (var i = 0; i < animations.length; i++) {
-        animations[i].node = this.containedElement;
-      }
-      this.animationConfig = {
-        open: this.openAnimationConfig,
-        close: this.closeAnimationConfig
-      };
-    },
-    _updateOverlayPosition: function() {
-      if (this.isAttached) {
-        this.notifyResize();
-      }
-    },
-    _applyFocus: function() {
-      var focusTarget = this.focusTarget || this.containedElement;
-      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: {
@@ skipping 528 matching lines @@
   _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;
     }
   },
@@ skipping 29 matching lines @@
   },
   _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')) {
-        var owner = Polymer.dom(item).getOwnerRoot() || document;
-        this._setFocusedItem(item);
-        if (Polymer.dom(owner).activeElement == 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')) {
-        var owner = Polymer.dom(item).getOwnerRoot() || document;
-        this._setFocusedItem(item);
-        if (Polymer.dom(owner).activeElement == 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
     }
@@ skipping 53 matching lines @@
       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');
-    }
-  }
-});
-
 // 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-lazy-render',
   "extends": 'template',
   behaviors: [ Polymer.Templatizer ],
   child_: null,
   get: function() {
     if (!this.child_) this.render_();
@@ skipping 869 matching lines @@
     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;
-  }
-});
-
-Polymer({
-  is: 'fade-out-animation',
-  behaviors: [ Polymer.NeonAnimationBehavior ],
-  configure: function(config) {
-    var node = config.node;
-    this._effect = new KeyframeEffect(node, [ {
-      opacity: '1'
-    }, {
-      opacity: '0'
-    } ], this.timingFromConfig(config));
-    return this._effect;
-  }
-});
-
-Polymer({
-  is: 'paper-menu-grow-height-animation',
-  behaviors: [ Polymer.NeonAnimationBehavior ],
-  configure: function(config) {
-    var node = config.node;
-    var rect = node.getBoundingClientRect();
-    var height = rect.height;
-    this._effect = new KeyframeEffect(node, [ {
-      height: height / 2 + 'px'
-    }, {
-      height: height + 'px'
-    } ], this.timingFromConfig(config));
-    return this._effect;
-  }
-});
-
-Polymer({
-  is: 'paper-menu-grow-width-animation',
-  behaviors: [ Polymer.NeonAnimationBehavior ],
-  configure: function(config) {
-    var node = config.node;
-    var rect = node.getBoundingClientRect();
-    var width = rect.width;
-    this._effect = new KeyframeEffect(node, [ {
-      width: width / 2 + 'px'
-    }, {
-      width: width + 'px'
-    } ], this.timingFromConfig(config));
-    return this._effect;
-  }
-});
-
-Polymer({
-  is: 'paper-menu-shrink-width-animation',
-  behaviors: [ Polymer.NeonAnimationBehavior ],
-  configure: function(config) {
-    var node = config.node;
-    var rect = node.getBoundingClientRect();
-    var width = rect.width;
-    this._effect = new KeyframeEffect(node, [ {
-      width: width + 'px'
-    }, {
-      width: width - width / 20 + 'px'
-    } ], this.timingFromConfig(config));
-    return this._effect;
-  }
-});
-
-Polymer({
-  is: 'paper-menu-shrink-height-animation',
-  behaviors: [ Polymer.NeonAnimationBehavior ],
-  configure: function(config) {
-    var node = config.node;
-    var rect = node.getBoundingClientRect();
-    var height = rect.height;
-    var top = rect.top;
-    this.setPrefixedProperty(node, 'transformOrigin', '0 0');
-    this._effect = new KeyframeEffect(node, [ {
-      height: height + 'px',
-      transform: 'translateY(0)'
-    }, {
-      height: height / 2 + 'px',
-      transform: 'translateY(-20px)'
-    } ], this.timingFromConfig(config));
-    return this._effect;
-  }
-});
-
-// 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 SLIDE_CUBIC_BEZIER = 'cubic-bezier(0.3, 0.95, 0.5, 1)';
-
-Polymer({
-  is: 'cr-shared-menu',
-  behaviors: [ Polymer.IronA11yKeysBehavior ],
-  properties: {
-    menuOpen: {
-      type: Boolean,
-      observer: 'menuOpenChanged_',
-      value: false,
-      notify: true
-    },
-    itemData: {
-      type: Object,
-      value: null
-    },
-    keyEventTarget: {
-      type: Object,
-      value: function() {
-        return this.$.menu;
-      }
-    },
-    openAnimationConfig: {
-      type: Object,
-      value: function() {
-        return [ {
-          name: 'fade-in-animation',
-          timing: {
-            delay: 50,
-            duration: 200
-          }
-        }, {
-          name: 'paper-menu-grow-width-animation',
-          timing: {
-            delay: 50,
-            duration: 150,
-            easing: SLIDE_CUBIC_BEZIER
-          }
-        }, {
-          name: 'paper-menu-grow-height-animation',
-          timing: {
-            delay: 100,
-            duration: 275,
-            easing: SLIDE_CUBIC_BEZIER
-          }
-        } ];
-      }
-    },
-    closeAnimationConfig: {
-      type: Object,
-      value: function() {
-        return [ {
-          name: 'fade-out-animation',
-          timing: {
-            duration: 150
-          }
-        } ];
-      }
-    }
-  },
-  keyBindings: {
-    tab: 'onTabPressed_'
-  },
-  listeners: {
-    'dropdown.iron-overlay-canceled': 'onOverlayCanceled_'
-  },
-  lastAnchor_: null,
-  firstFocus_: null,
-  lastFocus_: null,
-  attached: function() {
-    window.addEventListener('resize', this.closeMenu.bind(this));
-  },
-  closeMenu: function() {
-    if (this.root.activeElement == null) {
-      this.$.dropdown.restoreFocusOnClose = false;
-    }
-    this.menuOpen = false;
-  },
-  openMenu: function(anchor, itemData) {
-    if (this.lastAnchor_ == anchor && this.menuOpen) return;
-    if (this.menuOpen) this.closeMenu();
-    this.itemData = itemData;
-    this.lastAnchor_ = anchor;
-    this.$.dropdown.restoreFocusOnClose = true;
-    var focusableChildren = Polymer.dom(this).querySelectorAll('[tabindex]:not([disabled]):not([hidden]),' + 'button:not([disabled]):not([hidden])');
-    if (focusableChildren.length > 0) {
-      this.$.dropdown.focusTarget = focusableChildren[0];
-      this.firstFocus_ = focusableChildren[0];
-      this.lastFocus_ = focusableChildren[focusableChildren.length - 1];
-    }
-    this.$.dropdown.positionTarget = anchor;
-    this.menuOpen = true;
-  },
-  toggleMenu: function(anchor, itemData) {
-    if (anchor == this.lastAnchor_ && this.menuOpen) this.closeMenu(); else this.openMenu(anchor, itemData);
-  },
-  onTabPressed_: function(e) {
-    if (!this.firstFocus_ || !this.lastFocus_) return;
-    var toFocus;
-    var keyEvent = e.detail.keyboardEvent;
-    if (keyEvent.shiftKey && keyEvent.target == this.firstFocus_) toFocus = this.lastFocus_; else if (!keyEvent.shiftKey && keyEvent.target == this.lastFocus_) toFocus = this.firstFocus_;
-    if (!toFocus) return;
-    e.preventDefault();
-    toFocus.focus();
-  },
-  menuOpenChanged_: function() {
-    if (!this.menuOpen) {
-      this.itemData = null;
-      this.lastAnchor_ = null;
-    }
-  },
-  onOverlayCanceled_: function(e) {
-    if (e.detail.type == 'tap') this.$.dropdown.restoreFocusOnClose = false;
-  }
-});
-
-Polymer.PaperItemBehaviorImpl = {
-  hostAttributes: {
-    role: 'option',
-    tabindex: '0'
-  }
-};
-
-Polymer.PaperItemBehavior = [ Polymer.IronButtonState, Polymer.IronControlState, Polymer.PaperItemBehaviorImpl ];
-
-Polymer({
-  is: 'paper-item',
-  behaviors: [ Polymer.PaperItemBehavior ]
-});
-
-Polymer({
-  is: 'iron-collapse',
-  behaviors: [ Polymer.IronResizableBehavior ],
-  properties: {
-    horizontal: {
-      type: Boolean,
-      value: false,
-      observer: '_horizontalChanged'
-    },
-    opened: {
-      type: Boolean,
-      value: false,
-      notify: true,
-      observer: '_openedChanged'
-    },
-    noAnimation: {
-      type: Boolean
-    },
-    _desiredSize: {
-      type: String,
-      value: ''
-    }
-  },
-  get dimension() {
-    return this.horizontal ? 'width' : 'height';
-  },
-  get _dimensionMax() {
-    return this.horizontal ? 'maxWidth' : 'maxHeight';
-  },
-  get _dimensionMaxCss() {
-    return this.horizontal ? 'max-width' : 'max-height';
-  },
-  hostAttributes: {
-    role: 'group',
-    'aria-hidden': 'true',
-    'aria-expanded': 'false'
-  },
-  listeners: {
-    transitionend: '_transitionEnd'
-  },
-  attached: function() {
-    this._transitionEnd();
-  },
-  toggle: function() {
-    this.opened = !this.opened;
-  },
-  show: function() {
-    this.opened = true;
-  },
-  hide: function() {
-    this.opened = false;
-  },
-  updateSize: function(size, animated) {
-    size = size === 'auto' ? '' : size;
-    if (this._desiredSize === size) {
-      return;
-    }
-    this._desiredSize = size;
-    this._updateTransition(false);
-    var willAnimate = animated && !this.noAnimation && this._isDisplayed;
-    if (willAnimate) {
-      var startSize = this._calcSize();
-      if (size === '') {
-        this.style[this._dimensionMax] = '';
-        size = this._calcSize();
-      }
-      this.style[this._dimensionMax] = startSize;
-      this.scrollTop = this.scrollTop;
-      this._updateTransition(true);
-      willAnimate = size !== startSize;
-    }
-    this.style[this._dimensionMax] = size;
-    if (!willAnimate) {
-      this._transitionEnd();
-    }
-  },
-  enableTransition: function(enabled) {
-    Polymer.Base._warn('`enableTransition()` is deprecated, use `noAnimation` instead.');
-    this.noAnimation = !enabled;
-  },
-  _updateTransition: function(enabled) {
-    this.style.transitionDuration = enabled && !this.noAnimation ? '' : '0s';
-  },
-  _horizontalChanged: function() {
-    this.style.transitionProperty = this._dimensionMaxCss;
-    var otherDimension = this._dimensionMax === 'maxWidth' ? 'maxHeight' : 'maxWidth';
-    this.style[otherDimension] = '';
-    this.updateSize(this.opened ? 'auto' : '0px', false);
-  },
-  _openedChanged: function() {
-    this.setAttribute('aria-expanded', this.opened);
-    this.setAttribute('aria-hidden', !this.opened);
-    this.toggleClass('iron-collapse-closed', false);
-    this.toggleClass('iron-collapse-opened', false);
-    this.updateSize(this.opened ? 'auto' : '0px', true);
-    if (this.opened) {
-      this.focus();
-    }
-  },
-  _transitionEnd: function() {
-    this.style[this._dimensionMax] = this._desiredSize;
-    this.toggleClass('iron-collapse-closed', !this.opened);
-    this.toggleClass('iron-collapse-opened', this.opened);
-    this._updateTransition(false);
-    this.notifyResize();
-  },
-  get _isDisplayed() {
-    var rect = this.getBoundingClientRect();
-    for (var prop in rect) {
-      if (rect[prop] !== 0) return true;
-    }
-    return false;
-  },
-  _calcSize: function() {
-    return this.getBoundingClientRect()[this.dimension] + 'px';
-  }
-});
-
-// Copyright (c) 2011 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 EventTrackerEntry;
-
-function EventTracker() {
-  this.listeners_ = [];
-}
-
-EventTracker.prototype = {
-  add: function(target, eventType, listener, opt_capture) {
-    var capture = !!opt_capture;
-    var h = {
-      target: target,
-      eventType: eventType,
-      listener: listener,
-      capture: capture
-    };
-    this.listeners_.push(h);
-    target.addEventListener(eventType, listener, capture);
-  },
-  remove: function(target, eventType) {
-    this.listeners_ = this.listeners_.filter(function(h) {
-      if (h.target == target && (!eventType || h.eventType == eventType)) {
-        EventTracker.removeEventListener_(h);
-        return false;
-      }
-      return true;
-    });
-  },
-  removeAll: function() {
-    this.listeners_.forEach(EventTracker.removeEventListener_);
-    this.listeners_ = [];
-  }
-};
-
-EventTracker.removeEventListener_ = function(h) {
-  h.target.removeEventListener(h.eventType, h.listener, h.capture);
-};
-
-// Copyright 2014 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.ui', function() {
-  function FocusRow(root, boundary, opt_delegate) {
-    this.root = root;
-    this.boundary_ = boundary || document.documentElement;
-    this.delegate = opt_delegate;
-    this.eventTracker = new EventTracker();
-  }
-  FocusRow.Delegate = function() {};
-  FocusRow.Delegate.prototype = {
-    onKeydown: assertNotReached,
-    onFocus: assertNotReached
-  };
-  FocusRow.ACTIVE_CLASS = 'focus-row-active';
-  FocusRow.isFocusable = function(element) {
-    if (!element || element.disabled) return false;
-    function isVisible(element) {
-      assertInstanceof(element, Element);
-      var style = window.getComputedStyle(element);
-      if (style.visibility == 'hidden' || style.display == 'none') return false;
-      var parent = element.parentNode;
-      if (!parent) return false;
-      if (parent == element.ownerDocument || parent instanceof DocumentFragment) return true;
-      return isVisible(parent);
-    }
-    return isVisible(element);
-  };
-  FocusRow.prototype = {
-    addItem: function(type, query) {
-      assert(type);
-      var element = this.root.querySelector(query);
-      if (!element) return false;
-      element.setAttribute('focus-type', type);
-      element.tabIndex = this.isActive() ? 0 : -1;
-      this.eventTracker.add(element, 'blur', this.onBlur_.bind(this));
-      this.eventTracker.add(element, 'focus', this.onFocus_.bind(this));
-      this.eventTracker.add(element, 'keydown', this.onKeydown_.bind(this));
-      this.eventTracker.add(element, 'mousedown', this.onMousedown_.bind(this));
-      return true;
-    },
-    destroy: function() {
-      this.eventTracker.removeAll();
-    },
-    getCustomEquivalent: function(sampleElement) {
-      return assert(this.getFirstFocusable());
-    },
-    getElements: function() {
-      var elements = this.root.querySelectorAll('[focus-type]');
-      return Array.prototype.slice.call(elements);
-    },
-    getEquivalentElement: function(sampleElement) {
-      if (this.getFocusableElements().indexOf(sampleElement) >= 0) return sampleElement;
-      var sampleFocusType = this.getTypeForElement(sampleElement);
-      if (sampleFocusType) {
-        var sameType = this.getFirstFocusable(sampleFocusType);
-        if (sameType) return sameType;
-      }
-      return this.getCustomEquivalent(sampleElement);
-    },
-    getFirstFocusable: function(opt_type) {
-      var filter = opt_type ? '="' + opt_type + '"' : '';
-      var elements = this.root.querySelectorAll('[focus-type' + filter + ']');
-      for (var i = 0; i < elements.length; ++i) {
-        if (cr.ui.FocusRow.isFocusable(elements[i])) return elements[i];
-      }
-      return null;
-    },
-    getFocusableElements: function() {
-      return this.getElements().filter(cr.ui.FocusRow.isFocusable);
-    },
-    getTypeForElement: function(element) {
-      return element.getAttribute('focus-type') || '';
-    },
-    isActive: function() {
-      return this.root.classList.contains(FocusRow.ACTIVE_CLASS);
-    },
-    makeActive: function(active) {
-      if (active == this.isActive()) return;
-      this.getElements().forEach(function(element) {
-        element.tabIndex = active ? 0 : -1;
-      });
-      this.root.classList.toggle(FocusRow.ACTIVE_CLASS, active);
-    },
-    onBlur_: function(e) {
-      if (!this.boundary_.contains(e.relatedTarget)) return;
-      var currentTarget = e.currentTarget;
-      if (this.getFocusableElements().indexOf(currentTarget) >= 0) this.makeActive(false);
-    },
-    onFocus_: function(e) {
-      if (this.delegate) this.delegate.onFocus(this, e);
-    },
-    onMousedown_: function(e) {
-      if (e.button) return;
-      if (!e.currentTarget.disabled) e.currentTarget.tabIndex = 0;
-    },
-    onKeydown_: function(e) {
-      var elements = this.getFocusableElements();
-      var currentElement = e.currentTarget;
-      var elementIndex = elements.indexOf(currentElement);
-      assert(elementIndex >= 0);
-      if (this.delegate && this.delegate.onKeydown(this, e)) return;
-      if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) return;
-      var index = -1;
-      if (e.key == 'ArrowLeft') index = elementIndex + (isRTL() ? 1 : -1); else if (e.key == 'ArrowRight') index = elementIndex + (isRTL() ? -1 : 1); else if (e.key == 'Home') index = 0; else if (e.key == 'End') index = elements.length - 1;
-      var elementToFocus = elements[index];
-      if (elementToFocus) {
-        this.getEquivalentElement(elementToFocus).focus();
-        e.preventDefault();
-      }
-    }
-  };
-  return {
-    FocusRow: FocusRow
-  };
-});
-
-// 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(2);
-    } else {
-      supportedScaleFactors.push(window.devicePixelRatio);
-    }
-    return supportedScaleFactors;
-  }
-  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 getFavicon(url, opt_size, opt_type) {
-    var size = opt_size || 16;
-    var type = opt_type || 'favicon';
-    return getImageSet('chrome://' + type + '/size/' + size + '@scalefactorx/' + (FAVICON_URL_REGEX.test(url) ? 'iconurl/' : '') + url);
-  }
-  return {
-    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,
-    searchTerm: String
-  },
-  observers: [ 'setSearchedTextToBold_(title, searchTerm)' ],
-  setSearchedTextToBold_: function() {
-    var i = 0;
-    var titleText = this.title;
-    if (this.searchTerm == '' || this.searchTerm == null) {
-      this.textContent = titleText;
-      return;
-    }
-    var re = new RegExp(quoteString(this.searchTerm), 'gim');
-    var match;
-    this.textContent = '';
-    while (match = re.exec(titleText)) {
-      if (match.index > i) this.appendChild(document.createTextNode(titleText.slice(i, match.index)));
-      i = re.lastIndex;
-      var b = document.createElement('b');
-      b.textContent = titleText.substring(match.index, i);
-      this.appendChild(b);
-    }
-    if (i < titleText.length) this.appendChild(document.createTextNode(titleText.slice(i)));
-  }
-});
-
-// 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.
-function HistoryFocusRow(root, boundary, delegate) {
-  cr.ui.FocusRow.call(this, root, boundary, delegate);
-  this.addItems();
-}
-
-HistoryFocusRow.prototype = {
-  __proto__: cr.ui.FocusRow.prototype,
-  getCustomEquivalent: function(sampleElement) {
-    var equivalent;
-    if (this.getTypeForElement(sampleElement) == 'star') equivalent = this.getFirstFocusable('title');
-    return equivalent || cr.ui.FocusRow.prototype.getCustomEquivalent.call(this, sampleElement);
-  },
-  addItems: function() {
-    this.destroy();
-    assert(this.addItem('checkbox', '#checkbox'));
-    assert(this.addItem('title', '#title'));
-    assert(this.addItem('menu-button', '#menu-button'));
-    this.addItem('star', '#bookmark-star');
-  }
-};
-
-cr.define('md_history', function() {
-  function FocusRowDelegate(historyItemElement) {
-    this.historyItemElement = historyItemElement;
-  }
-  FocusRowDelegate.prototype = {
-    onFocus: function(row, e) {
-      this.historyItemElement.lastFocused = e.path[0];
-    },
-    onKeydown: function(row, e) {
-      if (e.key == 'Enter') e.stopPropagation();
-      return false;
-    }
-  };
-  var HistoryItem = Polymer({
-    is: 'history-item',
-    properties: {
-      item: {
-        type: Object,
-        observer: 'showIcon_'
-      },
-      searchTerm: {
-        type: String
-      },
-      selected: {
-        type: Boolean,
-        reflectToAttribute: true
-      },
-      isCardStart: {
-        type: Boolean,
-        reflectToAttribute: true
-      },
-      isCardEnd: {
-        type: Boolean,
-        reflectToAttribute: true
-      },
-      embedded: {
-        type: Boolean,
-        reflectToAttribute: true
-      },
-      hasTimeGap: {
-        type: Boolean
-      },
-      numberOfItems: {
-        type: Number
-      },
-      path: String,
-      index: Number,
-      lastFocused: {
-        type: Object,
-        notify: true
-      },
-      ironListTabIndex: {
-        type: Number,
-        observer: 'ironListTabIndexChanged_'
-      }
-    },
-    row_: null,
-    attached: function() {
-      Polymer.RenderStatus.afterNextRender(this, function() {
-        this.row_ = new HistoryFocusRow(this.$['sizing-container'], null, new FocusRowDelegate(this));
-        this.row_.makeActive(this.ironListTabIndex == 0);
-        this.listen(this, 'focus', 'onFocus_');
-        this.listen(this, 'dom-change', 'onDomChange_');
-      });
-    },
-    detached: function() {
-      this.unlisten(this, 'focus', 'onFocus_');
-      this.unlisten(this, 'dom-change', 'onDomChange_');
-      if (this.row_) this.row_.destroy();
-    },
-    onFocus_: function() {
-      if (this.lastFocused) this.row_.getEquivalentElement(this.lastFocused).focus(); else this.row_.getFirstFocusable().focus();
-      this.tabIndex = -1;
-    },
-    ironListTabIndexChanged_: function() {
-      if (this.row_) this.row_.makeActive(this.ironListTabIndex == 0);
-    },
-    onDomChange_: function() {
-      if (this.row_) this.row_.addItems();
-    },
-    onCheckboxSelected_: function(e) {
-      this.fire('history-checkbox-select', {
-        element: this,
-        shiftKey: e.shiftKey
-      });
-      e.preventDefault();
-    },
-    onCheckboxMousedown_: function(e) {
-      if (e.shiftKey) e.preventDefault();
-    },
-    getEntrySummary_: function() {
-      var item = this.item;
-      return loadTimeData.getStringF('entrySummary', item.dateTimeOfDay, item.starred ? loadTimeData.getString('bookmarked') : '', item.title, item.domain);
-    },
-    getAriaChecked_: function(selected) {
-      return selected ? 'true' : 'false';
-    },
-    onRemoveBookmarkTap_: function() {
-      if (!this.item.starred) return;
-      if (this.$$('#bookmark-star') == this.root.activeElement) this.$['menu-button'].focus();
-      var browserService = md_history.BrowserService.getInstance();
-      browserService.removeBookmark(this.item.url);
-      browserService.recordAction('BookmarkStarClicked');
-      this.fire('remove-bookmark-stars', this.item.url);
-    },
-    onMenuButtonTap_: function(e) {
-      this.fire('toggle-menu', {
-        target: Polymer.dom(e).localTarget,
-        index: this.index,
-        item: this.item,
-        path: this.path
-      });
-      e.stopPropagation();
-    },
-    onLinkClick_: function() {
-      var browserService = md_history.BrowserService.getInstance();
-      browserService.recordAction('EntryLinkClick');
-      if (this.searchTerm) browserService.recordAction('SearchResultClick');
-      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.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);
-    }
-  });
-  HistoryItem.needsTimeGap = function(visits, currentIndex, searchedTerm) {
-    if (currentIndex >= visits.length - 1 || visits.length == 0) return false;
-    var currentItem = visits[currentIndex];
-    var nextItem = visits[currentIndex + 1];
-    if (searchedTerm) return currentItem.dateShort != nextItem.dateShort;
-    return currentItem.time - nextItem.time > BROWSING_GAP_TIME && currentItem.dateRelativeDay == nextItem.dateRelativeDay;
-  };
-  return {
-    HistoryItem: HistoryItem
-  };
-});
-
-// 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 SelectionTreeNode = function(currentPath) {
-  this.currentPath = currentPath;
-  this.leaf = false;
-  this.indexes = [];
-  this.children = [];
-};
-
-SelectionTreeNode.prototype.addChild = function(index, path) {
-  this.indexes.push(index);
-  this.children[index] = new SelectionTreeNode(path);
-};
-
-var HistoryListBehavior = {
-  properties: {
-    selectedPaths: {
-      type: Object,
-      value: function() {
-        return new Set();
-      }
-    },
-    lastSelectedPath: String
-  },
-  listeners: {
-    'history-checkbox-select': 'itemSelected_'
-  },
-  hasResults: function(historyDataLength) {
-    return historyDataLength > 0;
-  },
-  noResultsMessage: function(searchedTerm, isLoading) {
-    if (isLoading) return '';
-    var messageId = searchedTerm !== '' ? 'noSearchResults' : 'noResults';
-    return loadTimeData.getString(messageId);
-  },
-  unselectAllItems: function() {
-    this.selectedPaths.forEach(function(path) {
-      this.set(path + '.selected', false);
-    }.bind(this));
-    this.selectedPaths.clear();
-  },
-  deleteSelected: function() {
-    var toBeRemoved = Array.from(this.selectedPaths.values()).map(function(path) {
-      return this.get(path);
-    }.bind(this));
-    md_history.BrowserService.getInstance().deleteItems(toBeRemoved).then(function() {
-      this.removeItemsByPath(Array.from(this.selectedPaths));
-      this.fire('unselect-all');
-    }.bind(this));
-  },
-  removeItemsByPath: function(paths) {
-    if (paths.length == 0) return;
-    this.removeItemsBeneathNode_(this.buildRemovalTree_(paths));
-  },
-  buildRemovalTree_: function(paths) {
-    var rootNode = new SelectionTreeNode(paths[0].split('.')[0]);
-    paths.forEach(function(path) {
-      var components = path.split('.');
-      var node = rootNode;
-      components.shift();
-      while (components.length > 1) {
-        var index = Number(components.shift());
-        var arrayName = components.shift();
-        if (!node.children[index]) node.addChild(index, [ node.currentPath, index, arrayName ].join('.'));
-        node = node.children[index];
-      }
-      node.leaf = true;
-      node.indexes.push(Number(components.shift()));
-    });
-    return rootNode;
-  },
-  removeItemsBeneathNode_: function(node) {
-    var array = this.get(node.currentPath);
-    var splices = [];
-    node.indexes.sort(function(a, b) {
-      return b - a;
-    });
-    node.indexes.forEach(function(index) {
-      if (node.leaf || this.removeItemsBeneathNode_(node.children[index])) {
-        var item = array.splice(index, 1)[0];
-        splices.push({
-          index: index,
-          removed: [ item ],
-          addedCount: 0,
-          object: array,
-          type: 'splice'
-        });
-      }
-    }.bind(this));
-    if (array.length == 0 && node.currentPath.indexOf('.') != -1) return true;
-    this.notifySplices(node.currentPath, splices);
-    return false;
-  },
-  itemSelected_: function(e) {
-    var item = e.detail.element;
-    var paths = [];
-    var itemPath = item.path;
-    if (e.detail.shiftKey && this.lastSelectedPath) {
-      var itemPathComponents = itemPath.split('.');
-      var itemIndex = Number(itemPathComponents.pop());
-      var itemArrayPath = itemPathComponents.join('.');
-      var lastItemPathComponents = this.lastSelectedPath.split('.');
-      var lastItemIndex = Number(lastItemPathComponents.pop());
-      if (itemArrayPath == lastItemPathComponents.join('.')) {
-        for (var i = Math.min(itemIndex, lastItemIndex); i <= Math.max(itemIndex, lastItemIndex); i++) {
-          paths.push(itemArrayPath + '.' + i);
-        }
-      }
-    }
-    if (paths.length == 0) paths.push(item.path);
-    var selected = !this.selectedPaths.has(item.path);
-    paths.forEach(function(path) {
-      this.set(path + '.selected', selected);
-      if (selected) {
-        this.selectedPaths.add(path);
-        return;
-      }
-      this.selectedPaths.delete(path);
-    }.bind(this));
-    this.lastSelectedPath = itemPath;
-  }
-};
-
-// 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 HistoryDomain;
-
-var HistoryGroup;
-
-Polymer({
-  is: 'history-grouped-list',
-  behaviors: [ HistoryListBehavior ],
-  properties: {
-    historyData: {
-      type: Array
-    },
-    groupedHistoryData_: {
-      type: Array
-    },
-    searchedTerm: {
-      type: String,
-      value: ''
-    },
-    range: {
-      type: Number
-    },
-    queryStartTime: String,
-    queryEndTime: String
-  },
-  observers: [ 'updateGroupedHistoryData_(range, historyData)' ],
-  createHistoryDomains_: function(visits) {
-    var domainIndexes = {};
-    var domains = [];
-    for (var i = 0, visit; visit = visits[i]; i++) {
-      var domain = visit.domain;
-      if (domainIndexes[domain] == undefined) {
-        domainIndexes[domain] = domains.length;
-        domains.push({
-          domain: domain,
-          visits: [],
-          expanded: false,
-          rendered: false
-        });
-      }
-      domains[domainIndexes[domain]].visits.push(visit);
-    }
-    var sortByVisits = function(a, b) {
-      return b.visits.length - a.visits.length;
-    };
-    domains.sort(sortByVisits);
-    return domains;
-  },
-  updateGroupedHistoryData_: function() {
-    if (this.historyData.length == 0) {
-      this.groupedHistoryData_ = [];
-      return;
-    }
-    if (this.range == HistoryRange.WEEK) {
-      var days = [];
-      var currentDayVisits = [ this.historyData[0] ];
-      var pushCurrentDay = function() {
-        days.push({
-          title: this.searchedTerm ? currentDayVisits[0].dateShort : currentDayVisits[0].dateRelativeDay,
-          domains: this.createHistoryDomains_(currentDayVisits)
-        });
-      }.bind(this);
-      var visitsSameDay = function(a, b) {
-        if (this.searchedTerm) return a.dateShort == b.dateShort;
-        return a.dateRelativeDay == b.dateRelativeDay;
-      }.bind(this);
-      for (var i = 1; i < this.historyData.length; i++) {
-        var visit = this.historyData[i];
-        if (!visitsSameDay(visit, currentDayVisits[0])) {
-          pushCurrentDay();
-          currentDayVisits = [];
-        }
-        currentDayVisits.push(visit);
-      }
-      pushCurrentDay();
-      this.groupedHistoryData_ = days;
-    } else if (this.range == HistoryRange.MONTH) {
-      this.groupedHistoryData_ = [ {
-        title: this.queryStartTime + ' – ' + this.queryEndTime,
-        domains: this.createHistoryDomains_(this.historyData)
-      } ];
-    }
-  },
-  toggleDomainExpanded_: function(e) {
-    var collapse = e.currentTarget.parentNode.querySelector('iron-collapse');
-    e.model.set('domain.rendered', true);
-    setTimeout(function() {
-      collapse.toggle();
-    }, 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.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;
   var HIDDEN_Y = '-10000px';
   var DEFAULT_GRID_SIZE = 200;
   var SECRET_TABINDEX = -100;
   Polymer({
     is: 'iron-list',
     properties: {
@@ skipping 933 matching lines @@
       this._setLowerTriggered(true);
       this.fire('lower-threshold');
     }
   },
   clearTriggers: function() {
     this._setUpperTriggered(false);
     this._setLowerTriggered(false);
   }
 });
 
+// Copyright (c) 2011 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 EventTrackerEntry;
+
+function EventTracker() {
+  this.listeners_ = [];
+}
+
+EventTracker.prototype = {
+  add: function(target, eventType, listener, opt_capture) {
+    var capture = !!opt_capture;
+    var h = {
+      target: target,
+      eventType: eventType,
+      listener: listener,
+      capture: capture
+    };
+    this.listeners_.push(h);
+    target.addEventListener(eventType, listener, capture);
+  },
+  remove: function(target, eventType) {
+    this.listeners_ = this.listeners_.filter(function(h) {
+      if (h.target == target && (!eventType || h.eventType == eventType)) {
+        EventTracker.removeEventListener_(h);
+        return false;
+      }
+      return true;
+    });
+  },
+  removeAll: function() {
+    this.listeners_.forEach(EventTracker.removeEventListener_);
+    this.listeners_ = [];
+  }
+};
+
+EventTracker.removeEventListener_ = function(h) {
+  h.target.removeEventListener(h.eventType, h.listener, h.capture);
+};
+
+// Copyright 2014 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.ui', function() {
+  function FocusRow(root, boundary, opt_delegate) {
+    this.root = root;
+    this.boundary_ = boundary || document.documentElement;
+    this.delegate = opt_delegate;
+    this.eventTracker = new EventTracker();
+  }
+  FocusRow.Delegate = function() {};
+  FocusRow.Delegate.prototype = {
+    onKeydown: assertNotReached,
+    onFocus: assertNotReached
+  };
+  FocusRow.ACTIVE_CLASS = 'focus-row-active';
+  FocusRow.isFocusable = function(element) {
+    if (!element || element.disabled) return false;
+    function isVisible(element) {
+      assertInstanceof(element, Element);
+      var style = window.getComputedStyle(element);
+      if (style.visibility == 'hidden' || style.display == 'none') return false;
+      var parent = element.parentNode;
+      if (!parent) return false;
+      if (parent == element.ownerDocument || parent instanceof DocumentFragment) return true;
+      return isVisible(parent);
+    }
+    return isVisible(element);
+  };
+  FocusRow.prototype = {
+    addItem: function(type, query) {
+      assert(type);
+      var element = this.root.querySelector(query);
+      if (!element) return false;
+      element.setAttribute('focus-type', type);
+      element.tabIndex = this.isActive() ? 0 : -1;
+      this.eventTracker.add(element, 'blur', this.onBlur_.bind(this));
+      this.eventTracker.add(element, 'focus', this.onFocus_.bind(this));
+      this.eventTracker.add(element, 'keydown', this.onKeydown_.bind(this));
+      this.eventTracker.add(element, 'mousedown', this.onMousedown_.bind(this));
+      return true;
+    },
+    destroy: function() {
+      this.eventTracker.removeAll();
+    },
+    getCustomEquivalent: function(sampleElement) {
+      return assert(this.getFirstFocusable());
+    },
+    getElements: function() {
+      var elements = this.root.querySelectorAll('[focus-type]');
+      return Array.prototype.slice.call(elements);
+    },
+    getEquivalentElement: function(sampleElement) {
+      if (this.getFocusableElements().indexOf(sampleElement) >= 0) return sampleElement;
+      var sampleFocusType = this.getTypeForElement(sampleElement);
+      if (sampleFocusType) {
+        var sameType = this.getFirstFocusable(sampleFocusType);
+        if (sameType) return sameType;
+      }
+      return this.getCustomEquivalent(sampleElement);
+    },
+    getFirstFocusable: function(opt_type) {
+      var filter = opt_type ? '="' + opt_type + '"' : '';
+      var elements = this.root.querySelectorAll('[focus-type' + filter + ']');
+      for (var i = 0; i < elements.length; ++i) {
+        if (cr.ui.FocusRow.isFocusable(elements[i])) return elements[i];
+      }
+      return null;
+    },
+    getFocusableElements: function() {
+      return this.getElements().filter(cr.ui.FocusRow.isFocusable);
+    },
+    getTypeForElement: function(element) {
+      return element.getAttribute('focus-type') || '';
+    },
+    isActive: function() {
+      return this.root.classList.contains(FocusRow.ACTIVE_CLASS);
+    },
+    makeActive: function(active) {
+      if (active == this.isActive()) return;
+      this.getElements().forEach(function(element) {
+        element.tabIndex = active ? 0 : -1;
+      });
+      this.root.classList.toggle(FocusRow.ACTIVE_CLASS, active);
+    },
+    onBlur_: function(e) {
+      if (!this.boundary_.contains(e.relatedTarget)) return;
+      var currentTarget = e.currentTarget;
+      if (this.getFocusableElements().indexOf(currentTarget) >= 0) this.makeActive(false);
+    },
+    onFocus_: function(e) {
+      if (this.delegate) this.delegate.onFocus(this, e);
+    },
+    onMousedown_: function(e) {
+      if (e.button) return;
+      if (!e.currentTarget.disabled) e.currentTarget.tabIndex = 0;
+    },
+    onKeydown_: function(e) {
+      var elements = this.getFocusableElements();
+      var currentElement = e.currentTarget;
+      var elementIndex = elements.indexOf(currentElement);
+      assert(elementIndex >= 0);
+      if (this.delegate && this.delegate.onKeydown(this, e)) return;
+      if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) return;
+      var index = -1;
+      if (e.key == 'ArrowLeft') index = elementIndex + (isRTL() ? 1 : -1); else if (e.key == 'ArrowRight') index = elementIndex + (isRTL() ? -1 : 1); else if (e.key == 'Home') index = 0; else if (e.key == 'End') index = elements.length - 1;
+      var elementToFocus = elements[index];
+      if (elementToFocus) {
+        this.getEquivalentElement(elementToFocus).focus();
+        e.preventDefault();
+      }
+    }
+  };
+  return {
+    FocusRow: FocusRow
+  };
+});
+
+// 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(2);
+    } else {
+      supportedScaleFactors.push(window.devicePixelRatio);
+    }
+    return supportedScaleFactors;
+  }
+  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 getFavicon(url, opt_size, opt_type) {
+    var size = opt_size || 16;
+    var type = opt_type || 'favicon';
+    return getImageSet('chrome://' + type + '/size/' + size + '@scalefactorx/' + (FAVICON_URL_REGEX.test(url) ? 'iconurl/' : '') + url);
+  }
+  return {
+    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,
+    searchTerm: String
+  },
+  observers: [ 'setSearchedTextToBold_(title, searchTerm)' ],
+  setSearchedTextToBold_: function() {
+    var i = 0;
+    var titleText = this.title;
+    if (this.searchTerm == '' || this.searchTerm == null) {
+      this.textContent = titleText;
+      return;
+    }
+    var re = new RegExp(quoteString(this.searchTerm), 'gim');
+    var match;
+    this.textContent = '';
+    while (match = re.exec(titleText)) {
+      if (match.index > i) this.appendChild(document.createTextNode(titleText.slice(i, match.index)));
+      i = re.lastIndex;
+      var b = document.createElement('b');
+      b.textContent = titleText.substring(match.index, i);
+      this.appendChild(b);
+    }
+    if (i < titleText.length) this.appendChild(document.createTextNode(titleText.slice(i)));
+  }
+});
+
 // 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.
+function HistoryFocusRow(root, boundary, delegate) {
+  cr.ui.FocusRow.call(this, root, boundary, delegate);
+  this.addItems();
+}
+
+HistoryFocusRow.prototype = {
+  __proto__: cr.ui.FocusRow.prototype,
+  getCustomEquivalent: function(sampleElement) {
+    var equivalent;
+    if (this.getTypeForElement(sampleElement) == 'star') equivalent = this.getFirstFocusable('title');
+    return equivalent || cr.ui.FocusRow.prototype.getCustomEquivalent.call(this, sampleElement);
+  },
+  addItems: function() {
+    this.destroy();
+    assert(this.addItem('checkbox', '#checkbox'));
+    assert(this.addItem('title', '#title'));
+    assert(this.addItem('menu-button', '#menu-button'));
+    this.addItem('star', '#bookmark-star');
+  }
+};
+
+cr.define('md_history', function() {
+  function FocusRowDelegate(historyItemElement) {
+    this.historyItemElement = historyItemElement;
+  }
+  FocusRowDelegate.prototype = {
+    onFocus: function(row, e) {
+      this.historyItemElement.lastFocused = e.path[0];
+    },
+    onKeydown: function(row, e) {
+      if (e.key == 'Enter') e.stopPropagation();
+      return false;
+    }
+  };
+  var HistoryItem = Polymer({
+    is: 'history-item',
+    properties: {
+      item: {
+        type: Object,
+        observer: 'showIcon_'
+      },
+      searchTerm: {
+        type: String
+      },
+      selected: {
+        type: Boolean,
+        reflectToAttribute: true
+      },
+      isCardStart: {
+        type: Boolean,
+        reflectToAttribute: true
+      },
+      isCardEnd: {
+        type: Boolean,
+        reflectToAttribute: true
+      },
+      embedded: {
+        type: Boolean,
+        reflectToAttribute: true
+      },
+      hasTimeGap: {
+        type: Boolean
+      },
+      numberOfItems: {
+        type: Number
+      },
+      path: String,
+      index: Number,
+      lastFocused: {
+        type: Object,
+        notify: true
+      },
+      ironListTabIndex: {
+        type: Number,
+        observer: 'ironListTabIndexChanged_'
+      }
+    },
+    row_: null,
+    attached: function() {
+      Polymer.RenderStatus.afterNextRender(this, function() {
+        this.row_ = new HistoryFocusRow(this.$['sizing-container'], null, new FocusRowDelegate(this));
+        this.row_.makeActive(this.ironListTabIndex == 0);
+        this.listen(this, 'focus', 'onFocus_');
+        this.listen(this, 'dom-change', 'onDomChange_');
+      });
+    },
+    detached: function() {
+      this.unlisten(this, 'focus', 'onFocus_');
+      this.unlisten(this, 'dom-change', 'onDomChange_');
+      if (this.row_) this.row_.destroy();
+    },
+    onFocus_: function() {
+      if (this.lastFocused) this.row_.getEquivalentElement(this.lastFocused).focus(); else this.row_.getFirstFocusable().focus();
+      this.tabIndex = -1;
+    },
+    ironListTabIndexChanged_: function() {
+      if (this.row_) this.row_.makeActive(this.ironListTabIndex == 0);
+    },
+    onDomChange_: function() {
+      if (this.row_) this.row_.addItems();
+    },
+    onCheckboxSelected_: function(e) {
+      this.fire('history-checkbox-select', {
+        element: this,
+        shiftKey: e.shiftKey
+      });
+      e.preventDefault();
+    },
+    onCheckboxMousedown_: function(e) {
+      if (e.shiftKey) e.preventDefault();
+    },
+    getEntrySummary_: function() {
+      var item = this.item;
+      return loadTimeData.getStringF('entrySummary', item.dateTimeOfDay, item.starred ? loadTimeData.getString('bookmarked') : '', item.title, item.domain);
+    },
+    getAriaChecked_: function(selected) {
+      return selected ? 'true' : 'false';
+    },
+    onRemoveBookmarkTap_: function() {
+      if (!this.item.starred) return;
+      if (this.$$('#bookmark-star') == this.root.activeElement) this.$['menu-button'].focus();
+      var browserService = md_history.BrowserService.getInstance();
+      browserService.removeBookmark(this.item.url);
+      browserService.recordAction('BookmarkStarClicked');
+      this.fire('remove-bookmark-stars', this.item.url);
+    },
+    onMenuButtonTap_: function(e) {
+      this.fire('toggle-menu', {
+        target: Polymer.dom(e).localTarget,
+        index: this.index,
+        item: this.item,
+        path: this.path
+      });
+      e.stopPropagation();
+    },
+    onLinkClick_: function() {
+      var browserService = md_history.BrowserService.getInstance();
+      browserService.recordAction('EntryLinkClick');
+      if (this.searchTerm) browserService.recordAction('SearchResultClick');
+      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.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);
+    }
+  });
+  HistoryItem.needsTimeGap = function(visits, currentIndex, searchedTerm) {
+    if (currentIndex >= visits.length - 1 || visits.length == 0) return false;
+    var currentItem = visits[currentIndex];
+    var nextItem = visits[currentIndex + 1];
+    if (searchedTerm) return currentItem.dateShort != nextItem.dateShort;
+    return currentItem.time - nextItem.time > BROWSING_GAP_TIME && currentItem.dateRelativeDay == nextItem.dateRelativeDay;
+  };
+  return {
+    HistoryItem: HistoryItem
+  };
+});
+
+// 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 SelectionTreeNode = function(currentPath) {
+  this.currentPath = currentPath;
+  this.leaf = false;
+  this.indexes = [];
+  this.children = [];
+};
+
+SelectionTreeNode.prototype.addChild = function(index, path) {
+  this.indexes.push(index);
+  this.children[index] = new SelectionTreeNode(path);
+};
+
+var HistoryListBehavior = {
+  properties: {
+    selectedPaths: {
+      type: Object,
+      value: function() {
+        return new Set();
+      }
+    },
+    lastSelectedPath: String
+  },
+  listeners: {
+    'history-checkbox-select': 'itemSelected_'
+  },
+  hasResults: function(historyDataLength) {
+    return historyDataLength > 0;
+  },
+  noResultsMessage: function(searchedTerm, isLoading) {
+    if (isLoading) return '';
+    var messageId = searchedTerm !== '' ? 'noSearchResults' : 'noResults';
+    return loadTimeData.getString(messageId);
+  },
+  unselectAllItems: function() {
+    this.selectedPaths.forEach(function(path) {
+      this.set(path + '.selected', false);
+    }.bind(this));
+    this.selectedPaths.clear();
+  },
+  deleteSelected: function() {
+    var toBeRemoved = Array.from(this.selectedPaths.values()).map(function(path) {
+      return this.get(path);
+    }.bind(this));
+    md_history.BrowserService.getInstance().deleteItems(toBeRemoved).then(function() {
+      this.removeItemsByPath(Array.from(this.selectedPaths));
+      this.fire('unselect-all');
+    }.bind(this));
+  },
+  removeItemsByPath: function(paths) {
+    if (paths.length == 0) return;
+    this.removeItemsBeneathNode_(this.buildRemovalTree_(paths));
+  },
+  buildRemovalTree_: function(paths) {
+    var rootNode = new SelectionTreeNode(paths[0].split('.')[0]);
+    paths.forEach(function(path) {
+      var components = path.split('.');
+      var node = rootNode;
+      components.shift();
+      while (components.length > 1) {
+        var index = Number(components.shift());
+        var arrayName = components.shift();
+        if (!node.children[index]) node.addChild(index, [ node.currentPath, index, arrayName ].join('.'));
+        node = node.children[index];
+      }
+      node.leaf = true;
+      node.indexes.push(Number(components.shift()));
+    });
+    return rootNode;
+  },
+  removeItemsBeneathNode_: function(node) {
+    var array = this.get(node.currentPath);
+    var splices = [];
+    node.indexes.sort(function(a, b) {
+      return b - a;
+    });
+    node.indexes.forEach(function(index) {
+      if (node.leaf || this.removeItemsBeneathNode_(node.children[index])) {
+        var item = array.splice(index, 1)[0];
+        splices.push({
+          index: index,
+          removed: [ item ],
+          addedCount: 0,
+          object: array,
+          type: 'splice'
+        });
+      }
+    }.bind(this));
+    if (array.length == 0 && node.currentPath.indexOf('.') != -1) return true;
+    this.notifySplices(node.currentPath, splices);
+    return false;
+  },
+  itemSelected_: function(e) {
+    var item = e.detail.element;
+    var paths = [];
+    var itemPath = item.path;
+    if (e.detail.shiftKey && this.lastSelectedPath) {
+      var itemPathComponents = itemPath.split('.');
+      var itemIndex = Number(itemPathComponents.pop());
+      var itemArrayPath = itemPathComponents.join('.');
+      var lastItemPathComponents = this.lastSelectedPath.split('.');
+      var lastItemIndex = Number(lastItemPathComponents.pop());
+      if (itemArrayPath == lastItemPathComponents.join('.')) {
+        for (var i = Math.min(itemIndex, lastItemIndex); i <= Math.max(itemIndex, lastItemIndex); i++) {
+          paths.push(itemArrayPath + '.' + i);
+        }
+      }
+    }
+    if (paths.length == 0) paths.push(item.path);
+    var selected = !this.selectedPaths.has(item.path);
+    paths.forEach(function(path) {
+      this.set(path + '.selected', selected);
+      if (selected) {
+        this.selectedPaths.add(path);
+        return;
+      }
+      this.selectedPaths.delete(path);
+    }.bind(this));
+    this.lastSelectedPath = itemPath;
+  }
+};
+
+// 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-list',
   behaviors: [ HistoryListBehavior ],
   properties: {
     searchedTerm: {
       type: String,
       value: ''
     },
     querying: Boolean,
@@ skipping 195 matching lines @@
         browserService.recordHistogram('HistoryPage.RemoveEntryPositionSubset', index, UMA_MAX_SUBSET_BUCKET_VALUE);
       }
     }.bind(this));
     menu.closeMenu();
   },
   getSelectedList_: function() {
     return this.$.content.selectedItem;
   }
 });
 
-// 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-synced-device-card',
+Polymer.IronMultiSelectableBehaviorImpl = {
   properties: {
-    device: String,
-    lastUpdateTime: String,
-    tabs: {
+    multi: {
+      type: Boolean,
+      value: false,
+      observer: 'multiChanged'
+    },
+    selectedValues: {
       type: Array,
-      value: function() {
-        return [];
-      },
-      observer: 'updateIcons_'
+      notify: true
     },
-    separatorIndexes: Array,
-    opened: Boolean,
-    searchTerm: String,
-    sessionTag: String
+    selectedItems: {
+      type: Array,
+      readOnly: true,
+      notify: true
+    }
   },
-  openTab_: function(e) {
-    var tab = e.model.tab;
-    var browserService = md_history.BrowserService.getInstance();
-    browserService.recordHistogram(SYNCED_TABS_HISTOGRAM_NAME, SyncedTabsHistogram.LINK_CLICKED, SyncedTabsHistogram.LIMIT);
-    browserService.openForeignSessionTab(this.sessionTag, tab.windowId, tab.sessionId, e);
-    e.preventDefault();
+  observers: [ '_updateSelected(selectedValues.splices)' ],
+  select: function(value) {
+    if (this.multi) {
+      if (this.selectedValues) {
+        this._toggleSelected(value);
+      } else {
+        this.selectedValues = [ value ];
+      }
+    } else {
+      this.selected = value;
+    }
   },
-  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';
+  multiChanged: function(multi) {
+    this._selection.multi = multi;
   },
-  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.getFavicon(this.tabs[i].url);
+  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);
       }
-    });
-  },
-  isWindowSeparatorIndex_: function(index, separatorIndexes) {
-    return this.separatorIndexes.indexOf(index) != -1;
-  },
-  getCollapseIcon_: function(opened) {
-    return opened ? 'cr:expand-less' : 'cr:expand-more';
-  },
-  getCollapseTitle_: function(opened) {
-    return opened ? loadTimeData.getString('collapseSessionButton') : loadTimeData.getString('expandSessionButton');
-  },
-  onMenuButtonTap_: function(e) {
-    this.fire('toggle-menu', {
-      target: Polymer.dom(e).localTarget,
-      tag: this.sessionTag
-    });
-    e.stopPropagation();
-  },
-  onLinkRightClick_: function() {
-    md_history.BrowserService.getInstance().recordHistogram(SYNCED_TABS_HISTOGRAM_NAME, SyncedTabsHistogram.LINK_RIGHT_CLICKED, SyncedTabsHistogram.LIMIT);
-  }
-});
-
-// 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 ForeignDeviceInternal;
-
-Polymer({
-  is: 'history-synced-device-manager',
-  properties: {
-    sessionList: {
-      type: Array,
-      observer: 'updateSyncedDevices'
-    },
-    searchTerm: {
-      type: String,
-      observer: 'searchTermChanged'
-    },
-    syncedDevices_: {
-      type: Array,
-      value: function() {
-        return [];
-      }
-    },
-    signInState: {
-      type: Boolean,
-      observer: 'signInStateChanged_'
-    },
-    guestSession_: {
-      type: Boolean,
-      value: loadTimeData.getBoolean('isGuestSession')
-    },
-    fetchingSyncedTabs_: {
-      type: Boolean,
-      value: false
-    },
-    hasSeenForeignData_: Boolean
-  },
-  listeners: {
-    'toggle-menu': 'onToggleMenu_',
-    scroll: 'onListScroll_'
-  },
-  attached: function() {
-    chrome.send('otherDevicesInitialized');
-    md_history.BrowserService.getInstance().recordHistogram(SYNCED_TABS_HISTOGRAM_NAME, SyncedTabsHistogram.INITIALIZED, SyncedTabsHistogram.LIMIT);
-  },
-  getContentScrollTarget: function() {
-    return this;
-  },
-  createInternalDevice_: function(session) {
-    var tabs = [];
-    var separatorIndexes = [];
-    for (var i = 0; i < session.windows.length; i++) {
-      var windowId = session.windows[i].sessionId;
-      var newTabs = session.windows[i].tabs;
-      if (newTabs.length == 0) continue;
-      newTabs.forEach(function(tab) {
-        tab.windowId = windowId;
-      });
-      var windowAdded = false;
-      if (!this.searchTerm) {
-        tabs = tabs.concat(newTabs);
-        windowAdded = true;
-      } else {
-        var searchText = this.searchTerm.toLowerCase();
-        for (var j = 0; j < newTabs.length; j++) {
-          var tab = newTabs[j];
-          if (tab.title.toLowerCase().indexOf(searchText) != -1) {
-            tabs.push(tab);
-            windowAdded = true;
-          }
+      if (this.fallbackSelection && this.items.length && !this._selection.get().length) {
+        var fallback = this._valueToItem(this.fallbackSelection);
+        if (fallback) {
+          this.selectedValues = [ this.fallbackSelection ];
         }
       }
-      if (windowAdded && i != session.windows.length - 1) separatorIndexes.push(tabs.length - 1);
-    }
-    return {
-      device: session.name,
-      lastUpdateTime: '– ' + session.modifiedTime,
-      opened: true,
-      separatorIndexes: separatorIndexes,
-      timestamp: session.timestamp,
-      tabs: tabs,
-      tag: session.tag
-    };
-  },
-  onSignInTap_: function() {
-    chrome.send('startSignInFlow');
-  },
-  onListScroll_: function() {
-    var menu = this.$.menu.getIfExists();
-    if (menu) menu.closeMenu();
-  },
-  onToggleMenu_: function(e) {
-    var menu = this.$.menu.get();
-    menu.toggleMenu(e.detail.target, e.detail.tag);
-    if (menu.menuOpen) {
-      md_history.BrowserService.getInstance().recordHistogram(SYNCED_TABS_HISTOGRAM_NAME, SyncedTabsHistogram.SHOW_SESSION_MENU, SyncedTabsHistogram.LIMIT);
+    } else {
+      this._selection.clear();
     }
   },
-  onOpenAllTap_: function() {
-    var menu = assert(this.$.menu.getIfExists());
-    var browserService = md_history.BrowserService.getInstance();
-    browserService.recordHistogram(SYNCED_TABS_HISTOGRAM_NAME, SyncedTabsHistogram.OPEN_ALL, SyncedTabsHistogram.LIMIT);
-    browserService.openForeignSessionAllTabs(menu.itemData);
-    menu.closeMenu();
-  },
-  onDeleteSessionTap_: function() {
-    var menu = assert(this.$.menu.getIfExists());
-    var browserService = md_history.BrowserService.getInstance();
-    browserService.recordHistogram(SYNCED_TABS_HISTOGRAM_NAME, SyncedTabsHistogram.HIDE_FOR_NOW, SyncedTabsHistogram.LIMIT);
-    browserService.deleteForeignSession(menu.itemData);
-    menu.closeMenu();
-  },
-  clearDisplayedSyncedDevices_: function() {
-    this.syncedDevices_ = [];
-  },
-  showNoSyncedMessage: function(signInState, syncedDevicesLength, guestSession) {
-    if (guestSession) return true;
-    return signInState && syncedDevicesLength == 0;
-  },
-  showSignInGuide: function(signInState, guestSession) {
-    var show = !signInState && !guestSession;
-    if (show) {
-      md_history.BrowserService.getInstance().recordAction('Signin_Impression_FromRecentTabs');
-    }
-    return show;
-  },
-  noSyncedTabsMessage: function(fetchingSyncedTabs) {
-    return loadTimeData.getString(fetchingSyncedTabs ? 'loading' : 'noSyncedResults');
-  },
-  updateSyncedDevices: function(sessionList) {
-    this.fetchingSyncedTabs_ = false;
-    if (!sessionList) return;
-    if (sessionList.length > 0 && !this.hasSeenForeignData_) {
-      this.hasSeenForeignData_ = true;
-      md_history.BrowserService.getInstance().recordHistogram(SYNCED_TABS_HISTOGRAM_NAME, SyncedTabsHistogram.HAS_FOREIGN_DATA, SyncedTabsHistogram.LIMIT);
-    }
-    var updateCount = Math.min(sessionList.length, this.syncedDevices_.length);
-    for (var i = 0; i < updateCount; i++) {
-      var oldDevice = this.syncedDevices_[i];
-      if (oldDevice.tag != sessionList[i].tag || oldDevice.timestamp != sessionList[i].timestamp) {
-        this.splice('syncedDevices_', i, 1, this.createInternalDevice_(sessionList[i]));
-      }
-    }
-    if (sessionList.length >= this.syncedDevices_.length) {
-      for (var i = updateCount; i < sessionList.length; i++) {
-        this.push('syncedDevices_', this.createInternalDevice_(sessionList[i]));
-      }
+  _selectionChange: function() {
+    var s = this._selection.get();
+    if (this.multi) {
+      this._setSelectedItems(s);
     } else {
-      this.splice('syncedDevices_', updateCount, this.syncedDevices_.length - updateCount);
+      this._setSelectedItems([ s ]);
+      this._setSelectedItem(s);
     }
   },
-  tabSyncDisabled: function() {
-    this.fetchingSyncedTabs_ = false;
-    this.clearDisplayedSyncedDevices_();
+  _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);
+    }
   },
-  signInStateChanged_: function() {
-    this.fire('history-view-changed');
-    if (!this.signInState) {
-      this.clearDisplayedSyncedDevices_();
-      return;
-    }
-    this.fetchingSyncedTabs_ = true;
-  },
-  searchTermChanged: function(searchTerm) {
-    this.clearDisplayedSyncedDevices_();
-    this.updateSyncedDevices(this.sessionList);
+  _valuesToItems: function(values) {
+    return values == null ? null : values.map(function(value) {
+      return this._valueToItem(value);
+    }, this);
   }
-});
+};
+
+Polymer.IronMultiSelectableBehavior = [ Polymer.IronSelectableBehavior, Polymer.IronMultiSelectableBehaviorImpl ];
 
 Polymer({
   is: 'iron-selector',
   behaviors: [ Polymer.IronMultiSelectableBehavior ]
 });
 
 // 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({
@@ skipping 28 matching lines @@
     e.preventDefault();
   },
   getQueryString_: function(route) {
     return window.location.search;
   }
 });
 
 // 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('md_history', function() {
+  var lazyLoadPromise = null;
+  function ensureLazyLoaded() {
+    if (!lazyLoadPromise) {
+      lazyLoadPromise = new Promise(function(resolve, reject) {
+        Polymer.Base.importHref('chrome://history/lazy_load.html', resolve, reject, true);
+      });
+    }
+    return lazyLoadPromise;
+  }
+  return {
+    ensureLazyLoaded: ensureLazyLoaded
+  };
+});
+
 Polymer({
   is: 'history-app',
   behaviors: [ Polymer.IronScrollTargetBehavior ],
   properties: {
     showSidebarFooter: Boolean,
     hasSyncedResults: Boolean,
     selectedPage_: {
       type: String,
       observer: 'unselectAll'
     },
@@ skipping 62 matching lines @@
       window.location.href = window.location.href.split('#')[0] + '?' + window.location.hash.substr(1);
     }
   },
   onFirstRender: function() {
     setTimeout(function() {
       chrome.send('metricsHandler:recordTime', [ 'History.ResultsRenderedTime', window.performance.now() ]);
     });
     if (!this.hasDrawer_) {
       this.focusToolbarSearchField();
     }
+    md_history.ensureLazyLoaded();
   },
   _scrollHandler: function() {
     this.toolbarShadow_ = this.scrollTarget.scrollTop != 0;
   },
   onMenuTap_: function() {
     var drawer = this.$$('#drawer');
     if (drawer) drawer.toggle();
   },
   checkboxSelected: function(e) {
     var toolbar = this.$.toolbar;
@@ skipping 112 matching lines @@
 
        case HistoryRange.MONTH:
         histogramValue = HistoryPageViewHistogram.GROUPED_MONTH;
         break;
       }
       break;
     }
     md_history.BrowserService.getInstance().recordHistogram('History.HistoryPageView', histogramValue, HistoryPageViewHistogram.END);
   }
 });