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 209 matching lines @@
       connection_started_(false),
       is_active_(false),
       priority_(kPriorityNotSet),
       auto_connect_(false),
       save_credentials_(false),
       priority_order_(0),
       added_(false),
       notify_failure_(false),
       profile_type_(PROFILE_NONE),
       service_path_(service_path),
-      type_(type) {
+      type_(type),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_pointer_factory_(this)) {
 }
 
 Network::~Network() {
   for (PropertyMap::const_iterator props = property_map_.begin();
        props != property_map_.end(); ++props) {
      delete props->second;
   }
 }
 
 Network::ProxyOncConfig::ProxyOncConfig() : type(PROXY_ONC_DIRECT) {}
@@ skipping 72 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 174 matching lines @@
   SetOrClearStringProperty(
       flimflam::kProxyConfigProperty, proxy_config, &proxy_config_);
 }
 
 void Network::InitIPAddress() {
   ip_address_.clear();
   if (!EnsureCrosLoaded())
     return;
   // If connected, get ip config.
   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,
+                                 weak_pointer_factory_.GetWeakPtr()));

[stevenjb, 2012/11/05 23:22:58]

I'd actually rather avoid the overhead of a WeakPtrFactory for Network (which
can get constructed/destroyed pretty frequently_). I think it would be better to
bind the service path to a static callback and look up the Network from there.

+  }
+}
+
+void Network::InitIPAddressCallback(
+    const NetworkIPConfigVector& ip_configs,
+    const std::string& hardware_address) {
+  for (size_t i = 0; i < ip_configs.size(); ++i) {
+    const NetworkIPConfig& ipconfig = ip_configs[i];
+    if (ipconfig.address.size() > 0) {
+      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