Settings: Network: Closure cleanup

chrome/browser/resources/settings/internet_page/network_summary.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.
 
 /**
  * @fileoverview Polymer element for displaying a summary of network states
  * by type: Ethernet, WiFi, Cellular, WiMAX, and VPN.
  */
 
-/** @typedef {chrome.networkingPrivate.DeviceStateProperties} */
-var DeviceStateProperties;
-
 /**
  * @typedef {{
- *   Ethernet: (DeviceStateProperties|undefined),
- *   WiFi: (DeviceStateProperties|undefined),
- *   Cellular: (DeviceStateProperties|undefined),
- *   WiMAX: (DeviceStateProperties|undefined),
- *   VPN: (DeviceStateProperties|undefined)
+ *   Ethernet: (!CrOnc.DeviceStateProperties|undefined),
+ *   WiFi: (!CrOnc.DeviceStateProperties|undefined),
+ *   Cellular: (!CrOnc.DeviceStateProperties|undefined),
+ *   WiMAX: (!CrOnc.DeviceStateProperties|undefined),
+ *   VPN: (!CrOnc.DeviceStateProperties|undefined)
  * }}
  */
 var DeviceStateObject;
 
 /**
  * @typedef {{
- *   Ethernet: (Array<CrOnc.NetworkStateProperties>|undefined),
- *   WiFi: (Array<CrOnc.NetworkStateProperties>|undefined),
- *   Cellular: (Array<CrOnc.NetworkStateProperties>|undefined),
- *   WiMAX: (Array<CrOnc.NetworkStateProperties>|undefined),
- *   VPN: (Array<CrOnc.NetworkStateProperties>|undefined)
+ *   Ethernet: (Array<!CrOnc.NetworkStateProperties>|undefined),
+ *   WiFi: (Array<!CrOnc.NetworkStateProperties>|undefined),
+ *   Cellular: (Array<!CrOnc.NetworkStateProperties>|undefined),
+ *   WiMAX: (Array<!CrOnc.NetworkStateProperties>|undefined),
+ *   VPN: (Array<!CrOnc.NetworkStateProperties>|undefined)
  * }}
  */
 var NetworkStateListObject;
 
 Polymer({
   is: 'network-summary',
 
   behaviors: [CrPolicyNetworkBehavior],
 
   properties: {
     /**
      * Highest priority connected network or null.
      * @type {?CrOnc.NetworkStateProperties}
      */
     defaultNetwork: {
       type: Object,
       value: null,
       notify: true,
     },
 
     /**
      * Interface for networkingPrivate calls, passed from internet_page.
-     * @type {NetworkingPrivate}
+     * @type {!NetworkingPrivate}
      */
     networkingPrivate: Object,
 
     /**
      * The device state for each network device type. We initialize this to
      * include a disabled WiFi type since WiFi is always present. This reduces
      * the amount of visual change on first load.
-     * @private {DeviceStateObject}
+     * @private {!DeviceStateObject}
      */
     deviceStates: {
       type: Object,
       value: function() {
         return {
-          WiFi: {
-            Type: chrome.networkingPrivate.NetworkType.WI_FI,
-            State: chrome.networkingPrivate.DeviceStateType.DISABLED
-          },
+          WiFi: {Type: CrOnc.Type.WI_FI, State: CrOnc.DeviceState.DISABLED},
         };
       },
       notify: true,
     },
 
     /**
      * Array of active network states, one per device type. Initialized to
      * include a default WiFi state (see deviceStates comment).
      * @private {!Array<!CrOnc.NetworkStateProperties>}
      */
     activeNetworkStates_: {
       type: Array,
       value: function() {
-        return [{GUID: '', Type: chrome.networkingPrivate.NetworkType.WI_FI}];
+        return [{GUID: '', Type: CrOnc.Type.WI_FI}];
       },
     },
 
     /**
      * List of network state data for each network type.
-     * @private {NetworkStateListObject}
+     * @private {!NetworkStateListObject}
      */
     networkStateLists_: {
       type: Object,
       value: function() {
         return {WiFi: []};
       },
     },
   },
 
   /**
    * Listener function for chrome.networkingPrivate.onNetworkListChanged event.
-   * @type {?function(!Array<string>)}
-   * @private
+   * @private {?function(!Array<string>)}
    */
   networkListChangedListener_: null,
 
   /**
    * Listener function for chrome.networkingPrivate.onDeviceStateListChanged
    * event.
-   * @type {?function(!Array<string>)}
-   * @private
+   * @private {?function(!Array<string>)}
    */
   deviceStateListChangedListener_: null,
 
   /**
    * Listener function for chrome.networkingPrivate.onNetworksChanged event.
-   * @type {?function(!Array<string>)}
-   * @private
+   * @private {?function(!Array<string>)}
    */
   networksChangedListener_: null,
 
   /**
    * Set of GUIDs identifying active networks, one for each type.
-   * @type {?Set<string>}
-   * @private
+   * @private {?Set<string>}
    */
   activeNetworkIds_: null,
 
   /** @override */
   attached: function() {
     this.getNetworkLists_();
 
     this.networkListChangedListener_ = this.networkListChangedListener_ ||
         this.onNetworkListChangedEvent_.bind(this);
     this.networkingPrivate.onNetworkListChanged.addListener(
@@ skipping 51 matching lines @@
       if (this.activeNetworkIds_.has(id)) {
         this.networkingPrivate.getState(
             id, this.getActiveStateCallback_.bind(this, id));
       }
     }, this);
   },
 
   /**
    * networkingPrivate.getState event callback for an active state.
    * @param {string} id The id of the requested state.
-   * @param {!chrome.networkingPrivate.NetworkStateProperties} state
+   * @param {!CrOnc.NetworkStateProperties} state
    * @private
    */
   getActiveStateCallback_: function(id, state) {
     if (chrome.runtime.lastError) {
       var message = chrome.runtime.lastError.message;
       if (message != 'Error.NetworkUnavailable') {
         console.error(
             'Unexpected networkingPrivate.getState error: ' + message +
             ' For: ' + id);
       }
@@ skipping 28 matching lines @@
     this.networkingPrivate.getDeviceStates(function(deviceStates) {
       // Second get the network states.
       this.getNetworkStates_(deviceStates);
     }.bind(this));
   },
 
   /**
    * Requests the list of network states from Chrome. Updates
    * activeNetworkStates and networkStateLists once the results are returned
    * from Chrome.
-   * @param {!Array<!DeviceStateProperties>=} opt_deviceStates
-   *     Optional list of state properties for all available devices.

[stevenjb, 2017/05/31 19:01:46]

This is no longer optional, this is now only called from getnetworkLists_, and
networkingPrivate.getDeviceStates always returns an Array.

+   * @param {!Array<!CrOnc.DeviceStateProperties>} deviceStates
    * @private
    */
-  getNetworkStates_: function(opt_deviceStates) {
+  getNetworkStates_: function(deviceStates) {
     var filter = {
-      networkType: chrome.networkingPrivate.NetworkType.ALL,
+      networkType: CrOnc.Type.ALL,
       visible: true,
       configured: false
     };
     this.networkingPrivate.getNetworks(filter, function(networkStates) {
-      this.updateNetworkStates_(networkStates, opt_deviceStates);
+      this.updateNetworkStates_(networkStates, deviceStates);
     }.bind(this));
   },
 
   /**
    * Called after network states are received from getNetworks.
    * @param {!Array<!CrOnc.NetworkStateProperties>} networkStates The state
    *     properties for all visible networks.
-   * @param {!Array<!DeviceStateProperties>=} opt_deviceStates
-   *     Optional list of state properties for all available devices. If not
-   *     defined the existing list of device states will be used.
+   * @param {!Array<!CrOnc.DeviceStateProperties>} deviceStates
    * @private
    */
-  updateNetworkStates_: function(networkStates, opt_deviceStates) {
-    var newDeviceStates;
-    if (opt_deviceStates) {
-      newDeviceStates = /** @type {!DeviceStateObject} */ ({});
-      for (var i = 0; i < opt_deviceStates.length; ++i) {
-        var state = opt_deviceStates[i];
-        newDeviceStates[state.Type] = state;
-      }
-    } else {
-      newDeviceStates = Object.assign({}, this.deviceStates);
+  updateNetworkStates_: function(networkStates, deviceStates) {
+    var newDeviceStates = /** @type {!DeviceStateObject} */ ({});
+    for (var i = 0; i < deviceStates.length; ++i) {
+      var state = deviceStates[i];
+      newDeviceStates[state.Type] = state;
     }
 
     // Clear any current networks.
     var activeNetworkStatesByType =
         /** @type {!Map<string, !CrOnc.NetworkStateProperties>} */ (new Map);
 
     // Complete list of states by type.
     /** @type {!NetworkStateListObject} */ var newNetworkStateLists = {
       Ethernet: [],
       Tether: [],
@@ skipping 13 matching lines @@
           firstConnectedNetwork = networkState;
         }
       }
       newNetworkStateLists[type].push(networkState);
     }, this);
 
     this.defaultNetwork = firstConnectedNetwork;
 
     // Create a VPN entry in deviceStates if there are any VPN networks.
     if (newNetworkStateLists.VPN && newNetworkStateLists.VPN.length > 0) {
-      newDeviceStates.VPN = /** @type {DeviceStateProperties} */ ({
+      newDeviceStates.VPN = {
         Type: CrOnc.Type.VPN,
-        State: chrome.networkingPrivate.DeviceStateType.ENABLED
-      });
+        State: CrOnc.DeviceState.ENABLED
+      };
     }
 
     // Push the active networks onto newActiveNetworkStates in order based on
     // device priority, creating an empty state for devices with no networks.
     var newActiveNetworkStates = [];
     this.activeNetworkIds_ = new Set;
     var orderedDeviceTypes = [
       CrOnc.Type.ETHERNET, CrOnc.Type.WI_FI, CrOnc.Type.CELLULAR,
       CrOnc.Type.TETHER, CrOnc.Type.WI_MAX, CrOnc.Type.VPN
     ];
     for (var i = 0; i < orderedDeviceTypes.length; ++i) {
       var type = orderedDeviceTypes[i];
       var device = newDeviceStates[type];
       if (!device)
         continue;
       var state = activeNetworkStatesByType.get(type) || {GUID: '', Type: type};
       if (state.Source === undefined &&
-          device.State == chrome.networkingPrivate.DeviceStateType.PROHIBITED) {
+          device.State == CrOnc.DeviceState.PROHIBITED) {
         // Prohibited technologies are enforced by the device policy.
         state.Source = CrOnc.Source.DEVICE_POLICY;
       }
       newActiveNetworkStates.push(state);
       this.activeNetworkIds_.add(state.GUID);
     }
 
     this.deviceStates = newDeviceStates;
     this.networkStateLists_ = newNetworkStateLists;
     // Set activeNetworkStates last to rebuild the dom-repeat.
     this.activeNetworkStates_ = newActiveNetworkStates;
   },
 });