Introduced AndroidDeviceProvider to simplify testing.

chrome/browser/devtools/android_device.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/android_device.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;
+
+namespace {
+
+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;
+
+// AdbDeviceImpl --------------------------------------------------------------
+
+class AdbDeviceImpl : public AndroidDevice {
+ public:
+  AdbDeviceImpl(const std::string& serial, bool is_connected);
+  virtual void RunCommand(const std::string& command,
+                          const CommandCallback& callback) OVERRIDE;
+  virtual void OpenSocket(const std::string& name,
+                          const SocketCallback& callback) OVERRIDE;
+ private:
+  virtual ~AdbDeviceImpl() {}
+};
+
+AdbDeviceImpl::AdbDeviceImpl(const std::string& serial, bool is_connected)
+    : AndroidDevice(serial, is_connected) {
+}
+
+void AdbDeviceImpl::RunCommand(const std::string& command,
+                               const CommandCallback& callback) {
+  std::string query = base::StringPrintf(kHostTransportCommand,
+                                         serial().c_str(), command.c_str());
+  AdbClientSocket::AdbQuery(kAdbPort, query, callback);
+}
+
+void AdbDeviceImpl::OpenSocket(const std::string& name,
+                               const SocketCallback& callback) {
+  std::string socket_name =
+      base::StringPrintf(kLocalAbstractCommand, name.c_str());
+  AdbClientSocket::TransportQuery(kAdbPort, serial(), socket_name, callback);
+}
+
+// UsbDeviceImpl --------------------------------------------------------------
+
+class UsbDeviceImpl : public AndroidDevice {
+ public:
+  explicit UsbDeviceImpl(AndroidUsbDevice* device);
+  virtual void RunCommand(const std::string& command,
+                          const CommandCallback& callback) OVERRIDE;
+  virtual void OpenSocket(const std::string& name,
+                          const SocketCallback& callback) OVERRIDE;
+ private:
+  void OnOpenSocket(const SocketCallback& callback,
+                    net::StreamSocket* socket,
+                    int result);
+  void OpenedForCommand(const CommandCallback& callback,
+                        net::StreamSocket* socket,
+                        int result);
+  void OnRead(net::StreamSocket* socket,
+              scoped_refptr<net::IOBuffer> buffer,
+              const std::string& data,
+              const CommandCallback& callback,
+              int result);
+
+  virtual ~UsbDeviceImpl() {}
+  scoped_refptr<AndroidUsbDevice> device_;
+};
+
+
+UsbDeviceImpl::UsbDeviceImpl(AndroidUsbDevice* device)
+    : AndroidDevice(device->serial(), device->is_connected()),
+      device_(device) {
+  device_->InitOnCallerThread();
+}
+
+void UsbDeviceImpl::RunCommand(const std::string& command,
+                               const CommandCallback& callback) {
+  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());
+}
+
+void UsbDeviceImpl::OpenSocket(const std::string& name,
+                               const SocketCallback& callback) {
+  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);
+}
+
+void UsbDeviceImpl::OnOpenSocket(const SocketCallback& callback,
+                  net::StreamSocket* socket,
+                  int result) {
+  callback.Run(result, result == net::OK ? socket : NULL);
+}
+
+void UsbDeviceImpl::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 UsbDeviceImpl::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);
+}
+
+// AdbDeviceProvider -------------------------------------------
+
+class AdbDeviceProvider: public AndroidDeviceProvider {
+ public:
+  virtual void QueryDevices(const QueryDevicesCallback& callback) OVERRIDE;
+ private:
+  void QueryDevicesOnAdbThread(const QueryDevicesCallback& callback);
+  void ReceivedAdbDevices(const QueryDevicesCallback& callback, int result,
+                          const std::string& response);
+
+  virtual ~AdbDeviceProvider();
+};
+
+AdbDeviceProvider::~AdbDeviceProvider() {
+}
+
+void AdbDeviceProvider::QueryDevices(const QueryDevicesCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  adb_thread_->message_loop()->PostTask(
+        FROM_HERE, base::Bind(&AdbDeviceProvider::QueryDevicesOnAdbThread,
+        this, callback));
+}
+
+void AdbDeviceProvider::QueryDevicesOnAdbThread(
+    const QueryDevicesCallback& callback) {
+  DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
+
+  AdbClientSocket::AdbQuery(
+      kAdbPort, kHostDevicesCommand,
+      base::Bind(&AdbDeviceProvider::ReceivedAdbDevices, this, callback));
+}
+
+void AdbDeviceProvider::ReceivedAdbDevices(const QueryDevicesCallback& 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("", true));
+#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);
+    bool offline = tokens.size() > 1 && tokens[1] == "offline";
+    result.push_back(new AdbDeviceImpl(tokens[0], !offline));
+  }
+
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&AdbDeviceProvider::RunCallbackOnUIThread,
+                          callback, result));
+}
+
+// UsbDeviceProvider -------------------------------------------
+
+class UsbDeviceProvider: public AndroidDeviceProvider {
+ public:
+  explicit UsbDeviceProvider(Profile* profile);
+
+  virtual void QueryDevices(const QueryDevicesCallback& callback) OVERRIDE;
+ private:
+  virtual ~UsbDeviceProvider();
+  void WrapDevicesOnAdbThread(const QueryDevicesCallback& callback,
+                              const AndroidUsbDevices& devices);
+  void EnumeratedDevices(const QueryDevicesCallback& callback,
+                         const AndroidUsbDevices& devices);
+
+  scoped_ptr<crypto::RSAPrivateKey>  rsa_key_;
+};
+
+UsbDeviceProvider::UsbDeviceProvider(Profile* profile){
+  rsa_key_.reset(AndroidRSAPrivateKey(profile));
+}
+
+UsbDeviceProvider::~UsbDeviceProvider() {
+}
+
+void UsbDeviceProvider::QueryDevices(const QueryDevicesCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  AndroidUsbDevice::Enumerate(rsa_key_.get(),
+                              base::Bind(&UsbDeviceProvider::EnumeratedDevices,
+                              this, callback));
+}
+
+void UsbDeviceProvider::EnumeratedDevices(const QueryDevicesCallback& callback,
+                                          const AndroidUsbDevices& devices) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  adb_thread_->message_loop()->PostTask(FROM_HERE,
+                          base::Bind(&UsbDeviceProvider::WrapDevicesOnAdbThread,
+                          this, callback, devices));
+}
+
+void UsbDeviceProvider::WrapDevicesOnAdbThread(
+    const QueryDevicesCallback& callback,const AndroidUsbDevices& devices) {
+  DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
+  AndroidDevices result;
+  for (AndroidUsbDevices::const_iterator it = devices.begin();
+      it != devices.end(); ++it)
+    result.push_back(new UsbDeviceImpl(*it));
+
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&UsbDeviceProvider::RunCallbackOnUIThread,
+                          callback, result));
+}
+
+} // namespace
+
+// AndroidDevice -------------------------------------------
+
+AndroidDevice::AndroidDevice(const std::string& serial, bool is_connected)
+    : serial_(serial),
+      is_connected_(is_connected) {
+}
+
+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);
+}
+
+// AdbCountDevicesCommand -----------------------------------------------------
+// TODO(zvorygin): Remove this class.
+class AdbCountDevicesCommand : public base::RefCountedThreadSafe<
+    AdbCountDevicesCommand, BrowserThread::DeleteOnUIThread> {
+ public:
+  typedef base::Callback<void(int)> Callback;
+
+  AdbCountDevicesCommand(
+      scoped_refptr<RefCountedAdbThread> adb_thread,
+      const Callback& callback);
+
+ private:
+  friend struct BrowserThread::DeleteOnThread<
+      BrowserThread::UI>;
+  friend class base::DeleteHelper<AdbCountDevicesCommand>;
+
+  virtual ~AdbCountDevicesCommand();
+  void RequestAdbDeviceCount();
+  void ReceivedAdbDeviceCount(int result, const std::string& response);
+  void Respond(int count);
+
+  scoped_refptr<RefCountedAdbThread> adb_thread_;
+  Callback callback_;
+};
+
+AdbCountDevicesCommand::AdbCountDevicesCommand(
+    scoped_refptr<RefCountedAdbThread> adb_thread,
+    const Callback& callback)
+    : adb_thread_(adb_thread),
+      callback_(callback) {
+  adb_thread_->message_loop()->PostTask(
+      FROM_HERE, base::Bind(&AdbCountDevicesCommand::RequestAdbDeviceCount,
+                            this));
+}
+
+AdbCountDevicesCommand::~AdbCountDevicesCommand() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+}
+
+void AdbCountDevicesCommand::RequestAdbDeviceCount() {
+  DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
+  AdbClientSocket::AdbQuery(
+      kAdbPort, kHostDevicesCommand,
+      base::Bind(&AdbCountDevicesCommand::ReceivedAdbDeviceCount, this));
+}
+
+void AdbCountDevicesCommand::ReceivedAdbDeviceCount(
+    int result,
+    const std::string& response) {
+  DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
+  std::vector<std::string> serials;
+  Tokenize(response, "\n", &serials);
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&AdbCountDevicesCommand::Respond, this, serials.size()));
+}
+
+void AdbCountDevicesCommand::Respond(int count) {
+  callback_.Run(count);
+}
+
+// AndroidDeviceProvider ---------------------------------------------------
+
+AndroidDeviceProvider::AndroidDeviceProvider()
+  : adb_thread_(RefCountedAdbThread::GetInstance()) {
+
+}
+
+AndroidDeviceProvider::~AndroidDeviceProvider() {
+}
+
+// static
+void AndroidDeviceProvider::RunCallbackOnUIThread(
+    const QueryDevicesCallback& callback,
+    const AndroidDevices& result) {
+  callback.Run(result);
+}
+
+// static
+void AndroidDeviceProvider::CountDevices(bool discover_usb_devices,
+    const base::Callback<void(int)>& callback) {
+  if (discover_usb_devices) {
+    AndroidUsbDevice::CountDevices(callback);
+    return;
+  }
+
+  new AdbCountDevicesCommand(RefCountedAdbThread::GetInstance(), callback);
+}
+
+// static
+scoped_refptr<AndroidDeviceProvider>
+    AndroidDeviceProvider::GetUsbDeviceProvider(Profile* profile) {
+  return new UsbDeviceProvider(profile);
+}
+
+// static
+scoped_refptr<AndroidDeviceProvider>
+    AndroidDeviceProvider::GetAdbDeviceProvider() {
+  return new AdbDeviceProvider();
+}