This is the first pass at making GetIPConfigs asynchronous.

chrome/browser/chromeos/cros/network_library.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/network_library.h"
 
 #include "base/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/i18n/time_formatting.h"
 #include "base/json/json_writer.h"  // for debug output only.
@@ skipping 302 matching lines @@
   } else if (new_state == STATE_IDLE && IsConnectingState(old_state)
              && connection_started()) {
     // If we requested a connect and never went through a connected state,
     // treat it as a failure.
     VLOG(1) << service_path() << ": Inferring Failure state.";
     notify_failure_ = true;
     error_ = ERROR_UNKNOWN;
   } else if (new_state != STATE_UNKNOWN) {
     notify_failure_ = false;
     // State changed, so refresh IP address.
-    // Note: blocking DBus call. TODO(stevenjb): refactor this.
     InitIPAddress();
   }
   VLOG(1) << name() << ".State [" << service_path() << "]: " << GetStateString()
           << " (was: " << ConnectionStateString(old_state) << ")";
   if (!IsConnectingState(new_state) && new_state != STATE_UNKNOWN)
     set_connection_started(false);
 }
 
 void Network::SetError(ConnectionError error) {
   error_ = error;
@@ skipping 172 matching lines @@
 
 void Network::SetProxyConfig(const std::string& proxy_config) {
   SetOrClearStringProperty(
       flimflam::kProxyConfigProperty, proxy_config, &proxy_config_);
 }
 
 void Network::InitIPAddress() {
   ip_address_.clear();
   if (!EnsureCrosLoaded())
     return;
-  // If connected, get ip config.
+  // If connected, get IPConfig.
   if (connected() && !device_path_.empty()) {
-    NetworkIPConfigVector ipconfigs;
-    if (CrosListIPConfigs(device_path_, &ipconfigs, NULL, NULL)) {
-      for (size_t i = 0; i < ipconfigs.size(); ++i) {
-        const NetworkIPConfig& ipconfig = ipconfigs[i];
-        if (ipconfig.address.size() > 0) {
-          ip_address_ = ipconfig.address;
-          break;
-        }
-      }
+    CrosListIPConfigs(device_path_,
+                      base::Bind(&Network::InitIPAddressCallback,
+                                 service_path_));
+  }
+}
+
+// static
+void Network::InitIPAddressCallback(
+    const std::string& service_path,
+    const NetworkIPConfigVector& ip_configs,
+    const std::string& hardware_address) {
+  Network* network =
+      CrosLibrary::Get()->GetNetworkLibrary()->FindNetworkByPath(service_path);
+  if (!network)
+    return;
+  for (size_t i = 0; i < ip_configs.size(); ++i) {
+    const NetworkIPConfig& ipconfig = ip_configs[i];
+    if (ipconfig.address.size() > 0) {
+      network->ip_address_ = ipconfig.address;
+      break;
     }
   }
 }
 
 bool Network::UpdateStatus(const std::string& key,
                            const Value& value,
                            PropertyIndex* index) {
   if (network_parser_.get())
     return network_parser_->UpdateStatus(key, value, this, index);
   return false;
@@ skipping 769 matching lines @@
     }
   }
   connect.Run();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WimaxNetwork
 
 WimaxNetwork::WimaxNetwork(const std::string& service_path)
     : WirelessNetwork(service_path, TYPE_WIMAX),
-      passphrase_required_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(weak_pointer_factory_(this)) {
+      passphrase_required_(false) {
 }
 
 WimaxNetwork::~WimaxNetwork() {
 }
 
 void WimaxNetwork::EraseCredentials() {
   WipeString(&eap_passphrase_);
   WipeString(&eap_identity_);
 }
 
@@ skipping 30 matching lines @@
   NetworkLibrary* impl;
   if (stub)
     impl = new NetworkLibraryImplStub();
   else
     impl = new NetworkLibraryImplCros();
   impl->Init();
   return impl;
 }
 
 }  // namespace chromeos