MD Downloads: vulcanize to pick up recent Polymer changes

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 11010 matching lines @@
      * 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) {
+    /**
+     * Transforms the key.
+     * @param {string} key The KeyBoardEvent.key
+     * @param {Boolean} [noSpecialChars] Limits the transformation to
+     * alpha-numeric characters.
+     */
+    function transformKey(key, noSpecialChars) {
       var validKey = '';
       if (key) {
         var lKey = key.toLowerCase();
         if (lKey === ' ' || SPACE_KEY.test(lKey)) {
           validKey = 'space';
         } else if (lKey.length == 1) {
-          validKey = lKey;
+          if (!noSpecialChars || KEY_CHAR.test(lKey)) {
+            validKey = lKey;
+          }
         } else if (ARROW_KEY.test(lKey)) {
           validKey = lKey.replace('arrow', '');
         } else if (lKey == 'multiply') {
           // numpad '*' can map to Multiply on IE/Windows
           validKey = '*';
         } else {
           validKey = lKey;
         }
       }
       return validKey;
@@ skipping 30 matching lines @@
         } else if (keyCode >= 96 && keyCode <= 105) {
           // num pad 0-9
           validKey = String(96 - keyCode);
         } else {
           validKey = KEY_CODE[keyCode];
         }
       }
       return validKey;
     }
 
-    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) ||
+    /**
+      * Calculates the normalized key for a KeyboardEvent.
+      * @param {KeyboardEvent} keyEvent
+      * @param {Boolean} [noSpecialChars] Set to true to limit keyEvent.key
+      * transformation to alpha-numeric chars. This is useful with key
+      * combinations like shift + 2, which on FF for MacOS produces
+      * 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) || '';
+        transformKey(keyEvent.detail.key, noSpecialChars) || '';
     }
 
-    function keyComboMatchesEvent(keyCombo, event, eventKey) {
-      return eventKey === keyCombo.key &&
+    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 &&
           !!event.metaKey === !!keyCombo.metaKey)
         );
     }
 
     function parseKeyComboString(keyComboString) {
       if (keyComboString.length === 1) {
@@ skipping 116 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 eventKey = normalizedKeyForEvent(event);
         for (var i = 0; i < keyCombos.length; ++i) {
-          if (keyComboMatchesEvent(keyCombos[i], event, eventKey)) {
+          if (keyComboMatchesEvent(keyCombos[i], event)) {
             return true;
           }
         }
         return false;
       },
 
       _collectKeyBindings: function() {
         var keyBindings = this.behaviors.map(function(behavior) {
           return behavior.keyBindings;
         });
@@ skipping 79 matching lines @@
       _onKeyBindingEvent: function(keyBindings, event) {
         if (this.stopKeyboardEventPropagation) {
           event.stopPropagation();
         }
 
         // if event has been already prevented, don't do anything
         if (event.defaultPrevented) {
           return;
         }
 
-        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)) {
+          if (keyComboMatchesEvent(keyCombo, event)) {
             this._triggerKeyHandler(keyCombo, handlerName, event);
             // exit the loop if eventDefault was prevented
             if (event.defaultPrevented) {
               return;
             }
           }
         }
       },
 
       _triggerKeyHandler: function(keyCombo, handlerName, keyboardEvent) {
@@ skipping 1189 matching lines @@
       raised: {
         type: Boolean,
         reflectToAttribute: true,
         value: false,
         observer: '_calculateElevation'
       }
     },
 
     _calculateElevation: function() {
       if (!this.raised) {
-        this.elevation = 0;
+        this._setElevation(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.
 
@@ skipping 92 matching lines @@
     return this.value !== v;
   },
 
   _update: function() {
     this._validateValue();
     this._setRatio(this._calcRatio(this.value) * 100);
   }
 
 };
 Polymer({
-
     is: 'paper-progress',
 
     behaviors: [
       Polymer.IronRangeBehavior
     ],
 
     properties: {
-
       /**
        * The number that represents the current secondary progress.
        */
       secondaryProgress: {
         type: Number,
         value: 0
       },
 
       /**
        * The secondary ratio
@@ skipping 65 matching lines @@
       this.setAttribute('aria-valuemax', max);
     },
 
     _disabledChanged: function(disabled) {
       this.setAttribute('aria-disabled', disabled ? 'true' : 'false');
     },
 
     _hideSecondaryProgress: function(secondaryRatio) {
       return secondaryRatio === 0;
     }
-
   });
 // 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.
 
 cr.define('downloads', function() {
   var InkyTextButton = Polymer({
     is: 'inky-text-button',
 
     behaviors: [
@@ skipping 326 matching lines @@
 /** @polymerBehavior Polymer.PaperItemBehavior */
   Polymer.PaperItemBehaviorImpl = {
     hostAttributes: {
       role: 'option',
       tabindex: '0'
     }
   };
 
   /** @polymerBehavior */
   Polymer.PaperItemBehavior = [
+    Polymer.IronButtonState,
     Polymer.IronControlState,
-    Polymer.IronButtonState,
     Polymer.PaperItemBehaviorImpl
   ];
 Polymer({
       is: 'paper-item',
 
       behaviors: [
         Polymer.PaperItemBehavior
       ]
     });
 /**
@@ skipping 1351 matching lines @@
       _boundOnCaptureKeydown: {
         type: Function,
         value: function() {
           return this._onCaptureKeydown.bind(this);
         }
       }
 
     },
 
     listeners: {
-      'tap': '_onClick',
       'iron-resize': '_onIronResize'
     },
 
     /**
      * The backdrop element.
      * @type Node
      */
     get backdropElement() {
       return this._backdrop;
     },
 
     get _focusNode() {
       return Polymer.dom(this).querySelector('[autofocus]') || this;
     },
 
     registered: function() {
       this._backdrop = document.createElement('iron-overlay-backdrop');
     },
 
     ready: function() {
       this._ensureSetup();
+    },
+
+    attached: function() {
+      // Call _openedChanged here so that position can be computed correctly.
       if (this._callOpenedWhenReady) {
         this._openedChanged();
       }
     },
 
     detached: function() {
       this.opened = false;
       this._completeBackdrop();
       this._manager.removeOverlay(this);
     },
