Run clang-format on .js files in c/b/r/chromeos/chromevox

chrome/browser/resources/chromeos/chromevox/common/key_util.js

 // Copyright 2014 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 A collection of JavaScript utilities used to simplify working
  * with keyboard events.
  */
 
 
 goog.provide('cvox.KeyUtil');
 goog.provide('cvox.SimpleKeyEvent');
 
 goog.require('Msgs');
 goog.require('cvox.ChromeVox');
 goog.require('cvox.KeySequence');
 
 /**
  * @typedef {{ctrlKey: (boolean|undefined),
  *            altKey: (boolean|undefined),
  *            shiftKey: (boolean|undefined),
  *            keyCode: (number|undefined)}}
  */
 cvox.SimpleKeyEvent;
 
 /**
  * Create the namespace
  * @constructor
  */
-cvox.KeyUtil = function() {
-};
+cvox.KeyUtil = function() {};
 
 /**
  * The time in ms at which the ChromeVox Sticky Mode key was pressed.
  * @type {number}
  */
 cvox.KeyUtil.modeKeyPressTime = 0;
 
 /**
  * Indicates if sequencing is currently active for building a keyboard shortcut.
  * @type {boolean}
@@ skipping 32 matching lines @@
 cvox.KeyUtil.keyEventToKeySequence = function(keyEvent) {
   var util = cvox.KeyUtil;
   if (util.prevKeySequence &&
       (util.maxSeqLength == util.prevKeySequence.length())) {
     // Reset the sequence buffer if max sequence length is reached.
     util.sequencing = false;
     util.prevKeySequence = null;
   }
   // Either we are in the middle of a key sequence (N > H), or the key prefix
   // was pressed before (Ctrl+Z), or sticky mode is enabled
-  var keyIsPrefixed = util.sequencing || keyEvent['keyPrefix'] ||
-      keyEvent['stickyMode'];
+  var keyIsPrefixed =
+      util.sequencing || keyEvent['keyPrefix'] || keyEvent['stickyMode'];
 
   // Create key sequence.
   var keySequence = new cvox.KeySequence(keyEvent);
 
   // Check if the Cvox key should be considered as pressed because the
   // modifier key combination is active.
   var keyWasCvox = keySequence.cvoxModifier;
 
   if (keyIsPrefixed || keyWasCvox) {
     if (!util.sequencing && util.isSequenceSwitchKeyCode(keySequence)) {
@@ skipping 11 matching lines @@
         throw 'Think sequencing is enabled, yet util.prevKeySequence already' +
             'has two key codes' + util.prevKeySequence;
       }
     }
   } else {
     util.sequencing = false;
   }
 
   // Repeated keys pressed.
   var currTime = new Date().getTime();
-  if (cvox.KeyUtil.isDoubleTapKey(keySequence) &&
-      util.prevKeySequence &&
+  if (cvox.KeyUtil.isDoubleTapKey(keySequence) && util.prevKeySequence &&
       keySequence.equals(util.prevKeySequence)) {
     var prevTime = util.modeKeyPressTime;
     var delta = currTime - prevTime;
     if (prevTime > 0 && delta > 100 && delta < 300) {  // Double tap
       keySequence = util.prevKeySequence;
       keySequence.doubleTap = true;
       util.prevKeySequence = null;
       util.sequencing = false;
       // Resets the search key state tracked for ChromeOS because in OOBE,
       // we never get a key up for the key down (keyCode 91).
@@ skipping 57 matching lines @@
 };
 
 /**
  * Returns the keycode of a string representation of the specified modifier.
  *
  * @param {string} keyString Modifier key.
  * @return {number} Key code.
  */
 cvox.KeyUtil.modStringToKeyCode = function(keyString) {
   switch (keyString) {
-  case 'Ctrl':
-    return 17;
-  case 'Alt':
-    return 18;
-  case 'Shift':
-    return 16;
-  case 'Cmd':
-  case 'Win':
-    return 91;
+    case 'Ctrl':
+      return 17;
+    case 'Alt':
+      return 18;
+    case 'Shift':
+      return 16;
+    case 'Cmd':
+    case 'Win':
+      return 91;
   }
   return -1;
 };
 
 /**
  * Returns the key codes of a string respresentation of the ChromeVox modifiers.
  *
  * @return {Array<number>} Array of key codes.
  */
 cvox.KeyUtil.cvoxModKeyCodes = function() {
@@ skipping 48 matching lines @@
     } else if (cvox.ChromeVox.isMac) {
       return 'Cmd';
     } else {
       return 'Win';
     }
   } else if (keyCode == 8) {
     return 'Backspace';
   } else if (keyCode == 32) {
     return 'Space';
   } else if (keyCode == 35) {
-    return'end';
+    return 'end';
   } else if (keyCode == 36) {
     return 'home';
   } else if (keyCode == 37) {
     return 'Left arrow';
   } else if (keyCode == 38) {
     return 'Up arrow';
   } else if (keyCode == 39) {
     return 'Right arrow';
   } else if (keyCode == 40) {
     return 'Down arrow';
@@ skipping 57 matching lines @@
   return '';
 };
 
 /**
  * Get the platform specific sticky key keycode.
  *
  * @return {number} The platform specific sticky key keycode.
  */
 cvox.KeyUtil.getStickyKeyCode = function() {
   // TODO (rshearer): This should not be hard-coded here.
-  var stickyKeyCode = 45; // Insert for Linux and Windows
+  var stickyKeyCode = 45;  // Insert for Linux and Windows
   if (cvox.ChromeVox.isChromeOS || cvox.ChromeVox.isMac) {
-    stickyKeyCode = 91; // GUI key (Search/Cmd) for ChromeOs and Mac
+    stickyKeyCode = 91;  // GUI key (Search/Cmd) for ChromeOs and Mac
   }
   return stickyKeyCode;
 };
 
 
 /**
  * Get readable string description for an internal string representation of a
  * key or a keyboard shortcut.
  *
  * @param {string} keyStr The internal string repsentation of a key or
@@ skipping 53 matching lines @@
     var tempStr = '';
     for (var keyPressed in keySequence.keys) {
       // This iterates through the actual key, taking into account any
       // modifiers.
       if (!keySequence.keys[keyPressed][index]) {
         continue;
       }
       var modifier = '';
       switch (keyPressed) {
         case 'ctrlKey':
-        // TODO(rshearer): This is a hack to work around the special casing
-        // of the Ctrl key that used to happen in keyEventToString. We won't
-        // need it once we move away from strings completely.
-        modifier = 'Ctrl';
-        break;
-      case 'searchKeyHeld':
-        var searchKey = cvox.KeyUtil.getReadableNameForKeyCode(91);
-        modifier = searchKey;
-        break;
-      case 'altKey':
-        modifier = 'Alt';
-        break;
-      case 'altGraphKey':
-        modifier = 'AltGraph';
-        break;
-      case 'shiftKey':
-        modifier = 'Shift';
-        break;
-      case 'metaKey':
-        var metaKey = cvox.KeyUtil.getReadableNameForKeyCode(91);
-        modifier = metaKey;
-        break;
-      case 'keyCode':
-        var keyCode = keySequence.keys[keyPressed][index];
-        // We make sure the keyCode isn't for a modifier key. If it is, then
-        // we've already added that into the string above.
-        if (!keySequence.isModifierKey(keyCode) && !opt_modifiers) {
-          if (opt_readableKeyCode) {
-            tempStr += cvox.KeyUtil.getReadableNameForKeyCode(keyCode);
-          } else {
-            tempStr += cvox.KeyUtil.keyCodeToString(keyCode);
+          // TODO(rshearer): This is a hack to work around the special casing
+          // of the Ctrl key that used to happen in keyEventToString. We won't
+          // need it once we move away from strings completely.
+          modifier = 'Ctrl';
+          break;
+        case 'searchKeyHeld':
+          var searchKey = cvox.KeyUtil.getReadableNameForKeyCode(91);
+          modifier = searchKey;
+          break;
+        case 'altKey':
+          modifier = 'Alt';
+          break;
+        case 'altGraphKey':
+          modifier = 'AltGraph';
+          break;
+        case 'shiftKey':
+          modifier = 'Shift';
+          break;
+        case 'metaKey':
+          var metaKey = cvox.KeyUtil.getReadableNameForKeyCode(91);
+          modifier = metaKey;
+          break;
+        case 'keyCode':
+          var keyCode = keySequence.keys[keyPressed][index];
+          // We make sure the keyCode isn't for a modifier key. If it is, then
+          // we've already added that into the string above.
+          if (!keySequence.isModifierKey(keyCode) && !opt_modifiers) {
+            if (opt_readableKeyCode) {
+              tempStr += cvox.KeyUtil.getReadableNameForKeyCode(keyCode);
+            } else {
+              tempStr += cvox.KeyUtil.keyCodeToString(keyCode);
+            }
           }
-        }
       }
       if (str.indexOf(modifier) == -1) {
-          tempStr += modifier + '+';
+        tempStr += modifier + '+';
       }
     }
     str += tempStr;
 
     // Strip trailing +.
     if (str[str.length - 1] == '+') {
       str = str.slice(0, -1);
     }
   }
 
@@ skipping 23 matching lines @@
   key.doubleTap = true;
   for (var i = 0, keySeq; keySeq = cvox.KeySequence.doubleTapCache[i]; i++) {
     if (keySeq.equals(key)) {
       isSet = true;
       break;
     }
   }
   key.doubleTap = originalState;
   return isSet;
 };