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

chrome/browser/resources/chromeos/chromevox/braille/braille_input_handler.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 Handles braille input keys when the user is typing or editing
  * text in an input field.  This class cooperates with the Braille IME
  * that is built into Chrome OS to do the actual text editing.
  */
 
@@ skipping 75 matching lines @@
 
   this.translatorManager_.addChangeListener(
       this.commitAndClearEntryState_.bind(this));
 };
 
 /**
  * The ID of the Braille IME extension built into Chrome OS.
  * @const {string}
  * @private
  */
-cvox.BrailleInputHandler.IME_EXTENSION_ID_ =
-    'jddehjeebkoimngcbdkaahpobgicbffp';
+cvox.BrailleInputHandler.IME_EXTENSION_ID_ = 'jddehjeebkoimngcbdkaahpobgicbffp';
 
 /**
  * Name of the port to use for communicating with the Braille IME.
  * @const {string}
  * @private
  */
 cvox.BrailleInputHandler.IME_PORT_NAME_ = 'cvox.BrailleIme.Port';
 
 /**
  * Regular expression that matches a string that starts with at least one
@@ skipping 60 matching lines @@
 
   /**
    * Handles braille key events used for input by editing the current input
    * field appropriately.
    * @param {!cvox.BrailleKeyEvent} event The key event.
    * @return {boolean} {@code true} if the event was handled, {@code false}
    *     if it should propagate further.
    */
   onBrailleKeyEvent: function(event) {
     if (event.command === cvox.BrailleKeyCommand.DOTS)
-      return this.onBrailleDots_(/** @type {number} */(event.brailleDots));
+      return this.onBrailleDots_(/** @type {number} */ (event.brailleDots));
     // Any other braille command cancels the pending cells.
     this.pendingCells_.length = 0;
     if (event.command === cvox.BrailleKeyCommand.STANDARD_KEY) {
-      if (event.standardKeyCode === 'Backspace' &&
-          !event.altKey && !event.ctrlKey && !event.shiftKey &&
-          this.onBackspace_()) {
+      if (event.standardKeyCode === 'Backspace' && !event.altKey &&
+          !event.ctrlKey && !event.shiftKey && this.onBackspace_()) {
         return true;
       } else {
         this.commitAndClearEntryState_();
         this.sendKeyEventPair_(event);
         return true;
       }
     }
     return false;
   },
 
   /**
    * Returns how the value of the currently displayed content should be
    * expanded given the current input state.
    * @return {cvox.ExpandingBrailleTranslator.ExpansionType}
    *     The current expansion type.
    */
   getExpansionType: function() {
     if (this.inAlwaysUncontractedContext_())
       return cvox.ExpandingBrailleTranslator.ExpansionType.ALL;
     if (this.entryState_ &&
         this.entryState_.translator ===
-        this.translatorManager_.getDefaultTranslator()) {
+            this.translatorManager_.getDefaultTranslator()) {
       return cvox.ExpandingBrailleTranslator.ExpansionType.NONE;
     }
     return cvox.ExpandingBrailleTranslator.ExpansionType.SELECTION;
   },
 
   /**
    * @return {boolean} {@code true} if we have an input context and
    *     uncontracted braille should always be used for that context.
    * @private
    */
@@ skipping 124 matching lines @@
     this.imePort_ = port;
   },
 
   /**
    * Called when a message is received from the IME.
    * @param {*} message The message.
    * @private
    */
   onImeMessage_: function(message) {
     if (!goog.isObject(message)) {
-      console.error('Unexpected message from Braille IME: ',
-                    JSON.stringify(message));
+      console.error(
+          'Unexpected message from Braille IME: ', JSON.stringify(message));
     }
     switch (message.type) {
       case 'activeState':
         this.imeActive_ = message.active;
         break;
       case 'inputContext':
         this.inputContext_ = message.context;
         this.clearEntryState_();
         if (this.imeActive_ && this.inputContext_)
           this.pendingCells_.forEach(this.onBrailleDots_, this);
         this.pendingCells_.length = 0;
         break;
       case 'brailleDots':
         this.onBrailleDots_(message['dots']);
         break;
       case 'backspace':
         // Note that we can't send the backspace key through the
         // virtualKeyboardPrivate API in this case because it would then be
         // processed by the IME again, leading to an infinite loop.
-        this.postImeMessage_(
-            {type: 'keyEventHandled', requestId: message['requestId'],
-             result: this.onBackspace_()});
+        this.postImeMessage_({
+          type: 'keyEventHandled',
+          requestId: message['requestId'],
+          result: this.onBackspace_()
+        });
         break;
       case 'reset':
         this.clearEntryState_();
         break;
       default:
-        console.error('Unexpected message from Braille IME: ',
-                      JSON.stringify(message));
-      break;
+        console.error(
+            'Unexpected message from Braille IME: ', JSON.stringify(message));
+        break;
     }
   },
 
   /**
    * Called when the IME port is disconnected.
    * @param {Port} port The port that was disconnected.
    * @private
    */
   onImeDisconnect_: function(port) {
     this.imePort_ = null;
@@ skipping 31 matching lines @@
     var numericCode = cvox.BrailleKeyEvent.keyCodeToLegacyCode(keyName);
     if (!goog.isDef(numericCode))
       throw Error('Unknown key code in event: ' + JSON.stringify(event));
     var keyEvent = {
       type: 'keydown',
       keyCode: numericCode,
       keyName: keyName,
       charValue: cvox.BrailleKeyEvent.keyCodeToCharValue(keyName),
       // See chrome/common/extensions/api/virtual_keyboard_private.json for
       // these constants.
-      modifiers: (event.shiftKey ? 2 : 0) |
-          (event.ctrlKey ? 4 : 0) |
+      modifiers: (event.shiftKey ? 2 : 0) | (event.ctrlKey ? 4 : 0) |
           (event.altKey ? 8 : 0)
     };
     chrome.virtualKeyboardPrivate.sendKeyEvent(keyEvent);
     keyEvent.type = 'keyup';
     chrome.virtualKeyboardPrivate.sendKeyEvent(keyEvent);
   }
 };
 
 /**
  * The entry state is the state related to entering a series of braille cells
@@ skipping 91 matching lines @@
     }
     // There was an actual text change (or cursor movement) that we hadn't
     // caused ourselves, reset any pending input.
     this.inputHandler_.clearEntryState_();
   },
 
   /**
    * Makes sure the current text is permanently added to the edit field.
    * After this call, this object should be abandoned.
    */
