Adding a NetworkProfileHandler used by ManagedNetworkConfigurationHandler.

chrome/browser/chromeos/extensions/networking_private_apitest.cc

 // 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.
 
 #include "base/command_line.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/policy/network_configuration_updater.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
@@ skipping 10 matching lines @@
 #include "chromeos/network/onc/onc_utils.h"
 #include "policy/policy_constants.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using testing::AnyNumber;
 using testing::Return;
 using testing::_;
 
 namespace chromeos {
 
-const char kUserProfilePath[] = "/profile/chronos/shill";
+const char kUser1ProfilePath[] = "/profile/user1/shill";
+const char kUser1[] = "user1";
 
 class ExtensionNetworkingPrivateApiTest : public ExtensionApiTest {
  public:
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     ExtensionApiTest::SetUpCommandLine(command_line);
     // Whitelist the extension ID of the test extension.
     command_line->AppendSwitchASCII(::switches::kWhitelistedExtensionID,
                                     "epcifkihnkjgphfkloaaleeakhpmgdmn");
     command_line->AppendSwitch(switches::kUseNewNetworkConfigurationHandlers);
   }
@@ skipping 10 matching lines @@
     EXPECT_CALL(provider_, RegisterPolicyDomain(_, _)).Times(AnyNumber());
     policy::BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
 
     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
   }
 
   virtual void SetUpOnMainThread() OVERRIDE {
     ExtensionApiTest::SetUpOnMainThread();
     content::RunAllPendingInMessageLoop();
 
+    ShillDeviceClient::TestInterface* device_test =
+        DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface();
     ShillProfileClient::TestInterface* profile_test =
         DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
-    profile_test->AddProfile(kUserProfilePath);
+    ShillServiceClient::TestInterface* service_test =
+        DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
 
     g_browser_process->browser_policy_connector()->
         GetNetworkConfigurationUpdater()->OnUserPolicyInitialized();
-    ShillDeviceClient::TestInterface* device_test =
-        DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface();
     device_test->ClearDevices();
+    service_test->ClearServices();
+
+    // Sends a notification about the added profile.
+    profile_test->AddProfile(kUser1ProfilePath, kUser1);
+
     device_test->AddDevice("/device/stub_wifi_device1",
                            flimflam::kTypeWifi, "stub_wifi_device1");
     device_test->AddDevice("/device/stub_cellular_device1",
                            flimflam::kTypeCellular, "stub_cellular_device1");
 
-    ShillServiceClient::TestInterface* service_test =
-        DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
-    service_test->ClearServices();
     const bool add_to_watchlist = true;
     service_test->AddService("stub_ethernet", "eth0",
                              flimflam::kTypeEthernet, flimflam::kStateOnline,
                              add_to_watchlist);
 
     service_test->AddService("stub_wifi1", "wifi1",
                              flimflam::kTypeWifi, flimflam::kStateOnline,
                              add_to_watchlist);
     service_test->SetServiceProperty("stub_wifi1",
                                      flimflam::kSecurityProperty,
                                      base::StringValue(flimflam::kSecurityWep));
 
     service_test->AddService("stub_wifi2", "wifi2_PSK",
                              flimflam::kTypeWifi, flimflam::kStateIdle,
                              add_to_watchlist);
     service_test->SetServiceProperty("stub_wifi2",
                                      flimflam::kGuidProperty,
                                      base::StringValue("stub_wifi2"));
     service_test->SetServiceProperty("stub_wifi2",
                                      flimflam::kSecurityProperty,
                                      base::StringValue(flimflam::kSecurityPsk));
     service_test->SetServiceProperty("stub_wifi2",
                                      flimflam::kSignalStrengthProperty,
                                      base::FundamentalValue(80));
+    service_test->SetServiceProperty("stub_wifi2",
+                                     flimflam::kProfileProperty,
+                                     base::StringValue(kUser1ProfilePath));
+    profile_test->AddService("stub_wifi2");
 
     service_test->AddService("stub_cellular1", "cellular1",
                              flimflam::kTypeCellular, flimflam::kStateIdle,
                              add_to_watchlist);
     service_test->SetServiceProperty(
         "stub_cellular1",
         flimflam::kNetworkTechnologyProperty,
         base::StringValue(flimflam::kNetworkTechnologyGsm));
     service_test->SetServiceProperty(
         "stub_cellular1",
         flimflam::kActivationStateProperty,
         base::StringValue(flimflam::kActivationStateNotActivated));
     service_test->SetServiceProperty(
         "stub_cellular1",
         flimflam::kRoamingStateProperty,
         base::StringValue(flimflam::kRoamingStateHome));
 
     service_test->AddService("stub_vpn1", "vpn1",
                              flimflam::kTypeVPN,
                              flimflam::kStateOnline,
                              add_to_watchlist);
+
+    content::RunAllPendingInMessageLoop();
   }
 
  protected:
   policy::MockConfigurationPolicyProvider provider_;
 };
 
 // Place each subtest into a separate browser test so that the stub networking
 // library state is reset for each subtest run. This way they won't affect each
 // other.
 
@@ skipping 48 matching lines @@
   EXPECT_TRUE(RunNetworkingSubtest("setProperties")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        GetManagedProperties) {
   ShillServiceClient::TestInterface* service_test =
       DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
   const std::string uidata_blob =
       "{ \"user_settings\": {"
       "      \"WiFi\": {"
-      "        \"Passphrase\": \"top secret\" }"
+      "        \"Passphrase\": \"FAKE_CREDENTIAL_VPaJDV9x\" }"
       "    }"
       "}";
   service_test->SetServiceProperty("stub_wifi2",
-                                   flimflam::kGuidProperty,
-                                   base::StringValue("stub_wifi2"));
-  service_test->SetServiceProperty("stub_wifi2",
                                    flimflam::kUIDataProperty,
                                    base::StringValue(uidata_blob));
   service_test->SetServiceProperty("stub_wifi2",
-                                   flimflam::kProfileProperty,
-                                   base::StringValue(kUserProfilePath));
-  service_test->SetServiceProperty("stub_wifi2",
                                    flimflam::kAutoConnectProperty,
                                    base::FundamentalValue(false));
 
   ShillProfileClient::TestInterface* profile_test =
       DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
-
+  // Update the profile entry.
   profile_test->AddService("stub_wifi2");
 
   content::RunAllPendingInMessageLoop();
 
   const std::string user_policy_blob =
       "{ \"NetworkConfigurations\": ["
       "    { \"GUID\": \"stub_wifi2\","
       "      \"Type\": \"WiFi\","
       "      \"Name\": \"My WiFi Network\","
       "      \"WiFi\": {"
@@ skipping 46 matching lines @@
   EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptCredentials")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionNetworkingPrivateApiTest,
                        VerifyAndEncryptData) {
   EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptData")) << message_;
 }
 
 
 }  // namespace chromeos