MD Downloads: limit the amount of downloads we send

chrome/browser/resources/md_downloads/crisper.js

 // 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.
 
 if (typeof Polymer == 'undefined')
   Polymer = {dom: 'shadow'};
 else
   console.error('Polymer is already defined.');
 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
@@ skipping 1535 matching lines @@
   /**
    * @param {string} searchText Input typed by the user into a search box.
    * @return {Array<string>} A list of terms extracted from |searchText|.
    */
   ActionService.splitTerms = function(searchText) {
     // Split quoted terms (e.g., 'The "lazy" dog' => ['The', 'lazy', 'dog']).
     return searchText.split(/"([^"]*)"/).map(trim).filter(truthy);
   };
 
   ActionService.prototype = {
+    /** @private {Array<string>} */
+    searchTerms_: [],
+
     /** @param {string} id ID of the download to cancel. */
     cancel: chromeSendWithId('cancel'),
 
     /** Instructs the browser to clear all finished downloads. */
     clearAll: function() {
       if (loadTimeData.getBoolean('allowDeletingHistory')) {
         chrome.send('clearAll');
         this.search('');
       }
     },
 
     /** @param {string} id ID of the dangerous download to discard. */
     discardDangerous: chromeSendWithId('discardDangerous'),
 
     /** @param {string} url URL of a file to download. */
     download: function(url) {
       var a = document.createElement('a');
       a.href = url;
       a.setAttribute('download', '');
       a.click();
     },
 
     /** @param {string} id ID of the download that the user started dragging. */
     drag: chromeSendWithId('drag'),
 
-    /** @private {boolean} */
-    isSearching_: false,
+    /** Loads more downloads with the current search terms. */
+    loadMore: function() {
+      chrome.send('getDownloads', this.searchTerms_);
+    },
 
     /**
      * @return {boolean} Whether the user is currently searching for downloads
      *     (i.e. has a non-empty search term).
      */
     isSearching: function() {
-      return this.isSearching_;
+      return this.searchTerms_.length > 0;
     },
 
     /** Opens the current local destination for downloads. */
     openDownloadsFolder: chrome.send.bind(chrome, 'openDownloadsFolder'),
 
     /**
      * @param {string} id ID of the download to run locally on the user's box.
      */
     openFile: chromeSendWithId('openFile'),
 
     /** @param {string} id ID the of the progressing download to pause. */
     pause: chromeSendWithId('pause'),
 
     /** @param {string} id ID of the finished download to remove. */
     remove: chromeSendWithId('remove'),
 
     /** @param {string} id ID of the paused download to resume. */
     resume: chromeSendWithId('resume'),
 
     /**
      * @param {string} id ID of the dangerous download to save despite
      *     warnings.
      */
     saveDangerous: chromeSendWithId('saveDangerous'),
 
     /** @param {string} searchText What to search for. */
     search: function(searchText) {
-      if (this.searchText_ == searchText)
+      var searchTerms = ActionService.splitTerms(searchText);
+      var sameTerms = searchTerms.length == this.searchTerms_.length;
+
+      for (var i = 0; sameTerms && i < searchTerms.length; ++i) {
+        if (searchTerms[i] != this.searchTerms_[i])
+          sameTerms = false;
+      }
+
+      if (sameTerms)
         return;
 
-      this.searchText_ = searchText;
-
-      var terms = ActionService.splitTerms(searchText);
-      this.isSearching_ = terms.length > 0;
-
-      chrome.send('getDownloads', terms);
+      this.searchTerms_ = searchTerms;
+      this.loadMore();
     },
 
     /**
      * Shows the local folder a finished download resides in.
      * @param {string} id ID of the download to show.
      */
     show: chromeSendWithId('show'),
 
     /** Undo download removal. */
     undo: chrome.send.bind(chrome, 'undo'),
@@ skipping 9331 matching lines @@
 (function() {
     'use strict';
 
     /**
      * Chrome uses an older version of DOM Level 3 Keyboard Events
      *
      * Most keys are labeled as text, but some are Unicode codepoints.
      * Values taken from: http://www.w3.org/TR/2007/WD-DOM-Level-3-Events-20071221/keyset.html#KeySet-Set
      */
     var KEY_IDENTIFIER = {
+      'U+0008': 'backspace',
       'U+0009': 'tab',
       'U+001B': 'esc',
       'U+0020': 'space',
-      'U+002A': '*',
-      'U+0030': '0',
-      'U+0031': '1',
-      'U+0032': '2',
-      'U+0033': '3',
-      'U+0034': '4',
-      'U+0035': '5',
-      'U+0036': '6',
-      'U+0037': '7',
-      'U+0038': '8',
-      'U+0039': '9',
-      'U+0041': 'a',
-      'U+0042': 'b',
-      'U+0043': 'c',
-      'U+0044': 'd',
-      'U+0045': 'e',
-      'U+0046': 'f',
-      'U+0047': 'g',
-      'U+0048': 'h',
-      'U+0049': 'i',
-      'U+004A': 'j',
-      'U+004B': 'k',
-      'U+004C': 'l',
-      'U+004D': 'm',
-      'U+004E': 'n',
-      'U+004F': 'o',
-      'U+0050': 'p',
-      'U+0051': 'q',
-      'U+0052': 'r',
-      'U+0053': 's',
-      'U+0054': 't',
-      'U+0055': 'u',
-      'U+0056': 'v',
-      'U+0057': 'w',
-      'U+0058': 'x',
-      'U+0059': 'y',
-      'U+005A': 'z',
       'U+007F': 'del'
     };
 
     /**
      * Special table for KeyboardEvent.keyCode.
      * KeyboardEvent.keyIdentifier is better, and KeyBoardEvent.key is even better
      * than that.
      *
      * Values from: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent.keyCode#Value_of_keyCode
      */
     var KEY_CODE = {
+      8: 'backspace',
       9: 'tab',
       13: 'enter',
       27: 'esc',
       33: 'pageup',
       34: 'pagedown',
       35: 'end',
       36: 'home',
       32: 'space',
       37: 'left',
       38: 'up',
       39: 'right',
       40: 'down',
       46: 'del',
       106: '*'
     };
 
     /**
      * MODIFIER_KEYS maps the short name for modifier keys used in a key
      * combo string to the property name that references those same keys
      * in a KeyboardEvent instance.
      */
     var MODIFIER_KEYS = {
       'shift': 'shiftKey',
       'ctrl': 'ctrlKey',
       'alt': 'altKey',
       'meta': 'metaKey'
     };
 
     /**
-     * KeyboardEvent.key is mostly represented by printable character made by
-     * the keyboard, with unprintable keys labeled nicely.
-     *
-     * However, on OS X, Alt+char can make a Unicode character that follows an
-     * Apple-specific mapping. In this case, we
-     * fall back to .keyCode.
-     */
-    var KEY_CHAR = /[a-z0-9*]/;
-
-    /**
      * Matches a keyIdentifier string.
      */
     var IDENT_CHAR = /U\+/;
 
     /**
      * Matches arrow keys in Gecko 27.0+
      */
     var ARROW_KEY = /^arrow/;
 
     /**
      * Matches space keys everywhere (notably including IE10's exceptional name
      * `spacebar`).
      */
     var SPACE_KEY = /^space(bar)?/;
 
     function transformKey(key) {
       var validKey = '';
       if (key) {
         var lKey = key.toLowerCase();
-        if (lKey.length == 1) {
-          if (KEY_CHAR.test(lKey)) {
-            validKey = lKey;
-          }
+        if (lKey === ' ' || SPACE_KEY.test(lKey)) {
+          validKey = 'space';
+        } else if (lKey.length == 1) {
+          validKey = lKey;
         } else if (ARROW_KEY.test(lKey)) {
           validKey = lKey.replace('arrow', '');
-        } else if (SPACE_KEY.test(lKey)) {
-          validKey = 'space';
         } else if (lKey == 'multiply') {
           // numpad '*' can map to Multiply on IE/Windows
           validKey = '*';
         } else {
           validKey = lKey;
         }
       }
       return validKey;
     }
 
     function transformKeyIdentifier(keyIdent) {
       var validKey = '';
       if (keyIdent) {
-        if (IDENT_CHAR.test(keyIdent)) {
+        if (keyIdent in KEY_IDENTIFIER) {
           validKey = KEY_IDENTIFIER[keyIdent];
+        } else if (IDENT_CHAR.test(keyIdent)) {
+          keyIdent = parseInt(keyIdent.replace('U+', '0x'), 16);
+          validKey = String.fromCharCode(keyIdent).toLowerCase();
         } else {
           validKey = keyIdent.toLowerCase();
         }
       }
       return validKey;
     }
 
     function transformKeyCode(keyCode) {
       var validKey = '';
       if (Number(keyCode)) {
@@ skipping 19 matching lines @@
 
     function normalizedKeyForEvent(keyEvent) {
       // fall back from .key, to .keyIdentifier, to .keyCode, and then to
       // .detail.key to support artificial keyboard events
       return transformKey(keyEvent.key) ||
         transformKeyIdentifier(keyEvent.keyIdentifier) ||
         transformKeyCode(keyEvent.keyCode) ||
         transformKey(keyEvent.detail.key) || '';
     }
 
-    function keyComboMatchesEvent(keyCombo, keyEvent) {
-      return normalizedKeyForEvent(keyEvent) === keyCombo.key &&
-        !!keyEvent.shiftKey === !!keyCombo.shiftKey &&
-        !!keyEvent.ctrlKey === !!keyCombo.ctrlKey &&
-        !!keyEvent.altKey === !!keyCombo.altKey &&
-        !!keyEvent.metaKey === !!keyCombo.metaKey;
+    function keyComboMatchesEvent(keyCombo, event, eventKey) {
+      return eventKey === keyCombo.key &&
+        (!keyCombo.hasModifiers || (
+          !!event.shiftKey === !!keyCombo.shiftKey &&
+          !!event.ctrlKey === !!keyCombo.ctrlKey &&
+          !!event.altKey === !!keyCombo.altKey &&
+          !!event.metaKey === !!keyCombo.metaKey)
+        );
     }
 
     function parseKeyComboString(keyComboString) {
+      if (keyComboString.length === 1) {
+        return {
+          combo: keyComboString,
+          key: keyComboString,
+          event: 'keydown'
+        };
+      }
       return keyComboString.split('+').reduce(function(parsedKeyCombo, keyComboPart) {
         var eventParts = keyComboPart.split(':');
         var keyName = eventParts[0];
         var event = eventParts[1];
 
         if (keyName in MODIFIER_KEYS) {
           parsedKeyCombo[MODIFIER_KEYS[keyName]] = true;
+          parsedKeyCombo.hasModifiers = true;
         } else {
           parsedKeyCombo.key = keyName;
           parsedKeyCombo.event = event || 'keydown';
         }
 
         return parsedKeyCombo;
       }, {
         combo: keyComboString.split(':').shift()
       });
     }
 
     function parseEventString(eventString) {
-      return eventString.split(' ').map(function(keyComboString) {
+      return eventString.trim().split(' ').map(function(keyComboString) {
         return parseKeyComboString(keyComboString);
       });
     }
 
-
     /**
      * `Polymer.IronA11yKeysBehavior` provides a normalized interface for processing
      * keyboard commands that pertain to [WAI-ARIA best practices](http://www.w3.org/TR/wai-aria-practices/#kbd_general_binding).
      * The element takes care of browser differences with respect to Keyboard events
      * and uses an expressive syntax to filter key presses.
      *
      * Use the `keyBindings` prototype property to express what combination of keys
      * will trigger the event to fire.
      *
      * Use the `key-event-target` attribute to set up event handlers on a specific
@@ skipping 75 matching lines @@
        * When called, will remove all imperatively-added key bindings.
        */
       removeOwnKeyBindings: function() {
         this._imperativeKeyBindings = {};
         this._prepKeyBindings();
         this._resetKeyEventListeners();
       },
 
       keyboardEventMatchesKeys: function(event, eventString) {
         var keyCombos = parseEventString(eventString);
-        var index;
-
-        for (index = 0; index < keyCombos.length; ++index) {
-          if (keyComboMatchesEvent(keyCombos[index], event)) {
+        var eventKey = normalizedKeyForEvent(event);
+        for (var i = 0; i < keyCombos.length; ++i) {
+          if (keyComboMatchesEvent(keyCombos[i], event, eventKey)) {
             return true;
           }
         }
-
         return false;
       },
 
       _collectKeyBindings: function() {
         var keyBindings = this.behaviors.map(function(behavior) {
           return behavior.keyBindings;
         });
 
         if (keyBindings.indexOf(this.keyBindings) === -1) {
           keyBindings.push(this.keyBindings);
         }
 
         return keyBindings;
       },
 
       _prepKeyBindings: function() {
         this._keyBindings = {};
 
         this._collectKeyBindings().forEach(function(keyBindings) {
           for (var eventString in keyBindings) {
             this._addKeyBinding(eventString, keyBindings[eventString]);
           }
         }, this);
 
         for (var eventString in this._imperativeKeyBindings) {
           this._addKeyBinding(eventString, this._imperativeKeyBindings[eventString]);
         }
+
+        // Give precedence to combos with modifiers to be checked first.
+        for (var eventName in this._keyBindings) {
+          this._keyBindings[eventName].sort(function (kb1, kb2) {
+            var b1 = kb1[0].hasModifiers;
+            var b2 = kb2[0].hasModifiers;
+            return (b1 === b2) ? 0 : b1 ? -1 : 1;
+          })
+        }
       },
 
       _addKeyBinding: function(eventString, handlerName) {
         parseEventString(eventString).forEach(function(keyCombo) {
           this._keyBindings[keyCombo.event] =
             this._keyBindings[keyCombo.event] || [];
 
           this._keyBindings[keyCombo.event].push([
             keyCombo,
             handlerName
@@ skipping 35 matching lines @@
 
           keyEventTarget.removeEventListener(eventName, boundKeyHandler);
         }
       },
 
       _onKeyBindingEvent: function(keyBindings, event) {
         if (this.stopKeyboardEventPropagation) {
           event.stopPropagation();
         }
 
-        keyBindings.forEach(function(keyBinding) {
-          var keyCombo = keyBinding[0];
-          var handlerName = keyBinding[1];
+        // if event has been already prevented, don't do anything
+        if (event.defaultPrevented) {
+          return;
+        }
 
-          if (!event.defaultPrevented && keyComboMatchesEvent(keyCombo, event)) {
+        var eventKey = normalizedKeyForEvent(event);
+        for (var i = 0; i < keyBindings.length; i++) {
+          var keyCombo = keyBindings[i][0];
+          var handlerName = keyBindings[i][1];
+          if (keyComboMatchesEvent(keyCombo, event, eventKey)) {
             this._triggerKeyHandler(keyCombo, handlerName, event);
+            // exit the loop if eventDefault was prevented
+            if (event.defaultPrevented) {
+              return;
+            }
           }
-        }, this);
+        }
       },
 
       _triggerKeyHandler: function(keyCombo, handlerName, keyboardEvent) {
         var detail = Object.create(keyCombo);
         detail.keyboardEvent = keyboardEvent;
         var event = new CustomEvent(keyCombo.event, {
           detail: detail,
           cancelable: true
         });
         this[handlerName].call(this, event);
@@ skipping 217 matching lines @@
 
     /**
      * @param {!KeyboardEvent} event .
      */
     _spaceKeyDownHandler: function(event) {
       var keyboardEvent = event.detail.keyboardEvent;
       var target = Polymer.dom(keyboardEvent).localTarget;
 
       // Ignore the event if this is coming from a focused light child, since that
       // element will deal with it.
-      if (this.isLightDescendant(target))
+      if (this.isLightDescendant(/** @type {Node} */(target)))
         return;
 
       keyboardEvent.preventDefault();
       keyboardEvent.stopImmediatePropagation();
       this._setPressed(true);
     },
 
     /**
      * @param {!KeyboardEvent} event .
      */
     _spaceKeyUpHandler: function(event) {
       var keyboardEvent = event.detail.keyboardEvent;
       var target = Polymer.dom(keyboardEvent).localTarget;
 
       // Ignore the event if this is coming from a focused light child, since that
       // element will deal with it.
-      if (this.isLightDescendant(target))
+      if (this.isLightDescendant(/** @type {Node} */(target)))
         return;
 
       if (this.pressed) {
         this._asyncClick();
       }
       this._setPressed(false);
     },
 
     // trigger click asynchronously, the asynchrony is useful to allow one
     // event handler to unwind before triggering another event
@@ skipping 932 matching lines @@
       }
     },
 
     _calculateElevation: function() {
       if (!this.raised) {
         this.elevation = 0;
       } else {
         Polymer.PaperButtonBehaviorImpl._calculateElevation.apply(this);
       }
     }
+    /**
+
+    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.
+    */
   });
 /**
  * `iron-range-behavior` provides the behavior for something with a minimum to maximum range.
  *
  * @demo demo/index.html
  * @polymerBehavior
  */
  Polymer.IronRangeBehavior = {
 
   properties: {
@@ skipping 1163 matching lines @@
     /**
      * Given a KeyboardEvent, this method will focus the appropriate item in the
      * menu (if there is a relevant item, and it is possible to focus it).
      *
      * @param {KeyboardEvent} event A KeyboardEvent.
      */
     _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 (title && title.trim().charAt(0).toLowerCase() === String.fromCharCode(event.keyCode).toLowerCase()) {
           this._setFocusedItem(item);
           break;
         }
       }
     },
 
     /**
      * Focuses the previous item (relative to the currently focused item) in the
      * menu.
@@ skipping 20 matching lines @@
      * @param {Element} item An item in the menu.
      * @param {boolean} isSelected True if the item should be shown in a
      * selected state, otherwise false.
      */
     _applySelection: function(item, isSelected) {
       if (isSelected) {
         item.setAttribute('aria-selected', 'true');
       } else {
         item.removeAttribute('aria-selected');
       }
-
       Polymer.IronSelectableBehavior._applySelection.apply(this, arguments);
     },
 
     /**
      * Discretely updates tabindex values among menu items as the focused item
      * changes.
      *
      * @param {Element} focusedItem The element that is currently focused.
      * @param {?Element} old The last element that was considered focused, if
      * applicable.
@@ skipping 27 matching lines @@
         }
       }
     },
 
     /**
      * Handler that is called when a shift+tab keypress is detected by the menu.
      *
      * @param {CustomEvent} event A key combination event.
      */
     _onShiftTabDown: function(event) {
-      var oldTabIndex;
+      var oldTabIndex = this.getAttribute('tabindex');
 
       Polymer.IronMenuBehaviorImpl._shiftTabPressed = true;
 
-      oldTabIndex = this.getAttribute('tabindex');
+      this._setFocusedItem(null);
 
       this.setAttribute('tabindex', '-1');
 
       this.async(function() {
         this.setAttribute('tabindex', oldTabIndex);
         Polymer.IronMenuBehaviorImpl._shiftTabPressed = false;
-      // NOTE(cdata): polymer/polymer#1305
+        // NOTE(cdata): polymer/polymer#1305
       }, 1);
     },
 
     /**
      * Handler that is called when the menu receives focus.
      *
      * @param {FocusEvent} event A focus event.
      */
     _onFocus: function(event) {
       if (Polymer.IronMenuBehaviorImpl._shiftTabPressed) {
+        // do not focus the menu itself
         return;
       }
-      // do not focus the menu itself
+
       this.blur();
+
       // clear the cached focus item
-      this._setFocusedItem(null);
       this._defaultFocusAsync = this.async(function() {
         // focus the selected item when the menu receives focus, or the first item
         // if no item is selected
         var selectedItem = this.multi ? (this.selectedItems && this.selectedItems[0]) : this.selectedItem;
+
+        this._setFocusedItem(null);
+
         if (selectedItem) {
           this._setFocusedItem(selectedItem);
         } else {
           this._setFocusedItem(this.items[0]);
         }
-      // async 100ms to wait for `select` to get called from `_itemActivate`
-      }, 100);
+      // async 1ms to wait for `select` to get called from `_itemActivate`
+      }, 1);
     },
 
     /**
      * Handler that is called when the up key is pressed.
      *
      * @param {CustomEvent} event A key combination event.
      */
     _onUpKey: function(event) {
       // up and down arrows moves the focus
       this._focusPrevious();
@@ skipping 17 matching lines @@
       // esc blurs the control
       this.focusedItem.blur();
     },
 
     /**
      * Handler that is called when a keydown event is detected.
      *
      * @param {KeyboardEvent} event A keyboard event.
      */
     _onKeydown: function(event) {
-      if (this.keyboardEventMatchesKeys(event, 'up down esc')) {
-        return;
+      if (!this.keyboardEventMatchesKeys(event, 'up down esc')) {
+        // all other keys focus the menu item starting with that character
+        this._focusWithKeyboardEvent(event);
       }
+      event.stopPropagation();
+    },
 
-      // all other keys focus the menu item starting with that character
-      this._focusWithKeyboardEvent(event);
+    // override _activateHandler
+    _activateHandler: function(event) {
+      Polymer.IronSelectableBehavior._activateHandler.call(this, event);
+      event.stopPropagation();
     }
   };
 
   Polymer.IronMenuBehaviorImpl._shiftTabPressed = false;
 
   /** @polymerBehavior Polymer.IronMenuBehavior */
   Polymer.IronMenuBehavior = [
     Polymer.IronMultiSelectableBehavior,
     Polymer.IronA11yKeysBehavior,
     Polymer.IronMenuBehaviorImpl
@@ skipping 3024 matching lines @@
       items_: {
         type: Array,
         value: function() { return []; },
       },
     },
 
     hostAttributes: {
       loading: true,
     },
 
+    listeners: {
+      'downloads-list.scroll': 'onListScroll_',
+    },
+
     observers: [
       'itemsChanged_(items_.*)',
     ],
 
     /** @private */
     clearAll_: function() {
       this.set('items_', []);
     },
 
     /** @private */
@@ skipping 47 matching lines @@
      * @param {Event} e
      * @private
      */
     onCommand_: function(e) {
       if (e.command.id == 'clear-all-command')
         downloads.ActionService.getInstance().clearAll();
       else if (e.command.id == 'undo-command')
         downloads.ActionService.getInstance().undo();
     },
 
+    /**
+     * @param {Event} e
+     * @private
+     */
+    onListScroll_: function(e) {
+      var list = this.$['downloads-list'];
+      if (list.scrollHeight - list.scrollTop - list.offsetHeight <= 100) {
+        // Approaching the end of the scrollback. Attempt to load more items.
+        downloads.ActionService.getInstance().loadMore();
+      }
+    },
+
     /** @private */
     onLoad_: function() {
       cr.ui.decorate('command', cr.ui.Command);
       document.addEventListener('canExecute', this.onCanExecute_.bind(this));
       document.addEventListener('command', this.onCommand_.bind(this));
 
-      // Shows all downloads.
-      downloads.ActionService.getInstance().search('');
+      downloads.ActionService.getInstance().loadMore();
     },
 
     /**
      * @param {number} index
      * @private
      */
     removeItem_: function(index) {
       this.splice('items_', index, 1);
       this.updateHideDates_(index, index);
+      this.onListScroll_();
     },
 
     /**
      * @param {number} start
      * @param {number} end
      * @private
      */
     updateHideDates_: function(start, end) {
       for (var i = start; i <= end; ++i) {
         var current = this.items_[i];
@@ skipping 42 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);