Run bower update

third_party/polymer/components/iron-overlay-behavior/iron-overlay-manager.html

 <!--
 @license
 Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
 This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
 The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
 The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
 Code distributed by Google as part of the polymer project is also
 subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
 -->
 
@@ skipping 21 matching lines @@
      * @private {number}
      */
     this._minimumZ = 101;
 
     /**
      * Memoized backdrop element.
      * @private {Element|null}
      */
     this._backdropElement = null;
 
-    // Listen to mousedown or touchstart to be sure to be the first to capture
-    // clicks outside the overlay.
-    var clickEvent = ('ontouchstart' in window) ? 'touchstart' : 'mousedown';
-    document.addEventListener(clickEvent, this._onCaptureClick.bind(this), true);
+    // Enable document-wide tap recognizer.
+    Polymer.Gestures.add(document, 'tap', null);
+    // Need to have useCapture=true, Polymer.Gestures doesn't offer that.
+    document.addEventListener('tap', this._onCaptureClick.bind(this), true);
     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.
@@ skipping 59 matching lines @@
      * 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
      */
     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
      */
     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);
 
       // Ensure always-on-top overlay stays on top.
       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;
+      this.trackBackdrop();
     },
 
     /**
      * @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;
       // Focus back only if still contained in document.body
       if (node && Polymer.dom(document.body).deepContains(node)) {
         node.focus();
       }
+      this.trackBackdrop();
     },
 
     /**
      * Returns the current overlay.
      * @return {Element|undefined}
      */
     currentOverlay: function() {
       var i = this._overlays.length - 1;
       return this._overlays[i];
     },
@@ skipping 128 matching lines @@
         }
         // Use logical parentNode, or native ShadowRoot host.
         node = Polymer.dom(node).parentNode || node.host;
       }
     },
 
     /**
      * Returns the deepest overlay in the path.
      * @param {Array<Element>=} path
      * @return {Element|undefined}
+     * @suppress {missingProperties}
      * @private
      */
     _overlayInPath: function(path) {
       path = path || [];
       for (var i = 0; i < path.length; i++) {
         if (path[i]._manager === this) {
           return path[i];
         }
       }
     },
 
     /**
      * Ensures the click event is delegated to the right overlay.
      * @param {!Event} event
      * @private
      */
     _onCaptureClick: function(event) {
       var overlay = /** @type {?} */ (this.currentOverlay());
       // Check if clicked outside of top overlay.
       if (overlay && this._overlayInPath(Polymer.dom(event).path) !== overlay) {
-        if (overlay.withBackdrop) {
-          // There's no need to stop the propagation as the backdrop element
-          // already got this mousedown/touchstart event. Calling preventDefault
-          // on this event ensures that click/tap won't be triggered at all.
-          event.preventDefault();
-        }
         overlay._onCaptureClick(event);
       }
     },
 
     /**
      * Ensures the focus event is delegated to the right overlay.
      * @param {!Event} event
      * @private
      */
     _onCaptureFocus: function(event) {
@@ skipping 17 matching lines @@
           overlay._onCaptureTab(event);
         }
       }
     },
 
     /**
      * Returns if the overlay1 should be behind overlay2.
      * @param {!Element} overlay1
      * @param {!Element} overlay2
      * @return {boolean}
+     * @suppress {missingProperties}
      * @private
      */
     _shouldBeBehindOverlay: function(overlay1, overlay2) {
-      var o1 = /** @type {?} */ (overlay1);
-      var o2 = /** @type {?} */ (overlay2);
-      return !o1.alwaysOnTop && o2.alwaysOnTop;
+      return !overlay1.alwaysOnTop && overlay2.alwaysOnTop;
     }
   };
 
   Polymer.IronOverlayManager = new Polymer.IronOverlayManagerClass();
 </script>