Use GUID instead of ServicePath in networkingPrivate API

chrome/browser/extensions/api/networking_private/networking_private_apitest.cc

 // Copyright 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/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/user.h"
@@ skipping 117 matching lines @@
   }
 };
 #endif  // defined(OS_CHROMEOS)
 
 class ExtensionNetworkingPrivateApiTest
     : public ExtensionApiTest,
       public testing::WithParamInterface<bool> {
  public:
   ExtensionNetworkingPrivateApiTest()
 #if defined(OS_CHROMEOS)
-      : detector_(NULL)
+      : detector_(NULL),
+        service_test_(NULL)
 #endif
   {
   }
 
   bool RunNetworkingSubtest(const std::string& subtest) {
     return RunExtensionSubtest(
         "networking", "main.html?" + subtest,
         kFlagEnableFileAccess | kFlagLoadAsComponent);
   }
 
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
 #if defined(OS_CHROMEOS)
     EXPECT_CALL(provider_, IsInitializationComplete(_))
         .WillRepeatedly(Return(true));
     policy::BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
 #endif
 
     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
   }
 
 #if defined(OS_CHROMEOS)
   static void AssignString(std::string* out,
-                    DBusMethodCallStatus call_status,
-                    const std::string& result) {
+                           DBusMethodCallStatus call_status,
+                           const std::string& result) {
     CHECK_EQ(call_status, DBUS_METHOD_CALL_SUCCESS);
     *out = result;
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     ExtensionApiTest::SetUpCommandLine(command_line);
     // Whitelist the extension ID of the test extension.
     command_line->AppendSwitchASCII(
         extensions::switches::kWhitelistedExtensionID,
         "epcifkihnkjgphfkloaaleeakhpmgdmn");
@@ skipping 15 matching lines @@
     chromeos::User* user = user_manager->GetActiveUser();
     CHECK(user);
     std::string userhash;
     DBusThreadManager::Get()->GetCryptohomeClient()->GetSanitizedUsername(
         user->email(),
         base::Bind(&AssignString, &userhash_));
     content::RunAllPendingInMessageLoop();
     CHECK(!userhash_.empty());
   }
 
