Renaming instances of "flimflam" with "shill", now that we're only

chrome/browser/chromeos/cros/cros_network_functions.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 "chrome/browser/chromeos/cros/cros_network_functions.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_tokenizer.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/sms_watcher.h"
 #include "chromeos/dbus/cashew_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/flimflam_device_client.h"
-#include "chromeos/dbus/flimflam_ipconfig_client.h"
-#include "chromeos/dbus/flimflam_manager_client.h"
-#include "chromeos/dbus/flimflam_network_client.h"
-#include "chromeos/dbus/flimflam_profile_client.h"
-#include "chromeos/dbus/flimflam_service_client.h"
+#include "chromeos/dbus/shill_device_client.h"
+#include "chromeos/dbus/shill_ipconfig_client.h"
+#include "chromeos/dbus/shill_manager_client.h"
+#include "chromeos/dbus/shill_network_client.h"
+#include "chromeos/dbus/shill_profile_client.h"
+#include "chromeos/dbus/shill_service_client.h"
 #include "dbus/object_path.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 // Class to watch network manager's properties without Libcros.
 class NetworkManagerPropertiesWatcher : public CrosNetworkWatcher {
  public:
   NetworkManagerPropertiesWatcher(
       const NetworkPropertiesWatcherCallback& callback) {
-    DBusThreadManager::Get()->GetFlimflamManagerClient()->
+    DBusThreadManager::Get()->GetShillManagerClient()->
         SetPropertyChangedHandler(base::Bind(callback,
                                              flimflam::kFlimflamServicePath));
   }
   virtual ~NetworkManagerPropertiesWatcher() {
-    DBusThreadManager::Get()->GetFlimflamManagerClient()->
+    DBusThreadManager::Get()->GetShillManagerClient()->
         ResetPropertyChangedHandler();
   }
 };
 
 // Class to watch network service's properties without Libcros.
 class NetworkServicePropertiesWatcher : public CrosNetworkWatcher {
  public:
   NetworkServicePropertiesWatcher(
       const NetworkPropertiesWatcherCallback& callback,
       const std::string& service_path) : service_path_(service_path) {
-    DBusThreadManager::Get()->GetFlimflamServiceClient()->
+    DBusThreadManager::Get()->GetShillServiceClient()->
         SetPropertyChangedHandler(dbus::ObjectPath(service_path),
                                   base::Bind(callback, service_path));
   }
   virtual ~NetworkServicePropertiesWatcher() {
-    DBusThreadManager::Get()->GetFlimflamServiceClient()->
+    DBusThreadManager::Get()->GetShillServiceClient()->
         ResetPropertyChangedHandler(dbus::ObjectPath(service_path_));
   }
 
  private:
   std::string service_path_;
 };
 
 // Class to watch network device's properties without Libcros.
 class NetworkDevicePropertiesWatcher : public CrosNetworkWatcher {
  public:
   NetworkDevicePropertiesWatcher(
       const NetworkPropertiesWatcherCallback& callback,
       const std::string& device_path) : device_path_(device_path) {
-    DBusThreadManager::Get()->GetFlimflamDeviceClient()->
+    DBusThreadManager::Get()->GetShillDeviceClient()->
         SetPropertyChangedHandler(dbus::ObjectPath(device_path),
                                   base::Bind(callback, device_path));
   }
   virtual ~NetworkDevicePropertiesWatcher() {
-    DBusThreadManager::Get()->GetFlimflamDeviceClient()->
+    DBusThreadManager::Get()->GetShillDeviceClient()->
         ResetPropertyChangedHandler(dbus::ObjectPath(device_path_));
   }
 
  private:
   std::string device_path_;
 };
 
 // Converts a string to a CellularDataPlanType.
 CellularDataPlanType ParseCellularDataPlanType(const std::string& type) {
   if (type == cashew::kCellularDataPlanUnlimited)
@@ skipping 99 matching lines @@
 void DoNothing(DBusMethodCallStatus call_status) {}
 
 // A callback used to implement CrosRequest*Properties functions.
 void RunCallbackWithDictionaryValue(const NetworkPropertiesCallback& callback,
                                     const std::string& path,
                                     DBusMethodCallStatus call_status,
                                     const base::DictionaryValue& value) {
   callback.Run(path, call_status == DBUS_METHOD_CALL_SUCCESS ? &value : NULL);
 }
 
-// Used as a callback for FlimflamManagerClient::GetService
+// Used as a callback for ShillManagerClient::GetService
 void OnGetService(const NetworkPropertiesCallback& callback,
                   DBusMethodCallStatus call_status,
                   const dbus::ObjectPath& service_path) {
   if (call_status == DBUS_METHOD_CALL_SUCCESS) {
     VLOG(1) << "OnGetServiceService: " << service_path.value();
-    DBusThreadManager::Get()->GetFlimflamServiceClient()->GetProperties(
+    DBusThreadManager::Get()->GetShillServiceClient()->GetProperties(
         service_path, base::Bind(&RunCallbackWithDictionaryValue,
                                  callback,
                                  service_path.value()));
   }
 }
 
 // A callback used to call a NetworkOperationCallback on error.
 void OnNetworkActionError(const NetworkOperationCallback& callback,
                           const std::string& path,
                           const std::string& error_name,
@@ skipping 38 matching lines @@
   return result;
 }
 
 // Gets NetworkIPConfigVector populated with data from a
 // given DBus object path.
 //
 // returns true on success.
 bool ParseIPConfig(const std::string& device_path,
                    const std::string& ipconfig_path,
                    NetworkIPConfigVector* ipconfig_vector) {
-  FlimflamIPConfigClient* ipconfig_client =
-      DBusThreadManager::Get()->GetFlimflamIPConfigClient();
+  ShillIPConfigClient* ipconfig_client =
+      DBusThreadManager::Get()->GetShillIPConfigClient();
   // TODO(hashimoto): Remove this blocking D-Bus method call. crosbug.com/29902
   scoped_ptr<base::DictionaryValue> properties(
       ipconfig_client->CallGetPropertiesAndBlock(
           dbus::ObjectPath(ipconfig_path)));
   if (!properties.get())
     return false;
 
   std::string type_string;
   properties->GetStringWithoutPathExpansion(flimflam::kMethodProperty,
                                             &type_string);
@@ skipping 29 matching lines @@
 
 SMS::SMS()
     : validity(0),
       msgclass(0) {
 }
 
 SMS::~SMS() {}
 
 bool CrosActivateCellularModem(const std::string& service_path,
                                const std::string& carrier) {
-  return DBusThreadManager::Get()->GetFlimflamServiceClient()->
+  return DBusThreadManager::Get()->GetShillServiceClient()->
       CallActivateCellularModemAndBlock(dbus::ObjectPath(service_path),
                                         carrier);
 }
 
 void CrosSetNetworkServiceProperty(const std::string& service_path,
                                    const std::string& property,
                                    const base::Value& value) {
-  DBusThreadManager::Get()->GetFlimflamServiceClient()->SetProperty(
+  DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
       dbus::ObjectPath(service_path), property, value,
       base::Bind(&DoNothing));
 }
 
 void CrosClearNetworkServiceProperty(const std::string& service_path,
                                      const std::string& property) {
-  DBusThreadManager::Get()->GetFlimflamServiceClient()->ClearProperty(
+  DBusThreadManager::Get()->GetShillServiceClient()->ClearProperty(
       dbus::ObjectPath(service_path), property, base::Bind(&DoNothing));
 }
 
 void CrosSetNetworkDeviceProperty(const std::string& device_path,
                                   const std::string& property,
                                   const base::Value& value) {
-  DBusThreadManager::Get()->GetFlimflamDeviceClient()->SetProperty(
+  DBusThreadManager::Get()->GetShillDeviceClient()->SetProperty(
       dbus::ObjectPath(device_path), property, value, base::Bind(&DoNothing));
 }
 
 void CrosSetNetworkIPConfigProperty(const std::string& ipconfig_path,
                                     const std::string& property,
                                     const base::Value& value) {
-  DBusThreadManager::Get()->GetFlimflamIPConfigClient()->SetProperty(
+  DBusThreadManager::Get()->GetShillIPConfigClient()->SetProperty(
       dbus::ObjectPath(ipconfig_path), property, value,
       base::Bind(&DoNothing));
 }
 
 void CrosSetNetworkManagerProperty(const std::string& property,
                                    const base::Value& value) {
-  DBusThreadManager::Get()->GetFlimflamManagerClient()->SetProperty(
+  DBusThreadManager::Get()->GetShillManagerClient()->SetProperty(
       property, value, base::Bind(&DoNothing));
 }
 
 void CrosDeleteServiceFromProfile(const std::string& profile_path,
                                   const std::string& service_path) {
-  DBusThreadManager::Get()->GetFlimflamProfileClient()->DeleteEntry(
+  DBusThreadManager::Get()->GetShillProfileClient()->DeleteEntry(
       dbus::ObjectPath(profile_path), service_path, base::Bind(&DoNothing));
 }
 
 void CrosRequestCellularDataPlanUpdate(const std::string& modem_service_path) {
   DBusThreadManager::Get()->GetCashewClient()->RequestDataPlansUpdate(
       modem_service_path);
 }
 
 CrosNetworkWatcher* CrosMonitorNetworkManagerProperties(
     const NetworkPropertiesWatcherCallback& callback) {
@@ skipping 18 matching lines @@
 }
 
 CrosNetworkWatcher* CrosMonitorSMS(const std::string& modem_device_path,
                                    MonitorSMSCallback callback) {
   return new SMSWatcher(modem_device_path, callback);
 }
 
 void CrosRequestNetworkServiceConnect(
     const std::string& service_path,
     const NetworkOperationCallback& callback) {
-  DBusThreadManager::Get()->GetFlimflamServiceClient()->Connect(
+  DBusThreadManager::Get()->GetShillServiceClient()->Connect(
       dbus::ObjectPath(service_path),
       base::Bind(callback, service_path, NETWORK_METHOD_ERROR_NONE,
                  std::string()),
       base::Bind(&OnNetworkActionError, callback, service_path));
 }
 
 void CrosRequestNetworkManagerProperties(
     const NetworkPropertiesCallback& callback) {
-  DBusThreadManager::Get()->GetFlimflamManagerClient()->GetProperties(
+  DBusThreadManager::Get()->GetShillManagerClient()->GetProperties(
       base::Bind(&RunCallbackWithDictionaryValue,
                  callback,
                  flimflam::kFlimflamServicePath));
 }
 
 void CrosRequestNetworkServiceProperties(
     const std::string& service_path,
     const NetworkPropertiesCallback& callback) {
-  DBusThreadManager::Get()->GetFlimflamServiceClient()->GetProperties(
+  DBusThreadManager::Get()->GetShillServiceClient()->GetProperties(
       dbus::ObjectPath(service_path),
       base::Bind(&RunCallbackWithDictionaryValue, callback, service_path));
 }
 
 void CrosRequestNetworkDeviceProperties(
     const std::string& device_path,
     const NetworkPropertiesCallback& callback) {
-  DBusThreadManager::Get()->GetFlimflamDeviceClient()->GetProperties(
+  DBusThreadManager::Get()->GetShillDeviceClient()->GetProperties(
       dbus::ObjectPath(device_path),
       base::Bind(&RunCallbackWithDictionaryValue, callback, device_path));
 }
 
 void CrosRequestNetworkProfileProperties(
     const std::string& profile_path,
     const NetworkPropertiesCallback& callback) {
-  DBusThreadManager::Get()->GetFlimflamProfileClient()->GetProperties(
+  DBusThreadManager::Get()->GetShillProfileClient()->GetProperties(
       dbus::ObjectPath(profile_path),
       base::Bind(&RunCallbackWithDictionaryValue, callback, profile_path));
 }
 
 void CrosRequestNetworkProfileEntryProperties(
     const std::string& profile_path,
     const std::string& profile_entry_path,
     const NetworkPropertiesCallback& callback) {
-  DBusThreadManager::Get()->GetFlimflamProfileClient()->GetEntry(
+  DBusThreadManager::Get()->GetShillProfileClient()->GetEntry(
       dbus::ObjectPath(profile_path),
       profile_entry_path,
       base::Bind(&RunCallbackWithDictionaryValue,
                  callback,
                  profile_entry_path));
 }
 
 void CrosRequestHiddenWifiNetworkProperties(
     const std::string& ssid,
     const std::string& security,
     const NetworkPropertiesCallback& callback) {
   base::DictionaryValue properties;
   properties.SetWithoutPathExpansion(
       flimflam::kModeProperty,
       base::Value::CreateStringValue(flimflam::kModeManaged));
   properties.SetWithoutPathExpansion(
       flimflam::kTypeProperty,
       base::Value::CreateStringValue(flimflam::kTypeWifi));
   properties.SetWithoutPathExpansion(
       flimflam::kSSIDProperty,
       base::Value::CreateStringValue(ssid));
   properties.SetWithoutPathExpansion(
       flimflam::kSecurityProperty,
       base::Value::CreateStringValue(security));
-  // flimflam.Manger.GetService() will apply the property changes in
+  // shill.Manger.GetService() will apply the property changes in
   // |properties| and return a new or existing service to OnGetService().
   // OnGetService will then call GetProperties which will then call callback.
-  DBusThreadManager::Get()->GetFlimflamManagerClient()->GetService(
+  DBusThreadManager::Get()->GetShillManagerClient()->GetService(
       properties, base::Bind(&OnGetService, callback));
 }
 
 void CrosRequestVirtualNetworkProperties(
     const std::string& service_name,
     const std::string& server_hostname,
     const std::string& provider_type,
     const NetworkPropertiesCallback& callback) {
   base::DictionaryValue properties;
   properties.SetWithoutPathExpansion(
       flimflam::kTypeProperty,
       base::Value::CreateStringValue(flimflam::kTypeVPN));
   properties.SetWithoutPathExpansion(
       flimflam::kProviderNameProperty,
       base::Value::CreateStringValue(service_name));
   properties.SetWithoutPathExpansion(
       flimflam::kProviderHostProperty,
       base::Value::CreateStringValue(server_hostname));
   properties.SetWithoutPathExpansion(
       flimflam::kProviderTypeProperty,
       base::Value::CreateStringValue(provider_type));
   // The actual value of Domain does not matter, so just use service_name.
   properties.SetWithoutPathExpansion(
       flimflam::kVPNDomainProperty,
       base::Value::CreateStringValue(service_name));
 
-  // flimflam.Manger.GetService() will apply the property changes in
+  // shill.Manger.GetService() will apply the property changes in
   // |properties| and pass a new or existing service to OnGetService().
   // OnGetService will then call GetProperties which will then call callback.
-  DBusThreadManager::Get()->GetFlimflamManagerClient()->GetService(
+  DBusThreadManager::Get()->GetShillManagerClient()->GetService(
       properties, base::Bind(&OnGetService, callback));
 }
 
 void CrosRequestNetworkServiceDisconnect(const std::string& service_path) {
-  DBusThreadManager::Get()->GetFlimflamServiceClient()->Disconnect(
+  DBusThreadManager::Get()->GetShillServiceClient()->Disconnect(
       dbus::ObjectPath(service_path), base::Bind(&DoNothing));
 }
 
 void CrosRequestRemoveNetworkService(const std::string& service_path) {
-  DBusThreadManager::Get()->GetFlimflamServiceClient()->Remove(
+  DBusThreadManager::Get()->GetShillServiceClient()->Remove(
       dbus::ObjectPath(service_path), base::Bind(&DoNothing));
 }
 
 void CrosRequestNetworkScan(const std::string& network_type) {
-  DBusThreadManager::Get()->GetFlimflamManagerClient()->RequestScan(
+  DBusThreadManager::Get()->GetShillManagerClient()->RequestScan(
       network_type, base::Bind(&DoNothing));
 }
 
 void CrosRequestNetworkDeviceEnable(const std::string& network_type,
                                     bool enable) {
   if (enable) {
-    DBusThreadManager::Get()->GetFlimflamManagerClient()->EnableTechnology(
+    DBusThreadManager::Get()->GetShillManagerClient()->EnableTechnology(
         network_type, base::Bind(&DoNothing));
   } else {
-    DBusThreadManager::Get()->GetFlimflamManagerClient()->DisableTechnology(
+    DBusThreadManager::Get()->GetShillManagerClient()->DisableTechnology(
         network_type, base::Bind(&DoNothing));
   }
 }
 
 void CrosRequestRequirePin(const std::string& device_path,
                            const std::string& pin,
                            bool enable,
                            const NetworkOperationCallback& callback) {
-  DBusThreadManager::Get()->GetFlimflamDeviceClient()->RequirePin(
+  DBusThreadManager::Get()->GetShillDeviceClient()->RequirePin(
       dbus::ObjectPath(device_path), pin, enable,
       base::Bind(callback, device_path, NETWORK_METHOD_ERROR_NONE,
                  std::string()),
       base::Bind(&OnNetworkActionError, callback, device_path));
 }
 
 void CrosRequestEnterPin(const std::string& device_path,
                          const std::string& pin,
                          const NetworkOperationCallback& callback) {
-  DBusThreadManager::Get()->GetFlimflamDeviceClient()->EnterPin(
+  DBusThreadManager::Get()->GetShillDeviceClient()->EnterPin(
       dbus::ObjectPath(device_path), pin,
       base::Bind(callback, device_path, NETWORK_METHOD_ERROR_NONE,
                  std::string()),
       base::Bind(&OnNetworkActionError, callback, device_path));
 }
 
 void CrosRequestUnblockPin(const std::string& device_path,
                            const std::string& unblock_code,
                            const std::string& pin,
                            const NetworkOperationCallback& callback) {
-  DBusThreadManager::Get()->GetFlimflamDeviceClient()->UnblockPin(
+  DBusThreadManager::Get()->GetShillDeviceClient()->UnblockPin(
       dbus::ObjectPath(device_path), unblock_code, pin,
       base::Bind(callback, device_path, NETWORK_METHOD_ERROR_NONE,
                  std::string()),
       base::Bind(&OnNetworkActionError, callback, device_path));
 }
 
 void CrosRequestChangePin(const std::string& device_path,
                           const std::string& old_pin,
                           const std::string& new_pin,
                           const NetworkOperationCallback& callback) {
-  DBusThreadManager::Get()->GetFlimflamDeviceClient()->ChangePin(
+  DBusThreadManager::Get()->GetShillDeviceClient()->ChangePin(
       dbus::ObjectPath(device_path), old_pin, new_pin,
       base::Bind(callback, device_path, NETWORK_METHOD_ERROR_NONE,
                  std::string()),
       base::Bind(&OnNetworkActionError, callback, device_path));
 }
 
 void CrosProposeScan(const std::string& device_path) {
-  DBusThreadManager::Get()->GetFlimflamDeviceClient()->ProposeScan(
+  DBusThreadManager::Get()->GetShillDeviceClient()->ProposeScan(
       dbus::ObjectPath(device_path), base::Bind(&DoNothing));
 }
 
 void CrosRequestCellularRegister(const std::string& device_path,
                                  const std::string& network_id,
                                  const NetworkOperationCallback& callback) {
-  DBusThreadManager::Get()->GetFlimflamDeviceClient()->Register(
+  DBusThreadManager::Get()->GetShillDeviceClient()->Register(
       dbus::ObjectPath(device_path), network_id,
       base::Bind(callback, device_path, NETWORK_METHOD_ERROR_NONE,
                  std::string()),
       base::Bind(&OnNetworkActionError, callback, device_path));
 }
 
 bool CrosSetOfflineMode(bool offline) {
   base::FundamentalValue value(offline);
-  DBusThreadManager::Get()->GetFlimflamManagerClient()->SetProperty(
+  DBusThreadManager::Get()->GetShillManagerClient()->SetProperty(
       flimflam::kOfflineModeProperty, value, base::Bind(&DoNothing));
   return true;
 }
 
 bool CrosListIPConfigs(const std::string& device_path,
                        NetworkIPConfigVector* ipconfig_vector,
                        std::vector<std::string>* ipconfig_paths,
                        std::string* hardware_address) {
   if (hardware_address)
     hardware_address->clear();
   const dbus::ObjectPath device_object_path(device_path);
-  FlimflamDeviceClient* device_client =
-      DBusThreadManager::Get()->GetFlimflamDeviceClient();
+  ShillDeviceClient* device_client =
+      DBusThreadManager::Get()->GetShillDeviceClient();
   // TODO(hashimoto): Remove this blocking D-Bus method call.
   // crosbug.com/29902
   scoped_ptr<base::DictionaryValue> properties(
       device_client->CallGetPropertiesAndBlock(device_object_path));
   if (!properties.get())
     return false;
 
   ListValue* ips = NULL;
   if (!properties->GetListWithoutPathExpansion(
           flimflam::kIPConfigsProperty, &ips))
@@ skipping 37 matching lines @@
     case IPCONFIG_TYPE_DHCP6:
       type_str = flimflam::kTypeDHCP6;
       break;
     case IPCONFIG_TYPE_PPP:
       type_str = flimflam::kTypePPP;
       break;
     default:
       return false;
   };
   const dbus::ObjectPath result =
-      DBusThreadManager::Get()->GetFlimflamDeviceClient()->
+      DBusThreadManager::Get()->GetShillDeviceClient()->
       CallAddIPConfigAndBlock(dbus::ObjectPath(device_path), type_str);
   if (result.value().empty()) {
     LOG(ERROR) << "Add IPConfig failed for device path " << device_path
                << " and type " << type_str;
     return false;
   }
   return true;
 }
 
 bool CrosRemoveIPConfig(const std::string& ipconfig_path) {
-  return DBusThreadManager::Get()->GetFlimflamIPConfigClient()->
+  return DBusThreadManager::Get()->GetShillIPConfigClient()->
       CallRemoveAndBlock(dbus::ObjectPath(ipconfig_path));
 }
 
 void CrosRequestIPConfigRefresh(const std::string& ipconfig_path) {
-  DBusThreadManager::Get()->GetFlimflamIPConfigClient()->Refresh(
+  DBusThreadManager::Get()->GetShillIPConfigClient()->Refresh(
       dbus::ObjectPath(ipconfig_path),
       base::Bind(&DoNothing));
 }
 
 bool CrosGetWifiAccessPoints(WifiAccessPointVector* result) {
   scoped_ptr<base::DictionaryValue> manager_properties(
-      DBusThreadManager::Get()->GetFlimflamManagerClient()->
+      DBusThreadManager::Get()->GetShillManagerClient()->
       CallGetPropertiesAndBlock());
   if (!manager_properties.get()) {
     LOG(WARNING) << "Couldn't read managers's properties";
     return false;
   }
 
   base::ListValue* devices = NULL;
   if (!manager_properties->GetListWithoutPathExpansion(
           flimflam::kDevicesProperty, &devices)) {
     LOG(WARNING) << flimflam::kDevicesProperty << " property not found";
     return false;
   }
   const base::Time now = base::Time::Now();
   bool found_at_least_one_device = false;
   result->clear();
   for (size_t i = 0; i < devices->GetSize(); i++) {
     std::string device_path;
     if (!devices->GetString(i, &device_path)) {
       LOG(WARNING) << "Couldn't get devices[" << i << "]";
       continue;
     }
     scoped_ptr<base::DictionaryValue> device_properties(
-        DBusThreadManager::Get()->GetFlimflamDeviceClient()->
+        DBusThreadManager::Get()->GetShillDeviceClient()->
         CallGetPropertiesAndBlock(dbus::ObjectPath(device_path)));
     if (!device_properties.get()) {
       LOG(WARNING) << "Couldn't read device's properties " << device_path;
       continue;
     }
 
     base::ListValue* networks = NULL;
     if (!device_properties->GetListWithoutPathExpansion(
             flimflam::kNetworksProperty, &networks))
       continue;  // Some devices do not list networks, e.g. ethernet.
@@ skipping 12 matching lines @@
 
     found_at_least_one_device = true;
     for (size_t j = 0; j < networks->GetSize(); j++) {
       std::string network_path;
       if (!networks->GetString(j, &network_path)) {
         LOG(WARNING) << "Couldn't get networks[" << j << "]";
         continue;
       }
 
       scoped_ptr<base::DictionaryValue> network_properties(
-          DBusThreadManager::Get()->GetFlimflamNetworkClient()->
+          DBusThreadManager::Get()->GetShillNetworkClient()->
           CallGetPropertiesAndBlock(dbus::ObjectPath(network_path)));
       if (!network_properties.get()) {
         LOG(WARNING) << "Couldn't read network's properties " << network_path;
         continue;
       }
 
       // Using the scan interval as a proxy for approximate age.
       // TODO(joth): Replace with actual age, when available from dbus.
       const int age_seconds = scan_interval;
       WifiAccessPoint ap;
       network_properties->GetStringWithoutPathExpansion(
           flimflam::kAddressProperty, &ap.mac_address);
       network_properties->GetStringWithoutPathExpansion(
           flimflam::kNameProperty, &ap.name);
       ap.timestamp = now - base::TimeDelta::FromSeconds(age_seconds);
       network_properties->GetIntegerWithoutPathExpansion(
           flimflam::kSignalStrengthProperty, &ap.signal_strength);
       network_properties->GetIntegerWithoutPathExpansion(
           flimflam::kWifiChannelProperty, &ap.channel);
       result->push_back(ap);
     }
   }
   if (!found_at_least_one_device)
     return false;  // No powered device found that has a 'Networks' array.
   return true;
 }
 
 void CrosConfigureService(const base::DictionaryValue& properties) {
-  DBusThreadManager::Get()->GetFlimflamManagerClient()->ConfigureService(
+  DBusThreadManager::Get()->GetShillManagerClient()->ConfigureService(
       properties, base::Bind(&DoNothing));
 }
 
 std::string CrosPrefixLengthToNetmask(int32 prefix_length) {
   std::string netmask;
   // Return the empty string for invalid inputs.
   if (prefix_length < 0 || prefix_length > 32)
     return netmask;
   for (int i = 0; i < 4; i++) {
     int remainder = 8;
@@ skipping 50 matching lines @@
       return -1;
     }
     count++;
   }
   if (count < 4)
     return -1;
   return prefix_length;
 }
 
 }  // namespace chromeos