Introduced AndroidDeviceProvider to simplify testing.

chrome/browser/devtools/devtools_device_provider.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 "chrome/browser/devtools/devtools_device_provider.h"
+
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/threading/thread.h"
+#include "chrome/browser/devtools/adb/android_rsa.h"
+#include "chrome/browser/devtools/adb/android_usb_device.h"
+#include "chrome/browser/devtools/adb_client_socket.h"
+#include "net/base/net_errors.h"
+
+using content::BrowserThread;
+
+const char kDevToolsAdbBridgeThreadName[] = "Chrome_DevToolsADBThread";
+const char kHostTransportCommand[] = "host:transport:%s|%s";
+const char kHostDevicesCommand[] = "host:devices";
+const char kLocalAbstractCommand[] = "localabstract:%s";
+
+const int kAdbPort = 5037;
+const int kBufferSize = 16 * 1024;
+
+
+RefCountedAdbThread* RefCountedAdbThread::instance_ = NULL;
+
+// static
+scoped_refptr<RefCountedAdbThread> RefCountedAdbThread::GetInstance() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (!instance_)
+    new RefCountedAdbThread();
+  return instance_;
+}
+
+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* RefCountedAdbThread::message_loop() {
+  return thread_ ? thread_->message_loop() : NULL;
+}
+
+// static
+void RefCountedAdbThread::StopThread(base::Thread* thread) {
+  thread->Stop();
+}
+
+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_));
+}
+
+
+AndroidDevice::AndroidDevice(const std::string& serial,
+                             scoped_refptr<RefCountedAdbThread> adb_thread)
+    : serial_(serial),
+      adb_thread_(adb_thread) {
+}
+
+void 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 AndroidDevice::HttpUpgrade(
+    const std::string& la_name,
+    const std::string& request,
+    const SocketCallback& callback) {
+  OpenSocket(la_name, base::Bind(&AndroidDevice::OnHttpSocketOpened2, this,
+                                 request, callback));
+}
+
+AndroidDevice::~AndroidDevice() {
+}
+
+void 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 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 AdbDeviceImpl : public AndroidDevice {
+ public:
+  explicit AdbDeviceImpl(const std::string& serial,
+                          scoped_refptr<RefCountedAdbThread> thread)
+      : AndroidDevice(serial, thread) {
+  }
+
+  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 AndroidDevice {
+ public:
+  explicit UsbDeviceImpl(AndroidUsbDevice* device,
+                          scoped_refptr<RefCountedAdbThread> thread)
+      : AndroidDevice(device->serial(), thread),
+        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_;
+};
+
+UsbDeviceProvider::UsbDeviceProvider(Profile* profile,
+      scoped_refptr<RefCountedAdbThread> adb_thread) : adb_thread_(adb_thread) {
+  rsa_key_.reset(AndroidRSAPrivateKey(profile));
+}
+
+UsbDeviceProvider::~UsbDeviceProvider() {
+}
+
+void UsbDeviceProvider::QueryDevices(const QueryDeviceCallback& callback) {
+  AndroidUsbDevice::Enumerate(rsa_key_.get(),
+                              base::Bind(&UsbDeviceProvider::EnumeratedDevices,
+                              this, callback));
+}
+
+void UsbDeviceProvider::EnumeratedDevices(const QueryDeviceCallback& callback,
+                                          const AndroidUsbDevices& devices) {
+  AndroidDevices result;
+  for (AndroidUsbDevices::const_iterator it = devices.begin();
+      it != devices.end(); ++it)
+    result.push_back(new UsbDeviceImpl(*it, adb_thread_));
+
+  adb_thread_->message_loop()->PostTask(
+      FROM_HERE, base::Bind(&UsbDeviceProvider::RunCallbackOnAdbThread,
+      this, callback, result));
+}
+
+void UsbDeviceProvider::RunCallbackOnAdbThread(
+    const QueryDeviceCallback& callback,
+    const AndroidDevices& result) {
+  callback.Run(result);
+}
+
+AdbDeviceProvider::AdbDeviceProvider(
+    scoped_refptr<RefCountedAdbThread> adb_thread) : adb_thread_(adb_thread) {
+}
+
+AdbDeviceProvider::~AdbDeviceProvider() {
+}
+
+void AdbDeviceProvider::QueryDevices(const QueryDeviceCallback& callback) {
+  DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
+
+  AdbClientSocket::AdbQuery(
+      kAdbPort, kHostDevicesCommand,
+      base::Bind(&AdbDeviceProvider::ReceivedAdbDevices, this, callback));
+}
+
+void AdbDeviceProvider::ReceivedAdbDevices(const QueryDeviceCallback& callback,
+                                           int result_code,
+                                           const std::string& response) {
+  DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
+
+  AndroidDevices result;
+
+  #if defined(DEBUG_DEVTOOLS)
+      // For desktop remote debugging.
+      result.push_back(new AdbDeviceImpl("", adb_thread_));
+  #endif  // defined(DEBUG_DEVTOOLS)
+
+
+  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);
+    result.push_back(new AdbDeviceImpl(tokens[0], adb_thread_));
+  }
+
+  callback.Run(result);
+}
+