Adding policy support to the new network configuration stack.

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 assertEq = chrome.test.assertEq;
 
 // Test properties for the verification API.
 var verificationProperties = {
   "certificate": "certificate",
   "publicKey": "public_key",
   "nonce": "nonce",
   "signedData": "signed_data",
   "deviceSerial": "device_serial"
 };
 
 var privateHelpers = {
   // Watches for the states |expectedStates| in reverse order. If all states
   // were observed in the right order, succeeds and calls |done|. If any
   // unexpected state is observed, fails.
   watchForStateChanges: function(network, expectedStates, done) {
     var self = this;
     var collectProperties = function(properties) {
       var finishTest = function() {
         chrome.networkingPrivate.onNetworksChanged.removeListener(
-          self.watchForConnect);
+            self.onNetworkChange);
         done();
       };
       var expectedState = expectedStates.pop();
       assertEq(expectedState, properties.ConnectionState);
       if (expectedStates.length == 0)
         finishTest();
     };
     this.onNetworkChange = function(changes) {
       assertEq([network], changes);
-      chrome.networkingPrivate.getProperties(network,
-                                             collectProperties.bind(undefined));
+      chrome.networkingPrivate.getProperties(
+          network,
+          callbackPass(collectProperties));
     };
     chrome.networkingPrivate.onNetworksChanged.addListener(
-      this.onNetworkChange);
+        this.onNetworkChange);
   },
   listListener: function(network, expected, done) {
     var self = this;
     this.listenForChanges = function(list) {
       assertEq(expected, list);
       chrome.networkingPrivate.onNetworkListChanged.removeListener(
-        self.listenForChanges);
+          self.listenForChanges);
       done();
     };
   }
 };
 
 var availableTests = [
   function startConnect() {
     chrome.networkingPrivate.startConnect("stub_wifi2", callbackPass());
   },
   function startDisconnect() {
@@ skipping 11 matching lines @@
   },
   function startGetPropertiesNonexistent() {
     chrome.networkingPrivate.getProperties(
       "nonexistent_path",
       callbackFail("Error.DBusFailed"));
   },
   function getVisibleNetworks() {
     chrome.networkingPrivate.getVisibleNetworks(
       "All",
       callbackPass(function(result) {
-        assertTrue(!!result);
         assertEq([{
                     "ConnectionState": "Connected",
                     "GUID": "stub_ethernet",
                     "Name": "eth0",
                     "Type": "Ethernet"
                   },
                   {
                     "ConnectionState": "Connected",
                     "GUID": "stub_wifi1",
                     "Name": "wifi1",
@@ skipping 10 matching lines @@
                     "Name": "wifi2_PSK",
                     "Type": "WiFi",
                     "WiFi": {
                       "AutoConnect": false,
                       "Security": "WPA-PSK",
                       "SignalStrength": 80
                     }
                   },
                   {
                     "Cellular": {
+                      "ActivateOverNonCellularNetwork": false,
                       "ActivationState": "not-activated",
                       "NetworkTechnology": "GSM",
                       "RoamingState": "home"
                     },
                     "ConnectionState": "NotConnected",
                     "GUID": "stub_cellular1",
                     "Name": "cellular1",
                     "Type": "Cellular"
                   },
                   {
                     "ConnectionState": "Connected",
                     "GUID": "stub_vpn1",
                     "Name": "vpn1",
                     "Type": "VPN",
                     "VPN": {
                       "AutoConnect": false
                     }
                   }], result);
       }));
   },
   function getVisibleNetworksWifi() {
     chrome.networkingPrivate.getVisibleNetworks(
       "WiFi",
       callbackPass(function(result) {
-        assertTrue(!!result);
         assertEq([{
                     "ConnectionState": "Connected",
                     "GUID": "stub_wifi1",
                     "Name": "wifi1",
                     "Type": "WiFi",
                     "WiFi": {
                       "AutoConnect": false,
                       "Security": "WEP-PSK",
                       "SignalStrength": 0
                     }
@@ skipping 22 matching lines @@
     var done = chrome.test.callbackAdded();
     var listener = new privateHelpers.listListener(network, expected, done);
     chrome.networkingPrivate.onNetworkListChanged.addListener(
       listener.listenForChanges);
     chrome.networkingPrivate.requestNetworkScan();
   },
   function getProperties() {
     chrome.networkingPrivate.getProperties(
       "stub_wifi2",
       callbackPass(function(result) {
-        assertTrue(!!result);
         assertEq({
                    "ConnectionState": "NotConnected",
                    "GUID": "stub_wifi2",
                    "Name": "wifi2_PSK",
                    "Type": "WiFi",
                    "WiFi": {
                      "SSID": "stub_wifi2",
                      "Security": "WPA-PSK",
                      "SignalStrength": 80
                    }
                  }, result);
       }));
   },
+  function getManagedProperties() {
+    chrome.networkingPrivate.getManagedProperties(
+      "stub_wifi2",
+      callbackPass(function(result) {
+        assertEq({
+                   "ConnectionState": {
+                     "Active": "NotConnected",
+                     "Effective": "Unmanaged"
+                   },
+                   "GUID": "stub_wifi2",
+                   "Name": {
+                     "Active": "wifi2_PSK",
+                     "Effective": "UserPolicy",
+                     "UserPolicy": "My WiFi Network"
+                   },
+                   "Type": {
+                     "Active": "WiFi",
+                     "Effective": "UserPolicy",
+                     "UserPolicy": "WiFi"
+                   },
+                   "WiFi": {
+                     "AutoConnect": {
+                       "Active": false,
+                       "UserEditable": true
+                     },
+                     "Passphrase": {
+                       "Effective": "UserSetting",
+                       "UserEditable": true,
+                       "UserSetting": "FAKE_CREDENTIAL"
+                     },
+                     "SSID": {
+                       "Active": "stub_wifi2",
+                       "Effective": "UserPolicy",
+                       "UserPolicy": "stub_wifi2"
+                     },
+                     "Security": {
+                       "Active": "WPA-PSK",
+                       "Effective": "UserPolicy",
+                       "UserPolicy": "WPA-PSK"
+                     },
+                     "SignalStrength": {
+                       "Active": 80,
+                       "Effective": "Unmanaged"
+                     }
+                   }
+                 }, result);
+      }));
+  },
   function setProperties() {
     var done = chrome.test.callbackAdded();
     chrome.networkingPrivate.getProperties(
       "stub_wifi2",
-      function(result) {
+      callbackPass(function(result) {
         result.WiFi.Security = "WEP-PSK";
         chrome.networkingPrivate.setProperties("stub_wifi2", result,
-          function() {
+          callbackPass(function() {
             chrome.networkingPrivate.getProperties(
               "stub_wifi2",
-              function(result) {
+              callbackPass(function(result) {
                 assertEq("WEP-PSK", result.WiFi.Security);
                 done();
-              });
-          });
-      });
+              }));
+          }));
+      }));
   },
   function getState() {
     chrome.networkingPrivate.getState(
       "stub_wifi2",
       callbackPass(function(result) {
         assertEq({
           "ConnectionState": "NotConnected",
-          "GUID": "",
+          "GUID": "stub_wifi2",
           "Name": "wifi2_PSK",
           "Type": "WiFi",
           "WiFi": {
             "AutoConnect": false,
             "Security": "WPA-PSK",
             "SignalStrength": 80
           }
         }, result);
       }));
   },
@@ skipping 48 matching lines @@
       callbackPass(function(result) {
         assertEq("encrypted_data", result);
       }));
   }
 ];
 
 var testToRun = window.location.search.substring(1);
 chrome.test.runTests(availableTests.filter(function(op) {
   return op.name == testToRun;
 }));