DevTools: Partially redesigned DevToolsAndroidBridge and AndroidDeviceManager

chrome/browser/devtools/device/devtools_android_bridge.cc

Index: chrome/browser/devtools/device/devtools_android_bridge.cc
diff --git a/chrome/browser/devtools/device/devtools_android_bridge.cc b/chrome/browser/devtools/device/devtools_android_bridge.cc
index 1a674dfa394e2eec144154033d4979ab78c65acc..5bf7b550be6e656189d5432afd05be2b4f35ff16 100644
--- a/chrome/browser/devtools/device/devtools_android_bridge.cc
+++ b/chrome/browser/devtools/device/devtools_android_bridge.cc
@@ -41,8 +41,6 @@ using content::BrowserThread;
 
 namespace {
 
-const char kModelOffline[] = "Offline";
-
 const char kPageListRequest[] = "/json";
 const char kVersionRequest[] = "/json/version";
 const char kClosePageRequest[] = "/json/close/%s";
@@ -65,14 +63,14 @@ class DiscoveryRequest : public base::RefCountedThreadSafe<
     DiscoveryRequest,
     BrowserThread::DeleteOnUIThread> {
  public:
-  typedef base::Callback<void(DevToolsAndroidBridge::RemoteDevices*)> Callback;
+  typedef base::Callback<void(scoped_ptr<DevToolsAndroidBridge::RemoteDevices>)>
+      DiscoveryCallback;
+  typedef AndroidDeviceManager::Device Device;
+  typedef AndroidDeviceManager::Devices Devices;
 
   DiscoveryRequest(
-      scoped_refptr<DevToolsAndroidBridge> android_bridge,
       AndroidDeviceManager* device_manager,
-      base::MessageLoop* device_message_loop,
-      const AndroidDeviceManager::DeviceProviders& device_providers,
-      const Callback& callback);
+      const DiscoveryCallback& callback);
 
  private:
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
@@ -80,14 +78,14 @@ class DiscoveryRequest : public base::RefCountedThreadSafe<
 
   virtual ~DiscoveryRequest();
 
-  void ReceivedSerials(const std::vector<std::string>& serials);
-  void ProcessSerials();
+  void ReceivedDevices(const Devices& devices);
+  void ProcessDevices();
   void ReceivedDeviceInfo(const AndroidDeviceManager::DeviceInfo& device_info);
   void ProcessSockets();
   void ReceivedVersion(int result, const std::string& response);
   void ReceivedPages(int result, const std::string& response);
 
-  std::string current_serial() const { return serials_.back(); }
+  scoped_refptr<Device> current_device() { return devices_.back(); }
 
   scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> current_browser() const {
     return browsers_.back();
@@ -98,84 +96,59 @@ class DiscoveryRequest : public base::RefCountedThreadSafe<
 
   void Respond();
 
-  scoped_refptr<DevToolsAndroidBridge> android_bridge_;
-  AndroidDeviceManager* device_manager_;
-  base::MessageLoop* device_message_loop_;
-  Callback callback_;
-  std::vector<std::string> serials_;
+  DiscoveryCallback callback_;
+  Devices devices_;
   DevToolsAndroidBridge::RemoteBrowsers browsers_;
   scoped_ptr<DevToolsAndroidBridge::RemoteDevices> remote_devices_;
 };
 
 DiscoveryRequest::DiscoveryRequest(
-    scoped_refptr<DevToolsAndroidBridge> android_bridge,
     AndroidDeviceManager* device_manager,
-    base::MessageLoop* device_message_loop,
-    const AndroidDeviceManager::DeviceProviders& device_providers,
-    const Callback& callback)
-    : android_bridge_(android_bridge),
-      device_manager_(device_manager),
-      device_message_loop_(device_message_loop),
-      callback_(callback) {
+    const DiscoveryCallback& callback)
+    : callback_(callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   remote_devices_.reset(new DevToolsAndroidBridge::RemoteDevices());
 
-  device_message_loop_->PostTask(
-      FROM_HERE, base::Bind(
-          &AndroidDeviceManager::QueryDevices,
-          device_manager_,
-          device_providers,
-          base::Bind(&DiscoveryRequest::ReceivedSerials, this)));
+  device_manager->QueryDevices(
+      base::Bind(&DiscoveryRequest::ReceivedDevices, this));
 }
 
 DiscoveryRequest::~DiscoveryRequest() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
-void DiscoveryRequest::ReceivedSerials(
-    const std::vector<std::string>& serials) {
-  DCHECK_EQ(device_message_loop_, base::MessageLoop::current());
-  serials_ = serials;
-  ProcessSerials();
+void DiscoveryRequest::ReceivedDevices(const Devices& devices) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  devices_ = devices;
+  ProcessDevices();
 }
 
-void DiscoveryRequest::ProcessSerials() {
-  DCHECK_EQ(device_message_loop_, base::MessageLoop::current());
-  if (serials_.size() == 0) {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&DiscoveryRequest::Respond, this));
+void DiscoveryRequest::ProcessDevices() {
+  if (devices_.size() == 0) {
+    Respond();
     return;
   }
 
-  if (device_manager_->IsConnected(current_serial())) {
-    device_manager_->QueryDeviceInfo(current_serial(),
-        base::Bind(&DiscoveryRequest::ReceivedDeviceInfo, this));
-  } else {
-    AndroidDeviceManager::DeviceInfo offline_info;
-    offline_info.model = kModelOffline;
-    remote_devices_->push_back(new DevToolsAndroidBridge::RemoteDevice(
-        android_bridge_, current_serial(), offline_info, false));
-    NextDevice();
-  }
+  current_device()->QueryDeviceInfo(
+      base::Bind(&DiscoveryRequest::ReceivedDeviceInfo, this));
 }
 
 void DiscoveryRequest::ReceivedDeviceInfo(
     const AndroidDeviceManager::DeviceInfo& device_info) {
-  remote_devices_->push_back(new DevToolsAndroidBridge::RemoteDevice(
-          android_bridge_, current_serial(), device_info, true));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  remote_devices_->push_back(
+      new DevToolsAndroidBridge::RemoteDevice(current_device(), device_info));
   browsers_ = remote_devices_->back()->browsers();
   ProcessSockets();
 }
 
 void DiscoveryRequest::ProcessSockets() {
-  DCHECK_EQ(device_message_loop_, base::MessageLoop::current());
   if (browsers_.size() == 0) {
     NextDevice();
     return;
   }
 
-  device_manager_->HttpQuery(
-      current_serial(),
+  current_device()->SendJsonRequest(
       current_browser()->socket(),
       kVersionRequest,
       base::Bind(&DiscoveryRequest::ReceivedVersion, this));
@@ -183,7 +156,7 @@ void DiscoveryRequest::ProcessSockets() {
 
 void DiscoveryRequest::ReceivedVersion(int result,
                                        const std::string& response) {
-  DCHECK_EQ(device_message_loop_, base::MessageLoop::current());
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (result < 0) {
     NextBrowser();
     return;
@@ -210,8 +183,7 @@ void DiscoveryRequest::ReceivedVersion(int result,
     }
   }
 
-  device_manager_->HttpQuery(
-      current_serial(),
+  current_device()->SendJsonRequest(
       current_browser()->socket(),
       kPageListRequest,
       base::Bind(&DiscoveryRequest::ReceivedPages, this));
@@ -219,7 +191,7 @@ void DiscoveryRequest::ReceivedVersion(int result,
 
 void DiscoveryRequest::ReceivedPages(int result,
                                      const std::string& response) {
-  DCHECK_EQ(device_message_loop_, base::MessageLoop::current());
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (result >= 0) {
     scoped_ptr<base::Value> value(base::JSONReader::Read(response));
     base::ListValue* list_value;
@@ -235,12 +207,12 @@ void DiscoveryRequest::NextBrowser() {
 }
 
 void DiscoveryRequest::NextDevice() {
-  serials_.pop_back();
-  ProcessSerials();
+  devices_.pop_back();
+  ProcessDevices();
 }
 
 void DiscoveryRequest::Respond() {
-  callback_.Run(remote_devices_.release());
+  callback_.Run(remote_devices_.Pass());
 }
 
 // ProtocolCommand ------------------------------------------------------------
@@ -588,11 +560,9 @@ void RemotePageTarget::Navigate(const std::string& url,
 // DevToolsAndroidBridge::RemoteBrowser ---------------------------------------
 
 DevToolsAndroidBridge::RemoteBrowser::RemoteBrowser(
-    scoped_refptr<DevToolsAndroidBridge> android_bridge,
-    const std::string& serial,
+    scoped_refptr<Device> device,
     const AndroidDeviceManager::BrowserInfo& browser_info)
-    : android_bridge_(android_bridge),
-      serial_(serial),
+    : device_(device),
       socket_(browser_info.socket_name),
       display_name_(browser_info.display_name),
       type_(browser_info.type),
@@ -642,7 +612,7 @@ void DevToolsAndroidBridge::RemoteBrowser::SetPageDescriptors(
 }
 
 static void RespondOnUIThread(
-    const DevToolsAndroidBridge::RemoteBrowser::JsonRequestCallback& callback,
+    const DevToolsAndroidBridge::JsonRequestCallback& callback,
     int result,
     const std::string& response) {
   if (callback.is_null())
@@ -653,12 +623,7 @@ static void RespondOnUIThread(
 
 void DevToolsAndroidBridge::RemoteBrowser::SendJsonRequest(
     const std::string& request, const JsonRequestCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  android_bridge_->device_message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&AndroidDeviceManager::HttpQuery,
-                 android_bridge_->device_manager(), serial_, socket_, request,
-                 base::Bind(&RespondOnUIThread, callback)));
+  device_->SendJsonRequest(socket_, request, callback);
 }
 
 void DevToolsAndroidBridge::RemoteBrowser::SendProtocolCommand(
@@ -684,7 +649,14 @@ void DevToolsAndroidBridge::RemoteBrowser::Open(
 scoped_refptr<content::DevToolsAgentHost>
 DevToolsAndroidBridge::RemoteBrowser::GetAgentHost() {
   return AgentHostDelegate::GetOrCreateAgentHost(
-      "adb:" + serial_ + ":" + socket_, this, kBrowserTargetSocket);
+      "adb:" + device_->serial() + ":" + socket_, this, kBrowserTargetSocket);
+}
+
+scoped_refptr<DevToolsAndroidBridge::AndroidWebSocket>
+DevToolsAndroidBridge::RemoteBrowser::CreateWebSocket(
+    const std::string& url,
+    DevToolsAndroidBridge::AndroidWebSocket::Delegate* delegate) {
+  return device_->CreateWebSocket(socket_, url, delegate);
 }
 
 void DevToolsAndroidBridge::RemoteBrowser::RespondToOpenOnUIThread(
@@ -764,113 +736,50 @@ void DevToolsAndroidBridge::RemoteBrowser::NavigatePageOnUIThread(
 DevToolsAndroidBridge::RemoteBrowser::~RemoteBrowser() {
 }
 
-
 // DevToolsAndroidBridge::RemoteDevice ----------------------------------------
 
 DevToolsAndroidBridge::RemoteDevice::RemoteDevice(
-    scoped_refptr<DevToolsAndroidBridge> android_bridge,
-    const std::string& serial,
-    const AndroidDeviceManager::DeviceInfo& device_info,
-    bool connected)
-    : android_bridge_(android_bridge),
-      serial_(serial),
+    scoped_refptr<AndroidDeviceManager::Device> device,
+    const AndroidDeviceManager::DeviceInfo& device_info)
+    : device_(device),
       model_(device_info.model),
-      connected_(connected),
+      connected_(device_info.connected),
       screen_size_(device_info.screen_size) {
   for (std::vector<AndroidDeviceManager::BrowserInfo>::const_iterator it =
       device_info.browser_info.begin();
       it != device_info.browser_info.end();
       ++it) {
-    browsers_.push_back(new DevToolsAndroidBridge::RemoteBrowser(
-        android_bridge_, serial_, *it));
+    browsers_.push_back(new DevToolsAndroidBridge::RemoteBrowser(device, *it));
   }
 }
 
 void DevToolsAndroidBridge::RemoteDevice::OpenSocket(
     const std::string& socket_name,
     const AndroidDeviceManager::SocketCallback& callback) {
-  android_bridge_->device_message_loop()->PostTask(FROM_HERE,
-      base::Bind(&AndroidDeviceManager::OpenSocket,
-                 android_bridge_->device_manager(),
-                 serial_,
-                 socket_name,
-                 callback));
+  device_->OpenSocket(socket_name, callback);
 }
 
 DevToolsAndroidBridge::RemoteDevice::~RemoteDevice() {
 }
 
-// DevToolsAndroidBridge::HandlerThread ---------------------------------
-
-const char kDevToolsAdbBridgeThreadName[] = "Chrome_DevToolsADBThread";
-
-DevToolsAndroidBridge::HandlerThread*
-DevToolsAndroidBridge::HandlerThread::instance_ = NULL;
-
-// static
-scoped_refptr<DevToolsAndroidBridge::HandlerThread>
-DevToolsAndroidBridge::HandlerThread::GetInstance() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!instance_)
-    new HandlerThread();
-  return instance_;
-}
-
-DevToolsAndroidBridge::HandlerThread::HandlerThread() {
-  instance_ = this;
-  thread_ = new base::Thread(kDevToolsAdbBridgeThreadName);
-  base::Thread::Options options;
-  options.message_loop_type = base::MessageLoop::TYPE_IO;
-  if (!thread_->StartWithOptions(options)) {
-    delete thread_;
-    thread_ = NULL;
-  }
-}
-
-base::MessageLoop* DevToolsAndroidBridge::HandlerThread::message_loop() {
-  return thread_ ? thread_->message_loop() : NULL;
-}
-
-// static
-void DevToolsAndroidBridge::HandlerThread::StopThread(
-    base::Thread* thread) {
-  thread->Stop();
-}
-
-DevToolsAndroidBridge::HandlerThread::~HandlerThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  instance_ = NULL;
-  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 ------------------------------------------------------
 
 DevToolsAndroidBridge::DevToolsAndroidBridge(Profile* profile)
     : profile_(profile),
-      handler_thread_(HandlerThread::GetInstance()) {
+      device_manager_(AndroidDeviceManager::Create()) {
   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_)
+  if (device_list_listeners_.size() == 1)
     RequestDeviceList();
 }
 
@@ -881,16 +790,14 @@ void DevToolsAndroidBridge::RemoveDeviceListListener(
       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_));
-  }
+  if (device_list_listeners_.empty())
+    devices_.clear();
 }
 
 void DevToolsAndroidBridge::AddDeviceCountListener(
     DeviceCountListener* listener) {
   device_count_listeners_.push_back(listener);
-  if (device_count_listeners_.size() == 1 && device_manager_)
+  if (device_count_listeners_.size() == 1)
     RequestDeviceCount();
 }
 
@@ -913,47 +820,28 @@ 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::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_,
+      device_manager_.get(),
       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();
-}
-
-void DevToolsAndroidBridge::ReceivedDeviceList(RemoteDevices* devices_ptr) {
+void DevToolsAndroidBridge::ReceivedDeviceList(
+    scoped_ptr<RemoteDevices> devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  scoped_ptr<RemoteDevices> devices(devices_ptr);
-
   if (device_list_listeners_.empty())
     return;
 
+  devices_ = *devices;
+
   DeviceListListeners copy(device_list_listeners_);
   for (DeviceListListeners::iterator it = copy.begin(); it != copy.end(); ++it)
     (*it)->DeviceListChanged(*devices.get());
@@ -967,7 +855,6 @@ void DevToolsAndroidBridge::ReceivedDeviceList(RemoteDevices* devices_ptr) {
 
 void DevToolsAndroidBridge::RequestDeviceCount() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(device_manager_);
 
   if (device_count_listeners_.empty())
     return;
@@ -994,15 +881,15 @@ void DevToolsAndroidBridge::ReceivedDeviceCount(int count) {
 }
 
 void DevToolsAndroidBridge::CreateDeviceProviders() {
-  device_providers_.clear();
+  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));
+  device_providers.push_back(new SelfAsDeviceProvider(kDefaultDebuggingPort));
 #endif
-  device_providers_.push_back(new AdbDeviceProvider());
+  device_providers.push_back(new AdbDeviceProvider());
 
   PrefService* service = profile_->GetPrefs();
   const PrefService::Preference* pref =
@@ -1011,6 +898,7 @@ void DevToolsAndroidBridge::CreateDeviceProviders() {
 
   bool enabled;
   if (pref_value->GetAsBoolean(&enabled) && enabled) {
-    device_providers_.push_back(new UsbDeviceProvider(profile_));
+    device_providers.push_back(new UsbDeviceProvider(profile_));
   }
+  device_manager_->SetDeviceProviders(device_providers);
 }