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

chrome/browser/resources/chromeos/emulator/bluetooth_settings.js

 // Copyright 2015 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.
 
 /**
  * A bluetooth device.
  * @constructor
  */
 var BluetoothDevice = function() {
   // The device's address (MAC format, must be unique).
@@ skipping 43 matching lines @@
 Polymer({
   is: 'bluetooth-settings',
 
   behaviors: [Polymer.NeonAnimatableBehavior],
 
   properties: {
     /**
      * A set of bluetooth devices.
      * @type !Array<!BluetoothDevice>
      */
-    devices: {type: Array, value: function() { return []; }},
+    devices: {
+      type: Array,
+      value: function() {
+        return [];
+      }
+    },
 
     /**
      * A set of predefined bluetooth devices.
      * @type !Array<!Bluetooth>
      */
-    predefinedDevices: {type: Array, value: function() { return []; }},
+    predefinedDevices: {
+      type: Array,
+      value: function() {
+        return [];
+      }
+    },
 
     /**
      * A bluetooth device object which is currently being edited.
      * @type {BluetoothDevice}
      */
     currentEditableObject: {
       type: Object,
-      value: function() { return {}; }
+      value: function() {
+        return {};
+      }
     },
 
     /**
      * The index of the bluetooth device object which is currently being edited.
      * This is initially set to -1 (i.e. no device selected) because not custom
      * devices exist when the page loads.
      */
-    currentEditIndex: {type: Number, value: function() { return -1; }},
+    currentEditIndex: {
+      type: Number,
+      value: function() {
+        return -1;
+      }
+    },
 
     /**
      * A set of options for the possible bluetooth device classes/types.
      * Object |value| attribute comes from values in the WebUI, set in
      * setDeviceClassOptions.
      * @type !Array<! {text: string, value: int} >
      */
     deviceClassOptions: {
       type: Array,
       value: function() {
         return [
-          {text: 'Unknown', value: 0},
-          {text: 'Mouse', value: 0x2580},
-          {text: 'Keyboard', value: 0x2540},
-          {text: 'Audio', value: 0x240408},
-          {text: 'Phone', value: 0x7a020c},
-          {text: 'Computer', value: 0x104}
+          {text: 'Unknown', value: 0}, {text: 'Mouse', value: 0x2580},
+          {text: 'Keyboard', value: 0x2540}, {text: 'Audio', value: 0x240408},
+          {text: 'Phone', value: 0x7a020c}, {text: 'Computer', value: 0x104}
         ];
       }
     },
 
     /**
      * A set of strings representing the method to be used for
      * authenticating a device during a pair request.
      * @type !Array<string>
      */
     deviceAuthenticationMethods: {
       type: Array,
-      value: function() { return []; }
+      value: function() {
+        return [];
+      }
     },
 
     /**
      * A set of strings representing the actions which can be done when
      * a secure device is paired/requests a pair.
      * @type !Array<string>
      */
     deviceAuthenticationActions: {
       type: Array,
-      value: function() { return []; }
+      value: function() {
+        return [];
+      }
     },
   },
 
   /**
    * Contains keys for all the device paths which have been discovered. Used
    * to look up whether or not a device is listed already.
    * @type {Object}
    */
   devicePaths: {},
 
   ready: function() {
     chrome.send('requestBluetoothInfo');
   },
 
   observers: ['currentEditableObjectChanged(currentEditableObject.*)'],
 
   /**
    * Called when a property of the currently editable object is edited.
    * Sets the corresponding property for the object in |this.devices|.
    * @param {Object} obj An object containing event information (ex. which
    *     property of |this.currentEditableObject| was changed, what its value
    *     is, etc.)
    */
   currentEditableObjectChanged: function(obj) {
     if (this.currentEditIndex >= 0) {
       var prop = obj.path.split('.')[1];
-      this.set('devices.' + this.currentEditIndex.toString() + '.' + prop,
-               obj.value);
+      this.set(
+          'devices.' + this.currentEditIndex.toString() + '.' + prop,
+          obj.value);
     }
   },
 
   /**
    * Called when the device edit dialog is opened. Re-validates necessary input
    * fields.
    */
   editDialogOpened: function() {
     this.validateAddress();
     this.validatePath();
@@ skipping 99 matching lines @@
    */
   showAuthToken: function(pairMethod) {
     return pairMethod && pairMethod != 'None';
   },
 
   /**
    * Called by the WebUI which provides a list of devices which are connected
    * to the main adapter.
    * @param {!Array<!BluetoothDevice>} devices A list of bluetooth devices.
    */
-  updateBluetoothInfo: function(predefinedDevices, loadedCustomDevices,
-                                pairingMethodOptions, pairingActionOptions) {
+  updateBluetoothInfo: function(
+      predefinedDevices, loadedCustomDevices, pairingMethodOptions,
+      pairingActionOptions) {
     this.predefinedDevices = this.loadDevicesFromList(predefinedDevices, true);
     this.devices = this.loadDevicesFromList(loadedCustomDevices, false);
     this.deviceAuthenticationMethods = pairingMethodOptions;
     this.deviceAuthenticationActions = pairingActionOptions;
   },
 
   /**
    * Builds complete BluetoothDevice objects for each element in |devices_list|.
    * @param {!Array<!BluetoothDevice>} devices_list A list of incomplete
    *     BluetoothDevice provided by the C++ WebUI.
    * @param {boolean} predefined Whether or not the device is a predefined one.
    */
   loadDevicesFromList: function(devices, predefined) {
     /** @type {!Array<!BluetoothDevice>} */ var deviceList = [];
 
     for (var i = 0; i < devices.length; ++i) {
-      if (this.devicePaths[devices[i].path] != undefined) continue;
+      if (this.devicePaths[devices[i].path] != undefined)
+        continue;
 
       // Get the label for the device class which should be selected.
       devices[i].class = this.getTextForDeviceClass(devices[i].classValue);
       devices[i].pairingAuthToken = devices[i].pairingAuthToken.toString();
       deviceList.push(devices[i]);
       this.devicePaths[devices[i].path] = {
         predefined: predefined,
         index: deviceList.length - 1
       };
     }
 
     return deviceList;
   },
 
   /**
    * Called when a device is paired from the Tray. Checks the paired box for
    * the device with path |path|.
    */
   devicePairedFromTray: function(path) {
     var obj = this.devicePaths[path];
 
-    if (obj == undefined) return;
+    if (obj == undefined)
+      return;
 
     var index = obj.index;
     var devicePath = (obj.predefined ? 'predefinedDevices.' : 'devices.');
     devicePath += obj.index.toString();
     this.set(devicePath + '.paired', true);
   },
 
   /**
    * On-change handler for a checkbox in the device list. Pairs/unpairs the
    * device associated with the box checked/unchecked.
@@ skipping 28 matching lines @@
     }
   },
 
   /**
    * Called from Chrome OS back-end when a pair request fails.
    * @param {string} path The path of the device which failed to pair.
    */
   pairFailed: function(path) {
     var obj = this.devicePaths[path];
 
-    if (obj == undefined) return;
+    if (obj == undefined)
+      return;
 
     var devicePath = (obj.predefined ? 'predefinedDevices.' : 'devices.');
     devicePath += obj.index.toString();
     this.set(devicePath + '.paired', false);
   },
 
   /**
    * On-change event handler for a checkbox in the device list.
    * @param {Event} event Contains event data. |event.model.index| is the index
    *     of the item which the target is contained in.
@@ skipping 102 matching lines @@
     this.splice('devices', index, 1);
   },
 
   /**
    * This function is called when a device is removed from the main bluetooth
    * adapter's device list. It sets that device's |.discoverable| and |.paired|
    * attributes to false.
    * @param {string} path A bluetooth device's path.
    */
   deviceRemovedFromMainAdapter: function(path) {
-    if (this.devicePaths[path] == undefined) return;
+    if (this.devicePaths[path] == undefined)
+      return;
 
     var obj = this.devicePaths[path];
     var devicePath = (obj.predefined ? 'predefinedDevices.' : 'devices.');
     devicePath += obj.index.toString();
     this.set(devicePath + '.discoverable', false);
     this.set(devicePath + '.paired', false);
   },
 
   /**
    * Returns the text for the label that corresponds to |classValue|.
@@ skipping 14 matching lines @@
    * @return {number} The value which |classText| represents.
    */
   getValueForDeviceClass: function(classText) {
     for (var i = 0; i < this.deviceClassOptions.length; ++i) {
       if (this.deviceClassOptions[i].text == classText)
         return this.deviceClassOptions[i].value;
     }
     return 0;
   },
 });