@@ skipping 211 matching lines @@
         if (!this.noAutoFocus) {
           this._focusNode.focus();
         }
       } else {
         this._focusNode.blur();
         this._manager.focusOverlay();
       }
     },
 
     _onCaptureClick: function(event) {
-      // attempt to close asynchronously and prevent the close of a tap event is immediately heard
-      // on target. This is because in shadow dom due to event retargetting event.target is not
-      // useful.
-      if (!this.noCancelOnOutsideClick && (this._manager.currentOverlay() == this)) {
-        this._cancelJob = this.async(function() {
-          this.cancel();
-        }, 10);
+      if (!this.noCancelOnOutsideClick &&
+          this._manager.currentOverlay() === this &&
+          Polymer.dom(event).path.indexOf(this) === -1) {
+        this.cancel();
       }
     },
 
-    _onClick: function(event) {
-      if (this._cancelJob) {
-        this.cancelAsync(this._cancelJob);
-        this._cancelJob = null;
-      }
-    },
-
     _onCaptureKeydown: function(event) {
       var ESC = 27;
       if (!this.noCancelOnEscKey && (event.keyCode === ESC)) {
         this.cancel();
         event.stopPropagation();
+        event.stopImmediatePropagation();
       }
     },
 
     _onIronResize: function() {
       if (this._squelchNextResize) {
         this._squelchNextResize = false;
         return;
       }
       if (this.opened) {
         this.refit();
@@ skipping 233 matching lines @@
       }
     },
 
     /**
      * An element implementing `Polymer.NeonAnimationRunnerBehavior` calls this method to configure
      * an animation with an optional type. Elements implementing `Polymer.NeonAnimatableBehavior`
      * should define the property `animationConfig`, which is either a configuration object
      * or a map of animation type to array of configuration objects.
      */
     getAnimationConfig: function(type) {
-      var map = [];
+      var map = {};
       var allConfigs = [];
       this._getAnimationConfigRecursive(type, map, allConfigs);
       // append the configurations saved in the map to the array
       for (var key in map) {
         allConfigs.push(map[key]);
       }
       return allConfigs;
     }
 
   };
