Use Shill's Manager::ConfigureServiceForProfile for all network types.

chromeos/network/network_configuration_handler_unittest.cc

   // Copyright (c) 2012 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/json/json_writer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_piece.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/mock_dbus_thread_manager.h"
 #include "chromeos/dbus/mock_shill_manager_client.h"
 #include "chromeos/dbus/mock_shill_profile_client.h"
 #include "chromeos/dbus/mock_shill_service_client.h"
+#include "chromeos/dbus/shill_profile_client_stub.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_state_handler_observer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using ::testing::_;
 using ::testing::Invoke;
@@ skipping 125 matching lines @@
   void OnClearPropertiesError(
       const dbus::ObjectPath& service_path,
       const std::vector<std::string>& names,
       const ShillClientHelper::ListValueCallback& callback,
       const ShillClientHelper::ErrorCallback& error_callback) {
     base::ListValue result;
     result.AppendBoolean(false);
     callback.Run(result);
   }
 
-  void OnConfigureService(const base::DictionaryValue& properties,
-                    const ObjectPathCallback& callback,
-                    const ShillClientHelper::ErrorCallback& error_callback) {
+  void OnConfigureService(
+      const dbus::ObjectPath& profile_path,
+      const base::DictionaryValue& properties,
+      const ObjectPathCallback& callback,
+      const ShillClientHelper::ErrorCallback& error_callback) {
     callback.Run(dbus::ObjectPath("/service/2"));
   }
 
   void OnGetLoadableProfileEntries(
       const dbus::ObjectPath& service_path,
       const ShillClientHelper::DictionaryValueCallback& callback) {
     base::DictionaryValue entries;
     entries.SetString("profile1", "entry1");
     entries.SetString("profile2", "entry2");
     callback.Run(DBUS_METHOD_CALL_SUCCESS, entries);
@@ skipping 147 matching lines @@
                  &NetworkConfigurationHandlerTest::OnClearPropertiesError));
   network_configuration_handler_->ClearProperties(
       service_path,
       values_to_clear,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, true, service_path));
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, CreateConfiguration) {
-  std::string expected_json = "{\n   \"SSID\": \"MyNetwork\"\n}\n";
   std::string networkName = "MyNetwork";
   std::string key = "SSID";
+  std::string profile = "profile path";
   scoped_ptr<base::StringValue> networkNameValue(
       base::Value::CreateStringValue(networkName));
   base::DictionaryValue value;
-  value.Set(key, base::Value::CreateStringValue(networkName));
+  value.SetWithoutPathExpansion(flimflam::kSSIDProperty,
+                                base::Value::CreateStringValue(networkName));
+  value.SetWithoutPathExpansion(flimflam::kProfileProperty,
+                                base::Value::CreateStringValue(profile));
 
-  EXPECT_CALL(
-      *mock_manager_client_,
-      ConfigureService(_, _, _)).WillOnce(
-          Invoke(this,
-                 &NetworkConfigurationHandlerTest::OnConfigureService));
+  EXPECT_CALL(*mock_manager_client_,
+              ConfigureServiceForProfile(dbus::ObjectPath(profile), _, _, _))
+      .WillOnce(
+           Invoke(this, &NetworkConfigurationHandlerTest::OnConfigureService));
   network_configuration_handler_->CreateConfiguration(
       value,
       base::Bind(&StringResultCallback, std::string("/service/2")),
       base::Bind(&ErrorCallback, false, std::string("")));
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, RemoveConfiguration) {
   std::string service_path = "/service/1";
 
@@ skipping 226 matching lines @@
   properties.SetStringWithoutPathExpansion(
       flimflam::kSSIDProperty, service_path);
   properties.SetStringWithoutPathExpansion(
       flimflam::kNameProperty, service_path);
   properties.SetStringWithoutPathExpansion(
       flimflam::kGuidProperty, service_path);
   properties.SetStringWithoutPathExpansion(
       flimflam::kTypeProperty, flimflam::kTypeWifi);
   properties.SetStringWithoutPathExpansion(
       flimflam::kStateProperty, flimflam::kStateIdle);
+  properties.SetStringWithoutPathExpansion(
+      flimflam::kProfileProperty, ShillProfileClientStub::kSharedProfilePath);
 
   network_configuration_handler_->CreateConfiguration(
       properties,
       base::Bind(
           &NetworkConfigurationHandlerStubTest::CreateConfigurationCallback,
           base::Unretained(this)),
       base::Bind(&ErrorCallback, false, service_path));
   message_loop_.RunUntilIdle();
 
   EXPECT_FALSE(create_service_path_.empty());
+
   std::string ssid;
   EXPECT_TRUE(GetServiceStringProperty(
       create_service_path_, flimflam::kSSIDProperty, &ssid));
+  std::string actual_profile;
   EXPECT_EQ(service_path, ssid);
+
+  EXPECT_TRUE(GetServiceStringProperty(
+      create_service_path_, flimflam::kProfileProperty, &actual_profile));
+  EXPECT_EQ(ShillProfileClientStub::kSharedProfilePath, actual_profile);
 }
 
 }  // namespace chromeos