Migrate DBus service constants from flimflam namespace to shill namespace.

chromeos/network/device_state.cc

Index: chromeos/network/device_state.cc
diff --git a/chromeos/network/device_state.cc b/chromeos/network/device_state.cc
index f71b978f1d3c6a29722d3a96cc39dd090e42a6bc..d39fc14dbe569ef5e872cdadef50511340f86542 100644
--- a/chromeos/network/device_state.cc
+++ b/chromeos/network/device_state.cc
@@ -31,23 +31,23 @@ bool DeviceState::PropertyChanged(const std::string& key,
 
   if (ManagedStatePropertyChanged(key, value))
     return true;
-  if (key == flimflam::kAddressProperty) {
+  if (key == shill::kAddressProperty) {
     return GetStringValue(key, value, &mac_address_);
-  } else if (key == flimflam::kScanningProperty) {
+  } else if (key == shill::kScanningProperty) {
     return GetBooleanValue(key, value, &scanning_);
-  } else if (key == flimflam::kSupportNetworkScanProperty) {
+  } else if (key == shill::kSupportNetworkScanProperty) {
     return GetBooleanValue(key, value, &support_network_scan_);
   } else if (key == shill::kProviderRequiresRoamingProperty) {
     return GetBooleanValue(key, value, &provider_requires_roaming_);
-  } else if (key == flimflam::kHomeProviderProperty) {
+  } else if (key == shill::kHomeProviderProperty) {
     const base::DictionaryValue* dict = NULL;
     if (!value.GetAsDictionary(&dict))
       return false;
     std::string home_provider_country;
     std::string home_provider_name;
-    dict->GetStringWithoutPathExpansion(flimflam::kOperatorCountryKey,
+    dict->GetStringWithoutPathExpansion(shill::kOperatorCountryKey,
                                         &home_provider_country);
-    dict->GetStringWithoutPathExpansion(flimflam::kOperatorNameKey,
+    dict->GetStringWithoutPathExpansion(shill::kOperatorNameKey,
                                         &home_provider_name);
     // Set home_provider_id_
     if (!home_provider_name.empty() && !home_provider_country.empty()) {
@@ -56,17 +56,17 @@ bool DeviceState::PropertyChanged(const std::string& key,
           home_provider_name.c_str(),
           home_provider_country.c_str());
     } else {
-      dict->GetStringWithoutPathExpansion(flimflam::kOperatorCodeKey,
+      dict->GetStringWithoutPathExpansion(shill::kOperatorCodeKey,
                                           &home_provider_id_);
       LOG(WARNING) << "Carrier ID not defined, using code instead: "
                    << home_provider_id_;
     }
     return true;
-  } else if (key == flimflam::kTechnologyFamilyProperty) {
+  } else if (key == shill::kTechnologyFamilyProperty) {
     return GetStringValue(key, value, &technology_family_);
-  } else if (key == flimflam::kCarrierProperty) {
+  } else if (key == shill::kCarrierProperty) {
     return GetStringValue(key, value, &carrier_);
-  } else if (key == flimflam::kFoundNetworksProperty) {
+  } else if (key == shill::kFoundNetworksProperty) {
     const base::ListValue* list = NULL;
     if (!value.GetAsList(&list))
       return false;
@@ -75,7 +75,7 @@ bool DeviceState::PropertyChanged(const std::string& key,
       return false;
     scan_results_.swap(parsed_results);
     return true;
-  } else if (key == flimflam::kSIMLockStatusProperty) {
+  } else if (key == shill::kSIMLockStatusProperty) {
     const base::DictionaryValue* dict = NULL;
     if (!value.GetAsDictionary(&dict))
       return false;
@@ -83,35 +83,35 @@ bool DeviceState::PropertyChanged(const std::string& key,
     // Return true if at least one of the property values changed.
     bool property_changed = false;
     const base::Value* out_value = NULL;
-    if (!dict->GetWithoutPathExpansion(flimflam::kSIMLockRetriesLeftProperty,
+    if (!dict->GetWithoutPathExpansion(shill::kSIMLockRetriesLeftProperty,
                                        &out_value))
       return false;
-    if (GetUInt32Value(flimflam::kSIMLockRetriesLeftProperty,
+    if (GetUInt32Value(shill::kSIMLockRetriesLeftProperty,
                        *out_value, &sim_retries_left_))
       property_changed = true;
 
-    if (!dict->GetWithoutPathExpansion(flimflam::kSIMLockTypeProperty,
+    if (!dict->GetWithoutPathExpansion(shill::kSIMLockTypeProperty,
                                        &out_value))
       return false;
-    if (GetStringValue(flimflam::kSIMLockTypeProperty,
+    if (GetStringValue(shill::kSIMLockTypeProperty,
                        *out_value, &sim_lock_type_))
       property_changed = true;
 
-    if (!dict->GetWithoutPathExpansion(flimflam::kSIMLockEnabledProperty,
+    if (!dict->GetWithoutPathExpansion(shill::kSIMLockEnabledProperty,
                                        &out_value))
       return false;
-    if (GetBooleanValue(flimflam::kSIMLockEnabledProperty,
+    if (GetBooleanValue(shill::kSIMLockEnabledProperty,
                         *out_value, &sim_lock_enabled_))
       property_changed = true;
 
     return property_changed;
-  } else if (key == flimflam::kMeidProperty) {
+  } else if (key == shill::kMeidProperty) {
     return GetStringValue(key, value, &meid_);
-  } else if (key == flimflam::kImeiProperty) {
+  } else if (key == shill::kImeiProperty) {
     return GetStringValue(key, value, &imei_);
-  } else if (key == flimflam::kIccidProperty) {
+  } else if (key == shill::kIccidProperty) {
     return GetStringValue(key, value, &iccid_);
-  } else if (key == flimflam::kMdnProperty) {
+  } else if (key == shill::kMdnProperty) {
     return GetStringValue(key, value, &mdn_);
   } else if (key == shill::kSIMPresentProperty) {
     return GetBooleanValue(key, value, &sim_present_);
@@ -130,7 +130,7 @@ bool DeviceState::InitialPropertiesReceived(
 }
 
 bool DeviceState::IsSimAbsent() const {
-  return technology_family_ == flimflam::kTechnologyFamilyGsm && !sim_present_;
+  return technology_family_ == shill::kTechnologyFamilyGsm && !sim_present_;
 }
 
 }  // namespace chromeos