Fix presubmit js style nits.

chrome/browser/resources/chromeos/keyboard_overlay.js

 // Copyright (c) 2012 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.
 
 <include src="keyboard_overlay_data.js"/>
 <include src="keyboard_overlay_accessibility_helper.js"/>
 
 var BASE_KEYBOARD = {
   top: 0,
   left: 0,
@@ skipping 19 matching lines @@
   '1D': 'is-ctrl',
   '38': 'is-alt'
 };
 
 var LABEL_TO_IDENTIFIER = {
   'search': 'E0 5B',
   'ctrl': '1D',
   'alt': '38',
   'caps lock': '3A',
   'disabled': 'DISABLED'
-}
+};
 
 var keyboardOverlayId = 'en_US';
 var identifierMap = {};
 
 /**
  * Returns layouts data.
+ * @return {Object} Keyboard layout data.
  */
 function getLayouts() {
   return keyboardOverlayData['layouts'];
 }
 
 /**
  * Returns shortcut data.
+ * @return {Object} Keyboard shortcut data.
  */
 function getShortcutData() {
   return keyboardOverlayData['shortcut'];
 }
 
 /**
  * Returns the keyboard overlay ID.
+ * @return {string} Keyboard overlay ID.
  */
 function getKeyboardOverlayId() {
   return keyboardOverlayId;
 }
 
 /**
  * Returns keyboard glyph data.
+ * @return {Object} Keyboard glyph data.
  */
 function getKeyboardGlyphData() {
   return keyboardOverlayData['keyboardGlyph'][getKeyboardOverlayId()];
 }
 
 /**
  * Converts a single hex number to a character.
+ * @param {string} hex Hexadecimal string.
+ * @return {string} Unicode values of hexadecimal string.
  */
 function hex2char(hex) {
   if (!hex) {
     return '';
   }
   var result = '';
   var n = parseInt(hex, 16);
   if (n <= 0xFFFF) {
     result += String.fromCharCode(n);
   } else if (n <= 0x10FFFF) {
     n -= 0x10000;
     result += (String.fromCharCode(0xD800 | (n >> 10)) +
                String.fromCharCode(0xDC00 | (n & 0x3FF)));
   } else {
     console.error('hex2Char error: Code point out of range :' + hex);
   }
   return result;
 }
 
 /**
  * Returns a list of modifiers from the key event.
+ * @param {Event} e The key event.
+ * @return {Array} List of modifiers based on key event.
  */
 function getModifiers(e) {
-  if (!e) {
+  if (!e)
     return [];
-  }
+
   var isKeyDown = (e.type == 'keydown');
   var keyCodeToModifier = {
     16: 'SHIFT',
     17: 'CTRL',
     18: 'ALT',
     91: 'ALT', // left ALT pressed with SHIFT
     92: 'ALT', // right ALT pressed with SHIFT
   };
   var modifierWithKeyCode = keyCodeToModifier[e.keyCode];
   var isPressed = {'SHIFT': e.shiftKey, 'CTRL': e.ctrlKey, 'ALT': e.altKey};
   // if e.keyCode is one of Shift, Ctrl and Alt, isPressed should
   // be changed because the key currently pressed
   // does not affect the values of e.shiftKey, e.ctrlKey and e.altKey
-  if(modifierWithKeyCode){
+  if (modifierWithKeyCode)
     isPressed[modifierWithKeyCode] = isKeyDown;
-  }
+
   // make the result array
   return ['SHIFT', 'CTRL', 'ALT'].filter(
       function(modifier) {
         return isPressed[modifier];
       }).sort();
 }
 
 /**
  * Returns an ID of the key.
+ * @param {string} identifier Key identifier.
+ * @param {number} i Key number.
+ * @return {string} Key ID.
  */
 function keyId(identifier, i) {
   return identifier + '-key-' + i;
 }
 
 /**
  * Returns an ID of the text on the key.
+ * @param {string} identifier Key identifier.
+ * @param {number} i Key number.
+ * @return {string} Key text ID.
  */
 function keyTextId(identifier, i) {
   return identifier + '-key-text-' + i;
 }
 
 /**
  * Returns an ID of the shortcut text.
+ * @param {string} identifier Key identifier.
+ * @param {number} i Key number.
+ * @return {string} Key shortcut text ID.
  */
 function shortcutTextId(identifier, i) {
   return identifier + '-shortcut-text-' + i;
 }
 
 /**
  * Returns true if |list| contains |e|.
+ * @param {Array} list Container list.
+ * @param {string} e Element string.
+ * @return {boolean} Returns true if the list contains the element.
  */
 function contains(list, e) {
   return list.indexOf(e) != -1;
 }
 
 /**
  * Returns a list of the class names corresponding to the identifier and
  * modifiers.
+ * @param {string} identifier Key identifier.
+ * @param {Array} modifiers List of key modifiers.
+ * @return {Array} List of class names corresponding to specified params.
  */
 function getKeyClasses(identifier, modifiers) {
   var classes = ['keyboard-overlay-key'];
   for (var i = 0; i < modifiers.length; ++i) {
     classes.push(MODIFIER_TO_CLASS[modifiers[i]]);
   }
 
   if ((identifier == '2A' && contains(modifiers, 'SHIFT')) ||
       (identifier == '1D' && contains(modifiers, 'CTRL')) ||
       (identifier == '38' && contains(modifiers, 'ALT'))) {
     classes.push('pressed');
     classes.push(IDENTIFIER_TO_CLASS[identifier]);
   }
   return classes;
 }
 
 /**
  * Returns true if a character is a ASCII character.
+ * @param {string} c A character to be checked.
+ * @return {boolean} True if the character is an ASCII character.
  */
 function isAscii(c) {
   var charCode = c.charCodeAt(0);
   return 0x00 <= charCode && charCode <= 0x7F;
 }
 
 /**
  * Returns a remapped identiifer based on the preference.
+ * @param {string} identifier Key identifier.
+ * @return {string} Remapped identifier.
  */
 function remapIdentifier(identifier) {
   return identifierMap[identifier] || identifier;
 }
 
 /**
  * Returns a label of the key.
+ * @param {string} keyData Key glyph data.
+ * @param {Array} modifiers Key Modifier list.
+ * @return {string} Label of the key.
  */
 function getKeyLabel(keyData, modifiers) {
   if (!keyData) {
     return '';
   }
   if (keyData.label) {
     return keyData.label;
   }
   var keyLabel = '';
   for (var j = 1; j <= 9; j++) {
-    var pos =  keyData['p' + j];
+    var pos = keyData['p' + j];
     if (!pos) {
       continue;
     }
     keyLabel = hex2char(pos);
     if (!keyLabel) {
       continue;
      }
     if (isAscii(keyLabel) &&
         getShortcutData()[getAction(keyLabel, modifiers)]) {
       break;
     }
   }
   return keyLabel;
 }
 
 /**
  * Returns a normalized string used for a key of shortcutData.
  *
  * Examples:
- *   keycode: 'd', modifiers: ['CTRL', 'SHIFT'] => 'd<>CTRL<>SHIFT'
- *   keycode: 'alt', modifiers: ['ALT', 'SHIFT'] => 'ALT<>SHIFT'
+ *   keyCode: 'd', modifiers: ['CTRL', 'SHIFT'] => 'd<>CTRL<>SHIFT'
+ *   keyCode: 'alt', modifiers: ['ALT', 'SHIFT'] => 'ALT<>SHIFT'
+ *
+ * @param {string} keyCode Key code.
+ * @param {Array} modifiers Key Modifier list.
+ * @return {string} Normalized key shortcut data string.
  */