@@ skipping 123 matching lines @@
 
       /**
        * Returns true if the provided element is "scroll locked," which is to
        * say that it cannot be scrolled via pointer or keyboard interactions.
        *
        * @param {HTMLElement} element An HTML element instance which may or may
        * not be scroll locked.
        */
       elementIsScrollLocked: function(element) {
         var currentLockingElement = this.currentLockingElement;
+
+        if (currentLockingElement === undefined)
+          return false;
+
         var scrollLocked;
 
         if (this._hasCachedLockedElement(element)) {
           return true;
         }
 
         if (this._hasCachedUnlockedElement(element)) {
           return false;
         }
 
@@ skipping 194 matching lines @@
            * vertically relative to the dropdown trigger.
            */
           verticalAlign: {
             type: String,
             value: 'top',
             reflectToAttribute: true
           },
 
           /**
            * A pixel value that will be added to the position calculated for the
-           * given `horizontalAlign`. Use a negative value to offset to the
-           * left, or a positive value to offset to the right.
+           * given `horizontalAlign`, in the direction of alignment. You can think
+           * of it as increasing or decreasing the distance to the side of the
+           * screen given by `horizontalAlign`.
+           *
+           * If `horizontalAlign` is "left", this offset will increase or decrease
+           * the distance to the left side of the screen: a negative offset will
+           * move the dropdown to the left; a positive one, to the right.
+           *
+           * Conversely if `horizontalAlign` is "right", this offset will increase
+           * or decrease the distance to the right side of the screen: a negative
+           * offset will move the dropdown to the right; a positive one, to the left.
            */
           horizontalOffset: {
             type: Number,
             value: 0,
             notify: true
           },
 
           /**
            * A pixel value that will be added to the position calculated for the
-           * given `verticalAlign`. Use a negative value to offset towards the
-           * top, or a positive value to offset towards the bottom.
+           * given `verticalAlign`, in the direction of alignment. You can think
+           * of it as increasing or decreasing the distance to the side of the
+           * screen given by `verticalAlign`.
+           *
+           * If `verticalAlign` is "top", this offset will increase or decrease
+           * the distance to the top side of the screen: a negative offset will
+           * move the dropdown upwards; a positive one, downwards.
+           *
+           * Conversely if `verticalAlign` is "bottom", this offset will increase
+           * or decrease the distance to the bottom side of the screen: a negative
+           * offset will move the dropdown downwards; a positive one, upwards.
            */
           verticalOffset: {
             type: Number,
             value: 0,
             notify: true
           },
 
           /**
            * The element that should be used to position the dropdown when
            * it is opened.
@@ skipping 79 matching lines @@
         },
 
         /**
          * The element that should be focused when the dropdown opens.
          */
         get _focusTarget() {
           return this.focusTarget || this.containedElement;
         },
 
         /**
+         * Whether the text direction is RTL
+         */
+        _isRTL: function() {
+          return window.getComputedStyle(this).direction == 'rtl';
+        },
+
+        /**
          * The element that should be used to position the dropdown when
          * it opens, if no position target is configured.
          */
         get _defaultPositionTarget() {
           var parent = Polymer.dom(this).parentNode;
 
           if (parent.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
             parent = parent.host;
           }
 
@@ skipping 10 matching lines @@
 
           return this._positionRectMemo;
         },
 
         /**
          * The horizontal offset value used to position the dropdown.
          */
         get _horizontalAlignTargetValue() {
           var target;
 
-          if (this.horizontalAlign === 'right') {
+          // In RTL, the direction flips, so what is "right" in LTR becomes "left".
+          var isRTL = this._isRTL();
+          if ((!isRTL && this.horizontalAlign === 'right') ||
+              (isRTL && this.horizontalAlign === 'left')) {
             target = document.documentElement.clientWidth - this._positionRect.right;
           } else {
             target = this._positionRect.left;
           }
 
           target += this.horizontalOffset;
 
           return Math.max(target, 0);
         },
 
         /**
          * The vertical offset value used to position the dropdown.
          */
         get _verticalAlignTargetValue() {
           var target;
 
           if (this.verticalAlign === 'bottom') {
             target = document.documentElement.clientHeight - this._positionRect.bottom;
           } else {
             target = this._positionRect.top;
           }
 
           target += this.verticalOffset;
 
           return Math.max(target, 0);
         },
 
         /**
+         * The horizontal align value, accounting for the RTL/LTR text direction.
+         */
+        get _localeHorizontalAlign() {
+          // In RTL, "left" becomes "right".
+          if (this._isRTL()) {
+            return this.horizontalAlign === 'right' ? 'left' : 'right';
+          } else {
+            return this.horizontalAlign;
+          }
+        },
+
+        /**
          * Called when the value of `opened` changes.
          *
          * @param {boolean} opened True if the dropdown is opened.
          */
         _openedChanged: function(opened) {
           if (opened && this.disabled) {
             this.cancel();
           } else {
             this.cancelAnimation();
             this._prepareDropdown();
@@ skipping 127 matching lines @@
          * and vertical alignment, and re-memoizes these values for the sake
          * of behavior in `IronFitBehavior`.
          */
         _updateOverlayPosition: function() {
           this._positionRectMemo = null;
 
           if (!this.positionTarget) {
             return;
           }
 
-          this.style[this.horizontalAlign] =
+          this.style[this._localeHorizontalAlign] =
             this._horizontalAlignTargetValue + 'px';
 
           this.style[this.verticalAlign] =
             this._verticalAlignTargetValue + 'px';
 
           // NOTE(cdata): We re-memoize inline styles here, otherwise
           // calling `refit` from `IronFitBehavior` will reset inline styles
           // to whatever they were when the dropdown first opened.
           if (this._fitInfo) {
             this._fitInfo.inlineStyle[this.horizontalAlign] =
@@ skipping 612 matching lines @@
       /**
        * Use this property instead of `value` for two-way data binding.
        */
       bindValue: {
         observer: '_bindValueChanged',
         type: String
       },
 
       /**
        * Set to true to prevent the user from entering invalid input. The new input characters are
-       * matched with `allowedPattern` if it is set, otherwise it will use the `pattern` attribute if
-       * set, or the `type` attribute (only supported for `type=number`).
+       * matched with `allowedPattern` if it is set, otherwise it will use the `type` attribute (only
+       * supported for `type=number`).
        */
       preventInvalidInput: {
         type: Boolean
       },
 
       /**
-       * Regular expression to match valid input characters.
+       * Regular expression expressing a set of characters to enforce the validity of input characters.
+       * The recommended value should follow this format: `[a-ZA-Z0-9.+-!;:]` that list the characters 
+       * allowed as input.
        */
       allowedPattern: {
         type: String,
         observer: "_allowedPatternChanged"
       },
 
       _previousValidInput: {
         type: String,
         value: ''
       },
 
       _patternAlreadyChecked: {
         type: Boolean,
         value: false
       }
 
     },
 
     listeners: {
       'input': '_onInput',
       'keypress': '_onKeypress'
     },
 
     get _patternRegExp() {
       var pattern;
       if (this.allowedPattern) {
         pattern = new RegExp(this.allowedPattern);
-      } else if (this.pattern) {
-        pattern = new RegExp(this.pattern);
       } else {
         switch (this.type) {
           case 'number':
             pattern = /[0-9.,e-]/;
             break;
         }
       }
       return pattern;
     },
 
     ready: function() {
       this.bindValue = this.value;
     },
 
     /**
      * @suppress {checkTypes}
      */
     _bindValueChanged: function() {
       if (this.value !== this.bindValue) {
-        this.value = !(this.bindValue || this.bindValue === 0) ? '' : this.bindValue;
+        this.value = !(this.bindValue || this.bindValue === 0 || this.bindValue === false) ? '' : this.bindValue;
       }
       // manually notify because we don't want to notify until after setting value
       this.fire('bind-value-changed', {value: this.bindValue});
     },
 
     _allowedPatternChanged: function() {
       // Force to prevent invalid input when an `allowed-pattern` is set
       this.preventInvalidInput = this.allowedPattern ? true : false;
     },
 
@@ skipping 88 matching lines @@
       // Empty, non-required input is valid.
       if (!this.required && this.value == '') {
         this.invalid = false;
         return true;
       }
 
       var valid;
       if (this.hasValidator()) {
         valid = Polymer.IronValidatableBehavior.validate.call(this, this.value);
       } else {
-        this.invalid = !this.validity.valid;
-        valid = this.validity.valid;
+        valid = this.checkValidity();
+        this.invalid = !valid;
       }
       this.fire('iron-input-validate');
       return valid;
     }
 
   });
 
   /*
   The `iron-input-validate` event is fired whenever `validate()` is called.
   @event iron-input-validate
@@ skipping 623 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);