This is the first pass at making GetIPConfigs asynchronous.

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/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_tokenizer.h"
@@ skipping 204 matching lines @@
 void DoNothingWithCallStatus(DBusMethodCallStatus call_status) {}
 
 // Ignores errors.
 void IgnoreErrors(const std::string& error_name,
                   const std::string& error_message) {}
 
 // 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);
+                                    scoped_ptr<base::DictionaryValue> value) {
+  if (call_status == DBUS_METHOD_CALL_SUCCESS) {
+    callback.Run(path, value.Pass());
+  } else {
+    scoped_ptr<base::DictionaryValue> empty(NULL);
+    callback.Run(path, empty.Pass());
+  }
 }
 
 // A callback used to implement CrosRequest*Properties functions.
 void RunCallbackWithDictionaryValueNoStatus(
     const NetworkPropertiesCallback& callback,
     const std::string& path,
-    const base::DictionaryValue& value) {
-  callback.Run(path, &value);
+    scoped_ptr<base::DictionaryValue> value) {
+  callback.Run(path, value.Pass());
 }
 
 // A callback used to implement the error callback for CrosRequest*Properties
 // functions.
 void RunCallbackWithDictionaryValueError(
     const NetworkPropertiesCallback& callback,
     const std::string& path,
     const std::string& error_name,
     const std::string& error_message) {
-  callback.Run(path, NULL);
+  scoped_ptr<base::DictionaryValue> null_dict(NULL);
+  callback.Run(path, null_dict.Pass());
 }
 
 // Used as a callback for ShillManagerClient::GetService
 void OnGetService(const NetworkPropertiesCallback& callback,
                   const dbus::ObjectPath& service_path) {
   VLOG(1) << "OnGetServiceService: " << service_path.value();
   DBusThreadManager::Get()->GetShillServiceClient()->GetProperties(
       service_path, base::Bind(&RunCallbackWithDictionaryValue,
                                callback,
                                service_path.value()));
@@ skipping 84 matching lines @@
   ipconfig_vector->push_back(
       NetworkIPConfig(device_path,
                       ParseIPConfigType(type_string),
                       address,
                       CrosPrefixLengthToNetmask(prefix_len),
                       gateway,
                       name_servers_string));
   return true;
 }
 
+void ListIPConfigsCallback(const NetworkGetIPConfigsCallback& callback,
+                           const std::string& device_path,
+                           DBusMethodCallStatus call_status,
+                           scoped_ptr<base::DictionaryValue> properties) {
+  DCHECK(properties.get());
+  NetworkIPConfigVector ipconfig_vector;
+  std::string hardware_address;
+  const ListValue* ips = NULL;
+  if (call_status != DBUS_METHOD_CALL_SUCCESS ||
+      !properties->GetListWithoutPathExpansion(flimflam::kIPConfigsProperty,
+                                              &ips)) {
+    callback.Run(ipconfig_vector, hardware_address);
+    return;
+  }
+
+  for (size_t i = 0; i < ips->GetSize(); i++) {
+    std::string ipconfig_path;
+    if (!ips->GetString(i, &ipconfig_path)) {
+      LOG(WARNING) << "Found NULL ip for device " << device_path;
+      continue;
+    }
+    ParseIPConfig(device_path, ipconfig_path, &ipconfig_vector);
+  }
+  // Get the hardware address as well.
+  properties->GetStringWithoutPathExpansion(flimflam::kAddressProperty,
+                                           &hardware_address);
+
+  callback.Run(ipconfig_vector, hardware_address);
+}
+
 }  // namespace
 
 SMS::SMS()
     : validity(0),
       msgclass(0) {
 }
 
 SMS::~SMS() {}
 
 bool CrosActivateCellularModem(const std::string& service_path,
@@ skipping 288 matching lines @@
 }
 
 bool CrosSetOfflineMode(bool offline) {
   base::FundamentalValue value(offline);
   DBusThreadManager::Get()->GetShillManagerClient()->SetProperty(
       flimflam::kOfflineModeProperty, value, base::Bind(&DoNothing),
       base::Bind(&IgnoreErrors));
   return true;
 }
 
-bool CrosListIPConfigs(const std::string& device_path,
-                       NetworkIPConfigVector* ipconfig_vector,
-                       std::vector<std::string>* ipconfig_paths,
-                       std::string* hardware_address) {
+void CrosListIPConfigs(const std::string& device_path,
+                       const NetworkGetIPConfigsCallback& callback) {
+  const dbus::ObjectPath device_object_path(device_path);
+  DBusThreadManager::Get()->GetShillDeviceClient()->GetProperties(
+      device_object_path,
+      base::Bind(&ListIPConfigsCallback, callback, device_path));
+}
+
+bool CrosListIPConfigsAndBlock(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);
   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())
@@ skipping 233 matching lines @@
                     const std::string& carrier,
                     const NetworkOperationCallback& callback) {
   DBusThreadManager::Get()->GetShillDeviceClient()->SetCarrier(
       dbus::ObjectPath(device_path), carrier,
       base::Bind(callback, device_path, NETWORK_METHOD_ERROR_NONE,
                  std::string()),
       base::Bind(&OnNetworkActionError, callback, device_path));
 }
 
 }  // namespace chromeos