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

chrome/browser/resources/chromeos/braille_ime/braille_ime.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.
 
 'use strict';
 
 /**
  * @fileoverview Braille hardware keyboard input method.
  *
  * This method is automatically enabled when a braille display is connected
@@ skipping 102 matching lines @@
   SPACE: 0x100,
 
   /**
    * Maps key codes on a standard keyboard to the correspodning dots.
    * Keys on the 'home row' correspond to the keys on a Perkins-style keyboard.
    * Note that the mapping below is arranged like the dots in a braille cell.
    * Only 6 dot input is supported.
    * @private
    * @const {Object<number>}
    */
-  CODE_TO_DOT_: {'KeyF': 0x01, 'KeyJ': 0x08,
-                 'KeyD': 0x02, 'KeyK': 0x10,
-                 'KeyS': 0x04, 'KeyL': 0x20,
-                 'Space': 0x100 },
+  CODE_TO_DOT_: {
+    'KeyF': 0x01,
+    'KeyJ': 0x08,
+    'KeyD': 0x02,
+    'KeyK': 0x10,
+    'KeyS': 0x04,
+    'KeyL': 0x20,
+    'Space': 0x100
+  },
 
   /**
    * The current engine ID as set by {@code onActivate}, or the empty string if
    * the IME is not active.
    * @type {string}
    * @private
    */
   engineID_: '',
 
   /**
@@ skipping 13 matching lines @@
   /**
    * Registers event listeners in the chrome IME API.
    */
   init: function() {
     chrome.input.ime.onActivate.addListener(this.onActivate_.bind(this));
     chrome.input.ime.onDeactivated.addListener(this.onDeactivated_.bind(this));
     chrome.input.ime.onFocus.addListener(this.onFocus_.bind(this));
     chrome.input.ime.onBlur.addListener(this.onBlur_.bind(this));
     chrome.input.ime.onInputContextUpdate.addListener(
         this.onInputContextUpdate_.bind(this));
-    chrome.input.ime.onKeyEvent.addListener(this.onKeyEvent_.bind(this),
-                                            ['async']);
+    chrome.input.ime.onKeyEvent.addListener(
+        this.onKeyEvent_.bind(this), ['async']);
     chrome.input.ime.onReset.addListener(this.onReset_.bind(this));
     chrome.input.ime.onMenuItemActivated.addListener(
         this.onMenuItemActivated_.bind(this));
     this.connectChromeVox_();
   },
 
   /**
    * Called by the IME framework when this IME is activated.
    * @param {string} engineID Engine ID, should be 'braille'.
    * @private
@@ skipping 119 matching lines @@
    *     {@code undefined} if handling was delegated to ChromeVox.
    * @private
    */
   processKey_: function(event) {
     if (!this.useStandardKeyboard_) {
       return false;
     }
     if (event.code === 'Backspace' && event.type === 'keydown') {
       this.pressed_ = 0;
       this.accumulated_ = 0;
-      this.sendToChromeVox_(
-          {type: 'backspace', requestId: event.requestId});
+      this.sendToChromeVox_({type: 'backspace', requestId: event.requestId});
       return undefined;
     }
     var dot = this.CODE_TO_DOT_[event.code];
     if (!dot || event.altKey || event.ctrlKey || event.shiftKey ||
         event.capsLock) {
       this.pressed_ = 0;
       this.accumulated_ = 0;
       return false;
     }
     if (event.type === 'keydown') {
@@ skipping 24 matching lines @@
    * Connects to the ChromeVox extension for message passing.
    * @private
    */
   connectChromeVox_: function() {
     if (this.port_) {
       this.port_.disconnect();
       this.port_ = null;
     }
     this.port_ = chrome.runtime.connect(
         this.CHROMEVOX_EXTENSION_ID_, {name: this.PORT_NAME});
-    this.port_.onMessage.addListener(
-        this.onChromeVoxMessage_.bind(this));
-    this.port_.onDisconnect.addListener(
-        this.onChromeVoxDisconnect_.bind(this));
+    this.port_.onMessage.addListener(this.onChromeVoxMessage_.bind(this));
+    this.port_.onDisconnect.addListener(this.onChromeVoxDisconnect_.bind(this));
   },
 
   /**
    * Handles a message from the ChromeVox extension.
    * @param {*} message The message from the extension.
    * @private
    */
   onChromeVoxMessage_: function(message) {
     message = /** @type {{type: string}} */ (message);
     this.log_('onChromeVoxMessage', message);
     switch (message.type) {
       case 'replaceText':
         message =
             /**
              * @type {{contextID: number, deleteBefore: number,
              *         newText: string}}
              */
             (message);
-        this.replaceText_(message.contextID, message.deleteBefore,
-                          message.newText);
+        this.replaceText_(
+            message.contextID, message.deleteBefore, message.newText);
         break;
       case 'keyEventHandled':
         message =
             /** @type {{requestId: string, result: boolean}} */ (message);
         this.keyEventHandled_(message.requestId, 'keydown', message.result);
         break;
       case 'setUncommitted':
         message =
             /** @type {{contextID: number, text: string}} */ (message);
         this.setUncommitted_(message.contextID, message.text);
         break;
       case 'commitUncommitted':
         message =
             /** @type {{contextID: number}} */ (message);
         this.commitUncommitted_(message.contextID);
         break;
       default:
-        console.error('Unknown message from ChromeVox: ' +
-            JSON.stringify(message));
+        console.error(
+            'Unknown message from ChromeVox: ' + JSON.stringify(message));
         break;
     }
   },
 
   /**
    * Handles a disconnect event from the ChromeVox side.
    * @private
    */
   onChromeVoxDisconnect_: function() {
     this.port_ = null;
@@ skipping 19 matching lines @@
    */
   sendInputContext_: function(context) {
     this.sendToChromeVox_({type: 'inputContext', context: context});
   },
 
   /**
    * Sends the active state to ChromeVox.
    * @private
    */
   sendActiveState_: function() {
-    this.sendToChromeVox_({type: 'activeState',
-                           active: this.engineID_.length > 0});
+    this.sendToChromeVox_(
+        {type: 'activeState', active: this.engineID_.length > 0});
   },
 
   /**
    * Replaces text in the current text field.
    * @param {number} contextID Context for the input field to replace the
    *     text in.
    * @param {number} deleteBefore How many characters to delete before the
    *     cursor.
    * @param {string} toInsert Text to insert at the cursor.
    */
   replaceText_: function(contextID, deleteBefore, toInsert) {
     var addText = chrome.input.ime.commitText.bind(
         null, {contextID: contextID, text: toInsert}, function() {});
     if (deleteBefore > 0) {
-      var deleteText = chrome.input.ime.deleteSurroundingText.bind(null,
-          {engineID: this.engineID_, contextID: contextID,
-           offset: -deleteBefore, length: deleteBefore}, addText);
+      var deleteText = chrome.input.ime.deleteSurroundingText.bind(
+          null, {
+            engineID: this.engineID_,
+            contextID: contextID,
+            offset: -deleteBefore,
+            length: deleteBefore
+          },
+          addText);
       // Make sure there's no non-zero length selection so that
       // deleteSurroundingText works correctly.
       chrome.input.ime.deleteSurroundingText(
-          {engineID: this.engineID_, contextID: contextID,
-           offset: 0, length: 0}, deleteText);
+          {
+            engineID: this.engineID_,
+            contextID: contextID,
+            offset: 0,
+            length: 0
+          },
+          deleteText);
     } else {
       addText();
     }
   },
 
   /**
    * Responds to an asynchronous key event, indicating whether it was handled
    * or not.  If it wasn't handled, any uncommitted text is committed
    * before sending the response to the IME API.
    * @param {string} requestId Key event request id.
@@ skipping 26 matching lines @@
     if (this.uncommitted_ && contextID === this.uncommitted_.contextID)
       chrome.input.ime.commitText(this.uncommitted_);
     this.uncommitted_ = null;
   },
 
   /**
    * Updates the menu items for this IME.
    */
   updateMenuItems_: function() {
     // TODO(plundblad): Localize when translations available.
-    chrome.input.ime.setMenuItems(
-        {engineID: this.engineID_,
-         items: [
-           {
-             id: this.USE_STANDARD_KEYBOARD_ID,
-             label: 'Use standard keyboard for braille',
-             style: 'check',
-             visible: true,
-             checked: this.useStandardKeyboard_,
-             enabled: true
-             }
-         ]
-        });
+    chrome.input.ime.setMenuItems({
+      engineID: this.engineID_,
+      items: [{
+        id: this.USE_STANDARD_KEYBOARD_ID,
+        label: 'Use standard keyboard for braille',
+        style: 'check',
+        visible: true,
+        checked: this.useStandardKeyboard_,
+        enabled: true
+      }]
+    });
   }
 };