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

chrome/browser/resources/options/chromeos/network_list.js

 // Copyright (c) 2012 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.
 
 /**
  * Partial definition of the result of networkingPrivate.getProperties()).
  * TODO(stevenjb): Replace with chrome.networkingPrivate.NetworkStateProperties
  * once that is fully speced.
  * @typedef {{
  *   ConnectionState: string,
@@ skipping 43 matching lines @@
    * @param {string} type A string that may contain a valid network type.
    * @return {boolean} Whether the string represents a valid network type.
    */
   function isNetworkType(type) {
     return (Constants.NETWORK_TYPES.indexOf(type) != -1);
   }
 
   /**
    * Order in which controls are to appear in the network list sorted by key.
    */
-  Constants.NETWORK_ORDER = ['Ethernet',
-                             'WiFi',
-                             'WiMAX',
-                             'Cellular',
-                             'VPN',
-                             'addConnection'];
+  Constants.NETWORK_ORDER =
+      ['Ethernet', 'WiFi', 'WiMAX', 'Cellular', 'VPN', 'addConnection'];
 
   /**
    * ID of the menu that is currently visible.
    * @type {?string}
    * @private
    */
   var activeMenu = null;
 
   /**
    * The state of the cellular device or undefined if not available.
@@ skipping 82 matching lines @@
    */
   function sendChromeMetricsAction(action) {
     chrome.send('coreOptionsUserMetricsAction', [action]);
   }
 
   /**
    * @param {string} guid The network GUID.
    */
   function showDetails(guid) {
     chrome.networkingPrivate.getManagedProperties(
-      guid, DetailsInternetPage.initializeDetailsPage);
+        guid, DetailsInternetPage.initializeDetailsPage);
   }
 
   /**
    * Decorate an element as a NetworkListItem.
    * @param {!Element} el The element to decorate.
    */
   NetworkListItem.decorate = function(el) {
     el.__proto__ = NetworkListItem.prototype;
     el.decorate();
   };
