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 328 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,
+                           const base::DictionaryValue& properties) {
+  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