NetworkingPrivate API events should supply list of GUIDs, not service paths

chrome/test/data/extensions/api_test/networking/test.js

 // Copyright (c) 2013 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.
 
 var callbackPass = chrome.test.callbackPass;
 var callbackFail = chrome.test.callbackFail;
 var assertTrue = chrome.test.assertTrue;
 var assertFalse = chrome.test.assertFalse;
 var assertEq = chrome.test.assertEq;
 
@@ skipping 56 matching lines @@
           self.onPortalDetectionCompleted);
       done();
     };
     chrome.networkingPrivate.onPortalDetectionCompleted.addListener(
         self.onPortalDetectionCompleted);
   }
 };
 
 var availableTests = [
   function startConnect() {
-    chrome.networkingPrivate.startConnect("stub_wifi2", callbackPass());
+    chrome.networkingPrivate.startConnect("stub_wifi2_GUID", callbackPass());
   },
   function startDisconnect() {
     // Must connect to a network before we can disconnect from it.
-    chrome.networkingPrivate.startConnect("stub_wifi2", callbackPass(
+    chrome.networkingPrivate.startConnect("stub_wifi2_GUID", callbackPass(
       function() {
-        chrome.networkingPrivate.startDisconnect("stub_wifi2", callbackPass());
+        chrome.networkingPrivate.startDisconnect("stub_wifi2_GUID",
+                                                 callbackPass());
       }));
   },
   function startConnectNonexistent() {
     chrome.networkingPrivate.startConnect(
       "nonexistent_path",
       callbackFail("Error.InvalidNetworkGuid"));
   },
   function startDisconnectNonexistent() {
     chrome.networkingPrivate.startDisconnect(
       "nonexistent_path",
@@ skipping 28 matching lines @@
       }));
   },
   function getNetworks() {
     // Test 'type' and 'configured'.
     chrome.networkingPrivate.getNetworks(
       { "networkType": "WiFi", "configured": true },
       callbackPass(function(result) {
         assertEq([{
           "Connectable": true,
           "ConnectionState": "Connected",
-          "GUID": "stub_wifi1",
+          "GUID": "stub_wifi1_GUID",
           "Name": "wifi1",
           "Type": "WiFi",
           "WiFi": {
             "Security": "WEP-PSK",
             "SignalStrength": 40
           }
         }, {
-          "GUID": "stub_wifi2",
+          "GUID": "stub_wifi2_GUID",
           "Name": "wifi2_PSK",
           "Type": "WiFi",
           "WiFi": {
             "Security": "WPA-PSK",
           }
         }], result);
 
         // Test 'visible' (and 'configured').
         chrome.networkingPrivate.getNetworks(
           { "networkType": "WiFi", "visible": true, "configured": true },
           callbackPass(function(result) {
             assertEq([{
               "Connectable": true,
               "ConnectionState": "Connected",
-              "GUID": "stub_wifi1",
+              "GUID": "stub_wifi1_GUID",
               "Name": "wifi1",
               "Type": "WiFi",
               "WiFi": {
                 "Security": "WEP-PSK",
                 "SignalStrength": 40
               }
             }], result);
 
             // Test 'limit'.
             chrome.networkingPrivate.getNetworks(
               { "networkType": "All", "limit": 1 },
               callbackPass(function(result) {
                 assertEq([{
                   "ConnectionState": "Connected",
                   "Ethernet": {
                     "Authentication": "None"
                   },
-                  "GUID": "stub_ethernet",
+                  "GUID": "stub_ethernet_GUID",
                   "Name": "eth0",
                   "Type": "Ethernet"
                 }], result);
               }));
           }));
       }));
   },
   function getVisibleNetworks() {
     chrome.networkingPrivate.getVisibleNetworks(
       "All",
       callbackPass(function(result) {
         assertEq([{
                     "ConnectionState": "Connected",
                     "Ethernet": {
                       "Authentication": "None"
                     },
-                    "GUID": "stub_ethernet",
+                    "GUID": "stub_ethernet_GUID",
                     "Name": "eth0",
                     "Type": "Ethernet"
                   },
                   {
                     "Connectable": true,
                     "ConnectionState": "Connected",
-                    "GUID": "stub_wifi1",
+                    "GUID": "stub_wifi1_GUID",
                     "Name": "wifi1",
                     "Type": "WiFi",
                     "WiFi": {
                       "Security": "WEP-PSK",
                       "SignalStrength": 40
                     }
                   },
                   {
                     "ConnectionState": "Connected",
-                    "GUID": "stub_vpn1",
+                    "GUID": "stub_vpn1_GUID",
                     "Name": "vpn1",
                     "Type": "VPN"
                   },
                   {
                     "Connectable": true,
                     "ConnectionState": "NotConnected",
-                    "GUID": "stub_wifi2",
+                    "GUID": "stub_wifi2_GUID",
                     "Name": "wifi2_PSK",
                     "Type": "WiFi",
                     "WiFi": {
                       "Security": "WPA-PSK",
                       "SignalStrength": 80
                     }
                   }], result);
       }));
   },
   function getVisibleNetworksWifi() {
     chrome.networkingPrivate.getVisibleNetworks(
       "WiFi",
       callbackPass(function(result) {
         assertEq([{
                     "Connectable": true,
                     "ConnectionState": "Connected",
-                    "GUID": "stub_wifi1",
+                    "GUID": "stub_wifi1_GUID",
                     "Name": "wifi1",
                     "Type": "WiFi",
                     "WiFi": {
                       "Security": "WEP-PSK",
                       "SignalStrength": 40
                     }
                   },
                   {
                     "Connectable": true,
                     "ConnectionState": "NotConnected",
-                    "GUID": "stub_wifi2",
+                    "GUID": "stub_wifi2_GUID",
                     "Name": "wifi2_PSK",
                     "Type": "WiFi",
                     "WiFi": {
                       "Security": "WPA-PSK",
                       "SignalStrength": 80
                     }
                   }
                   ], result);
       }));
   },
   function requestNetworkScan() {
     // Connected or Connecting networks should be listed first, sorted by type.
-    var expected = ["stub_ethernet",
-                    "stub_wifi1",
-                    "stub_vpn1",
-                    "stub_wifi2"];
+    var expected = ["stub_ethernet_GUID",
+                    "stub_wifi1_GUID",
+                    "stub_vpn1_GUID",
+                    "stub_wifi2_GUID"];
     var done = chrome.test.callbackAdded();
     var listener = new privateHelpers.listListener(expected, done);
     chrome.networkingPrivate.onNetworkListChanged.addListener(
       listener.listenForChanges);
     chrome.networkingPrivate.requestNetworkScan();
   },
   function getProperties() {
     chrome.networkingPrivate.getProperties(
-      "stub_wifi1",
+      "stub_wifi1_GUID",
       callbackPass(function(result) {
         assertEq({ "Connectable": true,
                    "ConnectionState": "Connected",
-                   "GUID": "stub_wifi1",
+                   "GUID": "stub_wifi1_GUID",
                    "MacAddress": "00:11:22:AA:BB:CC",
                    "IPConfigs": [{
                      "Gateway": "0.0.0.1",
                      "IPAddress": "0.0.0.0",
                      "RoutingPrefix": 0,
                      "Type": "IPv4"
                    }],
                    "Name": "wifi1",
                    "Type": "WiFi",
                    "WiFi": {
                      "Frequency": 2400,
                      "FrequencyList": [2400],
                      "SSID": "wifi1",
                      "Security": "WEP-PSK",
                      "SignalStrength": 40
                    }
                  }, result);
       }));
   },
   function getPropertiesCellular() {
     chrome.networkingPrivate.getProperties(
-      "stub_cellular1",
+      "stub_cellular1_GUID",
       callbackPass(function(result) {
         assertEq({ "Cellular": {
                      "ActivationState": "not-activated",
                      "AllowRoaming": false,
                      "Carrier": "Cellular1_Carrier",
                      "HomeProvider": {
                        "country": "us",
                        "name": "Cellular1_Provider"
                      },
                      "NetworkTechnology": "GSM",
                      "RoamingState": "home"
                    },
                    "ConnectionState": "NotConnected",
-                   "GUID": "stub_cellular1",
+                   "GUID": "stub_cellular1_GUID",
                    "Name": "cellular1",
                    "Type": "Cellular"
                  }, result);
       }));
   },
   function getManagedProperties() {
     chrome.networkingPrivate.getManagedProperties(
       "stub_wifi2",
       callbackPass(function(result) {
         assertEq({
@@ skipping 47 matching lines @@
                      "SignalStrength": {
                        "Active": 80,
                        "Effective": "Unmanaged"
                      }
                    }
                  }, result);
       }));
   },
   function setProperties() {
     var done = chrome.test.callbackAdded();
-    var network_guid = "stub_wifi2";
+    var network_guid = "stub_wifi2_GUID";
     chrome.networkingPrivate.getProperties(
         network_guid,
         callbackPass(function(result) {
           assertEq(network_guid, result.GUID);
           result.WiFi.Security = "WEP-PSK";
           chrome.networkingPrivate.setProperties(
               network_guid,
               result,
               callbackPass(function() {
                 chrome.networkingPrivate.getProperties(
                     network_guid,
                     callbackPass(function(result) {
                       // Ensure that the property was set.
                       assertEq("WEP-PSK", result.WiFi.Security);
                       // Ensure that the GUID doesn't change.
                       assertEq(network_guid, result.GUID);
                       done();
                     }));
               }));
         }));
   },
   function getState() {
     chrome.networkingPrivate.getState(
-      "stub_wifi2",
+      "stub_wifi2_GUID",
       callbackPass(function(result) {
         assertEq({
           "Connectable": true,
           "ConnectionState": "NotConnected",
-          "GUID": "stub_wifi2",
+          "GUID": "stub_wifi2_GUID",
           "Name": "wifi2_PSK",
           "Type": "WiFi",
           "WiFi": {
             "Security": "WPA-PSK",
             "SignalStrength": 80
           }
         }, result);
       }));
   },
   function getStateNonExistent() {
     chrome.networkingPrivate.getState(
       'non_existent',
       callbackFail('Error.InvalidNetworkGuid'));
   },
   function onNetworksChangedEventConnect() {
-    var network = "stub_wifi2";
+    var network = "stub_wifi2_GUID";
     var done = chrome.test.callbackAdded();
     var expectedStates = ["Connected"];
     var listener =
         new privateHelpers.watchForStateChanges(network, expectedStates, done);
     chrome.networkingPrivate.startConnect(network, callbackPass());
   },
   function onNetworksChangedEventDisconnect() {
-    var network = "stub_wifi1";
+    var network = "stub_wifi1_GUID";
     var done = chrome.test.callbackAdded();
     var expectedStates = ["NotConnected"];
     var listener =
         new privateHelpers.watchForStateChanges(network, expectedStates, done);
     chrome.networkingPrivate.startDisconnect(network, callbackPass());
   },
   function onNetworkListChangedEvent() {
     // Connecting to wifi2 should set wifi1 to offline. Connected or Connecting
     // networks should be listed first, sorted by type.
-    var expected = ["stub_ethernet",
-                    "stub_wifi2",
-                    "stub_vpn1",
-                    "stub_wifi1"];
+    var expected = ["stub_ethernet_GUID",
+                    "stub_wifi2_GUID",
+                    "stub_vpn1_GUID",
+                    "stub_wifi1_GUID"];
     var done = chrome.test.callbackAdded();
     var listener = new privateHelpers.listListener(expected, done);
     chrome.networkingPrivate.onNetworkListChanged.addListener(
       listener.listenForChanges);
-    var network = "stub_wifi2";
+    var network = "stub_wifi2_GUID";
     chrome.networkingPrivate.startConnect(network, callbackPass());
   },
   function verifyDestination() {
     chrome.networkingPrivate.verifyDestination(
       verificationProperties,
       callbackPass(function(isValid) {
         assertTrue(isValid);
       }));
   },
   function verifyAndEncryptCredentials() {
-    var network_guid = "stub_wifi2";
+    var network_guid = "stub_wifi2_GUID";
     chrome.networkingPrivate.verifyAndEncryptCredentials(
       verificationProperties,
       network_guid,
       callbackPass(function(result) {
         assertEq("encrypted_credentials", result);
       }));
   },
   function verifyAndEncryptData() {
     chrome.networkingPrivate.verifyAndEncryptData(
       verificationProperties,
@@ skipping 11 matching lines @@
       }));
   },
   function getWifiTDLSStatus() {
     chrome.networkingPrivate.getWifiTDLSStatus(
       "aa:bb:cc:dd:ee:ff",
       callbackPass(function(result) {
         assertEq("Connected", result);
       }));
   },
   function getCaptivePortalStatus() {
-    var networks = [['stub_ethernet', 'Online'],
-                    ['stub_wifi1', 'Offline'],
-                    ['stub_wifi2', 'Portal'],
-                    ['stub_cellular1', 'ProxyAuthRequired'],
-                    ['stub_vpn1', 'Unknown']];
+    var networks = [['stub_ethernet_GUID', 'Online'],
+                    ['stub_wifi1_GUID', 'Offline'],
+                    ['stub_wifi2_GUID', 'Portal'],
+                    ['stub_cellular1_GUID', 'ProxyAuthRequired'],
+                    ['stub_vpn1_GUID', 'Unknown']];
     networks.forEach(function(network) {
       var servicePath = network[0];
       var expectedStatus = network[1];
       chrome.networkingPrivate.getCaptivePortalStatus(
         servicePath,
         callbackPass(function(status) {
           assertEq(expectedStatus, status);
         }));
     });
   },
   function captivePortalNotification() {
     var done = chrome.test.callbackAdded();
     var listener =
-        new privateHelpers.watchForCaptivePortalState('wifi', 'Online', done);
+        new privateHelpers.watchForCaptivePortalState(
+            'wifi_GUID', 'Online', done);
     chrome.test.sendMessage('notifyPortalDetectorObservers');
   },
 ];
 
 var testToRun = window.location.search.substring(1);
 chrome.test.runTests(availableTests.filter(function(op) {
   return op.name == testToRun;
 }));