Use GUID instead of ServicePath in networkingPrivate API

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 38 matching lines @@
   },
   listListener: function(expected, done) {
     var self = this;
     this.listenForChanges = function(list) {
       assertEq(expected, list);
       chrome.networkingPrivate.onNetworkListChanged.removeListener(
           self.listenForChanges);
       done();
     };
   },
-  watchForCaptivePortalState: function(expectedNetworkPath,
+  watchForCaptivePortalState: function(expectedGuid,
                                        expectedState,
                                        done) {
     var self = this;
-    this.onPortalDetectionCompleted = function(networkPath, state) {
-      assertEq(expectedNetworkPath, networkPath);
+    this.onPortalDetectionCompleted = function(guid, state) {
+      assertEq(expectedGuid, guid);
       assertEq(expectedState, state);
       chrome.networkingPrivate.onPortalDetectionCompleted.removeListener(
           self.onPortalDetectionCompleted);
       done();
     };
     chrome.networkingPrivate.onPortalDetectionCompleted.addListener(
         self.onPortalDetectionCompleted);
   }
 };
 
 var availableTests = [
   function startConnect() {
     chrome.networkingPrivate.startConnect("stub_wifi2", callbackPass());
   },
   function startDisconnect() {
     // Must connect to a network before we can disconnect from it.
     chrome.networkingPrivate.startConnect("stub_wifi2", callbackPass(
       function() {
         chrome.networkingPrivate.startDisconnect("stub_wifi2", callbackPass());
       }));
   },
   function startConnectNonexistent() {
     chrome.networkingPrivate.startConnect(
       "nonexistent_path",
-      callbackFail("configure-failed"));
+      callbackFail("Error.InvalidNetworkGuid"));
   },
   function startDisconnectNonexistent() {
     chrome.networkingPrivate.startDisconnect(
       "nonexistent_path",
-      callbackFail("not-found"));
+      callbackFail("Error.InvalidNetworkGuid"));
   },
   function startGetPropertiesNonexistent() {
     chrome.networkingPrivate.getProperties(
       "nonexistent_path",
-      callbackFail("Error.DBusFailed"));
+      callbackFail("Error.InvalidNetworkGuid"));
   },
   function createNetwork() {
     chrome.networkingPrivate.createNetwork(
       false,  // shared
       { "Type": "WiFi",
         "GUID": "ignored_guid",
         "WiFi": {
           "SSID": "wifi_created",
           "Security": "WEP-PSK"
         }
@@ skipping 25 matching lines @@
                     "Type": "Ethernet"
                   },
                   {
                     "Connectable": true,
                     "ConnectionState": "Connected",
                     "GUID": "stub_wifi1",
                     "Name": "wifi1",
                     "Type": "WiFi",
                     "WiFi": {
                       "Security": "WEP-PSK",
-                      "SignalStrength": 0
+                      "SignalStrength": 1
                     }
                   },
                   {
                     "ConnectionState": "Connected",
                     "GUID": "stub_vpn1",
                     "Name": "vpn1",
                     "Type": "VPN",
                   },
                   {
                     "Connectable": true,
                     "ConnectionState": "NotConnected",
                     "GUID": "stub_wifi2",
                     "Name": "wifi2_PSK",
                     "Type": "WiFi",
                     "WiFi": {
                       "Security": "WPA-PSK",
                       "SignalStrength": 80
                     }
                   },
                   {
-                    "Connectable": false,
                     "Cellular": {
                       "ActivationState": "not-activated",
                       "NetworkTechnology": "GSM",
                       "RoamingState": "home"
                     },
+                    "Connectable": false,
                     "ConnectionState": "NotConnected",
                     "GUID": "stub_cellular1",
                     "Name": "cellular1",
                     "Type": "Cellular"
                   }], result);
       }));
   },
   function getVisibleNetworksWifi() {
     chrome.networkingPrivate.getVisibleNetworks(
       "WiFi",
       callbackPass(function(result) {
         assertEq([{
                     "Connectable": true,
                     "ConnectionState": "Connected",
                     "GUID": "stub_wifi1",
                     "Name": "wifi1",
                     "Type": "WiFi",
                     "WiFi": {
                       "Security": "WEP-PSK",
-                      "SignalStrength": 0
+                      "SignalStrength": 1
                     }
                   },
                   {
                     "Connectable": true,
                     "ConnectionState": "NotConnected",
                     "GUID": "stub_wifi2",
                     "Name": "wifi2_PSK",
                     "Type": "WiFi",
                     "WiFi": {
                       "Security": "WPA-PSK",
@@ skipping 46 matching lines @@
       callbackPass(function(result) {
         assertEq({
                    "Connectable": {
                      "Active": true,
                      "Effective": "Unmanaged"
                    },
                    "ConnectionState": {
                      "Active": "NotConnected",
                      "Effective": "Unmanaged"
                    },
-                   "GUID": "stub_wifi2",
+                   "GUID": {
+                     "Active": "stub_wifi2",
+                     "Effective": "UserPolicy",
+                     "UserPolicy": "stub_wifi2"
+                   },
                    "Name": {
                      "Active": "wifi2_PSK",
                      "Effective": "UserPolicy",
                      "UserPolicy": "My WiFi Network"
                    },
                    "Type": {
                      "Active": "WiFi",
                      "Effective": "UserPolicy",
                      "UserPolicy": "WiFi"
                    },
@@ skipping 63 matching lines @@
           "WiFi": {
             "Security": "WPA-PSK",
             "SignalStrength": 80
           }
         }, result);
       }));
   },
   function getStateNonExistent() {
     chrome.networkingPrivate.getState(
       'non_existent',
-      callbackFail('Error.InvalidParameter'));
+      callbackFail('Error.InvalidNetworkGuid'));
   },
   function onNetworksChangedEventConnect() {
     var network = "stub_wifi2";
     var done = chrome.test.callbackAdded();
     var expectedStates = ["Connected"];
     var listener =
         new privateHelpers.watchForStateChanges(network, expectedStates, done);
     chrome.networkingPrivate.startConnect(network, callbackPass());
   },
   function onNetworksChangedEventDisconnect() {
@@ skipping 20 matching lines @@
     chrome.networkingPrivate.startConnect(network, callbackPass());
   },
   function verifyDestination() {
     chrome.networkingPrivate.verifyDestination(
       verificationProperties,
       callbackPass(function(isValid) {
         assertTrue(isValid);
       }));
   },
   function verifyAndEncryptCredentials() {
+    var network_guid = "stub_wifi2";
     chrome.networkingPrivate.verifyAndEncryptCredentials(
       verificationProperties,
-      "guid",
+      network_guid,
       callbackPass(function(result) {
         assertEq("encrypted_credentials", result);
       }));
   },
   function verifyAndEncryptData() {
     chrome.networkingPrivate.verifyAndEncryptData(
       verificationProperties,
       "data",
       callbackPass(function(result) {
         assertEq("encrypted_data", result);
@@ skipping 35 matching lines @@
     var listener =
         new privateHelpers.watchForCaptivePortalState('wifi', 'Online', done);
     chrome.test.sendMessage('notifyPortalDetectorObservers');
   },
 ];
 
 var testToRun = window.location.search.substring(1);
 chrome.test.runTests(availableTests.filter(function(op) {
   return op.name == testToRun;
 }));