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 126 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 28 matching lines @@
                      "SignalStrength": {
                        "Active": 80,
                        "Effective": "Unmanaged"
                      }
                    }
                  }, result);
       }));
   },
   function setProperties() {
     var done = chrome.test.callbackAdded();
+    var network_guid = "stub_wifi2";
     chrome.networkingPrivate.getProperties(
-      "stub_wifi2",
+      network_guid,
       callbackPass(function(result) {
+        assertEq(network_guid, result.GUID);
         result.WiFi.Security = "WEP-PSK";
         chrome.networkingPrivate.setProperties("stub_wifi2", result,
           callbackPass(function() {
             chrome.networkingPrivate.getProperties(
               "stub_wifi2",
               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",
       callbackPass(function(result) {
         assertEq({
           "Connectable": true,
           "ConnectionState": "NotConnected",
           "GUID": "stub_wifi2",
           "Name": "wifi2_PSK",
           "Type": "WiFi",
           "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 19 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;
 }));