[Polymer] update third_party polymer

third_party/polymer/v1_0/components-chromium/iron-overlay-behavior/iron-overlay-manager-extracted.js

 /**
    * @struct
    * @constructor
    * @private
    */
   Polymer.IronOverlayManagerClass = function() {
     /**
      * Used to keep track of the opened overlays.
      * @private {Array<Element>}
      */
@@ skipping 19 matching lines @@
     document.addEventListener('focus', this._onCaptureFocus.bind(this), true);
     document.addEventListener('keydown', this._onCaptureKeyDown.bind(this), true);
   };
 
   Polymer.IronOverlayManagerClass.prototype = {
 
     constructor: Polymer.IronOverlayManagerClass,
 
     /**
      * The shared backdrop element.
-     * @type {Element} backdropElement
+     * @type {!Element} backdropElement
      */
     get backdropElement() {
       if (!this._backdropElement) {
         this._backdropElement = document.createElement('iron-overlay-backdrop');
       }
       return this._backdropElement;
     },
 
     /**
      * The deepest active element.
-     * @type {Element} activeElement the active element
+     * @type {!Element} activeElement the active element
      */
     get deepActiveElement() {
       // document.activeElement can be null
       // https://developer.mozilla.org/en-US/docs/Web/API/Document/activeElement
       // In case of null, default it to document.body.
       var active = document.activeElement || document.body;
       while (active.root && Polymer.dom(active.root).activeElement) {
         active = Polymer.dom(active.root).activeElement;
       }
       return active;
     },
 
     /**
      * Brings the overlay at the specified index to the front.
      * @param {number} i
      * @private
      */
     _bringOverlayAtIndexToFront: function(i) {
       var overlay = this._overlays[i];
+      if (!overlay) {
+        return;
+      }
       var lastI = this._overlays.length - 1;
+      var currentOverlay = this._overlays[lastI];
       // Ensure always-on-top overlay stays on top.
-      if (!overlay.alwaysOnTop && this._overlays[lastI].alwaysOnTop) {
+      if (currentOverlay && this._shouldBeBehindOverlay(overlay, currentOverlay)) {
         lastI--;
       }
       // If already the top element, return.
-      if (!overlay || i >= lastI) {
+      if (i >= lastI) {
         return;
       }
       // Update z-index to be on top.
       var minimumZ = Math.max(this.currentOverlayZ(), this._minimumZ);
       if (this._getZ(overlay) <= minimumZ) {
         this._applyOverlayZ(overlay, minimumZ);
       }
 
       // Shift other overlays behind the new on top.
       while (i < lastI) {
         this._overlays[i] = this._overlays[i + 1];
         i++;
       }
       this._overlays[lastI] = overlay;
     },
 
     /**
      * Adds the overlay and updates its z-index if it's opened, or removes it if it's closed.
      * Also updates the backdrop z-index.
-     * @param {Element} overlay
+     * @param {!Element} overlay
      */
     addOrRemoveOverlay: function(overlay) {
       if (overlay.opened) {
         this.addOverlay(overlay);
       } else {
         this.removeOverlay(overlay);
       }
       this.trackBackdrop();
     },
 
     /**
      * Tracks overlays for z-index and focus management.
      * Ensures the last added overlay with always-on-top remains on top.
-     * @param {Element} overlay
+     * @param {!Element} overlay
      */
     addOverlay: function(overlay) {
       var i = this._overlays.indexOf(overlay);
       if (i >= 0) {
         this._bringOverlayAtIndexToFront(i);
         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);
 
       // Ensure always-on-top overlay stays on top.
-      if (currentOverlay && currentOverlay.alwaysOnTop && !overlay.alwaysOnTop) {
+      if (currentOverlay && this._shouldBeBehindOverlay(overlay, currentOverlay)) {
         // This bumps the z-index of +2.
         this._applyOverlayZ(currentOverlay, minimumZ);
         insertionIndex--;
         // Update minimumZ to match previous overlay's z-index.
         var previousOverlay = this._overlays[insertionIndex - 1];
         minimumZ = Math.max(this._getZ(previousOverlay), this._minimumZ);
       }
 
       // Update z-index and insert overlay.
       if (newZ <= minimumZ) {
         this._applyOverlayZ(overlay, minimumZ);
       }
       this._overlays.splice(insertionIndex, 0, overlay);
 
       // Get focused node.
       var element = this.deepActiveElement;
       overlay.restoreFocusNode = this._overlayParent(element) ? null : element;
     },
 
     /**
-     * @param {Element} overlay
+     * @param {!Element} overlay
      */
     removeOverlay: function(overlay) {
       var i = this._overlays.indexOf(overlay);
       if (i === -1) {
         return;
       }
       this._overlays.splice(i, 1);
 
       var node = overlay.restoreFocusOnClose ? overlay.restoreFocusNode : null;
       overlay.restoreFocusNode = null;
@@ skipping 97 matching lines @@
         // Check if is a number
         // Number.isNaN not supported in IE 10+
         if (z1 === z1) {
           z = z1;
         }
       }
       return z;
     },
 
     /**
-     * @param {Element} element
+     * @param {!Element} element
      * @param {number|string} z
      * @private
      */
     _setZ: function(element, z) {
       element.style.zIndex = z;
     },
 
     /**
-     * @param {Element} overlay
+     * @param {!Element} overlay
      * @param {number} aboveZ
      * @private
      */
     _applyOverlayZ: function(overlay, aboveZ) {
       this._setZ(overlay, aboveZ + 2);
     },
 
     /**
      * Returns the overlay containing the provided node. If the node is an overlay,
      * it returns the node.
@@ skipping 59 matching lines @@
      */
     _onCaptureKeyDown: function(event) {
       var overlay = /** @type {?} */ (this.currentOverlay());
       if (overlay) {
         if (Polymer.IronA11yKeysBehavior.keyboardEventMatchesKeys(event, 'esc')) {
           overlay._onCaptureEsc(event);
         } else if (Polymer.IronA11yKeysBehavior.keyboardEventMatchesKeys(event, 'tab')) {
           overlay._onCaptureTab(event);
         }
       }
+    },
+
+    /**
+     * Returns if the overlay1 should be behind overlay2.
+     * @param {!Element} overlay1
+     * @param {!Element} overlay2
+     * @return {boolean}
+     * @private
+     */
+    _shouldBeBehindOverlay: function(overlay1, overlay2) {
+      var o1 = /** @type {?} */ (overlay1);
+      var o2 = /** @type {?} */ (overlay2);
+      return !o1.alwaysOnTop && o2.alwaysOnTop;
     }
   };
 
   Polymer.IronOverlayManager = new Polymer.IronOverlayManagerClass();