Migrate DBus service constants from flimflam namespace to shill namespace.

chromeos/network/network_change_notifier_chromeos_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_change_notifier_chromeos.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/strings/string_split.h"
@@ skipping 45 matching lines @@
 
 using net::NetworkChangeNotifier;
 
 TEST(NetworkChangeNotifierChromeosTest, ConnectionTypeFromShill) {
   struct TypeMapping {
     const char* shill_type;
     const char* technology;
     NetworkChangeNotifier::ConnectionType connection_type;
   };
   TypeMapping type_mappings[] = {
-    { flimflam::kTypeEthernet, "", NetworkChangeNotifier::CONNECTION_ETHERNET },
-    { flimflam::kTypeWifi, "", NetworkChangeNotifier::CONNECTION_WIFI },
-    { flimflam::kTypeWimax, "", NetworkChangeNotifier::CONNECTION_4G },
+    { shill::kTypeEthernet, "", NetworkChangeNotifier::CONNECTION_ETHERNET },
+    { shill::kTypeWifi, "", NetworkChangeNotifier::CONNECTION_WIFI },
+    { shill::kTypeWimax, "", NetworkChangeNotifier::CONNECTION_4G },
     { "unknown type", "unknown technology",
       NetworkChangeNotifier::CONNECTION_UNKNOWN },
-    { flimflam::kTypeCellular, flimflam::kNetworkTechnology1Xrtt,
+    { shill::kTypeCellular, shill::kNetworkTechnology1Xrtt,
       NetworkChangeNotifier::CONNECTION_2G },
-    { flimflam::kTypeCellular, flimflam::kNetworkTechnologyGprs,
+    { shill::kTypeCellular, shill::kNetworkTechnologyGprs,
       NetworkChangeNotifier::CONNECTION_2G },
-    { flimflam::kTypeCellular, flimflam::kNetworkTechnologyEdge,
+    { shill::kTypeCellular, shill::kNetworkTechnologyEdge,
       NetworkChangeNotifier::CONNECTION_2G },
-    { flimflam::kTypeCellular, flimflam::kNetworkTechnologyEvdo,
+    { shill::kTypeCellular, shill::kNetworkTechnologyEvdo,
       NetworkChangeNotifier::CONNECTION_3G },
-    { flimflam::kTypeCellular, flimflam::kNetworkTechnologyGsm,
+    { shill::kTypeCellular, shill::kNetworkTechnologyGsm,
       NetworkChangeNotifier::CONNECTION_3G },
-    { flimflam::kTypeCellular, flimflam::kNetworkTechnologyUmts,
+    { shill::kTypeCellular, shill::kNetworkTechnologyUmts,
       NetworkChangeNotifier::CONNECTION_3G },
-    { flimflam::kTypeCellular, flimflam::kNetworkTechnologyHspa,
+    { shill::kTypeCellular, shill::kNetworkTechnologyHspa,
       NetworkChangeNotifier::CONNECTION_3G },
-    { flimflam::kTypeCellular,  flimflam::kNetworkTechnologyHspaPlus,
+    { shill::kTypeCellular, shill::kNetworkTechnologyHspaPlus,
       NetworkChangeNotifier::CONNECTION_4G },
-    { flimflam::kTypeCellular, flimflam::kNetworkTechnologyLte,
+    { shill::kTypeCellular, shill::kNetworkTechnologyLte,
       NetworkChangeNotifier::CONNECTION_4G },
-    { flimflam::kTypeCellular, flimflam::kNetworkTechnologyLteAdvanced,
+    { shill::kTypeCellular, shill::kNetworkTechnologyLteAdvanced,
       NetworkChangeNotifier::CONNECTION_4G },
-    { flimflam::kTypeCellular, "unknown technology",
+    { shill::kTypeCellular, "unknown technology",
       NetworkChangeNotifier::CONNECTION_2G }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(type_mappings); ++i) {
     NetworkChangeNotifier::ConnectionType type =
         NetworkChangeNotifierChromeos::ConnectionTypeFromShill(
             type_mappings[i].shill_type, type_mappings[i].technology);
     EXPECT_EQ(type_mappings[i].connection_type, type);
   }
 }
@@ skipping 19 matching lines @@
     EXPECT_EQ(notifier_state.ip_address, notifier_.ip_address_);
     std::vector<std::string> dns_servers;
     base::SplitString(notifier_state.dns_servers, ',', &dns_servers);
     EXPECT_EQ(dns_servers, notifier_.dns_servers_);
   }
 
   // Sets the default network state used for notifier updates.
   void SetDefaultNetworkState(
       const DefaultNetworkState& default_network_state) {
     if (default_network_state.is_connected)
-      default_network_.connection_state_ = flimflam::kStateOnline;
+      default_network_.connection_state_ = shill::kStateOnline;
     else
-      default_network_.connection_state_ = flimflam::kStateConfiguration;
+      default_network_.connection_state_ = shill::kStateConfiguration;
     default_network_.type_ = default_network_state.type;
     default_network_.network_technology_ =
         default_network_state.network_technology;
     default_network_.path_ = default_network_state.service_path;
     default_network_.ip_address_ = default_network_state.ip_address;
     std::vector<std::string> dns_servers;
     base::SplitString(default_network_state.dns_servers, ',', &dns_servers);
     default_network_.dns_servers_ = dns_servers;
   }
 
   // Process an default network update based on the state of |default_network_|.
   void ProcessDefaultNetworkUpdate(bool* type_changed,
                                    bool* ip_changed,
                                    bool* dns_changed) {
     notifier_.UpdateState(&default_network_, type_changed, ip_changed,
                           dns_changed);
   }
 
  private:
   NetworkState default_network_;
   NetworkChangeNotifierChromeos notifier_;
 };
 
 NotifierUpdateTestCase test_cases[] = {
   { "Online -> Offline",
     { NetworkChangeNotifier::CONNECTION_ETHERNET, kService1, kIpAddress1,
       kDnsServers1 },
-    { false, flimflam::kTypeEthernet, "", kService1, "", "" },
+    { false, shill::kTypeEthernet, "", kService1, "", "" },
     { NetworkChangeNotifier::CONNECTION_NONE, "", "", "" },
     true, true, true
   },
   { "Offline -> Offline",
     { NetworkChangeNotifier::CONNECTION_NONE, "", "", "" },
-    { false, flimflam::kTypeEthernet, "", kService1, kIpAddress1,
+    { false, shill::kTypeEthernet, "", kService1, kIpAddress1,
       kDnsServers1 },
     { NetworkChangeNotifier::CONNECTION_NONE, "", "", "" },
     false, false, false
   },
   { "Offline -> Online",
     { NetworkChangeNotifier::CONNECTION_NONE, "", "", "" },
-    { true, flimflam::kTypeEthernet, "", kService1, kIpAddress1, kDnsServers1 },
+    { true, shill::kTypeEthernet, "", kService1, kIpAddress1, kDnsServers1 },
     { NetworkChangeNotifier::CONNECTION_ETHERNET, kService1, kIpAddress1,
       kDnsServers1 },
     true, true, true
   },
   { "Online -> Online (new default service, different connection type)",
     { NetworkChangeNotifier::CONNECTION_ETHERNET, kService1, kIpAddress1,
       kDnsServers1 },
-    { true, flimflam::kTypeWifi, "", kService2, kIpAddress1, kDnsServers1 },
+    { true, shill::kTypeWifi, "", kService2, kIpAddress1, kDnsServers1 },
     { NetworkChangeNotifier::CONNECTION_WIFI, kService2, kIpAddress1,
       kDnsServers1 },
     true, true, true
   },
   { "Online -> Online (new default service, same connection type)",
     { NetworkChangeNotifier::CONNECTION_WIFI, kService2, kIpAddress1,
       kDnsServers1 },
-    { true, flimflam::kTypeWifi, "", kService3, kIpAddress1, kDnsServers1 },
+    { true, shill::kTypeWifi, "", kService3, kIpAddress1, kDnsServers1 },
     { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress1,
       kDnsServers1 },
     false, true, true
   },
   { "Online -> Online (same default service, first IP address update)",
     { NetworkChangeNotifier::CONNECTION_WIFI, kService3, "", kDnsServers1 },
-    { true, flimflam::kTypeWifi, "", kService3, kIpAddress2, kDnsServers1 },
+    { true, shill::kTypeWifi, "", kService3, kIpAddress2, kDnsServers1 },
     { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress2,
       kDnsServers1 },
     false, false, false
   },
   { "Online -> Online (same default service, new IP address, same DNS)",
     { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress1,
       kDnsServers1 },
-    { true, flimflam::kTypeWifi, "", kService3, kIpAddress2, kDnsServers1 },
+    { true, shill::kTypeWifi, "", kService3, kIpAddress2, kDnsServers1 },
     { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress2,
       kDnsServers1 },
     false, true, false
   },
   { "Online -> Online (same default service, same IP address, new DNS)",
     { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress2,
       kDnsServers1 },
-    { true, flimflam::kTypeWifi, "", kService3, kIpAddress2, kDnsServers2 },
+    { true, shill::kTypeWifi, "", kService3, kIpAddress2, kDnsServers2 },
     { NetworkChangeNotifier::CONNECTION_WIFI, kService3, kIpAddress2,
       kDnsServers2 },
     false, false, true
   }
 };
 
 TEST_F(NetworkChangeNotifierChromeosUpdateTest, UpdateDefaultNetwork) {
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     SCOPED_TRACE(test_cases[i].test_description);
     SetNotifierState(test_cases[i].initial_state);
     SetDefaultNetworkState(test_cases[i].default_network_state);
     bool type_changed = false, ip_changed = false, dns_changed = false;
     ProcessDefaultNetworkUpdate(&type_changed, &ip_changed, &dns_changed);
     VerifyNotifierState(test_cases[i].expected_state);
     EXPECT_TRUE(type_changed == test_cases[i].expected_type_changed);
     EXPECT_TRUE(ip_changed == test_cases[i].expected_ip_changed);
     EXPECT_TRUE(dns_changed == test_cases[i].expected_dns_changed);
   }
 }
 
 }  // namespace chromeos