Introduced AndroidDeviceProvider to simplify testing.

chrome/browser/devtools/devtools_adb_bridge.cc

Index: chrome/browser/devtools/devtools_adb_bridge.cc
diff --git a/chrome/browser/devtools/devtools_adb_bridge.cc b/chrome/browser/devtools/devtools_adb_bridge.cc
index f9f66179f36a44a221a650054c0c819d3cc4dfc2..facf2a581071f62abd30c3a4d598a01852dc4d5e 100644
--- a/chrome/browser/devtools/devtools_adb_bridge.cc
+++ b/chrome/browser/devtools/devtools_adb_bridge.cc
@@ -42,9 +42,6 @@ using content::BrowserThread;
 namespace {
 
 const char kDevToolsAdbBridgeThreadName[] = "Chrome_DevToolsADBThread";
-const char kHostDevicesCommand[] = "host:devices";
-const char kHostTransportCommand[] = "host:transport:%s|%s";
-const char kLocalAbstractCommand[] = "localabstract:%s";
 const char kDeviceModelCommand[] = "shell:getprop ro.product.model";
 const char kOpenedUnixSocketsCommand[] = "shell:cat /proc/net/unix";
 const char kListProcessesCommand[] = "shell:ps";
@@ -57,8 +54,6 @@ const char kClosePageRequest[] = "GET /json/close/%s HTTP/1.1\r\n\r\n";
 const char kNewPageRequest[] = "GET /json/new HTTP/1.1\r\n\r\n";
 const char kActivatePageRequest[] =
     "GET /json/activate/%s HTTP/1.1\r\n\r\n";
-const int kAdbPort = 5037;
-const int kBufferSize = 16 * 1024;
 const int kAdbPollingIntervalMs = 1000;
 
 const char kUrlParam[] = "url";
@@ -71,126 +66,38 @@ const char kLocalChrome[] = "Local Chrome";
 #endif  // defined(DEBUG_DEVTOOLS)
 
 typedef DevToolsAdbBridge::Callback Callback;
-typedef std::vector<scoped_refptr<DevToolsAdbBridge::AndroidDevice> >
+typedef std::vector<scoped_refptr<AndroidDevice> >
     AndroidDevices;
 typedef base::Callback<void(const AndroidDevices&)> AndroidDevicesCallback;
 
-class AdbDeviceImpl : public DevToolsAdbBridge::AndroidDevice {
- public:
-  explicit AdbDeviceImpl(const std::string& serial)
-      : AndroidDevice(serial) {
-  }
-
-  virtual void RunCommand(const std::string& command,
-                          const CommandCallback& callback) OVERRIDE {
-    std::string query = base::StringPrintf(kHostTransportCommand,
-                                           serial().c_str(), command.c_str());
-    AdbClientSocket::AdbQuery(kAdbPort, query, callback);
-  }
-
-  virtual void OpenSocket(const std::string& name,
-                          const SocketCallback& callback) OVERRIDE {
-    std::string socket_name =
-        base::StringPrintf(kLocalAbstractCommand, name.c_str());
-    AdbClientSocket::TransportQuery(kAdbPort, serial(), socket_name, callback);
-  }
- private:
-  virtual ~AdbDeviceImpl() {}
-};
-
-class UsbDeviceImpl : public DevToolsAdbBridge::AndroidDevice {
- public:
-  explicit UsbDeviceImpl(AndroidUsbDevice* device)
-      : AndroidDevice(device->serial()),
-        device_(device) {
-    device_->InitOnCallerThread();
-  }
-
-  virtual void RunCommand(const std::string& command,
-                          const CommandCallback& callback) OVERRIDE {
-    net::StreamSocket* socket = device_->CreateSocket(command);
-    int result = socket->Connect(base::Bind(&UsbDeviceImpl::OpenedForCommand,
-                                            this, callback, socket));
-    if (result != net::ERR_IO_PENDING)
-      callback.Run(result, std::string());
-  }
-
-  virtual void OpenSocket(const std::string& name,
-                          const SocketCallback& callback) OVERRIDE {
-    std::string socket_name =
-        base::StringPrintf(kLocalAbstractCommand, name.c_str());
-    net::StreamSocket* socket = device_->CreateSocket(socket_name);
-    int result = socket->Connect(base::Bind(&UsbDeviceImpl::OnOpenSocket, this,
-                                            callback, socket));
-    if (result != net::ERR_IO_PENDING)
-      callback.Run(result, NULL);
-  }
-
- private:
-  void OnOpenSocket(const SocketCallback& callback,
-                    net::StreamSocket* socket,
-                    int result) {
-    callback.Run(result, result == net::OK ? socket : NULL);
-  }
-
-  void OpenedForCommand(const CommandCallback& callback,
-                        net::StreamSocket* socket,
-                        int result) {
-    if (result != net::OK) {
-      callback.Run(result, std::string());
-      return;
-    }
-    scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kBufferSize);
-    result = socket->Read(buffer, kBufferSize,
-                          base::Bind(&UsbDeviceImpl::OnRead, this,
-                                     socket, buffer, std::string(), callback));
-    if (result != net::ERR_IO_PENDING)
-      OnRead(socket, buffer, std::string(), callback, result);
-  }
-
-  void OnRead(net::StreamSocket* socket,
-              scoped_refptr<net::IOBuffer> buffer,
-              const std::string& data,
-              const CommandCallback& callback,
-              int result) {
-    if (result <= 0) {
-      callback.Run(result, result == 0 ? data : std::string());
-      delete socket;
-      return;
-    }
-
-    std::string new_data = data + std::string(buffer->data(), result);
-    result = socket->Read(buffer, kBufferSize,
-                          base::Bind(&UsbDeviceImpl::OnRead, this,
-                                     socket, buffer, new_data, callback));
-    if (result != net::ERR_IO_PENDING)
-      OnRead(socket, buffer, new_data, callback, result);
-  }
-
-  virtual ~UsbDeviceImpl() {}
-  scoped_refptr<AndroidUsbDevice> device_;
-};
-
 class AdbPagesCommand : public base::RefCountedThreadSafe<
     AdbPagesCommand,
     content::BrowserThread::DeleteOnUIThread> {
  public:
   typedef base::Callback<void(DevToolsAdbBridge::RemoteDevices*)> Callback;
 
-  AdbPagesCommand(DevToolsAdbBridge* bridge,
-                  crypto::RSAPrivateKey* rsa_key,
-                  const Callback& callback)
-     : bridge_(bridge),
-       callback_(callback) {
+  AdbPagesCommand(
+      scoped_refptr<RefCountedAdbThread> adb_thread,
+      crypto::RSAPrivateKey* rsa_key,
+      const Callback& callback,
+      const DevToolsAdbBridge::DeviceProviders& device_providers)
+    : adb_thread_(adb_thread),
+      callback_(callback),
+      device_providers_(device_providers) {
     remote_devices_.reset(new DevToolsAdbBridge::RemoteDevices());
 
-    if (CommandLine::ForCurrentProcess()->HasSwitch(
+    DCHECK(!device_providers_.empty());
+
+    ProcessDeviceProviders();
+
+    // TODO:dzvorygin fix later
+  /*  if (CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kRemoteDebuggingRawUSB)) {
       AndroidUsbDevice::Enumerate(rsa_key,
           base::Bind(&AdbPagesCommand::ReceivedUsbDevices, this));
     } else {
       ReceivedUsbDevices(AndroidUsbDevices());
-    }
+    }*/
   }
 
  private:
@@ -202,46 +109,34 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   }
 
-  void ReceivedUsbDevices(const AndroidUsbDevices& usb_devices) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    bridge_->GetAdbMessageLoop()->PostTask(
-        FROM_HERE, base::Bind(&AdbPagesCommand::WrapUsbDevices, this,
-                              usb_devices));
-  }
+  void ProcessDeviceProviders() {
+    if (device_providers_.empty()) {
+      ProcessSerials();
+      return;
+    }
 
-  void WrapUsbDevices(const AndroidUsbDevices& usb_devices) {
-    DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
+    const scoped_refptr<DevToolsDeviceProvider>& device_provider =
+        device_providers_.back();
 
-#if defined(DEBUG_DEVTOOLS)
-    devices_.push_back(new AdbDeviceImpl(""));  // For desktop remote debugging.
-#endif  // defined(DEBUG_DEVTOOLS)
+    device_provider->QueryDevices(
+        base::Bind(&AdbPagesCommand::ReceivedDevices, this));
+  }
 
-    for (AndroidUsbDevices::const_iterator it = usb_devices.begin();
-         it != usb_devices.end(); ++it) {
-      devices_.push_back(new UsbDeviceImpl(*it));
-    }
+  void ReceivedDevices(const AndroidDevices& devices) {
+    DCHECK(!device_providers_.empty());
+    device_providers_.pop_back();
 
-    AdbClientSocket::AdbQuery(
-        kAdbPort, kHostDevicesCommand,
-        base::Bind(&AdbPagesCommand::ReceivedAdbDevices, this));
-  }
+    devices_.insert(devices_.end(), devices.begin(), devices.end());
 
-  void ReceivedAdbDevices(
-      int result,
-      const std::string& response) {
-    DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
-    std::vector<std::string> serials;
-    Tokenize(response, "\n", &serials);
-    for (size_t i = 0; i < serials.size(); ++i) {
-      std::vector<std::string> tokens;
-      Tokenize(serials[i], "\t ", &tokens);
-      devices_.push_back(new AdbDeviceImpl(tokens[0]));
+    if (!device_providers_.empty()) {
+      ProcessDeviceProviders();
+    } else {
+      ProcessSerials();
     }
-    ProcessSerials();
   }
 
   void ProcessSerials() {
-    DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
+    DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
     if (devices_.size() == 0) {
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
@@ -252,13 +147,14 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
 #if defined(DEBUG_DEVTOOLS)
     // For desktop remote debugging.
     if (devices_.back()->serial().empty()) {
-      scoped_refptr<DevToolsAdbBridge::AndroidDevice> device =
+      scoped_refptr<AndroidDevice> device =
           devices_.back();
       device->set_model(kLocalChrome);
       remote_devices_->push_back(
-          new DevToolsAdbBridge::RemoteDevice(bridge_, device));
+          new DevToolsAdbBridge::RemoteDevice(device));
       scoped_refptr<DevToolsAdbBridge::RemoteBrowser> remote_browser =
-          new DevToolsAdbBridge::RemoteBrowser(bridge_, device, std::string());
+          new DevToolsAdbBridge::RemoteBrowser(
+              adb_thread_, device, std::string());
       remote_browser->set_product(kChrome);
       remote_devices_->back()->AddBrowser(remote_browser);
       browsers_.push_back(remote_browser);
@@ -269,28 +165,28 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
     }
 #endif  // defined(DEBUG_DEVTOOLS)
 
-    scoped_refptr<DevToolsAdbBridge::AndroidDevice> device = devices_.back();
+    scoped_refptr<AndroidDevice> device = devices_.back();
     device->RunCommand(kDeviceModelCommand,
                        base::Bind(&AdbPagesCommand::ReceivedModel, this));
   }
 
   void ReceivedModel(int result, const std::string& response) {
-    DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
+    DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
     if (result < 0) {
       devices_.pop_back();
       ProcessSerials();
       return;
     }
-    scoped_refptr<DevToolsAdbBridge::AndroidDevice> device = devices_.back();
+    scoped_refptr<AndroidDevice> device = devices_.back();
     device->set_model(response);
     remote_devices_->push_back(
-        new DevToolsAdbBridge::RemoteDevice(bridge_, device));
+        new DevToolsAdbBridge::RemoteDevice(device));
     device->RunCommand(kOpenedUnixSocketsCommand,
                        base::Bind(&AdbPagesCommand::ReceivedSockets, this));
   }
 
   void ReceivedSockets(int result, const std::string& response) {
-    DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
+    DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
     if (result < 0) {
       devices_.pop_back();
       ProcessSerials();
@@ -298,17 +194,17 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
     }
 
     ParseSocketsList(response);
-    scoped_refptr<DevToolsAdbBridge::AndroidDevice> device = devices_.back();
+    scoped_refptr<AndroidDevice> device = devices_.back();
     device->RunCommand(kDumpsysCommand,
                        base::Bind(&AdbPagesCommand::ReceivedDumpsys, this));
   }
 
   void ReceivedDumpsys(int result, const std::string& response) {
-    DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
+    DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
     if (result >= 0)
       ParseDumpsysResponse(response);
 
-    scoped_refptr<DevToolsAdbBridge::AndroidDevice> device = devices_.back();
+    scoped_refptr<AndroidDevice> device = devices_.back();
     device->RunCommand(kListProcessesCommand,
                        base::Bind(&AdbPagesCommand::ReceivedProcesses, this));
   }
@@ -326,12 +222,12 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
   }
 
   void ProcessSockets() {
-    DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
+    DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
     if (browsers_.size() == 0) {
       devices_.pop_back();
       ProcessSerials();
     } else {
-      scoped_refptr<DevToolsAdbBridge::AndroidDevice> device = devices_.back();
+      scoped_refptr<AndroidDevice> device = devices_.back();
       device->HttpQuery(browsers_.back()->socket(), kVersionRequest,
                         base::Bind(&AdbPagesCommand::ReceivedVersion, this));
     }
@@ -339,7 +235,7 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
 
   void ReceivedVersion(int result,
                        const std::string& response) {
-    DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
+    DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
     if (result < 0) {
       browsers_.pop_back();
       ProcessSockets();
@@ -364,14 +260,14 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
       }
     }
 
-    scoped_refptr<DevToolsAdbBridge::AndroidDevice> device = devices_.back();
+    scoped_refptr<AndroidDevice> device = devices_.back();
     device->HttpQuery(browsers_.back()->socket(), kPageListRequest,
                       base::Bind(&AdbPagesCommand::ReceivedPages, this));
   }
 
   void ReceivedPages(int result,
                      const std::string& response) {
-    DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
+    DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
     scoped_refptr<DevToolsAdbBridge::RemoteBrowser> browser = browsers_.back();
     browsers_.pop_back();
     if (result < 0) {
@@ -394,7 +290,7 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
       if (!item || !item->GetAsDictionary(&dict))
         continue;
       browser->AddPage(new DevToolsAdbBridge::RemotePage(
-          bridge_, browser->device(), browser->socket(), *dict));
+          adb_thread_, browser->device(), browser->socket(), *dict));
     }
     ProcessSockets();
   }
