Use networkingPrivate.getDeviceState in Internet Settings

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.
 
 /**
  * This partially describes the network list entries passed to
  * refreshNetworkData. The contents of those lists actually match
  * CrOnc.NetworkConfigType with the addition of the policyManaged property.
  * TODO(stevenjb): Use networkingPrivate.getNetworks.
  * @typedef {{
@@ skipping 46 matching lines @@
                              'addConnection'];
 
   /**
    * ID of the menu that is currently visible.
    * @type {?string}
    * @private
    */
   var activeMenu_ = null;
 
   /**
-   * Indicates if cellular networks are available.
-   * @type {boolean}
+   * The state of the cellular device or undefined if not available.
+   * @type {string|undefined}
    * @private
    */
-  var cellularAvailable_ = false;
-
-  /**
-   * Indicates if cellular networks are enabled.
-   * @type {boolean}
-   * @private
-   */
-  var cellularEnabled_ = false;
+  var cellularState_ = undefined;
 
   /**
    * Indicates if cellular device supports network scanning.
    * @type {boolean}
    * @private
    */
   var cellularSupportsScan_ = false;
 
   /**
    * Indicates the current SIM lock type of the cellular device.
    * @type {string}
    * @private
    */
   var cellularSimLockType_ = '';
 
   /**
    * Indicates whether the SIM card is absent on the cellular device.
    * @type {boolean}
    * @private
    */
   var cellularSimAbsent_ = false;
 
   /**
-   * Indicates if WiMAX networks are available.
-   * @type {boolean}
+   * The state of the WiFi device or undefined if not available.
+   * @type {string|undefined}
    * @private
    */
-  var wimaxAvailable_ = false;
+  var wifiState_ = undefined;
 
   /**
-   * Indicates if WiMAX networks are enabled.
-   * @type {boolean}
+   * The state of the WiMAX device or undefined if not available.
+   * @type {string|undefined}
    * @private
    */
-  var wimaxEnabled_ = false;
+  var wimaxState_ = undefined;
 
   /**
    * Indicates if mobile data roaming is enabled.
    * @type {boolean}
    * @private
    */
   var enableDataRoaming_ = false;
 
   /**
+   * List of wired networks.
+   * @type {Array<!NetworkInfo>}
+   * @private
+   */
+  var wiredList_ = [];
+
+  /**
+   * List of WiFi, Cellular, and WiMAX networks.
+   * @type {Array<!NetworkInfo>}
+   * @private
+   */
+  var wirelessList_ = [];
+
+  /**
+   * List of VPN networks.
+   * @type {Array<!NetworkInfo>}
+   * @private
+   */
+  var vpnList_ = [];
+
+  /**
+   * List of remembered (favorite) networks.
+   * @type {Array<!NetworkInfo>}
+   * @private
+   */
+  var rememberedList_ = [];
+
+  /**
    * Returns the display name for 'network'.
    * @param {Object} data The network data dictionary.
    */
   function getNetworkName(data) {
     if (data.Type == 'Ethernet')
       return loadTimeData.getString('ethernetName');
     if (data.Type == 'VPN')
       return options.VPNProviders.formatNetworkName(new cr.onc.OncData(data));
     return data.Name;
   }
