Convert Event#keyIdentifier (deprecated) to Event#key

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 821 matching lines @@
 
   /**
    * This is used to identify keyboard shortcuts.
    * @param {string} shortcut The text used to describe the keys for this
    *     keyboard shortcut.
    * @constructor
    */
   function KeyboardShortcut(shortcut) {
     var mods = {};
     var ident = '';
-    shortcut.split('-').forEach(function(part) {
+    shortcut.split('|').forEach(function(part) {
       var partLc = part.toLowerCase();
       switch (partLc) {
         case 'alt':
         case 'ctrl':
         case 'meta':
         case 'shift':
           mods[partLc + 'Key'] = true;
           break;
         default:
           if (ident)
             throw Error('Invalid shortcut');
           ident = part;
       }
     });
 
     this.ident_ = ident;
     this.mods_ = mods;
   }
 
   KeyboardShortcut.prototype = {
     /**
      * Whether the keyboard shortcut object matches a keyboard event.
      * @param {!Event} e The keyboard event object.
      * @return {boolean} Whether we found a match or not.
      */
     matchesEvent: function(e) {
-      if (e.keyIdentifier == this.ident_) {
+      if (e.key == this.ident_) {
         // All keyboard modifiers needs to match.
         var mods = this.mods_;
         return ['altKey', 'ctrlKey', 'metaKey', 'shiftKey'].every(function(k) {
           return e[k] == !!mods[k];
         });
       }
       return false;
     }
   };
 
@@ skipping 40 matching lines @@
      * command can be executed or not.
      * @param {Node=} opt_node Node for which to actuate command state.
      */
     canExecuteChange: function(opt_node) {
       dispatchCanExecuteEvent(this,
                               opt_node || this.ownerDocument.activeElement);
     },
 
     /**
      * The keyboard shortcut that triggers the command. This is a string
-     * consisting of a keyIdentifier (as reported by WebKit in keydown) as
-     * well as optional key modifiers joinded with a '-'.
+     * consisting of a key (as reported by WebKit in keydown) as
+     * well as optional key modifiers joinded with a '|'.
      *
      * Multiple keyboard shortcuts can be provided by separating them by
      * whitespace.
      *
      * For example:
      *   "F1"
-     *   "U+0008-Meta" for Apple command backspace.
-     *   "U+0041-Ctrl" for Control A
-     *   "U+007F U+0008-Meta" for Delete and Command Backspace
+     *   "Backspace-Meta" for Apple command backspace.
+     *   "a-Ctrl" for Control A
+     *   "Delete Backspace-Meta" for Delete and Command Backspace
      *
      * @type {string}
      */
     shortcut_: '',
     get shortcut() {
       return this.shortcut_;
     },
     set shortcut(shortcut) {
       var oldShortcut = this.shortcut_;
       if (shortcut !== oldShortcut) {
@@ skipping 756 matching lines @@
     var KEY_IDENTIFIER = {
       'U+0008': 'backspace',
       'U+0009': 'tab',
       'U+001B': 'esc',
       'U+0020': 'space',
       'U+007F': 'del'
     };
 
     /**
      * Special table for KeyboardEvent.keyCode.
-     * KeyboardEvent.keyIdentifier is better, and KeyBoardEvent.key is even better
-     * than that.
+     * 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',
@@ skipping 23 matching lines @@
     /**
      * 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)?/;
 
@@ skipping 27 matching lines @@
         } 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 (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)) {
         if (keyCode >= 65 && keyCode <= 90) {
           // ascii a-z
           // lowercase is 32 offset from uppercase
           validKey = String.fromCharCode(32 + keyCode);
         } else if (keyCode >= 112 && keyCode <= 123) {
           // function keys f1-f12
           validKey = 'f' + (keyCode - 112);
@@ skipping 14 matching lines @@
       * 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
+      // Fall back from .key, 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 ? 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 &&
@@ skipping 2294 matching lines @@
 
     /** @this {ActionLink} */
     createdCallback: function() {
       // Action links can start disabled (e.g. <a is="action-link" disabled>).
       this.tabIndex = this.disabled ? -1 : 0;
 
       if (!this.hasAttribute('role'))
         this.setAttribute('role', 'link');
 
       this.addEventListener('keydown', function(e) {
-        if (!this.disabled && e.keyIdentifier == 'Enter' && !this.href) {
+        if (!this.disabled && e.key == 'Enter' && !this.href) {
           // Schedule a click asynchronously because other 'keydown' handlers
           // may still run later (e.g. document.addEventListener('keydown')).
           // Specifically options dialogs break when this timeout isn't here.
           // NOTE: this affects the "trusted" state of the ensuing click. I
           // haven't found anything that breaks because of this (yet).
           window.setTimeout(this.click.bind(this), 0);
         }
       });
 
       function preventDefault(e) {
@@ skipping 7347 matching lines @@
   Manager.updateItem = function(index, data) {
     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);
+window.addEventListener('load', downloads.Manager.onLoad);