DevTools: DevToolsAndroidBridge polling loops

chrome/browser/devtools/device/devtools_android_bridge.cc

 // Copyright 2014 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/devtools/device/devtools_android_bridge.h"
 
 #include <map>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 45 matching lines @@
 
 const int kMinVersionNewWithURL = 32;
 const int kNewPageNavigateDelayMs = 500;
 
 // DiscoveryRequest -----------------------------------------------------
 
 class DiscoveryRequest : public base::RefCountedThreadSafe<
     DiscoveryRequest,
     BrowserThread::DeleteOnUIThread> {
  public:
-  typedef base::Callback<void(scoped_ptr<DevToolsAndroidBridge::RemoteDevices>)>
+  typedef base::Callback<void(const DevToolsAndroidBridge::RemoteDevices&)>
       DiscoveryCallback;
   typedef AndroidDeviceManager::Device Device;
   typedef AndroidDeviceManager::Devices Devices;
 
   DiscoveryRequest(
       AndroidDeviceManager* device_manager,
       const DiscoveryCallback& callback);
 
  private:
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
@@ skipping 15 matching lines @@
   }
 
   void NextBrowser();
   void NextDevice();
 
   void Respond();
 
   DiscoveryCallback callback_;
   Devices devices_;
   DevToolsAndroidBridge::RemoteBrowsers browsers_;
-  scoped_ptr<DevToolsAndroidBridge::RemoteDevices> remote_devices_;
+  DevToolsAndroidBridge::RemoteDevices remote_devices_;
 };
 
 DiscoveryRequest::DiscoveryRequest(
     AndroidDeviceManager* device_manager,
     const DiscoveryCallback& callback)
     : callback_(callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  remote_devices_.reset(new DevToolsAndroidBridge::RemoteDevices());
 
   device_manager->QueryDevices(
       base::Bind(&DiscoveryRequest::ReceivedDevices, this));
 }
 
 DiscoveryRequest::~DiscoveryRequest() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void DiscoveryRequest::ReceivedDevices(const Devices& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   devices_ = devices;
   ProcessDevices();
 }
 
 void DiscoveryRequest::ProcessDevices() {
   if (devices_.size() == 0) {
     Respond();
     return;
   }
 
   current_device()->QueryDeviceInfo(
       base::Bind(&DiscoveryRequest::ReceivedDeviceInfo, this));
 }
 
 void DiscoveryRequest::ReceivedDeviceInfo(
     const AndroidDeviceManager::DeviceInfo& device_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  remote_devices_->push_back(
+  remote_devices_.push_back(
       new DevToolsAndroidBridge::RemoteDevice(current_device(), device_info));
-  browsers_ = remote_devices_->back()->browsers();
+  browsers_ = remote_devices_.back()->browsers();
   ProcessSockets();
 }
 
 void DiscoveryRequest::ProcessSockets() {
   if (browsers_.size() == 0) {
     NextDevice();
     return;
   }
 
   current_device()->SendJsonRequest(
@@ skipping 53 matching lines @@
   browsers_.pop_back();
   ProcessSockets();
 }
 
 void DiscoveryRequest::NextDevice() {
   devices_.pop_back();
   ProcessDevices();
 }
 
 void DiscoveryRequest::Respond() {
-  callback_.Run(remote_devices_.Pass());
+  callback_.Run(remote_devices_);
 }
 
 // ProtocolCommand ------------------------------------------------------------
 
 class ProtocolCommand
     : public DevToolsAndroidBridge::AndroidWebSocket::Delegate {
  public:
   ProtocolCommand(
       scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser,
       const std::string& debug_url,
@@ skipping 533 matching lines @@
   device_->OpenSocket(socket_name, callback);
 }
 
 DevToolsAndroidBridge::RemoteDevice::~RemoteDevice() {
 }
 
 // DevToolsAndroidBridge ------------------------------------------------------
 
 DevToolsAndroidBridge::DevToolsAndroidBridge(Profile* profile)
     : profile_(profile),
-      device_manager_(AndroidDeviceManager::Create()) {
+      device_manager_(AndroidDeviceManager::Create()),
+      task_scheduler_(base::Bind(&DevToolsAndroidBridge::ScheduleTaskDefault)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(prefs::kDevToolsDiscoverUsbDevicesEnabled,
       base::Bind(&DevToolsAndroidBridge::CreateDeviceProviders,
                  base::Unretained(this)));
   CreateDeviceProviders();
 }
 
 void DevToolsAndroidBridge::AddDeviceListListener(
     DeviceListListener* listener) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   device_list_listeners_.push_back(listener);
   if (device_list_listeners_.size() == 1)
-    RequestDeviceList();
+    StartDeviceListPolling();
 }
 
 void DevToolsAndroidBridge::RemoveDeviceListListener(
     DeviceListListener* listener) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DeviceListListeners::iterator it = std::find(
       device_list_listeners_.begin(), device_list_listeners_.end(), listener);
   DCHECK(it != device_list_listeners_.end());
   device_list_listeners_.erase(it);
   if (device_list_listeners_.empty())
-    devices_.clear();
+    StopDeviceListPolling();
 }
 
 void DevToolsAndroidBridge::AddDeviceCountListener(
     DeviceCountListener* listener) {
   device_count_listeners_.push_back(listener);
   if (device_count_listeners_.size() == 1)
-    RequestDeviceCount();
+    StartDeviceCountPolling();
 }
 
 void DevToolsAndroidBridge::RemoveDeviceCountListener(
     DeviceCountListener* listener) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DeviceCountListeners::iterator it = std::find(
       device_count_listeners_.begin(), device_count_listeners_.end(), listener);
   DCHECK(it != device_count_listeners_.end());
   device_count_listeners_.erase(it);
+  if (device_count_listeners_.empty())
+    StopDeviceCountPolling();
 }
 
 // static
 bool DevToolsAndroidBridge::HasDevToolsWindow(const std::string& agent_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return g_host_delegates.Get().find(agent_id) != g_host_delegates.Get().end();
 }
 
 DevToolsAndroidBridge::~DevToolsAndroidBridge() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(device_list_listeners_.empty());
   DCHECK(device_count_listeners_.empty());
 }
 
