Migrate DBus service constants from flimflam namespace to shill namespace.

chromeos/network/shill_property_handler.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/shill_property_handler.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
@@ skipping 155 matching lines @@
         base::Bind(&network_handler::ShillErrorCallbackFunction,
                    "SetTechnologyEnabled Failed",
                    technology, error_callback));
   }
 }
 
 void ShillPropertyHandler::SetCheckPortalList(
     const std::string& check_portal_list) {
   base::StringValue value(check_portal_list);
   shill_manager_->SetProperty(
-      flimflam::kCheckPortalListProperty,
+      shill::kCheckPortalListProperty,
       value,
       base::Bind(&base::DoNothing),
       base::Bind(&network_handler::ShillErrorCallbackFunction,
                  "SetCheckPortalList Failed",
                  "", network_handler::ErrorCallback()));
 }
 
 void ShillPropertyHandler::RequestScan() const {
   shill_manager_->RequestScan(
       "",
@@ skipping 51 matching lines @@
     NET_LOG_ERROR("ManagerPropertiesCallback",
                   base::StringPrintf("Failed: %d", call_status));
     return;
   }
   NET_LOG_EVENT("ManagerPropertiesCallback", "Success");
   const base::Value* update_service_value = NULL;
   const base::Value* update_service_complete_value = NULL;
   for (base::DictionaryValue::Iterator iter(properties);
        !iter.IsAtEnd(); iter.Advance()) {
     // Defer updating Services until all other properties have been updated.
-    if (iter.key() == flimflam::kServicesProperty)
+    if (iter.key() == shill::kServicesProperty)
       update_service_value = &iter.value();
     else if (iter.key() == shill::kServiceCompleteListProperty)
       update_service_complete_value = &iter.value();
     else
       ManagerPropertyChanged(iter.key(), iter.value());
   }
   // Update Services which can safely assume other properties have been set.
   if (update_service_value)
-    ManagerPropertyChanged(flimflam::kServicesProperty, *update_service_value);
+    ManagerPropertyChanged(shill::kServicesProperty, *update_service_value);
   // Update ServiceCompleteList which skips entries that have already been
   // requested for Services.
   if (update_service_complete_value) {
     ManagerPropertyChanged(shill::kServiceCompleteListProperty,
                            *update_service_complete_value);
   }
 
   CheckPendingStateListUpdates("");
 }
 
 void ShillPropertyHandler::CheckPendingStateListUpdates(
     const std::string& key) {
   // Once there are no pending updates, signal the state list changed callbacks.
-  if ((key.empty() || key == flimflam::kServicesProperty) &&
+  if ((key.empty() || key == shill::kServicesProperty) &&
       pending_updates_[ManagedState::MANAGED_TYPE_NETWORK].size() == 0) {
     listener_->ManagedStateListChanged(ManagedState::MANAGED_TYPE_NETWORK);
   }
   // Both Network update requests and Favorite update requests will affect
   // the list of favorites, so wait for both to complete.
   if ((key.empty() || key == shill::kServiceCompleteListProperty) &&
       pending_updates_[ManagedState::MANAGED_TYPE_NETWORK].size() == 0 &&
       pending_updates_[ManagedState::MANAGED_TYPE_FAVORITE].size() == 0) {
     listener_->ManagedStateListChanged(ManagedState::MANAGED_TYPE_FAVORITE);
   }
-  if ((key.empty() || key == flimflam::kDevicesProperty) &&
+  if ((key.empty() || key == shill::kDevicesProperty) &&
       pending_updates_[ManagedState::MANAGED_TYPE_DEVICE].size() == 0) {
     listener_->ManagedStateListChanged(ManagedState::MANAGED_TYPE_DEVICE);
   }
 }
 
 void ShillPropertyHandler::ManagerPropertyChanged(const std::string& key,
                                                   const base::Value& value) {
-  if (key == flimflam::kServicesProperty) {
+  if (key == shill::kServicesProperty) {
     const base::ListValue* vlist = GetListValue(key, value);
     if (vlist) {
       listener_->UpdateManagedList(ManagedState::MANAGED_TYPE_NETWORK, *vlist);
       UpdateProperties(ManagedState::MANAGED_TYPE_NETWORK, *vlist);
       // UpdateObserved used to use kServiceWatchListProperty for TYPE_NETWORK,
       // however that prevents us from receiving Strength updates from inactive
       // networks. The overhead for observing all services is not unreasonable
       // (and we limit the max number of observed services to kMaxObserved).
       UpdateObserved(ManagedState::MANAGED_TYPE_NETWORK, *vlist);
     }
   } else if (key == shill::kServiceCompleteListProperty) {
     const ListValue* vlist = GetListValue(key, value);
     if (vlist) {
       listener_->UpdateManagedList(ManagedState::MANAGED_TYPE_FAVORITE, *vlist);
       UpdateProperties(ManagedState::MANAGED_TYPE_FAVORITE, *vlist);
     }
-  } else if (key == flimflam::kDevicesProperty) {
+  } else if (key == shill::kDevicesProperty) {
     const base::ListValue* vlist = GetListValue(key, value);
     if (vlist) {
       listener_->UpdateManagedList(ManagedState::MANAGED_TYPE_DEVICE, *vlist);
       UpdateProperties(ManagedState::MANAGED_TYPE_DEVICE, *vlist);
       UpdateObserved(ManagedState::MANAGED_TYPE_DEVICE, *vlist);
     }
-  } else if (key == flimflam::kAvailableTechnologiesProperty) {
+  } else if (key == shill::kAvailableTechnologiesProperty) {
     const base::ListValue* vlist = GetListValue(key, value);
     if (vlist)
       UpdateAvailableTechnologies(*vlist);
-  } else if (key == flimflam::kEnabledTechnologiesProperty) {
+  } else if (key == shill::kEnabledTechnologiesProperty) {
     const base::ListValue* vlist = GetListValue(key, value);
     if (vlist)
       UpdateEnabledTechnologies(*vlist);
   } else if (key == shill::kUninitializedTechnologiesProperty) {
     const base::ListValue* vlist = GetListValue(key, value);
     if (vlist)
       UpdateUninitializedTechnologies(*vlist);
-  } else if (key == flimflam::kProfilesProperty) {
+  } else if (key == shill::kProfilesProperty) {
     listener_->ProfileListChanged();
-  } else if (key == flimflam::kCheckPortalListProperty) {
+  } else if (key == shill::kCheckPortalListProperty) {
     std::string check_portal_list;
     if (value.GetAsString(&check_portal_list))
       listener_->CheckPortalListChanged(check_portal_list);
   } else {
     VLOG(2) << "Ignored Manager Property: " << key;
   }
 }
 
 void ShillPropertyHandler::UpdateProperties(ManagedState::ManagedType type,
                                             const base::ListValue& entries) {
@@ skipping 125 matching lines @@
     NET_LOG_DEBUG("Failed to get properties",
                   base::StringPrintf("%s: %d", path.c_str(), call_status));
     return;
   }
   listener_->UpdateManagedStateProperties(type, path, properties);
   // Update Favorite properties for networks in the Services list.
   if (type == ManagedState::MANAGED_TYPE_NETWORK) {
     // Only networks with a ProfilePath set are Favorites.
     std::string profile_path;
     properties.GetStringWithoutPathExpansion(
-        flimflam::kProfileProperty, &profile_path);
+        shill::kProfileProperty, &profile_path);
     if (!profile_path.empty()) {
       listener_->UpdateManagedStateProperties(
           ManagedState::MANAGED_TYPE_FAVORITE, path, properties);
     }
   }
   // Request IPConfig parameters for networks.
   if (type == ManagedState::MANAGED_TYPE_NETWORK &&
       properties.HasKey(shill::kIPConfigProperty)) {
     std::string ip_config_path;
     if (properties.GetString(shill::kIPConfigProperty, &ip_config_path)) {
@@ skipping 51 matching lines @@
 void ShillPropertyHandler::GetIPConfigCallback(
     const std::string& service_path,
     DBusMethodCallStatus call_status,
     const base::DictionaryValue& properties)  {
   if (call_status != DBUS_METHOD_CALL_SUCCESS) {
     NET_LOG_ERROR("Failed to get IP Config properties",
                   base::StringPrintf("%s: %d",
                                      service_path.c_str(), call_status));
     return;
   }
-  UpdateIPConfigProperty(service_path, properties,
-                         flimflam::kAddressProperty);
-  UpdateIPConfigProperty(service_path, properties,
-                         flimflam::kNameServersProperty);
-  UpdateIPConfigProperty(service_path, properties,
-                         flimflam::kPrefixlenProperty);
-  UpdateIPConfigProperty(service_path, properties,
-                         flimflam::kGatewayProperty);
+  UpdateIPConfigProperty(service_path, properties, shill::kAddressProperty);
+  UpdateIPConfigProperty(service_path, properties, shill::kNameServersProperty);
+  UpdateIPConfigProperty(service_path, properties, shill::kPrefixlenProperty);
+  UpdateIPConfigProperty(service_path, properties, shill::kGatewayProperty);
   UpdateIPConfigProperty(service_path, properties,
                          shill::kWebProxyAutoDiscoveryUrlProperty);
 }
 
 void ShillPropertyHandler::UpdateIPConfigProperty(
     const std::string& service_path,
     const base::DictionaryValue& properties,
     const char* property) {
   const base::Value* value;
   if (!properties.GetWithoutPathExpansion(property, &value)) {
     LOG(ERROR) << "Failed to get IPConfig property: " << property
                << ", for: " << service_path;
     return;
   }
   listener_->UpdateNetworkServiceProperty(
       service_path, NetworkState::IPConfigProperty(property), *value);
 }
 
 void ShillPropertyHandler::NetworkDevicePropertyChangedCallback(
     const std::string& path,
     const std::string& key,
     const base::Value& value) {
   listener_->UpdateDeviceProperty(path, key, value);
 }
 
 }  // namespace internal
 }  // namespace chromeos