Reimplement CrosGetWifiAccessPoints without Libcros

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/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/gvalue_util.h"
 #include "chromeos/dbus/cashew_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/flimflam_device_client.h"
 #include "chromeos/dbus/flimflam_ipconfig_client.h"
 #include "chromeos/dbus/flimflam_manager_client.h"
+#include "chromeos/dbus/flimflam_network_client.h"
 #include "chromeos/dbus/flimflam_profile_client.h"
 #include "chromeos/dbus/flimflam_service_client.h"
 #include "dbus/object_path.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 // Used as a callback for chromeos::MonitorNetwork*Properties.
@@ skipping 742 matching lines @@
     return DBusThreadManager::Get()->GetFlimflamIPConfigClient()->
         CallRemoveAndBlock(dbus::ObjectPath(config->path));
   }
 }
 
 void CrosFreeIPConfigStatus(IPConfigStatus* status) {
   chromeos::FreeIPConfigStatus(status);
 }
 
 bool CrosGetWifiAccessPoints(WifiAccessPointVector* result) {
-  DeviceNetworkList* network_list = chromeos::GetDeviceNetworkList();
-  if (network_list == NULL)
-    return false;
-  result->clear();
-  result->reserve(network_list->network_size);
-  const base::Time now = base::Time::Now();
-  for (size_t i = 0; i < network_list->network_size; ++i) {
-    DCHECK(network_list->networks[i].address);
-    DCHECK(network_list->networks[i].name);
-    WifiAccessPoint ap;
-    ap.mac_address = SafeString(network_list->networks[i].address);
-    ap.name = SafeString(network_list->networks[i].name);
-    ap.timestamp = now -
-        base::TimeDelta::FromSeconds(network_list->networks[i].age_seconds);
-    ap.signal_strength = network_list->networks[i].strength;
-    ap.channel = network_list->networks[i].channel;
-    result->push_back(ap);
+  if (g_libcros_network_functions_enabled) {
+    DeviceNetworkList* network_list = chromeos::GetDeviceNetworkList();
+    if (network_list == NULL)
+      return false;
+    result->clear();
+    result->reserve(network_list->network_size);
+    const base::Time now = base::Time::Now();
+    for (size_t i = 0; i < network_list->network_size; ++i) {
+      DCHECK(network_list->networks[i].address);
+      DCHECK(network_list->networks[i].name);
+      WifiAccessPoint ap;
+      ap.mac_address = SafeString(network_list->networks[i].address);
+      ap.name = SafeString(network_list->networks[i].name);
+      ap.timestamp = now -
+          base::TimeDelta::FromSeconds(network_list->networks[i].age_seconds);
+      ap.signal_strength = network_list->networks[i].strength;
+      ap.channel = network_list->networks[i].channel;
+      result->push_back(ap);
+    }
+    chromeos::FreeDeviceNetworkList(network_list);
+    return true;
+  } else {
+    scoped_ptr<base::DictionaryValue> manager_properties(
+        DBusThreadManager::Get()->GetFlimflamManagerClient()->
+        CallGetPropertiesAndBlock());
+    if (!manager_properties.get()) {
+      LOG(WARNING) << "Couldn't read managers's properties";
+      return false;
+    }
+
+    base::ListValue* devices = NULL;
+    if (!manager_properties->GetListWithoutPathExpansion(
+            flimflam::kDevicesProperty, &devices)) {
+      LOG(WARNING) << flimflam::kDevicesProperty << " property not found";
+      return false;
+    }
+    const base::Time now = base::Time::Now();
+    bool found_at_least_one_device = false;
+    result->clear();
+    for (size_t i = 0; i < devices->GetSize(); i++) {
+      std::string device_path;
+      if (!devices->GetString(i, &device_path)) {
+        LOG(WARNING) << "Couldn't get devices[" << i << "]";
+        continue;
+      }
+      scoped_ptr<base::DictionaryValue> device_properties(
+          DBusThreadManager::Get()->GetFlimflamDeviceClient()->
+          CallGetPropertiesAndBlock(dbus::ObjectPath(device_path)));
+      if (!device_properties.get()) {
+        LOG(WARNING) << "Couldn't read device's properties " << device_path;
+        continue;
+      }
+
+      base::ListValue* networks = NULL;
+      if (!device_properties->GetListWithoutPathExpansion(
+              flimflam::kNetworksProperty, &networks))
+        continue;  // Some devices do not list networks, e.g. ethernet.
+
+      base::Value* device_powered_value = NULL;
+      bool device_powered = false;
+      if (device_properties->GetWithoutPathExpansion(
+              flimflam::kPoweredProperty, &device_powered_value) &&
+          device_powered_value->GetAsBoolean(&device_powered) &&
+          !device_powered)
+        continue;  // Skip devices that are not powered up.
+
+      int scan_interval = 0;
+      device_properties->GetIntegerWithoutPathExpansion(
+          flimflam::kScanIntervalProperty, &scan_interval);
+
+      found_at_least_one_device = true;
+      for (size_t j = 0; j < networks->GetSize(); j++) {
+        std::string network_path;
+        if (!networks->GetString(j, &network_path)) {
+          LOG(WARNING) << "Couldn't get networks[" << j << "]";
+          continue;
+        }
+
+        scoped_ptr<base::DictionaryValue> network_properties(
+            DBusThreadManager::Get()->GetFlimflamNetworkClient()->
+            CallGetPropertiesAndBlock(dbus::ObjectPath(network_path)));
+        if (!network_properties.get()) {
+          LOG(WARNING) << "Couldn't read network's properties " << network_path;
+          continue;
+        }
+
+        // Using the scan interval as a proxy for approximate age.
+        // TODO(joth): Replace with actual age, when available from dbus.
+        const int age_seconds = scan_interval;
+        WifiAccessPoint ap;
+        network_properties->GetStringWithoutPathExpansion(
+            flimflam::kAddressProperty, &ap.mac_address);
+        network_properties->GetStringWithoutPathExpansion(
+            flimflam::kNameProperty, &ap.name);
+        ap.timestamp = now - base::TimeDelta::FromSeconds(age_seconds);
+        network_properties->GetIntegerWithoutPathExpansion(
+            flimflam::kSignalStrengthProperty, &ap.signal_strength);
+        network_properties->GetIntegerWithoutPathExpansion(
+            flimflam::kWifiChannelProperty, &ap.channel);
+        result->push_back(ap);
+      }
+    }
+    if (!found_at_least_one_device)
+      return false;  // No powered device found that has a 'Networks' array.
+    return true;
   }
-  chromeos::FreeDeviceNetworkList(network_list);
-  return true;
 }
 
 void CrosConfigureService(const base::DictionaryValue& properties) {
   if (g_libcros_network_functions_enabled) {
     ScopedGHashTable ghash(
         ConvertDictionaryValueToStringValueGHashTable(properties));
     chromeos::ConfigureService("", ghash.get(), OnConfigureService, NULL);
   } else {
     DBusThreadManager::Get()->GetFlimflamManagerClient()->ConfigureService(
         properties, base::Bind(&DoNothing));
   }
 }
 
 }  // namespace chromeos