Fix VPN connected logic in internet settings

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} */
@@ skipping 41 matching lines @@
   CrOnc.Type.CELLULAR,
   CrOnc.Type.WI_MAX,
   CrOnc.Type.VPN
 ];
 
 Polymer({
   is: 'network-summary',
 
   properties: {
     /**
+     * Highest priority connected network or null.
+     * @type {?CrOnc.NetworkStateProperties}
+     */
+    defaultNetwork: {
+      type: Object,
+      value: null,
+      notify: true
+    },
+
+    /**
      * The device state for each network device type.
      * @type {DeviceStateObject}
      */
     deviceStates: {
       type: Object,
       value: function() { return {}; },
     },
 
     /**
      * Network state data for each network type.
      * @type {NetworkStateObject}
      */
     networkStates: {
       type: Object,
       value: function() { return {}; },
     },
 
     /**
      * List of network state data for each network type.
      * @type {NetworkStateListObject}
      */
     networkStateLists: {
       type: Object,
       value: function() { return {}; },
-    }
+    },
   },
 
   /**
    * Listener function for chrome.networkingPrivate.onNetworkListChanged event.
    * @type {function(!Array<string>)}
    * @private
    */
   networkListChangedListener_: function() {},
 
   /**
@@ skipping 50 matching lines @@
     chrome.networkingPrivate.onNetworksChanged.removeListener(
         this.networksChangedListener_);
   },
 
   /**
    * Event triggered when the WiFi network-summary-item is expanded.
    * @param {!{detail: {expanded: boolean, type: string}}} event
    * @private
    */
   onWiFiExpanded_: function(event) {
-    this.getNetworkStates_();  // Get the latest network states (only).
+    // Get the latest network states (only).
+    this.getNetworkStates_(null);
     if (event.detail.expanded)
       chrome.networkingPrivate.requestNetworkScan();
   },
 
   /**
    * Event triggered when a network-summary-item is selected.
    * @param {!{detail: !CrOnc.NetworkStateProperties}} event
    * @private
    */
   onSelected_: function(event) {
     var state = event.detail;
-    if (state.ConnectionState == CrOnc.ConnectionState.NOT_CONNECTED) {
+    if (this.canConnect_(state)) {
       this.connectToNetwork_(state);
       return;
     }
     this.fire('show-detail', state);
   },
 
   /**
    * Event triggered when the enabled state of a network-summary-item is
    * toggled.
    * @param {!{detail: {enabled: boolean,
@@ skipping 45 matching lines @@
                 this.networkIds_[id] = undefined;
                 return;
               }
               this.updateNetworkState_(state.Type, state);
             }.bind(this));
       }
     }, this);
   },
 
   /**
+   * Determines whether or not a network state can be connected to.
+   * @param {!CrOnc.NetworkStateProperties} state The network state.
+   * @private
+   */
+  canConnect_: function(state) {
+    if (state.Type == CrOnc.Type.ETHERNET ||
+        state.Type == CrOnc.Type.VPN && !this.defaultNetwork) {
+      return false;
+    }
+    return state.ConnectionState == CrOnc.ConnectionState.NOT_CONNECTED;
+  },
+
+  /**
    * Handles UI requests to connect to a network.
    * TODO(stevenjb): Handle Cellular activation, etc.
    * @param {!CrOnc.NetworkStateProperties} state The network state.
    * @private
    */
   connectToNetwork_: function(state) {
     chrome.networkingPrivate.startConnect(state.GUID, function() {
       if (chrome.runtime.lastError &&
-          chrome.runtime.lastError != 'connecting') {
+          chrome.runtime.lastError.message != 'connecting') {
         console.error('Unexpected networkingPrivate.startConnect error:',
-                      chrome.runtime.lastError);
+                      chrome.runtime.lastError, 'For:', state.GUID);
       }
     });
   },
 
   /**
    * Requests the list of device states and network states from Chrome.
    * Updates deviceStates, networkStates, and networkStateLists once the
    * results are returned from Chrome.
    * @private
    */
   getNetworkLists_: function() {
     // First get the device states.
     chrome.networkingPrivate.getDeviceStates(
-      function(states) {
-        this.getDeviceStatesCallback_(states);
+      function(deviceStates) {
         // Second get the network states.
-        this.getNetworkStates_();
+        this.getNetworkStates_(deviceStates);
       }.bind(this));
   },
 
   /**
    * Requests the list of network states from Chrome. Updates networkStates and
    * networkStateLists once the results are returned from Chrome.
+   * @param {?Array<!DeviceStateProperties>} deviceStates The state properties
+   *     for all available devices.
    * @private
    */
-  getNetworkStates_: function() {
+  getNetworkStates_: function(deviceStates) {

[michaelpg, 2015/10/26 20:41:42]

Maybe make this opt_deviceStates (@param {Array<!DSP>|undefined}), so it can be
called as getNetworkStates_()?

[stevenjb, 2015/10/27 16:49:50]

Done.

     var filter = {
       networkType: chrome.networkingPrivate.NetworkType.ALL,
       visible: true,
       configured: false
     };
-    chrome.networkingPrivate.getNetworks(
-        filter, this.getNetworksCallback_.bind(this));
-  },
-
-  /**
-   * networkingPrivate.getDeviceStates callback.
-   * @param {!Array<!DeviceStateProperties>} states The state properties for all
-   *     available devices.
-   * @private
-   */
-  getDeviceStatesCallback_: function(states) {
-    var newStates = /** @type {!DeviceStateObject} */({});
-    states.forEach(function(state) { newStates[state.Type] = state; });
-    this.deviceStates = newStates;
+    var self = this;

[michaelpg, 2015/10/26 20:41:41]

we mostly/only use .bind(this) instead of var foo = this...

[stevenjb, 2015/10/27 16:49:50]

Done.

+    chrome.networkingPrivate.getNetworks(filter, function(networkStates) {
+      self.getNetworksCallback_(deviceStates, networkStates);
+    });
   },
 
   /**
    * networkingPrivate.getNetworksState callback.
-   * @param {!Array<!CrOnc.NetworkStateProperties>} states The state properties
-   *     for all visible networks.
+   * @param {?Array<!DeviceStateProperties>} deviceStates The state properties
+   *     for all available devices.
+   * @param {!Array<!CrOnc.NetworkStateProperties>} networkStates The state
+   *     properties for all visible networks.
    * @private
    */
-  getNetworksCallback_: function(states) {
+  getNetworksCallback_: function(deviceStates, networkStates) {
+    var newDeviceStates;
+    if (deviceStates) {
+      newDeviceStates = /** @type {!DeviceStateObject} */({});
+      deviceStates.forEach(function(state) {
+        newDeviceStates[state.Type] = state;
+      });
+    } else {
+      newDeviceStates = this.deviceStates;
+    }
+
     // Clear any current networks.
     this.networkIds_ = {};
 
     // Track the first (active) state for each type.
     var foundTypes = {};
 
     // Complete list of states by type.
     /** @type {!NetworkStateListObject} */ var networkStateLists = {
       Ethernet: [],
       WiFi: [],
       Cellular: [],
       WiMAX: [],
       VPN: []
     };
 
-    states.forEach(function(state) {
+    var firstConnectedNetwork = null;
+    networkStates.forEach(function(state) {
       var type = state.Type;
       if (!foundTypes[type]) {
         foundTypes[type] = true;
         this.updateNetworkState_(type, state);
+        if (!firstConnectedNetwork && state.Type != CrOnc.Type.VPN &&
+            state.ConnectionState == CrOnc.ConnectionState.CONNECTED) {
+          firstConnectedNetwork = state;
+        }
       }
       networkStateLists[type].push(state);
     }, this);
 
+    this.defaultNetwork = firstConnectedNetwork;
+
     // Set any types with a deviceState and no network to a default state,
     // and any types not found to undefined.
     NETWORK_TYPES.forEach(function(type) {
       if (!foundTypes[type]) {
         var defaultState = undefined;
-        if (this.deviceStates[type])
+        if (newDeviceStates[type])
           defaultState = {GUID: '', Type: type};
         this.updateNetworkState_(type, defaultState);
       }
     }, this);
 
     this.networkStateLists = networkStateLists;
 
     // Create a VPN entry in deviceStates if there are any VPN networks.
     if (networkStateLists.VPN && networkStateLists.VPN.length > 0) {
-      var vpn = {Type: CrOnc.Type.VPN, State: 'Enabled'};
-      this.set('deviceStates.VPN', vpn);
+      newDeviceStates.VPN = /** @type {DeviceStateProperties} */ ({
+        Type: CrOnc.Type.VPN,
+        State: chrome.networkingPrivate.DeviceStateType.ENABLED
+      });
     }
+
+    this.deviceStates = newDeviceStates;
   },
 
   /**
    * Sets 'networkStates[type]' which will update the cr-network-list-item
    * associated with 'type'.
    * @param {string} type The network type.
    * @param {!CrOnc.NetworkStateProperties|undefined} state The state properties
    *     for the network to associate with |type|. May be undefined if there are
    *     no networks matching |type|.
    * @private
    */
   updateNetworkState_: function(type, state) {
     this.set('networkStates.' + type, state);
     if (state)
       this.networkIds_[state.GUID] = true;
   },
 });
 })();