Migrate DBus service constants from flimflam namespace to shill namespace.

chromeos/network/onc/onc_translator_shill_to_onc.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/onc/onc_translator.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/json/json_reader.h"
@@ skipping 110 matching lines @@
   } else if (onc_signature_ == &kCellularWithStateSignature) {
     TranslateCellularWithState();
   } else {
     CopyPropertiesAccordingToSignature();
   }
   return onc_object_.Pass();
 }
 
 void ShillToONCTranslator::TranslateEthernet() {
   std::string shill_network_type;
-  shill_dictionary_->GetStringWithoutPathExpansion(flimflam::kTypeProperty,
+  shill_dictionary_->GetStringWithoutPathExpansion(shill::kTypeProperty,
                                                    &shill_network_type);
   const char* onc_auth = ethernet::kNone;
   if (shill_network_type == shill::kTypeEthernetEap)
     onc_auth = ethernet::k8021X;
   onc_object_->SetStringWithoutPathExpansion(ethernet::kAuthentication,
                                              onc_auth);
 }
 
 void ShillToONCTranslator::TranslateOpenVPN() {
   // Shill supports only one RemoteCertKU but ONC requires a list. If existing,
   // wraps the value into a list.
   std::string certKU;
   if (shill_dictionary_->GetStringWithoutPathExpansion(
-          flimflam::kOpenVPNRemoteCertKUProperty, &certKU)) {
+          shill::kOpenVPNRemoteCertKUProperty, &certKU)) {
     scoped_ptr<base::ListValue> certKUs(new base::ListValue);
     certKUs->AppendString(certKU);
     onc_object_->SetWithoutPathExpansion(openvpn::kRemoteCertKU,
                                          certKUs.release());
   }
 
   for (const OncFieldSignature* field_signature = onc_signature_->fields;
        field_signature->onc_field_name != NULL; ++field_signature) {
     const std::string& onc_field_name = field_signature->onc_field_name;
     if (onc_field_name == vpn::kSaveCredentials ||
@@ skipping 34 matching lines @@
       }
     } else {
       LOG(ERROR) << "Shill property '" << shill_property_name
                  << "' has value " << *shill_value
                  << ", but expected a string";
     }
   }
 }
 
 void ShillToONCTranslator::TranslateVPN() {
-  TranslateWithTableAndSet(flimflam::kProviderTypeProperty, kVPNTypeTable,
+  TranslateWithTableAndSet(shill::kProviderTypeProperty, kVPNTypeTable,
                            vpn::kType);
   CopyPropertiesAccordingToSignature();
 
   std::string vpn_type;
   if (onc_object_->GetStringWithoutPathExpansion(vpn::kType,
                                                  &vpn_type)) {
     if (vpn_type == vpn::kTypeL2TP_IPsec) {
       TranslateAndAddNestedObject(vpn::kIPsec);
       TranslateAndAddNestedObject(vpn::kL2TP);
     } else {
       TranslateAndAddNestedObject(vpn_type);
     }
   }
 }
 
 void ShillToONCTranslator::TranslateWiFiWithState() {
-  TranslateWithTableAndSet(flimflam::kSecurityProperty, kWiFiSecurityTable,
+  TranslateWithTableAndSet(shill::kSecurityProperty, kWiFiSecurityTable,
                            wifi::kSecurity);
   CopyPropertiesAccordingToSignature();
 }
 
 void ShillToONCTranslator::TranslateCellularWithState() {
   CopyPropertiesAccordingToSignature();
   const base::DictionaryValue* dictionary = NULL;
   if (shill_dictionary_->GetDictionaryWithoutPathExpansion(
-        flimflam::kServingOperatorProperty, &dictionary)) {
+        shill::kServingOperatorProperty, &dictionary)) {
     TranslateAndAddNestedObject(cellular::kServingOperator, *dictionary);
   }
   if (shill_dictionary_->GetDictionaryWithoutPathExpansion(
-        flimflam::kCellularApnProperty, &dictionary)) {
+        shill::kCellularApnProperty, &dictionary)) {
     TranslateAndAddNestedObject(cellular::kAPN, *dictionary);
   }
 }
 
 void ShillToONCTranslator::TranslateNetworkWithState() {
   CopyPropertiesAccordingToSignature();
 
   std::string shill_network_type;
-  shill_dictionary_->GetStringWithoutPathExpansion(flimflam::kTypeProperty,
+  shill_dictionary_->GetStringWithoutPathExpansion(shill::kTypeProperty,
                                                    &shill_network_type);
   std::string onc_network_type = network_type::kEthernet;
-  if (shill_network_type != flimflam::kTypeEthernet &&
+  if (shill_network_type != shill::kTypeEthernet &&
       shill_network_type != shill::kTypeEthernetEap) {
     TranslateStringToONC(
         kNetworkTypeTable, shill_network_type, &onc_network_type);
   }
   if (!onc_network_type.empty()) {
     onc_object_->SetStringWithoutPathExpansion(network_config::kType,
                                                onc_network_type);
     TranslateAndAddNestedObject(onc_network_type);
   }
 
   // Since Name is a read only field in Shill unless it's a VPN, it is copied
   // here, but not when going the other direction (if it's not a VPN).
   std::string name;
-  shill_dictionary_->GetStringWithoutPathExpansion(flimflam::kNameProperty,
+  shill_dictionary_->GetStringWithoutPathExpansion(shill::kNameProperty,
                                                    &name);
   onc_object_->SetStringWithoutPathExpansion(network_config::kName, name);
 
   std::string state;
-  if (shill_dictionary_->GetStringWithoutPathExpansion(flimflam::kStateProperty,
+  if (shill_dictionary_->GetStringWithoutPathExpansion(shill::kStateProperty,
                                                        &state)) {
     std::string onc_state = connection_state::kNotConnected;
     if (NetworkState::StateIsConnected(state)) {
       onc_state = connection_state::kConnected;
     } else if (NetworkState::StateIsConnecting(state)) {
       onc_state = connection_state::kConnecting;
     }
     onc_object_->SetStringWithoutPathExpansion(network_config::kConnectionState,
                                                onc_state);
   }
@@ skipping 83 matching lines @@
     const base::DictionaryValue& shill_dictionary,
     const OncValueSignature* onc_signature) {
   CHECK(onc_signature != NULL);
 
   ShillToONCTranslator translator(shill_dictionary, *onc_signature);
   return translator.CreateTranslatedONCObject();
 }
 
 }  // namespace onc
 }  // namespace chromeos