DO NOT SUBMIT: what chrome/browser/resources/ could eventually look like with clang-format

chrome/browser/resources/chromeos/chromevox/common/key_sequence.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 JavaScript class that represents a sequence of keys entered
  * by the user.
  */
 
 
@@ skipping 26 matching lines @@
  * specified. We will also accept an event-shaped object.
  * @param {boolean=} opt_cvoxModifier Whether or not the ChromeVox modifier key
  * is active. If not specified, we will try to determine whether the modifier
  * was active by looking at the originalEvent.
  * from key events when the cvox modifiers are set. Defaults to false.
  * @param {boolean=} opt_doubleTap Whether this is triggered via double tap.
  * @param {boolean=} opt_skipStripping Whether to strip cvox modifiers.
  * @param {boolean=} opt_requireStickyMode Whether to require sticky mode.
  * @constructor
  */
-cvox.KeySequence = function(originalEvent, opt_cvoxModifier, opt_doubleTap,
-                            opt_skipStripping, opt_requireStickyMode) {
+cvox.KeySequence = function(
+    originalEvent, opt_cvoxModifier, opt_doubleTap, opt_skipStripping,
+    opt_requireStickyMode) {
   /** @type {boolean} */
   this.doubleTap = !!opt_doubleTap;
 
   /** @type {boolean} */
   this.requireStickyMode = !!opt_requireStickyMode;
 
   /** @type {cvox.PlatformFilter} */
   this.platformFilter;
   /** @type {boolean} */
   this.skipStripping = !!opt_skipStripping;
@@ skipping 108 matching lines @@
 
   if (this.doubleTap != rhs.doubleTap) {
     return false;
   }
 
   // So now we know the actual keys are the same.
 
   // If one key sequence requires sticky mode, return early the strict
   // sticky mode state.
   if (this.requireStickyMode || rhs.requireStickyMode) {
-    return (this.stickyMode || rhs.stickyMode) &&
-        !this.cvoxModifier && !rhs.cvoxModifier;
+    return (this.stickyMode || rhs.stickyMode) && !this.cvoxModifier &&
+        !rhs.cvoxModifier;
   }
 
   // If they both have the ChromeVox modifier, or they both don't have the
   // ChromeVox modifier, then they are considered equal.
   if (this.cvoxModifier === rhs.cvoxModifier) {
     return true;
   }
 
   // So only one of them has the ChromeVox modifier. If the one that doesn't
   // have the ChromeVox modifier has sticky mode or the prefix key then the
@@ skipping 159 matching lines @@
  * keyEvent.
  */
 cvox.KeySequence.prototype.isCVoxModifierActive = function(keyEvent) {
   // TODO (rshearer): Update this when the modifier key becomes customizable
   var modifierKeyCombo = cvox.ChromeVox.modKeyStr.split(/\+/g);
 
   // For each modifier that is held down, remove it from the combo.
   // If the combo string becomes empty, then the user has activated the combo.
   if (this.isKeyModifierActive(keyEvent, 'ctrlKey')) {
     modifierKeyCombo = modifierKeyCombo.filter(function(modifier) {
-                              return modifier != 'Ctrl';
-                            });
+      return modifier != 'Ctrl';
+    });
   }
   if (this.isKeyModifierActive(keyEvent, 'altKey')) {
     modifierKeyCombo = modifierKeyCombo.filter(function(modifier) {
-                                                 return modifier != 'Alt';
-                                               });
+      return modifier != 'Alt';
+    });
   }
   if (this.isKeyModifierActive(keyEvent, 'shiftKey')) {
     modifierKeyCombo = modifierKeyCombo.filter(function(modifier) {
-                                                 return modifier != 'Shift';
-                                               });
+      return modifier != 'Shift';
+    });
   }
   if (this.isKeyModifierActive(keyEvent, 'metaKey') ||
       this.isKeyModifierActive(keyEvent, 'searchKeyHeld')) {
     var metaKeyName = this.getMetaKeyName_();
     modifierKeyCombo = modifierKeyCombo.filter(function(modifier) {
-                                                 return modifier != metaKeyName;
-                                               });
+      return modifier != metaKeyName;
+    });
   }
   return (modifierKeyCombo.length == 0);
 };
 
 
 /**
  * Determines whether a particular key modifier (for example, ctrl or alt) is
  * active during the keyEvent.
  * @param {Event|Object} keyEvent The keyEvent or Event-shaped object to check.
  * @param {string} modifier The modifier to check.
@@ skipping 11 matching lines @@
     case 'altKey':
       return (keyEvent.altKey || (keyEvent.keyCode == 18));
       break;
     case 'shiftKey':
       return (keyEvent.shiftKey || (keyEvent.keyCode == 16));
       break;
     case 'metaKey':
       return (keyEvent.metaKey || (keyEvent.keyCode == 91));
       break;
     case 'searchKeyHeld':
-      return ((cvox.ChromeVox.isChromeOS && keyEvent.keyCode == 91) ||
+      return (
+          (cvox.ChromeVox.isChromeOS && keyEvent.keyCode == 91) ||
           keyEvent['searchKeyHeld']);
       break;
   }
   return false;
 };
 
 /**
  * Returns if any modifier is active in this sequence.
  * @return {boolean} The result.
  */
