Migrate DBus service constants from flimflam namespace to shill namespace.

chromeos/network/network_configuration_handler_unittest.cc

-  // Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// 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"
@@ skipping 317 matching lines @@
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(NetworkConfigurationHandlerTest, CreateConfiguration) {
   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.SetWithoutPathExpansion(flimflam::kSSIDProperty,
+  value.SetWithoutPathExpansion(shill::kSSIDProperty,
                                 base::Value::CreateStringValue(networkName));
-  value.SetWithoutPathExpansion(flimflam::kProfileProperty,
+  value.SetWithoutPathExpansion(shill::kProfileProperty,
                                 base::Value::CreateStringValue(profile));
 
   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("")));
@@ skipping 140 matching lines @@
 
 TEST_F(NetworkConfigurationHandlerStubTest, StubSetAndClearProperties) {
   // TODO(stevenjb): Remove dependency on default Stub service.
   const std::string service_path("wifi1");
   const std::string test_identity("test_identity");
   const std::string test_passphrase("test_passphrase");
 
   // Set Properties
   base::DictionaryValue properties_to_set;
   properties_to_set.SetStringWithoutPathExpansion(
-      flimflam::kIdentityProperty, test_identity);
+      shill::kIdentityProperty, test_identity);
   properties_to_set.SetStringWithoutPathExpansion(
-      flimflam::kPassphraseProperty, test_passphrase);
+      shill::kPassphraseProperty, test_passphrase);
   network_configuration_handler_->SetProperties(
       service_path,
       properties_to_set,
       base::Bind(
           &NetworkConfigurationHandlerStubTest::SuccessCallback,
           base::Unretained(this), "SetProperties"),
       base::Bind(&ErrorCallback, false, service_path));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ("SetProperties", success_callback_name_);
   std::string identity, passphrase;
   EXPECT_TRUE(GetServiceStringProperty(
-      service_path, flimflam::kIdentityProperty, &identity));
+      service_path, shill::kIdentityProperty, &identity));
   EXPECT_TRUE(GetServiceStringProperty(
-      service_path, flimflam::kPassphraseProperty, &passphrase));
+      service_path, shill::kPassphraseProperty, &passphrase));
   EXPECT_EQ(test_identity, identity);
   EXPECT_EQ(test_passphrase, passphrase);
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(service_path));
 
   // Clear Properties
   std::vector<std::string> properties_to_clear;
-  properties_to_clear.push_back(flimflam::kIdentityProperty);
-  properties_to_clear.push_back(flimflam::kPassphraseProperty);
+  properties_to_clear.push_back(shill::kIdentityProperty);
+  properties_to_clear.push_back(shill::kPassphraseProperty);
   network_configuration_handler_->ClearProperties(
       service_path,
       properties_to_clear,
       base::Bind(
           &NetworkConfigurationHandlerStubTest::SuccessCallback,
           base::Unretained(this), "ClearProperties"),
       base::Bind(&ErrorCallback, false, service_path));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ("ClearProperties", success_callback_name_);
   EXPECT_FALSE(GetServiceStringProperty(
-      service_path, flimflam::kIdentityProperty, &identity));
+      service_path, shill::kIdentityProperty, &identity));
   EXPECT_FALSE(GetServiceStringProperty(
-      service_path, flimflam::kIdentityProperty, &passphrase));
+      service_path, shill::kIdentityProperty, &passphrase));
   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(service_path));
 }
 
 TEST_F(NetworkConfigurationHandlerStubTest, StubGetNameFromWifiHex) {
   // TODO(stevenjb): Remove dependency on default Stub service.
   const std::string service_path("wifi1");
   std::string wifi_hex = "5468697320697320484558205353494421";
   std::string expected_name = "This is HEX SSID!";
 
   // Set Properties
   base::DictionaryValue properties_to_set;
   properties_to_set.SetStringWithoutPathExpansion(
-      flimflam::kWifiHexSsid, wifi_hex);
+      shill::kWifiHexSsid, wifi_hex);
   network_configuration_handler_->SetProperties(
       service_path,
       properties_to_set,
       base::Bind(&base::DoNothing),
       base::Bind(&ErrorCallback, false, service_path));
   message_loop_.RunUntilIdle();
   std::string wifi_hex_result;
   EXPECT_TRUE(GetServiceStringProperty(
-      service_path, flimflam::kWifiHexSsid, &wifi_hex_result));
+      service_path, shill::kWifiHexSsid, &wifi_hex_result));
   EXPECT_EQ(wifi_hex, wifi_hex_result);
 
   // Get Properties
   network_configuration_handler_->GetProperties(
       service_path,
       base::Bind(&NetworkConfigurationHandlerStubTest::GetPropertiesCallback,
                  base::Unretained(this)),
       base::Bind(&ErrorCallback, false, service_path));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(service_path, get_properties_path_);
   std::string name_result;
   EXPECT_TRUE(GetReceivedStringProperty(
-      service_path, flimflam::kNameProperty, &name_result));
+      service_path, shill::kNameProperty, &name_result));
   EXPECT_EQ(expected_name, name_result);
 }
 
 TEST_F(NetworkConfigurationHandlerStubTest, StubCreateConfiguration) {
   const std::string service_path("test_wifi");
   base::DictionaryValue properties;
+  properties.SetStringWithoutPathExpansion(shill::kSSIDProperty, service_path);
+  properties.SetStringWithoutPathExpansion(shill::kNameProperty, service_path);
+  properties.SetStringWithoutPathExpansion(shill::kGuidProperty, service_path);
   properties.SetStringWithoutPathExpansion(
-      flimflam::kSSIDProperty, service_path);
+      shill::kTypeProperty, shill::kTypeWifi);
   properties.SetStringWithoutPathExpansion(
-      flimflam::kNameProperty, service_path);
+      shill::kStateProperty, shill::kStateIdle);
   properties.SetStringWithoutPathExpansion(
-      flimflam::kGuidProperty, service_path);
-  properties.SetStringWithoutPathExpansion(
-      flimflam::kTypeProperty, flimflam::kTypeWifi);
-  properties.SetStringWithoutPathExpansion(
-      flimflam::kStateProperty, flimflam::kStateIdle);
-  properties.SetStringWithoutPathExpansion(
-      flimflam::kProfileProperty, shill_stub_helper::kSharedProfilePath);
+      shill::kProfileProperty, shill_stub_helper::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));
+      create_service_path_, shill::kSSIDProperty, &ssid));
   std::string actual_profile;
   EXPECT_EQ(service_path, ssid);
 
   EXPECT_TRUE(GetServiceStringProperty(
-      create_service_path_, flimflam::kProfileProperty, &actual_profile));
+      create_service_path_, shill::kProfileProperty, &actual_profile));
   EXPECT_EQ(shill_stub_helper::kSharedProfilePath, actual_profile);
 }
 
 }  // namespace chromeos