Make network settings functions more closely match networkingPrivate

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.
 
 cr.define('options.network', function() {
   var ArrayDataModel = cr.ui.ArrayDataModel;
   var List = cr.ui.List;
   var ListItem = cr.ui.ListItem;
   var ListSingleSelectionModel = cr.ui.ListSingleSelectionModel;
   var Menu = cr.ui.Menu;
@@ skipping 45 matching lines @@
   var cellularEnabled_ = false;
 
   /**
    * Indicates if cellular device supports network scanning.
    * @type {boolean}
    * @private
    */
   var cellularSupportsScan_ = false;
 
   /**
+   * Indicates the current SIM lock type of the cellular device.
+   * @type {boolean}
+   * @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}
    * @private
    */
   var wimaxAvailable_ = false;
 
   /**
    * Indicates if WiMAX networks are enabled.
    * @type {boolean}
    * @private
@@ skipping 285 matching lines @@
           parent.appendChild(this.menu_);
       }
       var top = this.offsetTop + this.clientHeight;
       var menuId = this.getMenuName();
       if (menuId != activeMenu_ || rebuild) {
         closeMenu_();
         activeMenu_ = menuId;
         this.menu_.style.setProperty('top', top + 'px');
         this.menu_.hidden = false;
       }
-      if (rescan)
-        chrome.send('refreshNetworks');
-    },
+      if (rescan) {
+        // TODO(stevenjb): chrome.networkingPrivate.requestNetworkScan
+        chrome.send('requestNetworkScan');
+      }
+    }
   };
 
   /**
    * Creates a control for selecting or configuring a network connection based
    * on the type of connection (e.g. wifi versus vpn).
    * @param {{key: string, networkList: Array.<Object>}} data Description of the
    *     network.
    * @constructor
    * @extends {NetworkMenuItem}
    */
@@ skipping 120 matching lines @@
       list = this.data.networkList;
       var empty = !list || list.length == 0;
       if (list) {
         for (var i = 0; i < list.length; i++) {
           var data = list[i];
           this.createNetworkOptionsCallback_(networkGroup, data);
           if (data.ConnectionState == 'Connected') {
             if (data.Type == 'VPN') {
               var disconnectCallback = function() {
                 sendChromeMetricsAction('Options_NetworkDisconnectVPN');
-                chrome.send('networkCommand',
-                            ['VPN', data.servicePath, 'disconnect']);
+                // TODO(stevenjb): chrome.networkingPrivate.startDisconnect
+                chrome.send('startDisconnect', [data.servicePath]);
               };
               // Add separator
               addendum.push({});
               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.send('disableWifi');
-                       },
-                       data: {}});
+          addendum.push({
+            label: loadTimeData.getString('turnOffWifi'),
+            command: function() {
+              sendChromeMetricsAction('Options_NetworkWifiToggle');
+              // TODO(stevenjb): chrome.networkingPrivate.disableNetworkType
+              chrome.send('disableNetworkType', ['WiFi']);
+            },
+            data: {}});
         } else if (this.data_.key == 'Wimax') {
-          addendum.push({label: loadTimeData.getString('turnOffWimax'),
-                       command: function() {
-                         chrome.send('disableWimax');
-                       },
-                       data: {}});
+          addendum.push({
+            label: loadTimeData.getString('turnOffWimax'),
+            command: function() {
+              // TODO(stevenjb): chrome.networkingPrivate.disableNetworkType
+              chrome.send('disableNetworkType', ['Wimax']);
+            },
+            data: {}});
         } else if (this.data_.key == 'Cellular') {
-          addendum.push({label: loadTimeData.getString('turnOffCellular'),
-                       command: function() {
-                         chrome.send('disableCellular');
-                       },
-                       data: {}});
+          addendum.push({
+            label: loadTimeData.getString('turnOffCellular'),
+            command: function() {
+              // TODO(stevenjb): chrome.networkingPrivate.disableNetworkType
+              chrome.send('disableNetworkType', ['Cellular']);
+            },
+            data: {}});
         }
       }
       if (!empty)
         menu.appendChild(networkGroup);
       if (addendum.length > 0) {
         var separator = false;
         if (!empty) {
           menu.appendChild(MenuItem.createSeparator());
           separator = true;
         }
@@ skipping 94 matching lines @@
     /**
      * Adds a menu item for showing network details.
      * @param {!Element} parent The parent element.
      * @param {Object} data Description of the network.
      * @private
      */
     createNetworkOptionsCallback_: function(parent, data) {
       var menuItem = createCallback_(parent,
                                      data,
                                      getNetworkName(data),
-                                     'options',
+                                     'showDetails',
                                      data.iconURL);
       if (data.policyManaged)
         menuItem.appendChild(new ManagedNetworkIndicator());
       if (data.ConnectionState == 'Connected' ||
           data.ConnectionState == 'Connecting') {
         var label = menuItem.getElementsByClassName(
             'network-menu-item-label')[0];
         label.classList.add('active-network');
       }
     }
@@ skipping 282 matching lines @@
    *     cellularAvailable: boolean, cellularEnabled: boolean,
    *     cellularSupportsScan: boolean}} 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;
 
     // Only show Ethernet control if connected.
     var ethernetConnection = getConnection_(data.wiredList);
     if (ethernetConnection) {
       var type = String('Ethernet');
       var path = ethernetConnection.servicePath;
       var ethernetOptions = function() {
-        chrome.send('networkCommand',
-                    [type, path, 'options']);
+        chrome.send('networkCommand', [type, path, 'showDetails']);
       };
       networkList.update(
           { key: 'Ethernet',
             subtitle: loadTimeData.getString('OncConnectionStateConnected'),
             iconURL: ethernetConnection.iconURL,
             command: ethernetOptions,
             policyManaged: ethernetConnection.policyManaged }
           );
     } else {
       networkList.deleteItem('Ethernet');
     }
 
     if (data.wifiEnabled)
       loadData_('WiFi', data.wirelessList, data.rememberedList);
     else