-  commit: function() {
-  },
+  commit: function() {},
 
   /**
    * @return {boolean} true if the entry state uses uncommitted cells.
    */
   get usesUncommittedCells() {
     return false;
   },
 
   /**
    * Updates the translated text based on the current cells and sends the
@@ skipping 26 matching lines @@
   get lastCellIsBlank_() {
     return this.cells_[this.cells_.length - 1] === 0;
   },
 
   /**
    * Sends new text to the IME.  This dhould be overriden by subclasses.
    * The old text is still available in the {@code text_} property.
    * @param {string} newText Text to send.
    * @private
    */
-  sendTextChange_: function(newText) {
-  }
+  sendTextChange_: function(newText) {}
 };
 
 /**
  * Entry state that uses {@code deleteSurroundingText} and {@code commitText}
  * calls to the IME to update the currently enetered text.
  * @param {!cvox.BrailleInputHandler} inputHandler
  * @param {!cvox.LibLouis.Translator} translator
  * @constructor
  * @extends {cvox.BrailleInputHandler.EntryState_}
  * @private
  */
-cvox.BrailleInputHandler.EditsEntryState_ = function(
-    inputHandler, translator) {
+cvox.BrailleInputHandler.EditsEntryState_ = function(inputHandler, translator) {
   cvox.BrailleInputHandler.EntryState_.call(this, inputHandler, translator);
 };
 
 cvox.BrailleInputHandler.EditsEntryState_.prototype = {
   __proto__: cvox.BrailleInputHandler.EntryState_.prototype,
 
   /** @override */
   sendTextChange_: function(newText) {
     var oldText = this.text_;
     // Find the common prefix of the old and new text.
-    var commonPrefixLength = StringUtil.longestCommonPrefixLength(
-        oldText, newText);
+    var commonPrefixLength =
+        StringUtil.longestCommonPrefixLength(oldText, newText);
     // How many characters we need to delete from the existing text to replace
     // them with characters from the new text.
     var deleteLength = oldText.length - commonPrefixLength;
     // New text, if any, to insert after deleting the deleteLength characters
     // before the cursor.
     var toInsert = newText.substring(commonPrefixLength);
     if (deleteLength > 0 || toInsert.length > 0) {
       // After deleting, we expect this text to be present before the cursor.
       var textBeforeAfterDelete =
           this.inputHandler_.currentTextBefore_.substring(
               0, this.inputHandler_.currentTextBefore_.length - deleteLength);
       if (deleteLength > 0) {
         // Queue this text up to be ignored when the change comes in.
         this.pendingTextsBefore_.push(textBeforeAfterDelete);
       }
       if (toInsert.length > 0) {
         // Likewise, queue up what we expect to be before the cursor after
         // the replacement text is inserted.
         this.pendingTextsBefore_.push(textBeforeAfterDelete + toInsert);
       }
       // Send the replace operation to be performed asynchronously by the IME.
-      this.inputHandler_.postImeMessage_(
-          {type: 'replaceText',
-           contextID: this.inputHandler_.inputContext_.contextID,
-           deleteBefore: deleteLength,
-           newText: toInsert});
+      this.inputHandler_.postImeMessage_({
+        type: 'replaceText',
+        contextID: this.inputHandler_.inputContext_.contextID,
+        deleteBefore: deleteLength,
+        newText: toInsert
+      });
     }
   }
 };
 
 /**
  * Entry state that only updates the edit field when a blank cell is entered.
  * During the input of a single 'word', the uncommitted text is stored by the
  * IME.
  * @param {!cvox.BrailleInputHandler} inputHandler
  * @param {!cvox.LibLouis.Translator} translator
  * @constructor
  * @private
  * @extends {cvox.BrailleInputHandler.EntryState_}
  */
 cvox.BrailleInputHandler.LateCommitEntryState_ = function(
     inputHandler, translator) {
   cvox.BrailleInputHandler.EntryState_.call(this, inputHandler, translator);
 };
 
 cvox.BrailleInputHandler.LateCommitEntryState_.prototype = {
   __proto__: cvox.BrailleInputHandler.EntryState_.prototype,
 
   /** @override */
   commit: function() {
-    this.inputHandler_.postImeMessage_(
-        {type: 'commitUncommitted',
-         contextID: this.inputHandler_.inputContext_.contextID});
+    this.inputHandler_.postImeMessage_({
+      type: 'commitUncommitted',
+      contextID: this.inputHandler_.inputContext_.contextID
+    });
   },
 
   /** @override */
   get usesUncommittedCells() {
     return true;
   },
 
   /** @override */
   sendTextChange_: function(newText) {
-    this.inputHandler_.postImeMessage_(
-        {type: 'setUncommitted',
-         contextID: this.inputHandler_.inputContext_.contextID,
-         text: newText});
+    this.inputHandler_.postImeMessage_({
+      type: 'setUncommitted',
+      contextID: this.inputHandler_.inputContext_.contextID,
+      text: newText
+    });
   }
 };