Migrate DBus service constants from flimflam namespace to shill namespace.

chromeos/network/network_state_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 "chromeos/network/network_state_handler.h"
 
 #include <map>
 #include <set>
 #include <string>
 
@@ skipping 146 matching lines @@
     network_state_handler_->InitShillPropertyHandler();
   }
 
  protected:
   void SetupDefaultShillState() {
     message_loop_.RunUntilIdle();  // Process any pending updates
     ShillDeviceClient::TestInterface* device_test =
         DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface();
     device_test->ClearDevices();
     device_test->AddDevice("/device/stub_wifi_device1",
-                           flimflam::kTypeWifi, "stub_wifi_device1");
+                           shill::kTypeWifi, "stub_wifi_device1");
     device_test->AddDevice("/device/stub_cellular_device1",
-                           flimflam::kTypeCellular, "stub_cellular_device1");
+                           shill::kTypeCellular, "stub_cellular_device1");
 
     ShillServiceClient::TestInterface* service_test =
         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
     service_test->ClearServices();
     const bool add_to_visible = true;
     const bool add_to_watchlist = true;
     service_test->AddService(kShillManagerClientStubDefaultService,
                              kShillManagerClientStubDefaultService,
-                             flimflam::kTypeEthernet, flimflam::kStateOnline,
+                             shill::kTypeEthernet, shill::kStateOnline,
                              add_to_visible, add_to_watchlist);
     service_test->AddService(kShillManagerClientStubDefaultWireless,
                              kShillManagerClientStubDefaultWireless,
-                             flimflam::kTypeWifi, flimflam::kStateOnline,
+                             shill::kTypeWifi, shill::kStateOnline,
                              add_to_visible, add_to_watchlist);
     service_test->AddService(kShillManagerClientStubWireless2,
                              kShillManagerClientStubWireless2,
-                             flimflam::kTypeWifi, flimflam::kStateIdle,
+                             shill::kTypeWifi, shill::kStateIdle,
                              add_to_visible, add_to_watchlist);
     service_test->AddService(kShillManagerClientStubCellular,
                              kShillManagerClientStubCellular,
-                             flimflam::kTypeCellular, flimflam::kStateIdle,
+                             shill::kTypeCellular, shill::kStateIdle,
                              add_to_visible, add_to_watchlist);
   }
 
   base::MessageLoopForUI message_loop_;
   scoped_ptr<NetworkStateHandler> network_state_handler_;
   scoped_ptr<TestObserver> test_observer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkStateHandlerTest);
 };
@@ skipping 15 matching lines @@
   EXPECT_EQ(kShillManagerClientStubDefaultWireless,
             network_state_handler_->ConnectedNetworkByType(
                 NetworkTypePattern::Wireless())->path());
   EXPECT_EQ(kShillManagerClientStubCellular,
             network_state_handler_->FirstNetworkByType(
                 NetworkTypePattern::Mobile())->path());
   EXPECT_EQ(
       kShillManagerClientStubCellular,
       network_state_handler_->FirstNetworkByType(NetworkTypePattern::Cellular())
           ->path());
-  EXPECT_EQ(flimflam::kStateOnline,
+  EXPECT_EQ(shill::kStateOnline,
             test_observer_->default_network_connection_state());
 }
 
 TEST_F(NetworkStateHandlerTest, TechnologyChanged) {
   // There may be several manager changes during initialization.
   size_t initial_changed_count = test_observer_->device_list_changed_count();
   // Disable a technology.
   network_state_handler_->SetTechnologyEnabled(
       NetworkTypePattern::Wimax(), false, network_handler::ErrorCallback());
   EXPECT_NE(
@@ skipping 17 matching lines @@
   EXPECT_EQ(initial_changed_count + 4,
             test_observer_->device_list_changed_count());
   EXPECT_EQ(
       NetworkStateHandler::TECHNOLOGY_ENABLED,
       network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax()));
 }
 
 TEST_F(NetworkStateHandlerTest, TechnologyState) {
   ShillManagerClient::TestInterface* manager_test =
       DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface();
-  manager_test->RemoveTechnology(flimflam::kTypeWimax);
+  manager_test->RemoveTechnology(shill::kTypeWimax);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(
       NetworkStateHandler::TECHNOLOGY_UNAVAILABLE,
       network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax()));
 
-  manager_test->AddTechnology(flimflam::kTypeWimax, false);
+  manager_test->AddTechnology(shill::kTypeWimax, false);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(
       NetworkStateHandler::TECHNOLOGY_AVAILABLE,
       network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax()));
 
-  manager_test->SetTechnologyInitializing(flimflam::kTypeWimax, true);
+  manager_test->SetTechnologyInitializing(shill::kTypeWimax, true);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(
       NetworkStateHandler::TECHNOLOGY_UNINITIALIZED,
       network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax()));
 
-  manager_test->SetTechnologyInitializing(flimflam::kTypeWimax, false);
+  manager_test->SetTechnologyInitializing(shill::kTypeWimax, false);
   network_state_handler_->SetTechnologyEnabled(
       NetworkTypePattern::Wimax(), true, network_handler::ErrorCallback());
   message_loop_.RunUntilIdle();
   EXPECT_EQ(
       NetworkStateHandler::TECHNOLOGY_ENABLED,
       network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax()));
 