@@ skipping 11 matching lines @@
 
 /**
  * Creates a KeySequence event from a generic object.
  * @param {Object} sequenceObject The object.
  * @return {cvox.KeySequence} The created KeySequence object.
  */
 cvox.KeySequence.deserialize = function(sequenceObject) {
   var firstSequenceEvent = {};
 
   firstSequenceEvent['stickyMode'] = (sequenceObject.stickyMode == undefined) ?
-      false : sequenceObject.stickyMode;
+      false :
+      sequenceObject.stickyMode;
   firstSequenceEvent['prefixKey'] = (sequenceObject.prefixKey == undefined) ?
-      false : sequenceObject.prefixKey;
+      false :
+      sequenceObject.prefixKey;
 
   var secondKeyPressed = sequenceObject.keys.keyCode.length > 1;
   var secondSequenceEvent = {};
 
   for (var keyPressed in sequenceObject.keys) {
     firstSequenceEvent[keyPressed] = sequenceObject.keys[keyPressed][0];
     if (secondKeyPressed) {
       secondSequenceEvent[keyPressed] = sequenceObject.keys[keyPressed][1];
     }
   }
   var skipStripping = sequenceObject.skipStripping !== undefined ?
-      sequenceObject.skipStripping : true;
-  var keySeq = new cvox.KeySequence(firstSequenceEvent,
-                                    sequenceObject.cvoxModifier,
-                                    sequenceObject.doubleTap,
-                                    skipStripping,
-                                    sequenceObject.requireStickyMode);
+      sequenceObject.skipStripping :
+      true;
+  var keySeq = new cvox.KeySequence(
+      firstSequenceEvent, sequenceObject.cvoxModifier, sequenceObject.doubleTap,
+      skipStripping, sequenceObject.requireStickyMode);
   if (secondKeyPressed) {
     cvox.ChromeVox.sequenceSwitchKeyCodes.push(
         new cvox.KeySequence(firstSequenceEvent, sequenceObject.cvoxModifier));
     keySeq.addKeyEvent(secondSequenceEvent);
   }
 
   if (sequenceObject.doubleTap) {
     cvox.KeySequence.doubleTapCache.push(keySeq);
   }
 
@@ skipping 91 matching lines @@
   } else if (keyName == 'Cmd') {
     seqEvent['metaKey'] = true;
     seqEvent['keyCode'] = 91;
   } else if (keyName == 'Win') {
     seqEvent['metaKey'] = true;
     seqEvent['keyCode'] = 91;
   } else if (keyName == 'Insert') {
     seqEvent['keyCode'] = 45;
   }
 };