+  void AddService(const std::string& service_path,
+                  const std::string& name,
+                  const std::string& type,
+                  const std::string& state) {
+    const bool add_to_watchlist = true;
+    const bool add_to_visible = true;
+    // Tests need a known GUID, so use 'service_path'.
+    service_test_->AddServiceWithIPConfig(
+        service_path, service_path /* guid */, name,
+        type, state, "" /* ipconfig_path */,
+        add_to_visible, add_to_watchlist);
+  }
+
   virtual void SetUpOnMainThread() OVERRIDE {
     detector_ = new NetworkPortalDetectorTestImpl();
     NetworkPortalDetector::InitializeForTesting(detector_);
 
     ExtensionApiTest::SetUpOnMainThread();
     content::RunAllPendingInMessageLoop();
 
     InitializeSanitizedUsername();
 
     DBusThreadManager* dbus_manager = DBusThreadManager::Get();
     ShillManagerClient::TestInterface* manager_test =
         dbus_manager->GetShillManagerClient()->GetTestInterface();
     ShillIPConfigClient::TestInterface* ip_config_test =
         dbus_manager->GetShillIPConfigClient()->GetTestInterface();
     ShillDeviceClient::TestInterface* device_test =
         dbus_manager->GetShillDeviceClient()->GetTestInterface();
     ShillProfileClient::TestInterface* profile_test =
         dbus_manager->GetShillProfileClient()->GetTestInterface();
-    ShillServiceClient::TestInterface* service_test =
-        dbus_manager->GetShillServiceClient()->GetTestInterface();
+
+    service_test_ = dbus_manager->GetShillServiceClient()->GetTestInterface();
 
     device_test->ClearDevices();
-    service_test->ClearServices();
+    service_test_->ClearServices();
 
     // Sends a notification about the added profile.
     profile_test->AddProfile(kUser1ProfilePath, userhash_);
 
     // Add IPConfigs
     base::DictionaryValue ipconfig;
     ipconfig.SetStringWithoutPathExpansion(shill::kAddressProperty, "0.0.0.0");
     ipconfig.SetStringWithoutPathExpansion(shill::kGatewayProperty, "0.0.0.1");
     ipconfig.SetIntegerWithoutPathExpansion(shill::kPrefixlenProperty, 0);
     ipconfig.SetStringWithoutPathExpansion(
         shill::kMethodProperty, shill::kTypeIPv4);
     ip_config_test->AddIPConfig(kIPConfigPath, ipconfig);
 
     // Add Devices
     device_test->AddDevice(
         kWifiDevicePath, shill::kTypeWifi, "stub_wifi_device1");
     base::ListValue wifi_ip_configs;
     wifi_ip_configs.AppendString(kIPConfigPath);
     device_test->SetDeviceProperty(
         kWifiDevicePath, shill::kIPConfigsProperty, wifi_ip_configs);
     device_test->AddDevice(
         kCellularDevicePath, shill::kTypeCellular, "stub_cellular_device1");
 
     // Add Services
-    const bool add_to_watchlist = true;
-    const bool add_to_visible = true;
-    service_test->AddService("stub_ethernet", "eth0",
-                             shill::kTypeEthernet, shill::kStateOnline,
-                             add_to_visible, add_to_watchlist);
-    service_test->SetServiceProperty(
+    AddService("stub_ethernet", "eth0",
+               shill::kTypeEthernet, shill::kStateOnline);
+    service_test_->SetServiceProperty(
         "stub_ethernet",
         shill::kProfileProperty,
         base::StringValue(ShillProfileClient::GetSharedProfilePath()));
     profile_test->AddService(ShillProfileClient::GetSharedProfilePath(),
                              "stub_ethernet");
 
-    service_test->AddService("stub_wifi1", "wifi1",
-                             shill::kTypeWifi, shill::kStateOnline,
-                             add_to_visible, add_to_watchlist);
-    service_test->SetServiceProperty("stub_wifi1",
-                                     shill::kSecurityProperty,
-                                     base::StringValue(shill::kSecurityWep));
-    service_test->SetServiceProperty("stub_wifi1",
-                                     shill::kProfileProperty,
-                                     base::StringValue(kUser1ProfilePath));
-    service_test->SetServiceProperty("stub_wifi1",
-                                     shill::kConnectableProperty,
-                                     base::FundamentalValue(true));
-    service_test->SetServiceProperty("stub_wifi1",
-                                     shill::kDeviceProperty,
-                                     base::StringValue(kWifiDevicePath));
+    AddService("stub_wifi1", "wifi1", shill::kTypeWifi, shill::kStateOnline);
+    service_test_->SetServiceProperty("stub_wifi1",
+                                      shill::kSecurityProperty,
+                                      base::StringValue(shill::kSecurityWep));
+    service_test_->SetServiceProperty("stub_wifi1",
+                                      shill::kProfileProperty,
+                                      base::StringValue(kUser1ProfilePath));
+    service_test_->SetServiceProperty("stub_wifi1",
+                                      shill::kConnectableProperty,
+                                      base::FundamentalValue(true));
+    service_test_->SetServiceProperty("stub_wifi1",
+                                      shill::kDeviceProperty,
+                                      base::StringValue(kWifiDevicePath));
     profile_test->AddService(kUser1ProfilePath, "stub_wifi1");
     base::ListValue frequencies1;
     frequencies1.AppendInteger(2400);
-    service_test->SetServiceProperty("stub_wifi1",
-                                     shill::kWifiFrequencyListProperty,
-                                     frequencies1);
-    service_test->SetServiceProperty("stub_wifi1",
-                                     shill::kWifiFrequency,
-                                     base::FundamentalValue(2400));
+    service_test_->SetServiceProperty("stub_wifi1",
+                                      shill::kWifiFrequencyListProperty,
+                                      frequencies1);
+    service_test_->SetServiceProperty("stub_wifi1",
+                                      shill::kWifiFrequency,
+                                      base::FundamentalValue(2400));
 
-    service_test->AddService("stub_wifi2", "wifi2_PSK",
-                             shill::kTypeWifi, shill::kStateIdle,
-                             add_to_visible, add_to_watchlist);
-    service_test->SetServiceProperty("stub_wifi2",
-                                     shill::kGuidProperty,
-                                     base::StringValue("stub_wifi2"));
-    service_test->SetServiceProperty("stub_wifi2",
-                                     shill::kSecurityProperty,
-                                     base::StringValue(shill::kSecurityPsk));
-    service_test->SetServiceProperty("stub_wifi2",
-                                     shill::kSignalStrengthProperty,
-                                     base::FundamentalValue(80));
-    service_test->SetServiceProperty("stub_wifi2",
-                                     shill::kConnectableProperty,
-                                     base::FundamentalValue(true));
+    AddService("stub_wifi2", "wifi2_PSK", shill::kTypeWifi, shill::kStateIdle);
+    service_test_->SetServiceProperty("stub_wifi2",
+                                      shill::kGuidProperty,
+                                      base::StringValue("stub_wifi2"));
+    service_test_->SetServiceProperty("stub_wifi2",
+                                      shill::kSecurityProperty,
+                                      base::StringValue(shill::kSecurityPsk));
+    service_test_->SetServiceProperty("stub_wifi2",
+                                      shill::kSignalStrengthProperty,
+                                      base::FundamentalValue(80));
+    service_test_->SetServiceProperty("stub_wifi2",
+                                      shill::kConnectableProperty,
+                                      base::FundamentalValue(true));
 
     base::ListValue frequencies2;
     frequencies2.AppendInteger(2400);
     frequencies2.AppendInteger(5000);
-    service_test->SetServiceProperty("stub_wifi2",
-                                     shill::kWifiFrequencyListProperty,
-                                     frequencies2);
-    service_test->SetServiceProperty("stub_wifi2",
-                                     shill::kWifiFrequency,
-                                     base::FundamentalValue(5000));
-    service_test->SetServiceProperty("stub_wifi2",
-                                     shill::kProfileProperty,
-                                     base::StringValue(kUser1ProfilePath));
+    service_test_->SetServiceProperty("stub_wifi2",
+                                      shill::kWifiFrequencyListProperty,
+                                      frequencies2);
+    service_test_->SetServiceProperty("stub_wifi2",
+                                      shill::kWifiFrequency,
+                                      base::FundamentalValue(5000));
+    service_test_->SetServiceProperty("stub_wifi2",
+                                      shill::kProfileProperty,
+                                      base::StringValue(kUser1ProfilePath));
     profile_test->AddService(kUser1ProfilePath, "stub_wifi2");
 
-    service_test->AddService("stub_cellular1", "cellular1",
-                             shill::kTypeCellular, shill::kStateIdle,
-                             add_to_visible, add_to_watchlist);
-    service_test->SetServiceProperty(
+    AddService("stub_cellular1", "cellular1",
+               shill::kTypeCellular, shill::kStateIdle);
+    service_test_->SetServiceProperty(
         "stub_cellular1",
         shill::kNetworkTechnologyProperty,
         base::StringValue(shill::kNetworkTechnologyGsm));
-    service_test->SetServiceProperty(
+    service_test_->SetServiceProperty(
         "stub_cellular1",
         shill::kActivationStateProperty,
         base::StringValue(shill::kActivationStateNotActivated));
-    service_test->SetServiceProperty(
+    service_test_->SetServiceProperty(
         "stub_cellular1",
         shill::kRoamingStateProperty,
         base::StringValue(shill::kRoamingStateHome));
 
-    service_test->AddService("stub_vpn1", "vpn1",
-                             shill::kTypeVPN,
-                             shill::kStateOnline,
-                             add_to_visible, add_to_watchlist);
+    AddService("stub_vpn1", "vpn1", shill::kTypeVPN, shill::kStateOnline);
 
     manager_test->SortManagerServices();
 
     content::RunAllPendingInMessageLoop();
   }
 #else  // !defined(OS_CHROMEOS)
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     ExtensionApiTest::SetUpCommandLine(command_line);
     // Whitelist the extension ID of the test extension.
     command_line->AppendSwitchASCII(
@@ skipping 15 matching lines @@
         &CreateNetworkingPrivateServiceClient);
   }
 
 #endif  // OS_CHROMEOS
 
  protected:
 #if defined(OS_CHROMEOS)
   NetworkPortalDetectorTestImpl* detector() { return detector_; }
 
   NetworkPortalDetectorTestImpl* detector_;
+  ShillServiceClient::TestInterface* service_test_;
   policy::MockConfigurationPolicyProvider provider_;
   std::string userhash_;
 #endif
 };
 
 // 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.
 
 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, StartConnect) {
@@ skipping 52 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest, CreateNetwork) {
   EXPECT_TRUE(RunNetworkingSubtest("createNetwork")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
                        GetManagedProperties) {
 #if defined(OS_CHROMEOS)
   // TODO(mef): Move this to ChromeOS-specific helper or SetUpOnMainThread.
-  ShillServiceClient::TestInterface* service_test =
-      DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
   const std::string uidata_blob =
       "{ \"user_settings\": {"
       "      \"WiFi\": {"
       "        \"Passphrase\": \"FAKE_CREDENTIAL_VPaJDV9x\" }"
       "    }"
       "}";
-  service_test->SetServiceProperty("stub_wifi2",
-                                   shill::kUIDataProperty,
-                                   base::StringValue(uidata_blob));
-  service_test->SetServiceProperty("stub_wifi2",
-                                   shill::kAutoConnectProperty,
-                                   base::FundamentalValue(false));
+  service_test_->SetServiceProperty("stub_wifi2",
+                                    shill::kUIDataProperty,
+                                    base::StringValue(uidata_blob));
+  service_test_->SetServiceProperty("stub_wifi2",
+                                    shill::kAutoConnectProperty,
+                                    base::FundamentalValue(false));
 
   ShillProfileClient::TestInterface* profile_test =
       DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
   // Update the profile entry.
   profile_test->AddService(kUser1ProfilePath, "stub_wifi2");
 
   content::RunAllPendingInMessageLoop();
 
   const std::string user_policy_blob =
       "{ \"NetworkConfigurations\": ["
@@ skipping 104 matching lines @@
                  base::Unretained(detector())));
   EXPECT_TRUE(RunNetworkingSubtest("captivePortalNotification")) << message_;
 }
 #endif  // defined(OS_CHROMEOS)
 
 INSTANTIATE_TEST_CASE_P(ExtensionNetworkingPrivateApiTestInstantiation,
                         ExtensionNetworkingPrivateApiTest,
                         testing::Bool());
 
 }  // namespace