This is the first pass at making GetIPConfigs asynchronous.

chrome/browser/ui/webui/options/chromeos/internet_options_handler.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/ui/webui/options/chromeos/internet_options_handler.h"
 
 #include <ctype.h>
 
 #include <map>
 #include <string>
@@ skipping 1208 matching lines @@
   // and continue in the callback.
   chromeos::CrosRequestNetworkServiceProperties(
       network->service_path(),
       base::Bind(&InternetOptionsHandler::PopulateDictionaryDetailsCallback,
                  weak_factory_.GetWeakPtr(), network));
 }
 
 void InternetOptionsHandler::PopulateDictionaryDetailsCallback(
     const chromeos::Network* network,
     const std::string& service_path,
-    const base::DictionaryValue* shill_properties) {
+    scoped_ptr<base::DictionaryValue> shill_properties) {
+  chromeos::CrosListIPConfigs(
+      network->device_path(),
+      base::Bind(&InternetOptionsHandler::PopulateIPConfigsCallback,
+                 weak_factory_.GetWeakPtr(),
+                 network,
+                 base::Passed(&shill_properties)));

[Greg Spencer (Chromium), 2012/11/05 21:05:31]

This is why the dictionary callback needs to use a scoped_ptr, so that we can
pass the shill_properties on to the next callback.  Without the scoped_ptrs, we
would have to make a deep copy of the properties here.

+}
+
+void InternetOptionsHandler::PopulateIPConfigsCallback(
+    const chromeos::Network* network,
+    scoped_ptr<base::DictionaryValue> shill_properties,
+    const chromeos::NetworkIPConfigVector& ipconfigs,
+    const std::string& hardware_address) {
   if (VLOG_IS_ON(2)) {
     std::string properties_json;
-    base::JSONWriter::WriteWithOptions(shill_properties,
+    base::JSONWriter::WriteWithOptions(shill_properties.get(),
                                        base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                        &properties_json);
     VLOG(2) << "Shill Properties: " << std::endl << properties_json;
   }
 
   Profile::FromWebUI(web_ui())->GetProxyConfigTracker()->UISetCurrentNetwork(
       network->service_path());
 
   const chromeos::NetworkUIData& ui_data = network->ui_data();
   const chromeos::NetworkPropertyUIData property_ui_data(ui_data);
   const base::DictionaryValue* onc =
       cros_->FindOncForNetwork(network->unique_id());
 
   base::DictionaryValue dictionary;
-  std::string hardware_address;
-  chromeos::NetworkIPConfigVector ipconfigs = cros_->GetIPConfigs(
-      network->device_path(), &hardware_address,
-      chromeos::NetworkLibrary::FORMAT_COLON_SEPARATED_HEX);
   if (!hardware_address.empty())
     dictionary.SetString(kTagHardwareAddress, hardware_address);
 
   // The DHCP IPConfig contains the values that are actually in use at the
   // moment, even if some are overridden by static IP values.
   scoped_ptr<DictionaryValue> ipconfig_dhcp(new DictionaryValue);
   std::string ipconfig_name_servers;
   for (chromeos::NetworkIPConfigVector::const_iterator it = ipconfigs.begin();
        it != ipconfigs.end(); ++it) {
     const chromeos::NetworkIPConfig& ipconfig = *it;
     if (ipconfig.type == chromeos::IPCONFIG_TYPE_DHCP) {
       ipconfig_dhcp->SetString(kIpConfigAddress, ipconfig.address);
       VLOG(2) << "Found DHCP Address: " << ipconfig.address;
       ipconfig_dhcp->SetString(kIpConfigNetmask, ipconfig.netmask);
       VLOG(2) << "Found DHCP Netmask: " << ipconfig.netmask;
       ipconfig_dhcp->SetString(kIpConfigGateway, ipconfig.gateway);
       VLOG(2) << "Found DHCP Gateway: " << ipconfig.gateway;
       ipconfig_dhcp->SetString(kIpConfigNameServers, ipconfig.name_servers);
       ipconfig_name_servers = ipconfig.name_servers; // save for later
       VLOG(2) << "Found DHCP Name Servers: " << ipconfig.name_servers;
       break;
     }
   }
   SetValueDictionary(&dictionary, kDictionaryIpConfig, ipconfig_dhcp.release(),
                      property_ui_data);
 
   std::string name_server_type = kNameServerTypeAutomatic;
-  if (shill_properties) {
+  if (shill_properties.get()) {
     int automatic_ip_config = 0;
     scoped_ptr<DictionaryValue> static_ip_dict(
         BuildIPInfoDictionary(*shill_properties, true, &automatic_ip_config));
     dictionary.SetBoolean(kIpConfigAutoConfig, automatic_ip_config == 0);
     DCHECK(automatic_ip_config == 3 || automatic_ip_config == 0)
         << "UI doesn't support automatic specification of individual "
         << "static IP parameters.";
     scoped_ptr<DictionaryValue> saved_ip_dict(
         BuildIPInfoDictionary(*shill_properties, false, NULL));
     dictionary.Set(kDictionarySavedIp, saved_ip_dict.release());
 
     // Determine what kind of name server setting we have by comparing the
     // StaticIP and Google values with the ipconfig values.
     std::string static_ip_nameservers;
     static_ip_dict->GetString(kIpConfigNameServers, &static_ip_nameservers);
 
     if (!static_ip_nameservers.empty() &&
         static_ip_nameservers == ipconfig_name_servers) {
       name_server_type = kNameServerTypeUser;
     }
     if (ipconfig_name_servers == kGoogleNameServers) {
       name_server_type = kNameServerTypeGoogle;
     }
     SetValueDictionary(&dictionary,
                        kDictionaryStaticIp,
                        static_ip_dict.release(),
                        property_ui_data);
   } else {
-    LOG(ERROR) << "Unable to fetch IP configuration for " << service_path;
+    LOG(ERROR) << "Unable to fetch IP configuration";
     // If we were unable to fetch shill_properties for some reason,
     // then just go with some defaults.
     dictionary.SetBoolean(kIpConfigAutoConfig, false);
     dictionary.Set(kDictionarySavedIp, new DictionaryValue);
     SetValueDictionary(&dictionary, kDictionaryStaticIp, new DictionaryValue,
                        property_ui_data);
   }
 
   chromeos::ConnectionType type = network->type();
   dictionary.SetInteger(kTagType, type);
@@ skipping 494 matching lines @@
 
   dictionary->SetBoolean(kTagWimaxEnabled, cros_->wimax_enabled());
   dictionary->SetBoolean(kTagWimaxAvailable, cros_->wimax_available());
   dictionary->SetBoolean(kTagWimaxBusy, cros_->wimax_busy());
   // TODO(kevers): The use of 'offline_mode' is not quite correct.  Update once
   // we have proper back-end support.
   dictionary->SetBoolean(kTagAirplaneMode, cros_->offline_mode());
 }
 
 }  // namespace options