@@ skipping 160 matching lines @@
      * @private
      */
     menu_: null,
 
     /** @override */
     decorate: function() {
       this.subtitle = null;
       if (this.data.iconType)
         this.iconType = this.data.iconType;
       this.addEventListener('click', (function() {
-        this.showMenu();
-      }).bind(this));
+                                       this.showMenu();
+                                     }).bind(this));
     },
 
     /**
      * Retrieves the ID for the menu.
      */
     getMenuName: function() {
       return this.data_.key.toLowerCase() + '-network-menu';
     },
 
     /**
@@ skipping 171 matching lines @@
 
       if (candidateData && isManaged(candidateData.Source))
         this.showManagedNetworkIndicator();
 
       if (activeMenu == this.getMenuName()) {
         // Menu is already showing and needs to be updated. Explicitly calling
         // show menu will force the existing menu to be replaced.  The call
         // is deferred in order to ensure that position of this element has
         // beem properly updated.
         var self = this;
-        setTimeout(function() {self.showMenu();}, 0);
+        setTimeout(function() {
+          self.showMenu();
+        }, 0);
       }
     },
 
     /**
      * Creates a menu for selecting, configuring or disconnecting from a
      * network.
      * @return {!Element} The newly created menu.
      */
     createMenu: function() {
       var menu = this.ownerDocument.createElement('div');
       menu.id = this.getMenuName();
       menu.className = 'network-menu';
       menu.hidden = true;
       Menu.decorate(menu);
       menu.menuItemSelector = '.network-menu-item';
       var addendum = [];
       if (this.data_.key == 'WiFi') {
         var item = {
           label: loadTimeData.getString('joinOtherNetwork'),
           data: {}
         };
         if (allowUnmanagedNetworks_()) {
           item.command = createAddNonVPNConnectionCallback_('WiFi');
         } else {
           item.command = null;
           item.tooltip = loadTimeData.getString('prohibitedNetworkOther');
         }
         addendum.push(item);
       } else if (this.data_.key == 'Cellular') {
-        if (cellularDevice.State == 'Enabled' &&
-            cellularNetwork && cellularNetwork.Cellular &&
+        if (cellularDevice.State == 'Enabled' && cellularNetwork &&
+            cellularNetwork.Cellular &&
             cellularNetwork.Cellular.SupportNetworkScan) {
           addendum.push({
             label: loadTimeData.getString('otherCellularNetworks'),
             command: createAddNonVPNConnectionCallback_('Cellular'),
             addClass: ['other-cellulars'],
             data: {}
           });
         }
 
-        var label = enableDataRoaming ? 'disableDataRoaming' :
-            'enableDataRoaming';
+        var label =
+            enableDataRoaming ? 'disableDataRoaming' : 'enableDataRoaming';
         var disabled = !loadTimeData.getValue('loggedInAsOwner');
-        var entry = {label: loadTimeData.getString(label),
-                     data: {}};
+        var entry = {label: loadTimeData.getString(label), data: {}};
         if (disabled) {
           entry.command = null;
           entry.tooltip =
               loadTimeData.getString('dataRoamingDisableToggleTooltip');
         } else {
           var self = this;
           entry.command = function() {
             options.Preferences.setBooleanPref(
-                'cros.signed.data_roaming_enabled',
-                !enableDataRoaming, true);
+                'cros.signed.data_roaming_enabled', !enableDataRoaming, true);
             // Force revalidation of the menu the next time it is displayed.
             self.menu_ = null;
           };
         }
         addendum.push(entry);
       } else if (this.data_.key == 'VPN') {
         addendum = addendum.concat(createAddVPNConnectionEntries_());
       }
 
       var list = this.data.rememberedNetworks;
       if (list && list.length > 0) {
         var callback = function(list) {
           $('remembered-network-list').clear();
           var dialog = options.PreferredNetworks.getInstance();
           PageManager.showPageByName('preferredNetworksPage', false);
           dialog.update(list);
           sendChromeMetricsAction('Options_NetworkShowPreferred');
         };
-        addendum.push({label: loadTimeData.getString('preferredNetworks'),
-                       command: callback,
-                       data: list});
+        addendum.push({
+          label: loadTimeData.getString('preferredNetworks'),
+          command: callback,
+          data: list
+        });
       }
 
       var networkGroup = this.ownerDocument.createElement('div');
       networkGroup.className = 'network-menu-group';
       list = this.data.networkList;
       var empty = !list || list.length == 0;
       if (list) {
         var connectedVpnGuid = '';
         for (var i = 0; i < list.length; i++) {
           var data = list[i];
           this.createNetworkOptionsCallback_(networkGroup, data);
           // For VPN only, append a 'Disconnect' item to the dropdown menu.
           if (!connectedVpnGuid && data.Type == 'VPN' &&
               (data.ConnectionState == 'Connected' ||
                data.ConnectionState == 'Connecting')) {
             connectedVpnGuid = data.GUID;
           }
         }
         if (connectedVpnGuid) {
           var disconnectCallback = function() {
             sendChromeMetricsAction('Options_NetworkDisconnectVPN');
             chrome.networkingPrivate.startDisconnect(connectedVpnGuid);
           };
           // Add separator
           addendum.push({});
-          addendum.push({label: loadTimeData.getString('disconnectNetwork'),
-                         command: disconnectCallback,
-                         data: data});
+          addendum.push({
+            label: loadTimeData.getString('disconnectNetwork'),
+            command: disconnectCallback,
+            data: data
+          });
         }
       }
       if (this.data_.key == 'WiFi' || this.data_.key == 'WiMAX' ||
           this.data_.key == 'Cellular') {
         addendum.push({});
         if (this.data_.key == 'WiFi') {
           addendum.push({
             label: loadTimeData.getString('turnOffWifi'),
             command: function() {
               sendChromeMetricsAction('Options_NetworkWifiToggle');
               chrome.networkingPrivate.disableNetworkType(
                   chrome.networkingPrivate.NetworkType.WI_FI);
             },
-            data: {}});
+            data: {}
+          });
         } else if (this.data_.key == 'WiMAX') {
           addendum.push({
             label: loadTimeData.getString('turnOffWimax'),
             command: function() {
               chrome.networkingPrivate.disableNetworkType(
                   chrome.networkingPrivate.NetworkType.WI_MAX);
             },
-            data: {}});
+            data: {}
+          });
         } else if (this.data_.key == 'Cellular') {
           addendum.push({
             label: loadTimeData.getString('turnOffCellular'),
             command: function() {
               chrome.networkingPrivate.disableNetworkType(
                   chrome.networkingPrivate.NetworkType.CELLULAR);
             },
-            data: {}});
+            data: {}
+          });
         }
       }
       if (!empty)
         menu.appendChild(networkGroup);
       if (addendum.length > 0) {
         var separator = false;
         if (!empty) {
           menu.appendChild(MenuItem.createSeparator());
           separator = true;
         }
         for (var i = 0; i < addendum.length; i++) {
           var value = addendum[i];
           if (value.data) {
-            var item = createCallback_(menu, value.data, value.label,
-                                       value.command);
+            var item =
+                createCallback_(menu, value.data, value.label, value.command);
             if (value.tooltip)
               item.title = value.tooltip;
             if (value.addClass)
               item.classList.add(value.addClass);
             separator = false;
           } else if (!separator) {
             menu.appendChild(MenuItem.createSeparator());
             separator = true;
           }
         }
@@ skipping 20 matching lines @@
       var oldMenu = $(this.getMenuName());
       var group = oldMenu.getElementsByClassName('network-menu-group')[0];
       if (!group)
         return false;
       var newMenu = this.createMenu();
       var discardOnClose = false;
       var oldNetworkButtons = this.extractNetworkConnectButtons_(oldMenu);
       var newNetworkButtons = this.extractNetworkConnectButtons_(newMenu);
       for (var key in oldNetworkButtons) {
         if (newNetworkButtons[key]) {
-          group.replaceChild(newNetworkButtons[key].button,
-                             oldNetworkButtons[key].button);
+          group.replaceChild(
+              newNetworkButtons[key].button, oldNetworkButtons[key].button);
           if (newNetworkButtons[key].index != oldNetworkButtons[key].index)
             discardOnClose = true;
           newNetworkButtons[key] = null;
         } else {
           // Leave item in list to prevent network items from jumping due to
           // deletions.
           oldNetworkButtons[key].disabled = true;
           discardOnClose = true;
         }
       }
@@ skipping 31 matching lines @@
     /**
      * Adds a menu item for showing network details.
      * @param {!Element} parent The parent element.
      * @param {NetworkProperties} data Description of the network.
      * @private
      */
     createNetworkOptionsCallback_: function(parent, data) {
       var menuItem = null;
       if (data.Type == 'WiFi' && !allowUnmanagedNetworks_() &&
           !isManaged(data.Source)) {
-        menuItem = createCallback_(parent,
-                                   data,
-                                   getNetworkName(data),
-                                   null);
+        menuItem = createCallback_(parent, data, getNetworkName(data), null);
         menuItem.title = loadTimeData.getString('prohibitedNetwork');
       } else {
-        menuItem = createCallback_(parent,
-                                   data,
-                                   getNetworkName(data),
-                                   showDetails.bind(null, data.GUID));
+        menuItem = createCallback_(
+            parent, data, getNetworkName(data),
+            showDetails.bind(null, data.GUID));
       }
       if (isManaged(data.Source))
         menuItem.appendChild(new ManagedNetworkIndicator());
       if (data.ConnectionState == 'Connected' ||
           data.ConnectionState == 'Connecting') {
-        var label = menuItem.getElementsByClassName(
-            'network-menu-item-label')[0];
+        var label =
+            menuItem.getElementsByClassName('network-menu-item-label')[0];
         label.classList.add('active-network');
       }
     }
   };
 
   /**
    * Creates a button-like control for configurating internet connectivity.
    * @param {{key: string, subtitle: string, command: Function}} data
    *     Description of the network control.
    * @constructor
    * @extends {NetworkListItem}
    */
   function NetworkButtonItem(data) {
     var el = new NetworkListItem(data);
     el.__proto__ = NetworkButtonItem.prototype;
     el.decorate();
     return el;
   }
 
   NetworkButtonItem.prototype = {
     __proto__: NetworkListItem.prototype,
 
     /** @override */
     decorate: function() {
       if (this.data.subtitle)
         this.subtitle = this.data.subtitle;
       else
-       this.subtitle = null;
+        this.subtitle = null;
       if (this.data.command)
         this.addEventListener('click', this.data.command);
       if (this.data.iconData)
         this.iconData = this.data.iconData;
       else if (this.data.iconType)
         this.iconType = this.data.iconType;
       if (isManaged(this.data.Source))
         this.showManagedNetworkIndicator();
     },
   };
