Roll 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 1847 matching lines @@
       * keyEvent.key = @
       * To get 2 returned, set noSpecialChars = true
       * To get @ returned, set noSpecialChars = false
      */
     function normalizedKeyForEvent(keyEvent, noSpecialChars) {
       // Fall back from .key, to .keyIdentifier, to .keyCode, and then to
       // .detail.key to support artificial keyboard events.
       return transformKey(keyEvent.key, noSpecialChars) ||
         transformKeyIdentifier(keyEvent.keyIdentifier) ||
         transformKeyCode(keyEvent.keyCode) ||
-        transformKey(keyEvent.detail.key, noSpecialChars) || '';
+        transformKey(keyEvent.detail ? keyEvent.detail.key : keyEvent.detail, noSpecialChars) || '';
     }
 
     function keyComboMatchesEvent(keyCombo, event) {
       // For combos with modifiers we support only alpha-numeric keys
       var keyEvent = normalizedKeyForEvent(event, keyCombo.hasModifiers);
       return keyEvent === keyCombo.key &&
         (!keyCombo.hasModifiers || (
           !!event.shiftKey === !!keyCombo.shiftKey &&
           !!event.ctrlKey === !!keyCombo.ctrlKey &&
           !!event.altKey === !!keyCombo.altKey &&
@@ skipping 632 matching lines @@
      * This value is the same as `scrollTop`.
      */
     _scrollPosition: 0,
 
     /**
      * The sum of the heights of all the tiles in the DOM.
      */
     _physicalSize: 0,
 
     /**
-     * The average `F` of the tiles observed till now.
+     * The average `offsetHeight` of the tiles observed till now.
      */
     _physicalAverage: 0,
 
     /**
      * The number of tiles which `offsetHeight` > 0 observed until now.
      */
     _physicalAverageCount: 0,
 
     /**
      * The Y position of the item rendered in the `_physicalStart`
@@ skipping 247 matching lines @@
       if (this._firstVisibleIndexVal === null) {
         var physicalOffset = Math.floor(this._physicalTop + this._scrollerPaddingTop);
 
         this._firstVisibleIndexVal = this._iterateItems(
           function(pidx, vidx) {
             physicalOffset += this._getPhysicalSizeIncrement(pidx);
 
             if (physicalOffset > this._scrollPosition) {
               return this.grid ? vidx - (vidx % this._itemsPerRow) : vidx;
             }
-
             // Handle a partially rendered final row in grid mode
             if (this.grid && this._virtualCount - 1 === vidx) {
               return vidx - (vidx % this._itemsPerRow);
             }
           }) || 0;
       }
       return this._firstVisibleIndexVal;
     },
 
     /**
      * Gets the index of the last visible item in the viewport.
      *
      * @type {number}
      */
     get lastVisibleIndex() {
       if (this._lastVisibleIndexVal === null) {
         if (this.grid) {
           var lastIndex = this.firstVisibleIndex + this._estRowsInView * this._itemsPerRow - 1;
-          this._lastVisibleIndexVal = lastIndex > this._virtualCount ? this._virtualCount : lastIndex;
+          this._lastVisibleIndexVal = Math.min(this._virtualCount, lastIndex);
         } else {
           var physicalOffset = this._physicalTop;
-
           this._iterateItems(function(pidx, vidx) {
+            if (physicalOffset < this._scrollBottom) {
+              this._lastVisibleIndexVal = vidx;
+            } else {
+              // Break _iterateItems
+              return true;
+            }
             physicalOffset += this._getPhysicalSizeIncrement(pidx);
-
-            if(physicalOffset <= this._scrollBottom) {
-              if (this.grid) {
-                var lastIndex = vidx - vidx % this._itemsPerRow + this._itemsPerRow - 1;
-                this._lastVisibleIndexVal = lastIndex > this._virtualCount ? this._virtualCount : lastIndex;
-              } else {
-                this._lastVisibleIndexVal = vidx;
-              }
-            }
           });
         }
       }
       return this._lastVisibleIndexVal;
     },
 
     get _defaultScrollTarget() {
       return this;
     },
     get _virtualRowCount() {
@@ skipping 354 matching lines @@
     },
 
     /**
      * Called as a side effect of a host items.<key>.<path> path change,
      * responsible for notifying item.<path> changes.
      */
     _forwardItemPath: function(path, value) {
       if (!this._physicalIndexForKey) {
         return;
       }
-      var inst;
       var dot = path.indexOf('.');
       var key = path.substring(0, dot < 0 ? path.length : dot);
       var idx = this._physicalIndexForKey[key];
-      var el = this._physicalItems[idx];
+      var offscreenItem = this._offscreenFocusedItem;
+      var el = offscreenItem && offscreenItem._templateInstance.__key__ === key ?
+          offscreenItem : this._physicalItems[idx];
 
-
-      if (idx === this._focusedIndex && this._offscreenFocusedItem) {
-        el = this._offscreenFocusedItem;
-      }
-      if (!el) {
+      if (!el || el._templateInstance.__key__ !== key) {
         return;
       }
-
-      inst = el._templateInstance;
-
-      if (inst.__key__ !== key) {
-        return;
-      }
+      
       if (dot >= 0) {
         path = this.as + '.' + path.substring(dot+1);
-        inst.notifyPath(path, value, true);
+        el._templateInstance.notifyPath(path, value, true);
       } else {
-        inst[this.as] = 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;
         this._physicalTop = 0;
         this._virtualCount = this.items ? this.items.length : 0;
         this._collection = this.items ? Polymer.Collection.get(this.items) : null;
         this._physicalIndexForKey = {};
+        this._firstVisibleIndexVal = null;
+        this._lastVisibleIndexVal = null;
 
         this._resetScrollPosition(0);
         this._removeFocusedItem();
-
         // create the initial physical items
         if (!this._physicalItems) {
           this._physicalCount = Math.max(1, Math.min(DEFAULT_PHYSICAL_COUNT, this._virtualCount));
           this._physicalItems = this._createPool(this._physicalCount);
           this._physicalSizes = new Array(this._physicalCount);
         }
 
         this._physicalStart = 0;
 
       } else if (change.path === 'items.splices') {
+
         this._adjustVirtualIndex(change.value.indexSplices);
         this._virtualCount = this.items ? this.items.length : 0;
 
       } else {
         // update a single item
         this._forwardItemPath(change.path.split('.').slice(1).join('.'), change.value);
         return;
       }
 
       this._itemsRendered = false;
@@ skipping 212 matching lines @@
     /**
      * Adjusts the scroll position when it was overestimated.
      */
     _adjustScrollPosition: function() {
       var deltaHeight = this._virtualStart === 0 ? this._physicalTop :
           Math.min(this._scrollPosition + this._physicalTop, 0);
 
       if (deltaHeight) {
         this._physicalTop = this._physicalTop - deltaHeight;
         // juking scroll position during interial scrolling on iOS is no bueno
-        if (!IOS_TOUCH_SCROLLING) {
+        if (!IOS_TOUCH_SCROLLING && this._physicalTop !== 0) {
           this._resetScrollPosition(this._scrollTop - deltaHeight);
         }
       }
     },
 
     /**
      * Sets the position of the scroll.
      */
     _resetScrollPosition: function(pos) {
       if (this.scrollTarget) {
@@ skipping 18 matching lines @@
       forceUpdate = forceUpdate || this._scrollHeight === 0;
       forceUpdate = forceUpdate || this._scrollPosition >= this._estScrollHeight - this._physicalSize;
       forceUpdate = forceUpdate || this.grid && this.$.items.style.height < this._estScrollHeight;
 
       // amortize height adjustment, so it won't trigger repaints very often
       if (forceUpdate || Math.abs(this._estScrollHeight - this._scrollHeight) >= this._optPhysicalSize) {
         this.$.items.style.height = this._estScrollHeight + 'px';
         this._scrollHeight = this._estScrollHeight;
       }
     },
+
     /**
      * Scroll to a specific item in the virtual list regardless
      * of the physical items in the DOM tree.
      *
+     * @method scrollToItem
+     * @param {(Object)} item The item to be scrolled to
+     */
+    scrollToItem: function(item){
+      return this.scrollToIndex(this.items.indexOf(item));
+    },
+
+    /**
+     * Scroll to a specific index in the virtual list regardless
+     * of the physical items in the DOM tree.
+     *
      * @method scrollToIndex
      * @param {number} idx The index of the item
      */
     scrollToIndex: function(idx) {
-      if (typeof idx !== 'number') {
+      if (typeof idx !== 'number' || idx < 0 || idx > this.items.length - 1) {
         return;
       }
 
       Polymer.dom.flush();
 
       idx = Math.min(Math.max(idx, 0), this._virtualCount-1);
       // update the virtual start only when needed
       if (!this._isIndexRendered(idx) || idx >= this._maxVirtualStart) {
         this._virtualStart = this.grid ? (idx - this._itemsPerRow * 2) : (idx - 1);
       }
@@ skipping 6832 matching lines @@
   },
 
   /**
    * @return {string} The value of the search field.
    */
   getValue: function() {
     return this.$.searchInput.value;
   },
 
   /**
-   * Sets the value of the search field, if it exists.
+   * Sets the value of the search field.
    * @param {string} value
    */
   setValue: function(value) {
     // Use bindValue when setting the input value so that changes propagate
     // correctly.
     this.$.searchInput.bindValue = value;
-    this.hasSearchText = value != '';
+    this.onValueChanged_(value);
   },
 
   showAndFocus: function() {
     this.showingSearch = true;
     this.focus_();
   },
 
   /** @private */
   focus_: function() {
     this.$.searchInput.focus();
   },
 
   onSearchTermSearch: function() {
-    var newValue = this.getValue();
+    this.onValueChanged_(this.getValue());
+  },
+
+  /**
+   * 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 */
   showingSearchChanged_: function() {
     if (this.showingSearch) {
       this.focus_();
       return;
     }
 
     this.setValue('');
     this.$.searchInput.blur();
-    this.onSearchTermSearch();
   },
 
   /** @private */
   toggleShowingSearch_: function() {
     this.showingSearch = !this.showingSearch;
   },
 };
 (function() {
       'use strict';
 
@@ skipping 1045 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);