Migrate DBus service constants from flimflam namespace to shill namespace.

chromeos/network/network_cert_migrator_unittest.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 "chromeos/network/network_cert_migrator.h"
 
 #include <cert.h>
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 86 matching lines @@
     network_state_handler_.reset(NetworkStateHandler::InitializeForTest());
     network_cert_migrator_.reset(new NetworkCertMigrator);
     network_cert_migrator_->Init(network_state_handler_.get());
   }
 
   void SetupWifiWithNss() {
     const bool add_to_visible = true;
     const bool add_to_watchlist = true;
     service_test_->AddService(kWifiStub,
                               kWifiStub,
-                              flimflam::kTypeWifi,
-                              flimflam::kStateOnline,
+                              shill::kTypeWifi,
+                              shill::kStateOnline,
                               add_to_visible,
                               add_to_watchlist);
     service_test_->SetServiceProperty(kWifiStub,
-                                      flimflam::kEapCaCertNssProperty,
+                                      shill::kEapCaCertNssProperty,
                                       base::StringValue(kNSSNickname));
   }
 
   void GetEapCACertProperties(std::string* nss_nickname, std::string* ca_pem) {
     nss_nickname->clear();
     ca_pem->clear();
     const base::DictionaryValue* properties =
         service_test_->GetServiceProperties(kWifiStub);
-    properties->GetStringWithoutPathExpansion(flimflam::kEapCaCertNssProperty,
+    properties->GetStringWithoutPathExpansion(shill::kEapCaCertNssProperty,
                                               nss_nickname);
     const base::ListValue* ca_pems = NULL;
     properties->GetListWithoutPathExpansion(shill::kEapCaCertPemProperty,
                                             &ca_pems);
     if (ca_pems && !ca_pems->empty())
       ca_pems->GetString(0, ca_pem);
   }
 
   void SetupVpnWithNss(bool open_vpn) {
     const bool add_to_visible = true;
     const bool add_to_watchlist = true;
     service_test_->AddService(kVPNStub,
                               kVPNStub,
-                              flimflam::kTypeVPN,
-                              flimflam::kStateIdle,
+                              shill::kTypeVPN,
+                              shill::kStateIdle,
                               add_to_visible,
                               add_to_watchlist);
     base::DictionaryValue provider;
-    const char* nss_property = open_vpn ? flimflam::kOpenVPNCaCertNSSProperty
-                                        : flimflam::kL2tpIpsecCaCertNssProperty;
+    const char* nss_property = open_vpn ? shill::kOpenVPNCaCertNSSProperty
+                                        : shill::kL2tpIpsecCaCertNssProperty;
     provider.SetStringWithoutPathExpansion(nss_property, kNSSNickname);
     service_test_->SetServiceProperty(
-        kVPNStub, flimflam::kProviderProperty, provider);
+        kVPNStub, shill::kProviderProperty, provider);
   }
 
   void GetVpnCACertProperties(bool open_vpn,
                               std::string* nss_nickname,
                               std::string* ca_pem) {
     nss_nickname->clear();
     ca_pem->clear();
     const base::DictionaryValue* properties =
         service_test_->GetServiceProperties(kVPNStub);
     const base::DictionaryValue* provider = NULL;
-    properties->GetDictionaryWithoutPathExpansion(flimflam::kProviderProperty,
+    properties->GetDictionaryWithoutPathExpansion(shill::kProviderProperty,
                                                   &provider);
     if (!provider)
       return;
-    const char* nss_property = open_vpn ? flimflam::kOpenVPNCaCertNSSProperty
-                                        : flimflam::kL2tpIpsecCaCertNssProperty;
+    const char* nss_property = open_vpn ? shill::kOpenVPNCaCertNSSProperty
+                                        : shill::kL2tpIpsecCaCertNssProperty;
     provider->GetStringWithoutPathExpansion(nss_property, nss_nickname);
     const base::ListValue* ca_pems = NULL;
     const char* pem_property = open_vpn ? shill::kOpenVPNCaCertPemProperty
                                         : shill::kL2tpIpsecCaCertPemProperty;
     provider->GetListWithoutPathExpansion(pem_property, &ca_pems);
     if (ca_pems && !ca_pems->empty())
       ca_pems->GetString(0, ca_pem);
   }
 
   ShillServiceClient::TestInterface* service_test_;
@@ skipping 84 matching lines @@
 
   message_loop_.RunUntilIdle();
   std::string nss_nickname, ca_pem;
   GetVpnCACertProperties(false /* not OpenVPN */, &nss_nickname, &ca_pem);
   EXPECT_TRUE(nss_nickname.empty());
   EXPECT_EQ(test_ca_cert_pem_, ca_pem);
 }
 
 
 }  // namespace chromeos