-void DevToolsAndroidBridge::RequestDeviceList() {
+void DevToolsAndroidBridge::StartDeviceListPolling() {
+  device_list_callback_.Reset(
+    base::Bind(&DevToolsAndroidBridge::ReceivedDeviceList, this));
+  RequestDeviceList(device_list_callback_.callback());
+}
+
+void DevToolsAndroidBridge::StopDeviceListPolling() {
+  device_list_callback_.Cancel();
+  devices_.clear();
+}
+
+void DevToolsAndroidBridge::RequestDeviceList(
+    const base::Callback<void(const RemoteDevices&)>& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  if (device_list_listeners_.empty() ||
+      !callback.Equals(device_list_callback_.callback()))
+    return;
+
+  new DiscoveryRequest(device_manager_.get(), callback);
+}
+
+void DevToolsAndroidBridge::ReceivedDeviceList(const RemoteDevices& devices) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  DeviceListListeners copy(device_list_listeners_);
+  for (DeviceListListeners::iterator it = copy.begin(); it != copy.end(); ++it)
+    (*it)->DeviceListChanged(devices);
+
   if (device_list_listeners_.empty())
     return;
 
-  new DiscoveryRequest(
-      device_manager_.get(),
-      base::Bind(&DevToolsAndroidBridge::ReceivedDeviceList, this));
+  devices_ = devices;
+
+  task_scheduler_.Run(
+      base::Bind(&DevToolsAndroidBridge::RequestDeviceList,
+                 this, device_list_callback_.callback()));
 }
 
-void DevToolsAndroidBridge::ReceivedDeviceList(
-    scoped_ptr<RemoteDevices> devices) {
+void DevToolsAndroidBridge::StartDeviceCountPolling() {
+  device_count_callback_.Reset(
+      base::Bind(&DevToolsAndroidBridge::ReceivedDeviceCount, this));
+  RequestDeviceCount(device_count_callback_.callback());
+}
+
+void DevToolsAndroidBridge::StopDeviceCountPolling() {
+  device_count_callback_.Cancel();
+}
+
+void DevToolsAndroidBridge::RequestDeviceCount(
+    const base::Callback<void(int)>& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (device_list_listeners_.empty())
+  if (device_count_listeners_.empty() ||
+      !callback.Equals(device_count_callback_.callback()))
     return;
 
-  devices_ = *devices;
-
-  DeviceListListeners copy(device_list_listeners_);
-  for (DeviceListListeners::iterator it = copy.begin(); it != copy.end(); ++it)
-    (*it)->DeviceListChanged(*devices.get());
-
-  BrowserThread::PostDelayedTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&DevToolsAndroidBridge::RequestDeviceList, this),
-      base::TimeDelta::FromMilliseconds(kAdbPollingIntervalMs));
-}
-
-void DevToolsAndroidBridge::RequestDeviceCount() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (device_count_listeners_.empty())
-    return;
-
-  UsbDeviceProvider::CountDevices(
-      base::Bind(&DevToolsAndroidBridge::ReceivedDeviceCount, this));
+  UsbDeviceProvider::CountDevices(callback);
 }
 
 void DevToolsAndroidBridge::ReceivedDeviceCount(int count) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (device_count_listeners_.empty())
-     return;
-
   DeviceCountListeners copy(device_count_listeners_);
   for (DeviceCountListeners::iterator it = copy.begin(); it != copy.end(); ++it)
     (*it)->DeviceCountChanged(count);
 
+  if (device_count_listeners_.empty())
+     return;
+
+  task_scheduler_.Run(
+      base::Bind(&DevToolsAndroidBridge::RequestDeviceCount,
+                 this, device_count_callback_.callback()));
+}
+
+// static
+void DevToolsAndroidBridge::ScheduleTaskDefault(const base::Closure& task) {
   BrowserThread::PostDelayedTask(
       BrowserThread::UI,
       FROM_HERE,
-      base::Bind(&DevToolsAndroidBridge::RequestDeviceCount, this),
+      task,
       base::TimeDelta::FromMilliseconds(kAdbPollingIntervalMs));
 }
 
 void DevToolsAndroidBridge::CreateDeviceProviders() {
   AndroidDeviceManager::DeviceProviders device_providers;
 #if defined(DEBUG_DEVTOOLS)
   BrowserListTabContentsProvider::EnableTethering();
   // We cannot rely on command line switch here as we might want to connect
   // to another instance of Chrome. Using hard-coded port number instead.
   const int kDefaultDebuggingPort = 9222;
   device_providers.push_back(new SelfAsDeviceProvider(kDefaultDebuggingPort));
 #endif
   device_providers.push_back(new AdbDeviceProvider());
 
   PrefService* service = profile_->GetPrefs();
   const PrefService::Preference* pref =
       service->FindPreference(prefs::kDevToolsDiscoverUsbDevicesEnabled);
   const base::Value* pref_value = pref->GetValue();
 
   bool enabled;
   if (pref_value->GetAsBoolean(&enabled) && enabled) {
     device_providers.push_back(new UsbDeviceProvider(profile_));
   }
   device_manager_->SetDeviceProviders(device_providers);
+  if (!device_list_listeners_.empty()) {
+    StopDeviceListPolling();
+    StartDeviceListPolling();
+  }
 }