-function getAction(keycode, modifiers) {
-  const SEPARATOR = '<>';
-  if (keycode.toUpperCase() in MODIFIER_TO_CLASS) {
-    keycode = keycode.toUpperCase();
-    if (keycode in modifiers) {
-      return modifiers.join(SEPARATOR);
+function getAction(keyCode, modifiers) {
+  /** @const */ var separatorStr = '<>';
+  if (keyCode.toUpperCase() in MODIFIER_TO_CLASS) {
+    keyCode = keyCode.toUpperCase();
+    if (keyCode in modifiers) {
+      return modifiers.join(separatorStr);
     } else {
-      var action = [keycode].concat(modifiers)
+      var action = [keyCode].concat(modifiers);
       action.sort();
-      return action.join(SEPARATOR);
+      return action.join(separatorStr);
     }
   }
-  return [keycode].concat(modifiers).join(SEPARATOR);
+  return [keyCode].concat(modifiers).join(separatorStr);
 }
 
 /**
  * Returns a text which displayed on a key.
+ * @param {string} keyData Key glyph data.
+ * @return {string} Key text value.
  */
 function getKeyTextValue(keyData) {
   if (keyData.label) {
     // Do not show text on the space key.
     if (keyData.label == 'space') {
       return '';
     }
     return keyData.label;
   }
 
   var chars = [];
   for (var j = 1; j <= 9; ++j) {
     var pos = keyData['p' + j];
     if (pos && pos.length > 0) {
       chars.push(hex2char(pos));
     }
   }
   return chars.join(' ');
 }
 
 /**
  * Updates the whole keyboard.
+ * @param {Array} modifiers Key Modifier list.
  */
 function update(modifiers) {
   var instructions = document.getElementById('instructions');
   if (modifiers.length == 0) {
     instructions.style.visibility = 'visible';
   } else {
     instructions.style.visibility = 'hidden';
   }
 
   var keyboardGlyphData = getKeyboardGlyphData();
@@ skipping 48 matching lines @@
       if (format == 'left' || format == 'right') {
         shortcutText.style.textAlign = format;
         keyText.style.textAlign = format;
       }
     }
   }
 }
 
 /**
  * A callback function for onkeydown and onkeyup events.
+ * @param {Event} e Key event.
  */
-function handleKeyEvent(e){
+function handleKeyEvent(e) {
   var modifiers = getModifiers(e);
   if (!getKeyboardOverlayId()) {
     return;
   }
   update(modifiers);
   KeyboardOverlayAccessibilityHelper.maybeSpeakAllShortcuts(modifiers);
 }
 
 /**
  * Initializes the layout of the keys.
@@ skipping 97 matching lines @@
 function init() {
   document.addEventListener('keydown', handleKeyEvent);
   document.addEventListener('keyup', handleKeyEvent);
   chrome.send('getLabelMap');
 }
 
 /**
  * Initializes the global map for remapping identifiers of modifier keys based
  * on the preference.
  * Called after sending the 'getLabelMap' message.
+ * @param {Object} remap Identifier map.
  */
 function initIdentifierMap(remap) {
   for (var key in remap) {
     var val = remap[key];
     if ((key in LABEL_TO_IDENTIFIER) &&
         (val in LABEL_TO_IDENTIFIER)) {
       identifierMap[LABEL_TO_IDENTIFIER[key]] =
           LABEL_TO_IDENTIFIER[val];
     } else {
       console.error('Invalid label map element: ' + key + ', ' + val);
     }
   }
   chrome.send('getInputMethodId');
 }
 
 /**
  * Initializes the global keyboad overlay ID and the layout of keys.
  * Called after sending the 'getInputMethodId' message.
+ * @param {inputMethodId} inputMethodId Input Method Identifier.
  */
 function initKeyboardOverlayId(inputMethodId) {
   // Libcros returns an empty string when it cannot find the keyboard overlay ID
   // corresponding to the current input method.
   // In such a case, fallback to the default ID (en_US).
-  var inputMethodIdToOverlayId = keyboardOverlayData['inputMethodIdToOverlayId']
+  var inputMethodIdToOverlayId =
+      keyboardOverlayData['inputMethodIdToOverlayId'];
   if (inputMethodId) {
     keyboardOverlayId = inputMethodIdToOverlayId[inputMethodId];
   }
   if (!keyboardOverlayId) {
     console.error('No keyboard overlay ID for ' + inputMethodId);
     keyboardOverlayId = 'en_US';
   }
-  while(document.body.firstChild) {
+  while (document.body.firstChild) {
     document.body.removeChild(document.body.firstChild);
   }
   initLayout();
   update([]);
 }
 
 /**
  * Handles click events of the learn more link.
+ * @param {Event} e Mouse click event.
  */
 function learnMoreClicked(e) {
   chrome.send('openLearnMorePage');
   chrome.send('DialogClose');
   e.preventDefault();
 }
 
 document.addEventListener('DOMContentLoaded', init);