src/chrome/browser/devtools/device/usb/usb_device_provider.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/devtools/device/usb/usb_device_provider.h"
   6
   7 #include "base/strings/stringprintf.h"
   8 #include "chrome/browser/devtools/device/adb/adb_device_info_query.h"
   9 #include "chrome/browser/devtools/device/usb/android_rsa.h"
  10 #include "chrome/browser/devtools/device/usb/android_usb_device.h"
  11 #include "crypto/rsa_private_key.h"
  12 #include "net/base/net_errors.h"
  13 #include "net/socket/stream_socket.h"
  14
  15 namespace {
  16
  17 const char kLocalAbstractCommand[] = "localabstract:%s";
  18
  19 const int kBufferSize = 16 * 1024;
  20
  21 void OnOpenSocket(const UsbDeviceProvider::SocketCallback& callback,
  22                   net::StreamSocket* socket_raw,
  23                   int result) {
  24   scoped_ptr<net::StreamSocket> socket(socket_raw);
  25   if (result != net::OK)
  26     socket.reset();
  27   callback.Run(result, socket.Pass());
  28 }
  29
  30 void OnRead(net::StreamSocket* socket,
  31             scoped_refptr<net::IOBuffer> buffer,
  32             const std::string& data,
  33             const UsbDeviceProvider::CommandCallback& callback,
  34             int result) {
  35   if (result <= 0) {
  36     callback.Run(result, result == 0 ? data : std::string());
  37     delete socket;
  38     return;
  39   }
  40
  41   std::string new_data = data + std::string(buffer->data(), result);
  42   result =
  43       socket->Read(buffer.get(),
  44                    kBufferSize,
  45                    base::Bind(&OnRead, socket, buffer, new_data, callback));
  46   if (result != net::ERR_IO_PENDING)
  47     OnRead(socket, buffer, new_data, callback, result);
  48 }
  49
  50 void OpenedForCommand(const UsbDeviceProvider::CommandCallback& callback,
  51                       net::StreamSocket* socket,
  52                       int result) {
  53   if (result != net::OK) {
  54     callback.Run(result, std::string());
  55     return;
  56   }
  57   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kBufferSize);
  58   result = socket->Read(
  59       buffer.get(),
  60       kBufferSize,
  61       base::Bind(&OnRead, socket, buffer, std::string(), callback));
  62   if (result != net::ERR_IO_PENDING)
  63     OnRead(socket, buffer, std::string(), callback, result);
  64 }
  65
  66 void RunCommand(scoped_refptr<AndroidUsbDevice> device,
  67                 const std::string& command,
  68                 const UsbDeviceProvider::CommandCallback& callback) {
  69   net::StreamSocket* socket = device->CreateSocket(command);
  70   if (!socket) {
  71     callback.Run(net::ERR_CONNECTION_FAILED, std::string());
  72     return;
  73   }
  74   int result = socket->Connect(
  75       base::Bind(&OpenedForCommand, callback, socket));
  76   if (result != net::ERR_IO_PENDING)
  77     callback.Run(result, std::string());
  78 }
  79
  80 } // namespace
  81
  82 // static
  83 void UsbDeviceProvider::CountDevices(
  84     const base::Callback<void(int)>& callback) {
  85   AndroidUsbDevice::CountDevices(callback);
  86 }
  87
  88 UsbDeviceProvider::UsbDeviceProvider(Profile* profile){
  89   rsa_key_.reset(AndroidRSAPrivateKey(profile));
  90 }
  91
  92 void UsbDeviceProvider::QueryDevices(const SerialsCallback& callback) {
  93   AndroidUsbDevice::Enumerate(
  94       rsa_key_.get(),
  95       base::Bind(&UsbDeviceProvider::EnumeratedDevices, this, callback));
  96 }
  97
  98 void UsbDeviceProvider::QueryDeviceInfo(const std::string& serial,
  99                                         const DeviceInfoCallback& callback) {
 100   UsbDeviceMap::iterator it = device_map_.find(serial);
 101   if (it == device_map_.end() || !it->second->is_connected()) {
 102     AndroidDeviceManager::DeviceInfo offline_info;
 103     callback.Run(offline_info);
 104     return;
 105   }
 106   AdbDeviceInfoQuery::Start(base::Bind(&RunCommand, it->second), callback);
 107 }
 108
 109 void UsbDeviceProvider::OpenSocket(const std::string& serial,
 110                                    const std::string& name,
 111                                    const SocketCallback& callback) {
 112   UsbDeviceMap::iterator it = device_map_.find(serial);
 113   if (it == device_map_.end()) {
 114     callback.Run(net::ERR_CONNECTION_FAILED,
 115                  make_scoped_ptr<net::StreamSocket>(NULL));
 116     return;
 117   }
 118   std::string socket_name =
 119       base::StringPrintf(kLocalAbstractCommand, name.c_str());
 120   net::StreamSocket* socket = it->second->CreateSocket(socket_name);
 121   if (!socket) {
 122     callback.Run(net::ERR_CONNECTION_FAILED,
 123                  make_scoped_ptr<net::StreamSocket>(NULL));
 124     return;
 125   }
 126   int result = socket->Connect(base::Bind(&OnOpenSocket, callback, socket));
 127   if (result != net::ERR_IO_PENDING)
 128     callback.Run(result, make_scoped_ptr<net::StreamSocket>(NULL));
 129 }
 130
 131 void UsbDeviceProvider::ReleaseDevice(const std::string& serial) {
 132   device_map_.erase(serial);
 133 }
 134
 135 UsbDeviceProvider::~UsbDeviceProvider() {
 136 }
 137
 138 void UsbDeviceProvider::EnumeratedDevices(const SerialsCallback& callback,
 139                                           const AndroidUsbDevices& devices) {
 140   std::vector<std::string> result;
 141   device_map_.clear();
 142   for (AndroidUsbDevices::const_iterator it = devices.begin();
 143        it != devices.end(); ++it) {
 144     result.push_back((*it)->serial());
 145     device_map_[(*it)->serial()] = *it;
 146     (*it)->InitOnCallerThread();
 147   }
 148   callback.Run(result);
 149 }
 150