@@ skipping 372 matching lines @@
       menu.hidden = true;
       Menu.decorate(menu);
       var addendum = [];
       if (this.data_.key == 'WiFi') {
         addendum.push({
           label: loadTimeData.getString('joinOtherNetwork'),
           command: createAddNonVPNConnectionCallback_('WiFi'),
           data: {}
         });
       } else if (this.data_.key == 'Cellular') {
-        if (cellularEnabled_ && cellularSupportsScan_) {
+        if (cellularState_ == 'Enabled' && cellularSupportsScan_) {
           addendum.push({
             label: loadTimeData.getString('otherCellularNetworks'),
             command: createAddNonVPNConnectionCallback_('Cellular'),
             addClass: ['other-cellulars'],
             data: {}
           });
         }
 
         var label = enableDataRoaming_ ? 'disableDataRoaming' :
             'enableDataRoaming';
@@ skipping 495 matching lines @@
       if (index != undefined) {
         var entry = this.dataModel.item(index);
         entry.iconType = active ? 'control-active' : 'control-inactive';
         this.update(entry);
       }
     }
   };
 
   /**
    * Chrome callback for updating network controls.
-   * @param {{cellularAvailable: boolean,
-   *          cellularEnabled: boolean,
-   *          cellularSimAbsent: boolean,
+   * @param {{cellularSimAbsent: boolean,
    *          cellularSimLockType: string,
    *          cellularSupportsScan: boolean,
    *          rememberedList: Array<NetworkInfo>,
    *          vpnList: Array<NetworkInfo>,
-   *          wifiAvailable: boolean,
-   *          wifiEnabled: boolean,
-   *          wimaxAvailable: boolean,
-   *          wimaxEnabled: boolean,
    *          wiredList: Array<NetworkInfo>,
    *          wirelessList: Array<NetworkInfo>}} data Description of available
    *     network devices and their corresponding state.
    */
   NetworkList.refreshNetworkData = function(data) {
-    var networkList = $('network-list');
-    networkList.startBatchUpdates();
-    cellularAvailable_ = data.cellularAvailable;
-    cellularEnabled_ = data.cellularEnabled;
     cellularSupportsScan_ = data.cellularSupportsScan;
     cellularSimAbsent_ = data.cellularSimAbsent;
     cellularSimLockType_ = data.cellularSimLockType;
-    wimaxAvailable_ = data.wimaxAvailable;
-    wimaxEnabled_ = data.wimaxEnabled;
+    wiredList_ = data.wiredList;
+    wirelessList_ = data.wirelessList;
+    vpnList_ = data.vpnList;
+    rememberedList_ = data.rememberedList;
+
+    // Request device states.
+    chrome.networkingPrivate.getDeviceStates(
+        NetworkList.onGetDeviceStates.bind(this));
+  };
+
+  /**
+   * Callback from getDeviceStates. Updates network controls.
+   * @param {Array<{State: string, Type: string}>} deviceStates The result
+   *     from getDeviceStates.
+   */
+  NetworkList.onGetDeviceStates = function(deviceStates) {
+    var networkList = $('network-list');
+    networkList.startBatchUpdates();
+
+    cellularState_ = undefined;
+    wifiState_ = undefined;
+    wimaxState_ = undefined;
+    for (var i = 0; i < deviceStates.length; ++i) {
+      var device = deviceStates[i];
+      var type = device.Type;
+      var state = device.State;
+      if (type == 'Cellular')
+        cellularState_ = cellularState_ || state;
+      else if (type == 'WiFi')
+        wifiState_ = wifiState_ || state;
+      else if (type == 'WiMAX')
+        wimaxState_ = wimaxState_ || state;
+    }
 
     // Only show Ethernet control if connected.
-    var ethernetConnection = getConnection_(data.wiredList);
+    var ethernetConnection = getConnection_(wiredList_);
     if (ethernetConnection) {
       var type = String('Ethernet');
       var ethernetOptions = showDetails.bind(null, ethernetConnection.GUID);
       networkList.update(
           { key: 'Ethernet',
             subtitle: loadTimeData.getString('OncConnectionStateConnected'),
             iconData: ethernetConnection,
             command: ethernetOptions,
             policyManaged: ethernetConnection.policyManaged }
           );
     } else {
       networkList.deleteItem('Ethernet');
     }
 
-    if (data.wifiEnabled)
-      loadData_('WiFi', data.wirelessList, data.rememberedList);
+    if (wifiState_ == 'Enabled')
+      loadData_('WiFi', wirelessList_, rememberedList_);
     else
       addEnableNetworkButton_('WiFi');
 
     // Only show cellular control if available.
-    if (data.cellularAvailable) {
-      if (data.cellularEnabled)
-        loadData_('Cellular', data.wirelessList, data.rememberedList);
+    if (cellularState_) {
+      if (cellularState_ == 'Enabled')
+        loadData_('Cellular', wirelessList_, rememberedList_);
       else
         addEnableNetworkButton_('Cellular');
     } else {
       networkList.deleteItem('Cellular');
     }
 
     // Only show wimax control if available. Uses cellular icons.
-    if (data.wimaxAvailable) {
-      if (data.wimaxEnabled)
-        loadData_('WiMAX', data.wirelessList, data.rememberedList);
+    if (wimaxState_) {
+      if (wimaxState_ == 'Enabled')
+        loadData_('WiMAX', wirelessList_, rememberedList_);
       else
         addEnableNetworkButton_('WiMAX');
     } else {
       networkList.deleteItem('WiMAX');
     }
 
     // Only show VPN control if there is at least one VPN configured.
-    if (data.vpnList.length > 0)
-      loadData_('VPN', data.vpnList, data.rememberedList);
+    if (vpnList_.length > 0)
+      loadData_('VPN', vpnList_, rememberedList_);
     else
       networkList.deleteItem('VPN');
     networkList.endBatchUpdates();
   };
 
   /**
    * Replaces a network menu with a button for enabling the network type.
    * @param {string} type The type of network (WiFi, Cellular or Wimax).
    * @private
    */
   function addEnableNetworkButton_(type) {
     var subtitle = loadTimeData.getString('networkDisabled');
     var enableNetwork = function() {
       if (type == 'WiFi')
         sendChromeMetricsAction('Options_NetworkWifiToggle');
       if (type == 'Cellular') {
         if (cellularSimLockType_) {
           chrome.send('simOperation', ['unlock']);
           return;
-        } else if (cellularEnabled_ && cellularSimAbsent_) {
+        } else if (cellularState_ == 'Enabled' && cellularSimAbsent_) {
           chrome.send('simOperation', ['configure']);
           return;
         }
       }
       chrome.networkingPrivate.enableNetworkType(type);
     };
     $('network-list').update({key: type,
                               subtitle: subtitle,
                               iconType: type,
                               command: enableNetwork});
@@ skipping 173 matching lines @@
   /**
    * Whether the Network list is disabled. Only used for display purpose.
    */
   cr.defineProperty(NetworkList, 'disabled', cr.PropertyKind.BOOL_ATTR);
 
   // Export
   return {
     NetworkList: NetworkList
   };
 });