@@ skipping 24 matching lines @@
     }
 
     var buttonLabel = menu.ownerDocument.createElement('span');
     buttonLabel.className = 'network-menu-item-label';
     buttonLabel.textContent = label;
     button.appendChild(buttonLabel);
     var callback = null;
     if (command != null) {
       if (data) {
         callback = function() {
-          (/** @type {Function} */(command))(data);
+          (/** @type {Function} */ (command))(data);
           closeMenu_();
         };
       } else {
         callback = function() {
-          (/** @type {Function} */(command))();
+          (/** @type {Function} */ (command))();
           closeMenu_();
         };
       }
     }
     if (callback != null)
       button.addEventListener('activate', callback);
     else
       buttonLabel.classList.add('network-disabled-control');
 
     button.data = {label: label};
@@ skipping 13 matching lines @@
     __proto__: List.prototype,
 
     /** @override */
     decorate: function() {
       List.prototype.decorate.call(this);
       this.startBatchUpdates();
       this.autoExpands = true;
       this.dataModel = new ArrayDataModel([]);
       this.selectionModel = new ListSingleSelectionModel();
       this.addEventListener('blur', this.onBlur_.bind(this));
-      this.selectionModel.addEventListener('change',
-                                           this.onSelectionChange_.bind(this));
+      this.selectionModel.addEventListener(
+          'change', this.onSelectionChange_.bind(this));
 
       // Wi-Fi control is always visible.
       this.update({key: 'WiFi', networkList: []});
 
       this.updateAddConnectionMenuEntries_();
 
       var prefs = options.Preferences.getInstance();
-      prefs.addEventListener('cros.signed.data_roaming_enabled',
-          function(event) {
+      prefs.addEventListener(
+          'cros.signed.data_roaming_enabled', function(event) {
             enableDataRoaming = event.value.value;
           });
       this.endBatchUpdates();
 
       this.onNetworkListChanged_();  // Trigger an initial network update
 
       chrome.networkingPrivate.onNetworkListChanged.addListener(
           this.onNetworkListChanged_.bind(this));
       chrome.networkingPrivate.onDeviceStateListChanged.addListener(
           this.onNetworkListChanged_.bind(this));
@@ skipping 11 matching lines @@
       chrome.management.getAll(this.onGetAllExtensions_.bind(this));
       chrome.networkingPrivate.requestNetworkScan();
     },
 
     /**
      * networkingPrivate event called when the network list has changed.
      */
     onNetworkListChanged_: function() {
       var networkList = this;
       chrome.networkingPrivate.getDeviceStates(function(deviceStates) {
-        var filter = {
-          networkType: chrome.networkingPrivate.NetworkType.ALL
-        };
+        var filter = {networkType: chrome.networkingPrivate.NetworkType.ALL};
         chrome.networkingPrivate.getNetworks(filter, function(networkStates) {
           networkList.updateNetworkStates(deviceStates, networkStates);
         });
       });
     },
 
     /**
      * chrome.management.getAll callback.
      * @param {!Array<!ExtensionInfo>} extensions
      * @private
@@ skipping 75 matching lines @@
      * Updates the entries in the "add connection" menu, based on the VPN
      * providers currently enabled in the user's profile.
      * @private
      */
     updateAddConnectionMenuEntries_: function() {
       var entries = [{
         label: loadTimeData.getString('addConnectionWifi'),
         command: createAddNonVPNConnectionCallback_('WiFi')
       }];
       entries = entries.concat(createAddVPNConnectionEntries_());
-      this.update({key: 'addConnection',
-                   iconType: 'add-connection',
-                   menu: entries
-                  });
+      this.update(
+          {key: 'addConnection', iconType: 'add-connection', menu: entries});
     },
 
     /**
      * When the list loses focus, unselect all items in the list and close the
      * active menu.
      * @private
      */
     onBlur_: function() {
       this.selectionModel.unselectAll();
       closeMenu_();
     },
 
     /** @override */
     handleKeyDown: function(e) {
       if (activeMenu) {
         // keyIdentifier does not report 'Esc' correctly
         if (e.keyCode == 27 /* Esc */) {
           closeMenu_();
           return;
         }
 
         if ($(activeMenu).handleKeyDown(e)) {
           e.preventDefault();
           e.stopPropagation();
         }
         return;
       }
 
-      if (e.key == 'Enter' ||
-          e.key == ' ' /* Space */) {
-        var selectedListItem = this.getListItemByIndex(
-            this.selectionModel.selectedIndex);
+      if (e.key == 'Enter' || e.key == ' ' /* Space */) {
+        var selectedListItem =
+            this.getListItemByIndex(this.selectionModel.selectedIndex);
         if (selectedListItem) {
           selectedListItem.click();
           return;
         }
       }
 
       List.prototype.handleKeyDown.call(this, e);
     },
 
     /**
@@ skipping 83 matching lines @@
      * @override
      * @param {Object} entry
      */
     createItem: function(entry) {
       if (entry.networkList)
         return new NetworkSelectorItem(
             /** @type {{key: string, networkList: Array<!NetworkProperties>}} */
             (entry));
       if (entry.command)
         return new NetworkButtonItem(
-            /** @type {{key: string, subtitle: string, command: Function}} */(
+            /** @type {{key: string, subtitle: string, command: Function}} */ (
                 entry));
       if (entry.menu)
         return new NetworkMenuItem(entry);
       assertNotReached();
     },
 
     /**
      * Deletes an element from the list.
      * @param {string} key  Unique identifier for the element.
      */
@@ skipping 75 matching lines @@
       if (ethernetNetwork) {
         var ethernetOptions = showDetails.bind(null, ethernetNetwork.GUID);
         var state = ethernetNetwork.ConnectionState;
         var subtitle;
         if (state == 'Connected')
           subtitle = loadTimeData.getString('OncConnectionStateConnected');
         else if (state == 'Connecting')
           subtitle = loadTimeData.getString('OncConnectionStateConnecting');
         else
           subtitle = loadTimeData.getString('OncConnectionStateNotConnected');
-        this.update(
-          { key: 'Ethernet',
-            subtitle: subtitle,
-            iconData: ethernetNetwork,
-            command: ethernetOptions,
-            Source: ethernetNetwork.Source }
-        );
+        this.update({
+          key: 'Ethernet',
+          subtitle: subtitle,
+          iconData: ethernetNetwork,
+          command: ethernetOptions,
+          Source: ethernetNetwork.Source
+        });
       } else {
         this.deleteItem('Ethernet');
       }
 
       if (wifiDeviceState == 'Enabled')
         loadData_('WiFi', networkStates);
-      else if (wifiDeviceState ==
+      else if (
+          wifiDeviceState ==
           chrome.networkingPrivate.DeviceStateType.PROHIBITED)
         setTechnologiesProhibited_(chrome.networkingPrivate.NetworkType.WI_FI);
       else
         addEnableNetworkButton_(chrome.networkingPrivate.NetworkType.WI_FI);
 
       // Only show cellular control if available.
       if (cellularDevice) {
         if (cellularDevice.State == 'Enabled' &&
             !isCellularSimAbsent(cellularDevice) &&
             !isCellularSimLocked(cellularDevice)) {
           loadData_('Cellular', networkStates);
-        } else if (cellularDevice.State ==
+        } else if (
+            cellularDevice.State ==
             chrome.networkingPrivate.DeviceStateType.PROHIBITED) {
           setTechnologiesProhibited_(
               chrome.networkingPrivate.NetworkType.CELLULAR);
         } else {
           addEnableNetworkButton_(
               chrome.networkingPrivate.NetworkType.CELLULAR);
         }
       } else {
         this.deleteItem('Cellular');
       }
 
       // Only show wimax control if available. Uses cellular icons.
       if (wimaxDeviceState) {
         if (wimaxDeviceState == 'Enabled') {
           loadData_('WiMAX', networkStates);
-        } else if (wimaxDeviceState ==
+        } else if (
+            wimaxDeviceState ==
             chrome.networkingPrivate.DeviceStateType.PROHIBITED) {
           setTechnologiesProhibited_(
               chrome.networkingPrivate.NetworkType.WI_MAX);
         } else {
           addEnableNetworkButton_(chrome.networkingPrivate.NetworkType.WI_MAX);
         }
       } else {
         this.deleteItem('WiMAX');
       }
 
@@ skipping 19 matching lines @@
         if (isCellularSimLocked(cellularDevice)) {
           chrome.send('simOperation', ['unlock']);
           return;
         } else if (isCellularSimAbsent(cellularDevice)) {
           chrome.send('simOperation', ['configure']);
           return;
         }
       }
       chrome.networkingPrivate.enableNetworkType(type);
     };
-    $('network-list').update({key: type,
-                              subtitle: subtitle,
-                              iconType: type,
-                              command: enableNetwork});
+    $('network-list').update({
+      key: type,
+      subtitle: subtitle,
+      iconType: type,
+      command: enableNetwork
+    });
   }
 
   /**
    * Replaces a network menu with a button with nothing to do.
    * @param {!chrome.networkingPrivate.NetworkType} type
    * @private
    */
   function setTechnologiesProhibited_(type) {
     var subtitle = loadTimeData.getString('networkProhibited');
     var doNothingButRemoveClickShadow = function() {
       this.removeAttribute('lead');
       this.removeAttribute('selected');
       this.parentNode.removeAttribute('has-element-focus');
     };
-    $('network-list').update({key: type,
-                              subtitle: subtitle,
-                              iconType: type,
-                              command: doNothingButRemoveClickShadow});
+    $('network-list').update({
+      key: type,
+      subtitle: subtitle,
+      iconType: type,
+      command: doNothingButRemoveClickShadow
+    });
   }
 
   /**
    * Element for indicating a policy managed network.
    * @constructor
    * @extends {options.ControlledSettingIndicator}
    */
   function ManagedNetworkIndicator() {
     var el = cr.doc.createElement('span');
     el.__proto__ = ManagedNetworkIndicator.prototype;
@@ skipping 113 matching lines @@
    * provider. If |opt_extensionID| is omitted, the dialog for the built-in
    * OpenVPN/L2TP provider is shown. Otherwise, |opt_extensionID| identifies the
    * third-party provider for which the dialog should be shown.
    * @param {string=} opt_extensionID Extension ID identifying the third-party
    *     VPN provider for which the dialog should be shown.
    * @return {function()} The created callback.
    * @private
    */
   function createVPNConnectionCallback_(opt_extensionID) {
     return function() {
-      sendChromeMetricsAction(opt_extensionID ?
-          'Options_NetworkAddVPNThirdParty' :
-          'Options_NetworkAddVPNBuiltIn');
-      chrome.send('addVPNConnection',
-                  opt_extensionID ? [opt_extensionID] : undefined);
+      sendChromeMetricsAction(
+          opt_extensionID ? 'Options_NetworkAddVPNThirdParty' :
+                            'Options_NetworkAddVPNBuiltIn');
+      chrome.send(
+          'addVPNConnection', opt_extensionID ? [opt_extensionID] : undefined);
     };
   }
 
   /**
    * Generates an "add network" entry for each VPN provider currently enabled in
    * the user's profile.
    * @return {!Array<{label: string, command: function(), data: !Object}>} The
    *     list of entries.
    * @private
    */
   function createAddVPNConnectionEntries_() {
     var entries = [];
     for (var i = 0; i < vpnProviders.length; ++i) {
       var provider = vpnProviders[i];
       entries.push({
-        label: loadTimeData.getStringF('addConnectionVPNTemplate',
-                                       provider.ProviderName),
+        label: loadTimeData.getStringF(
+            'addConnectionVPNTemplate', provider.ProviderName),
         command: createVPNConnectionCallback_(provider.ExtensionID),
         data: {}
       });
     }
     // Add an entry for the built-in OpenVPN/L2TP provider.
     entries.push({
       label: loadTimeData.getString('vpnBuiltInProvider'),
       command: createVPNConnectionCallback_(),
       data: {}
     });
@@ skipping 11 matching lines @@
     }
     return true;
   }
 
   /**
    * Whether the Network list is disabled. Only used for display purpose.
    */
   cr.defineProperty(NetworkList, 'disabled', cr.PropertyKind.BOOL_ATTR);
 
   // Export
-  return {
-    NetworkList: NetworkList
-  };
+  return {NetworkList: NetworkList};
 });