[Polymer] update polymer

chrome/browser/resources/md_downloads/crisper.js

 // Copyright (c) 2013 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.
 
 /**
  * @fileoverview Assertion support.
  */
 
 /**
  * Verify |condition| is truthy and return |condition| if so.
@@ skipping 1915 matching lines @@
      * node.
      * The `keys-pressed` event will fire when one of the key combinations set with the
      * `keys` property is pressed.
      *
      * @demo demo/index.html
      * @polymerBehavior
      */
     Polymer.IronA11yKeysBehavior = {
       properties: {
         /**
-         * The HTMLElement that will be firing relevant KeyboardEvents.
+         * The EventTarget that will be firing relevant KeyboardEvents. Set it to
+         * `null` to disable the listeners.
+         * @type {?EventTarget}
          */
         keyEventTarget: {
           type: Object,
           value: function() {
             return this;
           }
         },
 
         /**
          * If true, this property will cause the implementing element to
@@ skipping 125 matching lines @@
 
       _resetKeyEventListeners: function() {
         this._unlistenKeyEventListeners();
 
         if (this.isAttached) {
           this._listenKeyEventListeners();
         }
       },
 
       _listenKeyEventListeners: function() {
+        if (!this.keyEventTarget) {
+          return;
+        }
         Object.keys(this._keyBindings).forEach(function(eventName) {
           var keyBindings = this._keyBindings[eventName];
           var boundKeyHandler = this._onKeyBindingEvent.bind(this, keyBindings);
 
           this._boundKeyHandlers.push([this.keyEventTarget, eventName, boundKeyHandler]);
 
           this.keyEventTarget.addEventListener(eventName, boundKeyHandler);
         }, this);
       },
 
@@ skipping 269 matching lines @@
       return this.scrollTarget instanceof HTMLElement;
     }
   };
 (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: {
 
       /**
        * An array containing items determining how many instances of the template
        * to stamp and that that each template instance should bind to.
@@ skipping 811 matching lines @@
       var dot = path.indexOf('.');
       var key = path.substring(0, dot < 0 ? path.length : dot);
       var idx = this._physicalIndexForKey[key];
       var offscreenItem = this._offscreenFocusedItem;
       var el = offscreenItem && offscreenItem._templateInstance.__key__ === key ?
           offscreenItem : this._physicalItems[idx];
 
       if (!el || el._templateInstance.__key__ !== key) {
         return;
       }
-      
       if (dot >= 0) {
         path = this.as + '.' + path.substring(dot+1);
         el._templateInstance.notifyPath(path, value, true);
       } else {
+        // Update selection if needed
+        var currentItem = el._templateInstance[this.as];
+        if (Array.isArray(this.selectedItems)) {
+          for (var i = 0; i < this.selectedItems.length; i++) {
+            if (this.selectedItems[i] === currentItem) {
+              this.set('selectedItems.' + i, value);
+              break;
+            }
+          }
+        } else if (this.selectedItem === currentItem) {
+          this.set('selectedItem', value);
+        }
         el._templateInstance[this.as] = value;
       }
-
     },
 
     /**
      * Called when the items have changed. That is, ressignments
      * to `items`, splices or updates to a single item.
      */
     _itemsChanged: function(change) {
       if (change.path === 'items') {
         // reset items
         this._virtualStart = 0;
@@ skipping 167 matching lines @@
 
       // update the average if we measured something
       if (this._physicalAverageCount !== prevAvgCount) {
         this._physicalAverage = Math.round(
             ((prevPhysicalAvg * prevAvgCount) + newPhysicalSize) /
             this._physicalAverageCount);
       }
     },
 
     _updateGridMetrics: function() {
-      this._viewportWidth = this._scrollTargetWidth;
+      this._viewportWidth = this.$.items.offsetWidth;
       // Set item width to the value of the _physicalItems offsetWidth
-      this._itemWidth = this._physicalCount > 0 ? this._physicalItems[0].offsetWidth : DEFAULT_GRID_SIZE;
+      this._itemWidth = this._physicalCount > 0 ? this._physicalItems[0].getBoundingClientRect().width : DEFAULT_GRID_SIZE;
       // Set row height to the value of the _physicalItems offsetHeight
       this._rowHeight = this._physicalCount > 0 ? this._physicalItems[0].offsetHeight : DEFAULT_GRID_SIZE;
       // If in grid mode compute how many items with exist in each row
       this._itemsPerRow = this._itemWidth ? Math.floor(this._viewportWidth / this._itemWidth) : this._itemsPerRow;
     },
 
     /**
      * Updates the position of the physical items.
      */
     _positionItems: function() {
@@ skipping 306 matching lines @@
      */
     _selectionEnabledChanged: function(selectionEnabled) {
       var handler = selectionEnabled ? this.listen : this.unlisten;
       handler.call(this, this, 'tap', '_selectionHandler');
     },
 
     /**
      * Select an item from an event object.
      */
     _selectionHandler: function(e) {
-      if (this.selectionEnabled) {
-        var model = this.modelForElement(e.target);
-        if (model) {
-          this.toggleSelectionForItem(model[this.as]);
-        }
+      var model = this.modelForElement(e.target);
+      if (!model) {
+        return;
       }
+      var modelTabIndex, activeElTabIndex;
+      var target = Polymer.dom(e).path[0];
+      var activeEl = Polymer.dom(this.domHost ? this.domHost.root : document).activeElement;
+      var physicalItem = this._physicalItems[this._getPhysicalIndex(model[this.indexAs])];
+      // Safari does not focus certain form controls via mouse
+      // https://bugs.webkit.org/show_bug.cgi?id=118043
+      if (target.localName === 'input' ||
+          target.localName === 'button' ||
+          target.localName === 'select') {
+        return;
+      }
+      // Set a temporary tabindex
+      modelTabIndex = model.tabIndex;
+      model.tabIndex = SECRET_TABINDEX;
+      activeElTabIndex = activeEl ? activeEl.tabIndex : -1;
+      model.tabIndex = modelTabIndex;
+      // Only select the item if the tap wasn't on a focusable child
+      // or the element bound to `tabIndex`
+      if (activeEl && physicalItem.contains(activeEl) && activeElTabIndex !== SECRET_TABINDEX) {
+        return;
+      }
+      this.toggleSelectionForItem(model[this.as]);
     },
 
     _multiSelectionChanged: function(multiSelection) {
       this.clearSelection();
       this.$.selector.multi = multiSelection;
     },
 
     /**
      * Updates the size of an item.
      *
@@ skipping 52 matching lines @@
       if (idx < 0 || idx >= this._virtualCount) {
         return;
       }
       this._restoreFocusedItem();
       // scroll to index to make sure it's rendered
       if (!this._isIndexRendered(idx)) {
         this.scrollToIndex(idx);
       }
 
       var physicalItem = this._physicalItems[this._getPhysicalIndex(idx)];
-      var SECRET = ~(Math.random() * 100);
       var model = physicalItem._templateInstance;
       var focusable;
 
       // set a secret tab index
-      model.tabIndex = SECRET;
+      model.tabIndex = SECRET_TABINDEX;
       // check if focusable element is the physical item
-      if (physicalItem.tabIndex === SECRET) {
+      if (physicalItem.tabIndex === SECRET_TABINDEX) {
        focusable = physicalItem;
       }
       // search for the element which tabindex is bound to the secret tab index
       if (!focusable) {
-        focusable = Polymer.dom(physicalItem).querySelector('[tabindex="' + SECRET + '"]');
+        focusable = Polymer.dom(physicalItem).querySelector('[tabindex="' + SECRET_TABINDEX + '"]');
       }
       // restore the tab index
       model.tabIndex = 0;
       // focus the focusable element
       this._focusedIndex = idx;
       focusable && focusable.focus();
     },
 
     _removeFocusedItem: function() {
       if (this._offscreenFocusedItem) {
@@ skipping 1456 matching lines @@
 
         _boundAnimate: {
           type: Function,
           value: function() {
             return this.animate.bind(this);
           }
         }
       },
 
       get target () {
-        var ownerRoot = Polymer.dom(this).getOwnerRoot();
-        var target;
-
-        if (this.parentNode.nodeType == 11) { // DOCUMENT_FRAGMENT_NODE
-          target = ownerRoot.host;
-        } else {
-          target = this.parentNode;
-        }
-
-        return target;
+        return this.keyEventTarget;
       },
 
       keyBindings: {
         'enter:keydown': '_onEnterKeydown',
         'space:keydown': '_onSpaceKeydown',
         'space:keyup': '_onSpaceKeyup'
       },
 
       attached: function() {
         // Set up a11yKeysBehavior to listen to key events on the target,
         // so that space and enter activate the ripple even if the target doesn't
         // handle key events. The key handlers deal with `noink` themselves.
-        this.keyEventTarget = this.target;
-        this.listen(this.target, 'up', 'uiUpAction');
-        this.listen(this.target, 'down', 'uiDownAction');
+        if (this.parentNode.nodeType == 11) { // DOCUMENT_FRAGMENT_NODE
+          this.keyEventTarget = Polymer.dom(this).getOwnerRoot().host;
+        } else {
+          this.keyEventTarget = this.parentNode;
+        }
+        var keyEventTarget = /** @type {!EventTarget} */ (this.keyEventTarget);
+        this.listen(keyEventTarget, 'up', 'uiUpAction');
+        this.listen(keyEventTarget, 'down', 'uiDownAction');
       },
 
       detached: function() {
-        this.unlisten(this.target, 'up', 'uiUpAction');
-        this.unlisten(this.target, 'down', 'uiDownAction');
+        this.unlisten(this.keyEventTarget, 'up', 'uiUpAction');
+        this.unlisten(this.keyEventTarget, 'down', 'uiDownAction');
+        this.keyEventTarget = null;
       },
 
       get shouldKeepAnimating () {
         for (var index = 0; index < this.ripples.length; ++index) {
           if (!this.ripples[index].isAnimationComplete) {
             return true;
           }
         }
 
         return false;
@@ skipping 27 matching lines @@
       downAction: function(event) {
         if (this.holdDown && this.ripples.length > 0) {
           return;
         }
 
         var ripple = this.addRipple();
 
         ripple.downAction(event);
 
         if (!this._animating) {
+          this._animating = true;
           this.animate();
         }
       },
 
       /**
        * Provokes a ripple up effect via a UI event,
        * respecting the `noink` property.
        * @param {Event=} event
        */
       uiUpAction: function(event) {
         if (!this.noink) {
           this.upAction(event);
         }
       },
 
       /**
        * Provokes a ripple up effect via a UI event,
        * *not* respecting the `noink` property.
        * @param {Event=} event
        */
       upAction: function(event) {
         if (this.holdDown) {
           return;
         }
 
         this.ripples.forEach(function(ripple) {
           ripple.upAction(event);
         });
 
+        this._animating = true;
         this.animate();
       },
 
       onAnimationComplete: function() {
         this._animating = false;
         this.$.background.style.backgroundColor = null;
         this.fire('transitionend');
       },
 
       addRipple: function() {
@@ skipping 18 matching lines @@
         this.ripples.splice(rippleIndex, 1);
 
         ripple.remove();
 
         if (!this.ripples.length) {
           this._setAnimating(false);
         }
       },
 
       animate: function() {
+        if (!this._animating) {
+          return;
+        }
         var index;
         var ripple;
 
-        this._animating = true;
-
         for (index = 0; index < this.ripples.length; ++index) {
           ripple = this.ripples[index];
 
           ripple.draw();
 
           this.$.background.style.opacity = ripple.outerOpacity;
 
           if (ripple.isOpacityFullyDecayed && !ripple.isRestingAtMaxRadius) {
             this.removeRipple(ripple);
           }
@@ skipping 24 matching lines @@
       _holdDownChanged: function(newVal, oldVal) {
         if (oldVal === undefined) {
           return;
         }
         if (newVal) {
           this.downAction();
         } else {
           this.upAction();
         }
       }
+
+      /**
+      Fired when the animation finishes.
+      This is useful if you want to wait until
+      the ripple animation finishes to perform some action.
+
+      @event transitionend
+      @param {{node: Object}} detail Contains the animated node.
+      */
     });
   })();
 /**
    * `Polymer.PaperRippleBehavior` dynamically implements a ripple
    * when the element has focus via pointer or keyboard.
    *
    * NOTE: This behavior is intended to be used in conjunction with and after
    * `Polymer.IronButtonState` and `Polymer.IronControlState`.
    *
    * @polymerBehavior Polymer.PaperRippleBehavior
@@ skipping 2162 matching lines @@
      */
     fit: function() {
       this._discoverInfo();
       this.position();
       this.constrain();
       this.center();
     },
 
     /**
      * Memoize information needed to position and size the target element.
+     * @suppress {deprecated}
      */
     _discoverInfo: function() {
       if (this._fitInfo) {
         return;
       }
       var target = window.getComputedStyle(this);
       var sizer = window.getComputedStyle(this.sizingTarget);
 
       this._fitInfo = {
         inlineStyle: {
@@ skipping 749 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];
         }
       }
     },
@@ skipping 37 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();
 (function() {
 'use strict';
 
 /**
 Use `Polymer.IronOverlayBehavior` to implement an element that can be hidden or shown, and displays
 on top of other content. It includes an optional backdrop, and can be used to implement a variety
@@ skipping 1853 matching lines @@
     },
 
     showingSearch: {
       type: Boolean,
       value: false,
       notify: true,
       observer: 'showingSearchChanged_',
       reflectToAttribute: true
     },
 
-    hasSearchText: Boolean,
-
     /** @private */
     lastValue_: {
       type: String,
       value: '',
     },
   },
 
   /**
    * @return {string} The value of the search field.
    */
@@ skipping 29 matching lines @@
   /**
    * Updates the internal state of the search field based on a change that has
    * already happened.
    * @param {string} newValue
    * @private
    */
   onValueChanged_: function(newValue) {
     if (newValue == this.lastValue_)
       return;
 
-    this.hasSearchText = newValue != '';
     this.fire('search-changed', newValue);
     this.lastValue_ = newValue;
   },
 
   onSearchTermKeydown: function(e) {
     if (e.key == 'Escape')
       this.showingSearch = false;
   },
 
   /** @private */
@@ skipping 1063 matching lines @@
     Manager.get().updateItem_(index, data);
   };
 
   return {Manager: Manager};
 });
 // 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.
 
 window.addEventListener('load', downloads.Manager.onLoad);