-  manager_test->RemoveTechnology(flimflam::kTypeWimax);
+  manager_test->RemoveTechnology(shill::kTypeWimax);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(
       NetworkStateHandler::TECHNOLOGY_UNAVAILABLE,
       network_state_handler_->GetTechnologyState(NetworkTypePattern::Wimax()));
 }
 
 TEST_F(NetworkStateHandlerTest, ServicePropertyChanged) {
   // Set a service property.
   const std::string eth1 = kShillManagerClientStubDefaultService;
   EXPECT_EQ("", network_state_handler_->GetNetworkState(eth1)->security());
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(eth1));
   base::StringValue security_value("TestSecurity");
   DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
       dbus::ObjectPath(eth1),
-      flimflam::kSecurityProperty, security_value,
+      shill::kSecurityProperty, security_value,
       base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
   message_loop_.RunUntilIdle();
   EXPECT_EQ("TestSecurity",
             network_state_handler_->GetNetworkState(eth1)->security());
   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(eth1));
 
   // Changing a service to the existing value should not trigger an update.
   DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
       dbus::ObjectPath(eth1),
-      flimflam::kSecurityProperty, security_value,
+      shill::kSecurityProperty, security_value,
       base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
   message_loop_.RunUntilIdle();
   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(eth1));
 }
 
 TEST_F(NetworkStateHandlerTest, FavoriteState) {
   // Set the profile entry of a service
   const std::string wifi1 = kShillManagerClientStubDefaultWireless;
   ShillProfileClient::TestInterface* profile_test =
       DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
   EXPECT_TRUE(profile_test->AddService("/profile/default", wifi1));
   message_loop_.RunUntilIdle();
   network_state_handler_->UpdateManagerProperties();
   message_loop_.RunUntilIdle();
   EXPECT_EQ(1u, test_observer_->favorite_count());
 }
 
 TEST_F(NetworkStateHandlerTest, NetworkConnectionStateChanged) {
   // Change a network state.
   ShillServiceClient::TestInterface* service_test =
       DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
   const std::string eth1 = kShillManagerClientStubDefaultService;
-  base::StringValue connection_state_idle_value(flimflam::kStateIdle);
-  service_test->SetServiceProperty(eth1, flimflam::kStateProperty,
+  base::StringValue connection_state_idle_value(shill::kStateIdle);
+  service_test->SetServiceProperty(eth1, shill::kStateProperty,
                                    connection_state_idle_value);
   message_loop_.RunUntilIdle();
-  EXPECT_EQ(flimflam::kStateIdle,
+  EXPECT_EQ(shill::kStateIdle,
             test_observer_->NetworkConnectionStateForService(eth1));
   EXPECT_EQ(2, test_observer_->ConnectionStateChangesForService(eth1));
   // Confirm that changing the connection state to the same value does *not*
   // signal the observer.
-  service_test->SetServiceProperty(eth1, flimflam::kStateProperty,
+  service_test->SetServiceProperty(eth1, shill::kStateProperty,
                                    connection_state_idle_value);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(2, test_observer_->ConnectionStateChangesForService(eth1));
 }
 
 TEST_F(NetworkStateHandlerTest, DefaultServiceChanged) {
   ShillManagerClient::TestInterface* manager_test =
       DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface();
   ASSERT_TRUE(manager_test);
   ShillServiceClient::TestInterface* service_test =
       DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
   ASSERT_TRUE(service_test);
 
   // Change the default network by  changing the state of eth1 to Idle which
   // should re-sort Manager.Services.
   const std::string eth1 = kShillManagerClientStubDefaultService;
   const std::string wifi1 = kShillManagerClientStubDefaultWireless;
-  base::StringValue connection_state_idle_value(flimflam::kStateIdle);
-  service_test->SetServiceProperty(eth1, flimflam::kStateProperty,
+  base::StringValue connection_state_idle_value(shill::kStateIdle);
+  service_test->SetServiceProperty(eth1, shill::kStateProperty,
                                    connection_state_idle_value);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(wifi1, test_observer_->default_network());
-  EXPECT_EQ(flimflam::kStateOnline,
+  EXPECT_EQ(shill::kStateOnline,
             test_observer_->default_network_connection_state());
   // We should have seen 2 default network updates - for the default
   // service change, and for the state change.
   EXPECT_EQ(2u, test_observer_->default_network_change_count());
 
   // Updating a property on the default network should trigger
   // a default network change.
   DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
       dbus::ObjectPath(wifi1),
-      flimflam::kSecurityProperty, base::StringValue("TestSecurity"),
+      shill::kSecurityProperty, base::StringValue("TestSecurity"),
       base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
   message_loop_.RunUntilIdle();
   EXPECT_EQ(3u, test_observer_->default_network_change_count());
 
   // No default network updates for signal strength changes.
   DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
       dbus::ObjectPath(wifi1),
-      flimflam::kSignalStrengthProperty, base::FundamentalValue(32),
+      shill::kSignalStrengthProperty, base::FundamentalValue(32),
       base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
   message_loop_.RunUntilIdle();
   EXPECT_EQ(3u, test_observer_->default_network_change_count());
 }
 
 TEST_F(NetworkStateHandlerTest, RequestUpdate) {
   // Request an update for kShillManagerClientStubDefaultWireless.
   EXPECT_EQ(1, test_observer_->PropertyUpdatesForService(
       kShillManagerClientStubDefaultWireless));
   network_state_handler_->RequestUpdateForNetwork(
@@ skipping 11 matching lines @@
   // Other networks should have 2 updates (inital + request).
   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(
       kShillManagerClientStubDefaultService));
   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(
       kShillManagerClientStubWireless2));
   EXPECT_EQ(2, test_observer_->PropertyUpdatesForService(
       kShillManagerClientStubCellular));
 }
 
 }  // namespace chromeos