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 180 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();
@@ skipping 27 matching lines @@
     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);
+    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);
+    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::kSignalStrengthProperty,
                                       base::FundamentalValue(40));
     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_->AddService("stub_wifi2", "wifi2_PSK",
-                              shill::kTypeWifi, shill::kStateIdle,
-                              add_to_visible, add_to_watchlist);
+    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));
     profile_test->AddService(kUser1ProfilePath, "stub_wifi2");
 
-    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 197 matching lines @@
 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
                        GetWifiTDLSStatus) {
   EXPECT_TRUE(RunNetworkingSubtest("getWifiTDLSStatus")) << message_;
 }
 #endif
 
 // NetworkPortalDetector is only enabled for Chrome OS.
 #if defined(OS_CHROMEOS)
 IN_PROC_BROWSER_TEST_P(ExtensionNetworkingPrivateApiTest,
                        GetCaptivePortalStatus) {
-  service_test_->AddService("stub_cellular1", "cellular1",
-                            shill::kTypeCellular, shill::kStateIdle,
-                            true /* add_to_visible */,
-                            true /* add_to_watchlist */);
+  AddService("stub_cellular1", "cellular1",
+             shill::kTypeCellular, shill::kStateIdle);
   service_test_->SetServiceProperty(
       "stub_cellular1",
       shill::kNetworkTechnologyProperty,
       base::StringValue(shill::kNetworkTechnologyGsm));
   service_test_->SetServiceProperty(
       "stub_cellular1",
       shill::kActivationStateProperty,
       base::StringValue(shill::kActivationStateNotActivated));
   service_test_->SetServiceProperty(
       "stub_cellular1",
@@ skipping 33 matching lines @@
                  base::Unretained(detector())));
   EXPECT_TRUE(RunNetworkingSubtest("captivePortalNotification")) << message_;
 }
 #endif  // defined(OS_CHROMEOS)
 
 INSTANTIATE_TEST_CASE_P(ExtensionNetworkingPrivateApiTestInstantiation,
                         ExtensionNetworkingPrivateApiTest,
                         testing::Bool());
 
 }  // namespace