-      addEnableNetworkButton_('WiFi', 'enableWifi', 'WiFi');
+      addEnableNetworkButton_('WiFi');
 
     // Only show cellular control if available.
     if (data.cellularAvailable) {
       if (data.cellularEnabled)
         loadData_('Cellular', data.wirelessList, data.rememberedList);
       else
-        addEnableNetworkButton_('Cellular', 'enableCellular', 'Cellular');
+        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);
       else
-        addEnableNetworkButton_('Wimax', 'enableWimax', 'Cellular');
+        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);
     else
       networkList.deleteItem('VPN');
     networkList.endBatchUpdates();
   };
 
   /**
-   * Replaces a network menu with a button for reenabling the type of network.
-   * @param {string} name The type of network (WiFi, Cellular or Wimax).
-   * @param {string} command The command for reenabling the network.
-   * @param {string} icon Type of icon (WiFi or Cellular).
+   * 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, command, icon) {
+  function addEnableNetworkButton_(type) {
     var subtitle = loadTimeData.getString('networkDisabled');
+    var icon = (type == 'Wimax') ? 'Cellular' : type;
     var enableNetwork = function() {
       if (type == 'WiFi')
         sendChromeMetricsAction('Options_NetworkWifiToggle');
-      chrome.send(command);
+      if (type == 'Cellular') {
+        if (cellularSimLockType_) {
+          chrome.send('simOperation', ['unlock']);
+          return;
+        } else if (cellularEnabled_ && cellularSimAbsent_) {
+          chrome.send('simOperation', ['configure']);
+          return;
+        }
+      }
+      // TODO(stevenjb): chrome.networkingPrivate.enableNetworkType
+      chrome.send('enableNetworkType', [type]);
     };
-    var networkList = $('network-list');
-    networkList.update({key: type,
-                        subtitle: subtitle,
-                        iconType: icon,
-                        command: enableNetwork});
+    $('network-list').update({key: type,
+                              subtitle: subtitle,
+                              iconType: icon,
+                              command: enableNetwork});
   }
 
   /**
    * Element for indicating a policy managed network.
    * @constructor
    * @extends {options.ControlledSettingIndicator}
    */
   function ManagedNetworkIndicator() {
     var el = cr.doc.createElement('span');
     el.__proto__ = ManagedNetworkIndicator.prototype;
@@ skipping 122 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
   };
 });