This is the first pass at making GetIPConfigs asynchronous.

chrome/browser/chromeos/cros/network_library_impl_cros.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_impl_cros.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"  // for debug output only.
 #include "base/metrics/histogram.h"
@@ skipping 216 matching lines @@
 void NetworkLibraryImplCros::CallConnectToNetwork(Network* network) {
   DCHECK(network);
   CrosRequestNetworkServiceConnect(
       network->service_path(),
       base::Bind(&NetworkLibraryImplCros::NetworkConnectCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void NetworkLibraryImplCros::WifiServiceUpdateAndConnect(
     const std::string& service_path,
-    const base::DictionaryValue* properties) {
-  if (properties) {
+    scoped_ptr<base::DictionaryValue> properties) {
+  if (properties.get()) {
     Network* network = ParseNetwork(service_path, *properties);
     CHECK_EQ(network->type(), TYPE_WIFI);
     ConnectToWifiNetworkUsingConnectData(static_cast<WifiNetwork*>(network));
   }
 }
 
 void NetworkLibraryImplCros::CallRequestWifiNetworkAndConnect(
     const std::string& ssid, ConnectionSecurity security) {
   // Asynchronously request service properties and call
   // WifiServiceUpdateAndConnect.
   CrosRequestHiddenWifiNetworkProperties(
       ssid,
       SecurityToString(security),
       base::Bind(&NetworkLibraryImplCros::WifiServiceUpdateAndConnect,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void NetworkLibraryImplCros::VPNServiceUpdateAndConnect(
     const std::string& service_path,
-    const base::DictionaryValue* properties) {
-  if (properties) {
+    scoped_ptr<base::DictionaryValue> properties) {
+  if (properties.get()) {
     VLOG(1) << "Connecting to new VPN Service: " << service_path;
     Network* network = ParseNetwork(service_path, *properties);
     CHECK_EQ(network->type(), TYPE_VPN);
     ConnectToVirtualNetworkUsingConnectData(
         static_cast<VirtualNetwork*>(network));
   } else {
     LOG(WARNING) << "Unable to create VPN Service: " << service_path;
   }
 }
 
@@ skipping 201 matching lines @@
 void NetworkLibraryImplCros::RefreshIPConfig(Network* network) {
   DCHECK(network);
   CrosRequestNetworkDeviceProperties(
       network->device_path(),
       base::Bind(&NetworkLibraryImplCros::RefreshIPConfigCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void NetworkLibraryImplCros::RefreshIPConfigCallback(
     const std::string& device_path,
-    const base::DictionaryValue* properties) {
+    scoped_ptr<base::DictionaryValue> properties) {
   const ListValue* ips = NULL;
   if (!properties->GetListWithoutPathExpansion(
       flimflam::kIPConfigsProperty, &ips))
     return;
 
   for (size_t i = 0; i < ips->GetSize(); i++) {
     std::string ipconfig_path;
     if (!ips->GetString(i, &ipconfig_path))
       continue;
     CrosRequestIPConfigRefresh(ipconfig_path);
@@ skipping 19 matching lines @@
     CrosRequestNetworkServiceDisconnect(service_path);
   CrosRequestRemoveNetworkService(service_path);
 }
 
 void NetworkLibraryImplCros::EnableOfflineMode(bool enable) {
   // If network device is already enabled/disabled, then don't do anything.
   if (CrosSetOfflineMode(enable))
     offline_mode_ = enable;
 }
 
-NetworkIPConfigVector NetworkLibraryImplCros::GetIPConfigs(
+
+void NetworkLibraryImplCros::GetIPConfigsCallback(
+    const NetworkGetIPConfigsCallback& callback,
+    HardwareAddressFormat format,
+    const NetworkIPConfigVector& ipconfig_vector,
+    const std::string& hardware_address) {
+  std::string hardware_address_tmp = hardware_address;
+  for (size_t i = 0; i < hardware_address_tmp.size(); ++i)
+    hardware_address_tmp[i] = toupper(hardware_address_tmp[i]);
+  if (format == FORMAT_COLON_SEPARATED_HEX) {
+    if (hardware_address_tmp.size() % 2 == 0) {
+      std::string output;
+      for (size_t i = 0; i < hardware_address_tmp.size(); ++i) {
+        if ((i != 0) && (i % 2 == 0))
+          output.push_back(':');
+        output.push_back(hardware_address_tmp[i]);
+      }
+      hardware_address_tmp.swap(output);
+    }
+  } else {
+    DCHECK_EQ(format, FORMAT_RAW_HEX);
+  }
+  callback.Run(ipconfig_vector, hardware_address_tmp);
+}
+
+void NetworkLibraryImplCros::GetIPConfigs(
+    const std::string& device_path,
+    HardwareAddressFormat format,
+    const NetworkGetIPConfigsCallback& callback) {
+  CrosListIPConfigs(device_path,
+                    base::Bind(&NetworkLibraryImplCros::GetIPConfigsCallback,
+                               weak_ptr_factory_.GetWeakPtr(),
+                               callback,
+                               format));
+}
+
+NetworkIPConfigVector NetworkLibraryImplCros::GetIPConfigsAndBlock(
     const std::string& device_path,
     std::string* hardware_address,
     HardwareAddressFormat format) {
   NetworkIPConfigVector ipconfig_vector;
-  CrosListIPConfigs(device_path, &ipconfig_vector, NULL, hardware_address);
+  CrosListIPConfigsAndBlock(device_path,
+                            &ipconfig_vector,
+                            NULL,
+                            hardware_address);
 
   for (size_t i = 0; i < hardware_address->size(); ++i)
     (*hardware_address)[i] = toupper((*hardware_address)[i]);
   if (format == FORMAT_COLON_SEPARATED_HEX) {
     if (hardware_address->size() % 2 == 0) {
       std::string output;
       for (size_t i = 0; i < hardware_address->size(); ++i) {
         if ((i != 0) && (i % 2 == 0))
           output.push_back(':');
         output.push_back((*hardware_address)[i]);
@@ skipping 153 matching lines @@
   }
   base::TimeDelta delta = base::TimeTicks::Now() - start;
   VLOG(2) << "NetworkManagerStatusChanged: time: "
           << delta.InMilliseconds() << " ms.";
   HISTOGRAM_TIMES("CROS_NETWORK_UPDATE", delta);
   return true;
 }
 
 void NetworkLibraryImplCros::NetworkManagerUpdate(
     const std::string& manager_path,
-    const base::DictionaryValue* properties) {
-  if (!properties) {
+    scoped_ptr<base::DictionaryValue> properties) {
+  if (!properties.get()) {
     LOG(ERROR) << "Error retrieving manager properties: " << manager_path;
     return;
   }
   VLOG(1) << "Received NetworkManagerUpdate.";
 
   for (DictionaryValue::key_iterator iter = properties->begin_keys();
        iter != properties->end_keys(); ++iter) {
     const std::string& key = *iter;
     const Value* value;
     bool res = properties->GetWithoutPathExpansion(key, &value);
@@ skipping 147 matching lines @@
       CrosRequestNetworkServiceProperties(
           service_path,
           base::Bind(&NetworkLibraryImplCros::NetworkServiceUpdate,
                      weak_ptr_factory_.GetWeakPtr()));
     }
   }
 }
 
 void NetworkLibraryImplCros::NetworkServiceUpdate(
     const std::string& service_path,
-    const base::DictionaryValue* properties) {
-  if (!properties)
+    scoped_ptr<base::DictionaryValue> properties) {
+  if (!properties.get())
     return;  // Network no longer in visible list, ignore.
   VLOG(2) << "NetworkServiceUpdate: " << service_path;
   ParseNetwork(service_path, *properties);
 }
 
 // Called from NetworkServiceUpdate and WifiServiceUpdateAndConnect.
 Network* NetworkLibraryImplCros::ParseNetwork(
     const std::string& service_path, const DictionaryValue& info) {
   Network* network = FindNetworkByPath(service_path);
   if (!network) {
@@ skipping 89 matching lines @@
     VLOG(1) << " Requesting Profile: " << profile.path;
     CrosRequestNetworkProfileProperties(
         profile.path,
         base::Bind(&NetworkLibraryImplCros::UpdateProfile,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void NetworkLibraryImplCros::UpdateProfile(
     const std::string& profile_path,
-    const base::DictionaryValue* properties) {
-  if (!properties) {
+    scoped_ptr<base::DictionaryValue> properties) {
+  if (!properties.get()) {
     LOG(ERROR) << "Error retrieving profile: " << profile_path;
     return;
   }
   VLOG(1) << "UpdateProfile for path: " << profile_path;
   const ListValue* profile_entries(NULL);
   properties->GetList(flimflam::kEntriesProperty, &profile_entries);
   if (!profile_entries) {
     LOG(ERROR) << "'Entries' property is missing.";
     return;
   }
@@ skipping 26 matching lines @@
     CrosRequestNetworkProfileEntryProperties(
         profile_path,
         service_path,
         base::Bind(&NetworkLibraryImplCros::RememberedNetworkServiceUpdate,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void NetworkLibraryImplCros::RememberedNetworkServiceUpdate(
     const std::string& service_path,
-    const base::DictionaryValue* properties) {
-  if (!properties) {
+    scoped_ptr<base::DictionaryValue> properties) {
+  if (!properties.get()) {
     // Remembered network no longer exists.
     DeleteRememberedNetwork(service_path);
   } else {
     ParseRememberedNetwork(service_path, *properties);
   }
 }
 
 // Returns NULL if |service_path| refers to a network that is not a
 // remembered type. Called from RememberedNetworkServiceUpdate.
 Network* NetworkLibraryImplCros::ParseRememberedNetwork(
@@ skipping 83 matching lines @@
   for (NetworkDeviceMap::iterator iter = old_device_map.begin();
        iter != old_device_map.end(); ++iter) {
     DeleteDeviceFromDeviceObserversMap(iter->first);
     // Delete device.
     delete iter->second;
   }
 }
 
 void NetworkLibraryImplCros::NetworkDeviceUpdate(
     const std::string& device_path,
-    const base::DictionaryValue* properties) {
-  if (!properties) {
+    scoped_ptr<base::DictionaryValue> properties) {
+  if (!properties.get()) {
     // device no longer exists.
     DeleteDevice(device_path);
   } else {
     ParseNetworkDevice(device_path, *properties);
   }
 }
 
 void NetworkLibraryImplCros::ParseNetworkDevice(const std::string& device_path,
                                                 const DictionaryValue& info) {
   NetworkDeviceMap::iterator found = device_map_.find(device_path);
@@ skipping 16 matching lines @@
   if (device && device->type() == TYPE_CELLULAR)
     UpdateCellularDeviceStatus(device, PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING);
 
   NotifyNetworkManagerChanged(false);  // Not forced.
   AddNetworkDeviceObserver(device_path, network_device_observer_.get());
 }
 
 void NetworkLibraryImplCros::SetIPParametersCallback(
     const IPParameterInfo& info,
     const std::string& service_path,
-    const base::DictionaryValue* properties) {
+    scoped_ptr<base::DictionaryValue> properties) {
   // crbug.com/146616 will fix this once we have better
   // handling of shill errors.
-  if (!properties)
+  if (!properties.get())
     return;
 
   // Find the properties we're going to set, and minimize the DBus calls below
   // by not clearing if it's already cleared, and not setting if it's already
   // set to the same value. Also, don't reconnect at the end if nothing changed.
   bool something_changed = false;
   std::string current_address;
   int32 current_prefixlen = -1;
   std::string current_gateway;
   std::string current_name_servers;
@@ skipping 98 matching lines @@
   // Find the network associated with this service path, and attempt to refresh
   // its IP parameters, so that the changes to the service properties can take
   // effect.
   Network* network = FindNetworkByPath(service_path);
 
   if (network && network->connecting_or_connected())
     RefreshIPConfig(network);
 }
 
 }  // namespace chromeos