Call RequestScan periodically while the network list is open

chromeos/dbus/shill_manager_client_stub.cc

 // Copyright (c) 2013 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 "chromeos/dbus/shill_manager_client_stub.h"
 
 #include "base/bind.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/values.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_property_changed_observer.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "dbus/values_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
@@ skipping 63 matching lines @@
                                          const ErrorCallback& error_callback) {
   stub_properties_.SetWithoutPathExpansion(name, value.DeepCopy());
   if (callback.is_null())
     return;
   MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void ShillManagerClientStub::RequestScan(const std::string& type,
                                          const base::Closure& callback,
                                          const ErrorCallback& error_callback) {
-  const int kScanDelayMilliseconds = 3000;
-  CallNotifyObserversPropertyChanged(
-      flimflam::kServicesProperty, kScanDelayMilliseconds);
-  if (callback.is_null())
-    return;
-  MessageLoop::current()->PostTask(FROM_HERE, callback);
+  // For Stub purposes, default to a Wifi scan.
+  std::string device_type = flimflam::kTypeWifi;
+  if (!type.empty())
+    device_type = type;
+  ShillDeviceClient::TestInterface* device_client =
+      DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface();
+  std::string device_path = device_client->GetDevicePathForType(device_type);
+  if (!device_path.empty()) {
+    device_client->SetDeviceProperty(device_path,
+                                     flimflam::kScanningProperty,
+                                     base::FundamentalValue(true));
+  }
+  const int kScanDurationSeconds = 3;
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&ShillManagerClientStub::ScanCompleted,
+                 weak_ptr_factory_.GetWeakPtr(), device_path, callback),
+      base::TimeDelta::FromSeconds(kScanDurationSeconds));
 }
 
 void ShillManagerClientStub::EnableTechnology(
     const std::string& type,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   base::ListValue* enabled_list = NULL;
   if (!stub_properties_.GetListWithoutPathExpansion(
       flimflam::kEnabledTechnologiesProperty, &enabled_list)) {
     if (!error_callback.is_null()) {
@@ skipping 192 matching lines @@
 
 void ShillManagerClientStub::AddServiceAtIndex(const std::string& service_path,
                                                size_t index,
                                                bool add_to_watch_list) {
   base::StringValue path_value(service_path);
   base::ListValue* service_list =
       GetListProperty(flimflam::kServicesProperty);
   base::ListValue::iterator iter =
       std::find_if(service_list->begin(), service_list->end(),
                    ValueEquals(&path_value));
-  service_list->Find(path_value);
   if (iter != service_list->end())
     service_list->Erase(iter, NULL);
   service_list->Insert(index, path_value.DeepCopy());
   CallNotifyObserversPropertyChanged(flimflam::kServicesProperty, 0);
   if (add_to_watch_list)
     AddServiceToWatchList(service_path);
 }
 
 void ShillManagerClientStub::RemoveService(const std::string& service_path) {
   base::StringValue service_path_value(service_path);
@@ skipping 174 matching lines @@
       properties->GetString(flimflam::kNameProperty, &name);
       std::string type;
       properties->GetString(flimflam::kTypeProperty, &type);
       if (TechnologyEnabled(type))
         new_service_list->Append((*iter)->DeepCopy());
     }
   }
   return new_service_list;
 }
 
+void ShillManagerClientStub::ScanCompleted(const std::string& device_path,
+                                           const base::Closure& callback) {
+  if (!device_path.empty()) {
+    DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface()->
+        SetDeviceProperty(device_path,
+                          flimflam::kScanningProperty,
+                          base::FundamentalValue(false));
+  }
+  if (!callback.is_null())
+    MessageLoop::current()->PostTask(FROM_HERE, callback);
+}
+
 }  // namespace chromeos