Fixed case when DevtoolsAdbBridge may start few 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 32 matching lines @@
 
 const char kModelOffline[] = "Offline";
 
 const char kPageListRequest[] = "/json";
 const char kVersionRequest[] = "/json/version";
 const char kClosePageRequest[] = "/json/close/%s";
 const char kNewPageRequest[] = "/json/new";
 const char kNewPageRequestWithURL[] = "/json/new?%s";
 const char kActivatePageRequest[] = "/json/activate/%s";
 const char kBrowserTargetSocket[] = "/devtools/browser";
-const int kAdbPollingIntervalMs = 1000;
 
 const char kUrlParam[] = "url";
 const char kPageReloadCommand[] = "Page.reload";
 const char kPageNavigateCommand[] = "Page.navigate";
 
 const int kMinVersionNewWithURL = 32;
 const int kNewPageNavigateDelayMs = 500;
 
 // DiscoveryRequest -----------------------------------------------------
 
@@ skipping 773 matching lines @@
   if (!thread_)
     return;
   // Shut down thread on FILE thread to join into IO.
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&HandlerThread::StopThread, thread_));
 }
 
 // DevToolsAndroidBridge ------------------------------------------------------
 
+const int DevToolsAndroidBridge::kAdbPollingIntervalMs = 1000;
+
 DevToolsAndroidBridge::DevToolsAndroidBridge(Profile* profile)
     : profile_(profile),
       handler_thread_(HandlerThread::GetInstance()) {
   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();
   base::PostTaskAndReplyWithResult(
       device_message_loop()->message_loop_proxy(),
       FROM_HERE,
       base::Bind(&AndroidDeviceManager::Create),
       base::Bind(&DevToolsAndroidBridge::CreatedDeviceManager, this));
 }
 
 void DevToolsAndroidBridge::AddDeviceListListener(
     DeviceListListener* listener) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   device_list_listeners_.push_back(listener);
   if (device_list_listeners_.size() == 1 && device_manager_)
-    RequestDeviceList();
+    StartDeviceListPollingLoop();
 }
 
 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() && device_manager_) {
     device_message_loop()->PostTask(FROM_HERE,
         base::Bind(&AndroidDeviceManager::Stop, device_manager_));
+    StopDeviceListPollingLoop();
   }
 }
 
 void DevToolsAndroidBridge::AddDeviceCountListener(
     DeviceCountListener* listener) {
   device_count_listeners_.push_back(listener);
   if (device_count_listeners_.size() == 1 && device_manager_)
-    RequestDeviceCount();
+    StartDeviceCountPollingLoop();
 }
 
 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())
+    StopDeviceCountPollingLoop();
 }
 
 // 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());
   if (device_manager_) {
     AndroidDeviceManager* raw_ptr = device_manager_.get();
     device_manager_->AddRef();
     device_manager_ = NULL;
     device_message_loop()->ReleaseSoon(FROM_HERE, raw_ptr);
   }
 }
 
+void DevToolsAndroidBridge::CreatedDeviceManager(
+    scoped_refptr<AndroidDeviceManager> device_manager) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  device_manager_ = device_manager;
+  if (!device_list_listeners_.empty())
+    StartDeviceListPollingLoop();
+  if (!device_count_listeners_.empty())
+    StartDeviceCountPollingLoop();
+}
+
 void DevToolsAndroidBridge::RequestDeviceList() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(device_manager_);
 
   if (device_list_listeners_.empty())
     return;
 
-  new DiscoveryRequest(
-      this,
-      device_manager(),
-      device_message_loop(),
-      device_providers_,
-      base::Bind(&DevToolsAndroidBridge::ReceivedDeviceList, this));
-}
-
-void DevToolsAndroidBridge::CreatedDeviceManager(
-    scoped_refptr<AndroidDeviceManager> device_manager) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  device_manager_ = device_manager;
-  if (!device_list_listeners_.empty())
-    RequestDeviceList();
-  if (!device_count_listeners_.empty())
-    RequestDeviceCount();
+  new DiscoveryRequest(this,
+                       device_manager(),
+                       device_message_loop(),
+                       device_providers_,
+                       received_device_list_bound_.callback());
 }
 
 void DevToolsAndroidBridge::ReceivedDeviceList(RemoteDevices* devices_ptr) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   scoped_ptr<RemoteDevices> devices(devices_ptr);
 
-  if (device_list_listeners_.empty())
-    return;
-
   DeviceListListeners copy(device_list_listeners_);
   for (DeviceListListeners::iterator it = copy.begin(); it != copy.end(); ++it)
     (*it)->DeviceListChanged(*devices.get());
 
+  if (device_list_listeners_.empty())
+    return;
+
   BrowserThread::PostDelayedTask(
       BrowserThread::UI,
       FROM_HERE,
-      base::Bind(&DevToolsAndroidBridge::RequestDeviceList, this),
+      request_device_list_bound_.callback(),
       base::TimeDelta::FromMilliseconds(kAdbPollingIntervalMs));
 }
 
+void DevToolsAndroidBridge::StartDeviceListPollingLoop() {
+  request_device_list_bound_.Reset(
+      base::Bind(&DevToolsAndroidBridge::RequestDeviceList, this));
+  received_device_list_bound_.Reset(
+      base::Bind(&DevToolsAndroidBridge::ReceivedDeviceList, this));
+  RequestDeviceList();
+}
+
+void DevToolsAndroidBridge::StopDeviceListPollingLoop() {
+  request_device_list_bound_.Cancel();
+  received_device_list_bound_.Cancel();
+}
+
 void DevToolsAndroidBridge::RequestDeviceCount() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(device_manager_);
 
   if (device_count_listeners_.empty())
     return;
 
-  UsbDeviceProvider::CountDevices(
-      base::Bind(&DevToolsAndroidBridge::ReceivedDeviceCount, this));
+  UsbDeviceProvider::CountDevices(received_device_count_bound_.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);
 
-  BrowserThread::PostDelayedTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&DevToolsAndroidBridge::RequestDeviceCount, this),
-      base::TimeDelta::FromMilliseconds(kAdbPollingIntervalMs));
+  if (device_count_listeners_.empty())
+    return;
+
+  ScheduleDeviceCountRequest(request_device_count_bound_.callback());
+}
+
+void DevToolsAndroidBridge::ScheduleDeviceCountRequest(base::Closure callback) {
+  if (!device_count_request_scheduler_for_test_.is_null())
+    device_count_request_scheduler_for_test_.Run(callback);
+  else
+    BrowserThread::PostDelayedTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        callback,
+        base::TimeDelta::FromMilliseconds(kAdbPollingIntervalMs));
+}
+
+void DevToolsAndroidBridge::StartDeviceCountPollingLoop() {
+  request_device_count_bound_.Reset(
+      base::Bind(&DevToolsAndroidBridge::RequestDeviceCount, this));
+  received_device_count_bound_.Reset(
+      base::Bind(&DevToolsAndroidBridge::ReceivedDeviceCount, this));
+  RequestDeviceCount();
+}
+
+void DevToolsAndroidBridge::StopDeviceCountPollingLoop() {
+  request_device_count_bound_.Cancel();
+  received_device_count_bound_.Cancel();
 }
 
 void DevToolsAndroidBridge::CreateDeviceProviders() {
   device_providers_.clear();
 #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_));
   }
 }