@@ -439,7 +335,7 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
       std::string socket = path_field.substr(1);
       scoped_refptr<DevToolsAdbBridge::RemoteBrowser> remote_browser =
           new DevToolsAdbBridge::RemoteBrowser(
-              bridge_, remote_device->device(), socket);
+              adb_thread_, remote_device->device(), socket);
 
       std::string product = path_field.substr(1, socket_name_pos - 1);
       product[0] = base::ToUpperASCII(product[0]);
@@ -511,9 +407,10 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
     remote_devices_->back()->SetScreenSize(gfx::Size(width, height));
 }
 
-  scoped_refptr<DevToolsAdbBridge> bridge_;
+  scoped_refptr<RefCountedAdbThread> adb_thread_;
   Callback callback_;
   AndroidDevices devices_;
+  DevToolsAdbBridge::DeviceProviders device_providers_;
   DevToolsAdbBridge::RemoteBrowsers browsers_;
   scoped_ptr<DevToolsAdbBridge::RemoteDevices> remote_devices_;
 };
@@ -523,8 +420,8 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
 class AdbProtocolCommand : public AdbWebSocket::Delegate {
  public:
   AdbProtocolCommand(
-      scoped_refptr<DevToolsAdbBridge> bridge_,
-      scoped_refptr<DevToolsAdbBridge::AndroidDevice> device,
+      scoped_refptr<RefCountedAdbThread> adb_thread,
+      scoped_refptr<AndroidDevice> device,
       const std::string& socket_name,
       const std::string& debug_url,
       const std::string& command);
@@ -535,7 +432,7 @@ class AdbProtocolCommand : public AdbWebSocket::Delegate {
   virtual void OnSocketClosed(bool closed_by_device) OVERRIDE;
   virtual bool ProcessIncomingMessage(const std::string& message) OVERRIDE;
 
-  scoped_refptr<DevToolsAdbBridge> bridge_;
+  scoped_refptr<RefCountedAdbThread> adb_thread_;
   const std::string command_;
   scoped_refptr<AdbWebSocket> web_socket_;
 
@@ -543,15 +440,15 @@ class AdbProtocolCommand : public AdbWebSocket::Delegate {
 };
 
 AdbProtocolCommand::AdbProtocolCommand(
-    scoped_refptr<DevToolsAdbBridge> bridge,
-    scoped_refptr<DevToolsAdbBridge::AndroidDevice> device,
+    scoped_refptr<RefCountedAdbThread> adb_thread,
+    scoped_refptr<AndroidDevice> device,
     const std::string& socket_name,
     const std::string& debug_url,
     const std::string& command)
-    : bridge_(bridge),
+    : adb_thread_(adb_thread),
       command_(command) {
   web_socket_ = new AdbWebSocket(
-      device, socket_name, debug_url, bridge_->GetAdbMessageLoop(), this);
+      device, socket_name, debug_url, adb_thread_->message_loop(), this);
 }
 
 void AdbProtocolCommand::OnSocketOpened() {
@@ -580,8 +477,9 @@ typedef std::map<std::string, AgentHostDelegate*> AgentHostDelegates;
 base::LazyInstance<AgentHostDelegates>::Leaky g_host_delegates =
     LAZY_INSTANCE_INITIALIZER;
 
-DevToolsAdbBridge::Wrapper::Wrapper(Profile* profile)
-    : bridge_(new DevToolsAdbBridge(profile)) {
+DevToolsAdbBridge::Wrapper::Wrapper(Profile* profile,
+                                    const DeviceProviders& device_providers)
+    : bridge_(new DevToolsAdbBridge(profile, device_providers)) {
 }
 
 DevToolsAdbBridge::Wrapper::~Wrapper() {
@@ -615,62 +513,24 @@ DevToolsAdbBridge::Factory::~Factory() {}
 BrowserContextKeyedService*
 DevToolsAdbBridge::Factory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
-  return new DevToolsAdbBridge::Wrapper(Profile::FromBrowserContext(context));
-}
-
-DevToolsAdbBridge::AndroidDevice::AndroidDevice(const std::string& serial)
-    : serial_(serial) {
-}
+  Profile* profile = Profile::FromBrowserContext(context);
 
-void DevToolsAdbBridge::AndroidDevice::HttpQuery(
-    const std::string& la_name,
-    const std::string& request,
-    const CommandCallback& callback) {
-  OpenSocket(la_name, base::Bind(&AndroidDevice::OnHttpSocketOpened, this,
-                                 request, callback));
-}
-
-void DevToolsAdbBridge::AndroidDevice::HttpUpgrade(
-    const std::string& la_name,
-    const std::string& request,
-    const SocketCallback& callback) {
-  OpenSocket(la_name, base::Bind(&AndroidDevice::OnHttpSocketOpened2, this,
-                                 request, callback));
-}
+  DeviceProviders device_providers;
+  device_providers.push_back(
+      new UsbDeviceProvider(profile, RefCountedAdbThread::GetInstance()));
+  device_providers.push_back(
+      new AdbDeviceProvider(RefCountedAdbThread::GetInstance()));
 
-DevToolsAdbBridge::AndroidDevice::~AndroidDevice() {
+  return new DevToolsAdbBridge::Wrapper(profile, device_providers);
 }
 
-void DevToolsAdbBridge::AndroidDevice::OnHttpSocketOpened(
-    const std::string& request,
-    const CommandCallback& callback,
-    int result,
-    net::StreamSocket* socket) {
-  if (result != net::OK) {
-    callback.Run(result, std::string());
-    return;
-  }
-  AdbClientSocket::HttpQuery(socket, request, callback);
-}
-
-void DevToolsAdbBridge::AndroidDevice::OnHttpSocketOpened2(
-    const std::string& request,
-    const SocketCallback& callback,
-    int result,
-    net::StreamSocket* socket) {
-  if (result != net::OK) {
-    callback.Run(result, NULL);
-    return;
-  }
-  AdbClientSocket::HttpQuery(socket, request, callback);
-}
 
 class AgentHostDelegate : public content::DevToolsExternalAgentProxyDelegate,
                           public AdbWebSocket::Delegate {
  public:
   AgentHostDelegate(
       const std::string& id,
-      scoped_refptr<DevToolsAdbBridge::AndroidDevice> device,
+      scoped_refptr<AndroidDevice> device,
       const std::string& socket_name,
       const std::string& debug_url,
       const std::string& frontend_url,
@@ -739,11 +599,11 @@ class AgentHostDelegate : public content::DevToolsExternalAgentProxyDelegate,
 };
 
 DevToolsAdbBridge::RemotePage::RemotePage(
-    scoped_refptr<DevToolsAdbBridge> bridge,
+    scoped_refptr<RefCountedAdbThread> adb_thread,
     scoped_refptr<AndroidDevice> device,
     const std::string& socket,
     const base::DictionaryValue& value)
-    : bridge_(bridge),
+    : adb_thread_(adb_thread),
       device_(device),
       socket_(socket) {
   value.GetString("id", &id_);
@@ -792,7 +652,7 @@ void DevToolsAdbBridge::RemotePage::Close() {
   if (attached())
     return;
   std::string request = base::StringPrintf(kClosePageRequest, id_.c_str());
-  bridge_->GetAdbMessageLoop()->PostTask(FROM_HERE,
+  adb_thread_->message_loop()->PostTask(FROM_HERE,
       base::Bind(&AndroidDevice::HttpQuery,
           device_, socket_, request, base::Bind(&Noop)));
 }
@@ -808,7 +668,7 @@ void DevToolsAdbBridge::RemotePage::SendProtocolCommand(
     return;
   DevToolsProtocol::Command command(1, method, params);
   new AdbProtocolCommand(
-      bridge_, device_, socket_, debug_url_, command.Serialize());
+      adb_thread_, device_, socket_, debug_url_, command.Serialize());
 }
 
 DevToolsAdbBridge::RemotePage::~RemotePage() {
@@ -817,7 +677,7 @@ DevToolsAdbBridge::RemotePage::~RemotePage() {
 void DevToolsAdbBridge::RemotePage::RequestActivate(
     const CommandCallback& callback) {
   std::string request = base::StringPrintf(kActivatePageRequest, id_.c_str());
-  bridge_->GetAdbMessageLoop()->PostTask(FROM_HERE,
+  adb_thread_->message_loop()->PostTask(FROM_HERE,
       base::Bind(&AndroidDevice::HttpQuery,
           device_, socket_, request, callback));
 }
@@ -840,21 +700,21 @@ void DevToolsAdbBridge::RemotePage::InspectOnUIThread(Profile* profile) {
   } else if (!attached()) {
     new AgentHostDelegate(
         agent_id, device_, socket_, debug_url_,
-        frontend_url_, bridge_->GetAdbMessageLoop(), profile);
+        frontend_url_, adb_thread_->message_loop(), profile);
   }
 }
 
 DevToolsAdbBridge::RemoteBrowser::RemoteBrowser(
-    scoped_refptr<DevToolsAdbBridge> bridge,
+    scoped_refptr<RefCountedAdbThread> adb_thread,
     scoped_refptr<AndroidDevice> device,
     const std::string& socket)
-    : bridge_(bridge),
+    : adb_thread_(adb_thread),
       device_(device),
       socket_(socket) {
 }
 
 void DevToolsAdbBridge::RemoteBrowser::Open(const std::string& url) {
-  bridge_->GetAdbMessageLoop()->PostTask(FROM_HERE,
+  adb_thread_->message_loop()->PostTask(FROM_HERE,
       base::Bind(&AndroidDevice::HttpQuery,
           device_, socket_, kNewPageRequest,
           base::Bind(&RemoteBrowser::PageCreatedOnHandlerThread, this, url)));
@@ -875,7 +735,7 @@ void DevToolsAdbBridge::RemoteBrowser::PageCreatedOnUIThread(
   base::DictionaryValue* dict;
   if (value && value->GetAsDictionary(&dict)) {
     scoped_refptr<RemotePage> new_page =
-        new RemotePage(bridge_, device_, socket_, *dict);
+        new RemotePage(adb_thread_, device_, socket_, *dict);
     base::DictionaryValue params;
     params.SetString(kUrlParam, url);
     new_page->SendProtocolCommand(kPageNavigateCommand, &params);
@@ -886,62 +746,19 @@ DevToolsAdbBridge::RemoteBrowser::~RemoteBrowser() {
 }
 
 DevToolsAdbBridge::RemoteDevice::RemoteDevice(
-    scoped_refptr<DevToolsAdbBridge> bridge,
     scoped_refptr<AndroidDevice> device)
-    : bridge_(bridge),
-      device_(device) {
+    : device_(device) {
 }
 
 DevToolsAdbBridge::RemoteDevice::~RemoteDevice() {
 }
 
 
-DevToolsAdbBridge::RefCountedAdbThread*
-DevToolsAdbBridge::RefCountedAdbThread::instance_ = NULL;
-
-// static
-scoped_refptr<DevToolsAdbBridge::RefCountedAdbThread>
-DevToolsAdbBridge::RefCountedAdbThread::GetInstance() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!instance_)
-    new RefCountedAdbThread();
-  return instance_;
-}
-
-DevToolsAdbBridge::RefCountedAdbThread::RefCountedAdbThread() {
-  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* DevToolsAdbBridge::RefCountedAdbThread::message_loop() {
-  return thread_ ? thread_->message_loop() : NULL;
-}
 
-// static
-void DevToolsAdbBridge::RefCountedAdbThread::StopThread(base::Thread* thread) {
-  thread->Stop();
-}
-
-DevToolsAdbBridge::RefCountedAdbThread::~RefCountedAdbThread() {
-  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(&RefCountedAdbThread::StopThread, thread_));
-}
-
-DevToolsAdbBridge::DevToolsAdbBridge(Profile* profile)
-    : profile_(profile),
-      adb_thread_(RefCountedAdbThread::GetInstance()),
+DevToolsAdbBridge::DevToolsAdbBridge(Profile* profile,
+                                     const DeviceProviders& device_providers)
+    : adb_thread_(RefCountedAdbThread::GetInstance()),
+      device_providers_(device_providers),
       has_message_loop_(adb_thread_->message_loop() != NULL) {
   rsa_key_.reset(AndroidRSAPrivateKey(profile));
 }
@@ -961,10 +778,6 @@ void DevToolsAdbBridge::RemoveListener(Listener* listener) {
   listeners_.erase(it);
 }
 
-base::MessageLoop* DevToolsAdbBridge::GetAdbMessageLoop() {
-  return adb_thread_->message_loop();
-}
-
 DevToolsAdbBridge::~DevToolsAdbBridge() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(listeners_.empty());
@@ -976,8 +789,9 @@ void DevToolsAdbBridge::RequestRemoteDevices() {
     return;
 
   new AdbPagesCommand(
-      this, rsa_key_.get(),
-      base::Bind(&DevToolsAdbBridge::ReceivedRemoteDevices, this));
+      adb_thread_, rsa_key_.get(),
+      base::Bind(&DevToolsAdbBridge::ReceivedRemoteDevices, this),
+      device_providers_);
 }
 
 void DevToolsAdbBridge::ReceivedRemoteDevices(RemoteDevices* devices_ptr) {