DevTools: display 'Pending authentication' message upon raw usb debugging.

chrome/browser/devtools/devtools_adb_bridge.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_adb_bridge.h"
 
 #include <map>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 66 matching lines @@
 
 // AdbDeviceImpl --------------------------------------------------------------
 
 class AdbDeviceImpl : public DevToolsAdbBridge::AndroidDevice {
  public:
   explicit AdbDeviceImpl(const std::string& serial);
   virtual void RunCommand(const std::string& command,
                           const CommandCallback& callback) OVERRIDE;
   virtual void OpenSocket(const std::string& name,
                           const SocketCallback& callback) OVERRIDE;
+  virtual bool IsConnected() OVERRIDE;
+
  private:
   virtual ~AdbDeviceImpl() {}
 };
 
 AdbDeviceImpl::AdbDeviceImpl(const std::string& serial)
     : AndroidDevice(serial) {
 }
 
 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);
 }
 
+bool AdbDeviceImpl::IsConnected() {
+  return true;
+}
+
 
 // UsbDeviceImpl --------------------------------------------------------------
 
 class UsbDeviceImpl : public DevToolsAdbBridge::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;
+  virtual bool IsConnected() 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,
@@ skipping 65 matching lines @@
   }
 
   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);
 }
 
+bool UsbDeviceImpl::IsConnected() {
+  return device_->is_connected();
+}
+
 
 // AdbCountDevicesCommand -----------------------------------------------------
 
 class AdbCountDevicesCommand : public base::RefCountedThreadSafe<
     AdbCountDevicesCommand,
     content::BrowserThread::DeleteOnUIThread> {
  public:
   typedef base::Callback<void(int)> Callback;
 
   AdbCountDevicesCommand(
@@ skipping 177 matching lines @@
     remote_devices_->back()->AddBrowser(remote_browser);
     browsers_.push_back(remote_browser);
     device->HttpQuery(
         std::string(), kVersionRequest,
         base::Bind(&AdbPagesCommand::ReceivedVersion, this));
     return;
   }
 #endif  // defined(DEBUG_DEVTOOLS)
 
   scoped_refptr<DevToolsAdbBridge::AndroidDevice> device = devices_.back();
-  device->RunCommand(kDeviceModelCommand,
-                     base::Bind(&AdbPagesCommand::ReceivedModel, this));
+  if (device->IsConnected()) {
+    device->RunCommand(kDeviceModelCommand,
+                       base::Bind(&AdbPagesCommand::ReceivedModel, this));
+  } else {
+    remote_devices_->push_back(new DevToolsAdbBridge::RemoteDevice(device));
+    devices_.pop_back();
+    ProcessSerials();
+  }
 }
 
 void AdbPagesCommand::ReceivedModel(int result, const std::string& response) {
   DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
   if (result < 0) {
     devices_.pop_back();
     ProcessSerials();
     return;
   }
   scoped_refptr<DevToolsAdbBridge::AndroidDevice> device = devices_.back();
@@ skipping 219 matching lines @@
 
   int width;
   int height;
   std::vector<std::string> numbers;
   Tokenize(pairs[1].substr(1, pairs[1].size() - 2), ",", &numbers);
   if (numbers.size() != 2 ||
       !base::StringToInt(numbers[0], &width) ||
       !base::StringToInt(numbers[1], &height))
     return;
 
-  remote_devices_->back()->SetScreenSize(gfx::Size(width, height));
+  remote_devices_->back()->set_screen_size(gfx::Size(width, height));
 }
 
 
 // AdbProtocolCommand ---------------------------------------------------------
 
 class AdbProtocolCommand : public AdbWebSocket::Delegate {
  public:
   AdbProtocolCommand(
       scoped_refptr<DevToolsAdbBridge::RefCountedAdbThread> adb_thread,
       scoped_refptr<DevToolsAdbBridge::AndroidDevice> device,
@@ skipping 376 matching lines @@
 }
 
 
 // DevToolsAdbBridge::RemoteDevice --------------------------------------------
 
 DevToolsAdbBridge::RemoteDevice::RemoteDevice(
     scoped_refptr<AndroidDevice> device)
     : device_(device) {
 }
 
+std::string DevToolsAdbBridge::RemoteDevice::GetSerial() {
+  return device_->serial();
+}
+
+std::string DevToolsAdbBridge::RemoteDevice::GetModel() {
+  return device_->model();
+}
+
+bool DevToolsAdbBridge::RemoteDevice::IsConnected() {
+  return device_->IsConnected();
+}
+
+void DevToolsAdbBridge::RemoteDevice::AddBrowser(
+    scoped_refptr<RemoteBrowser> browser) {
+  browsers_.push_back(browser);
+}
+
 DevToolsAdbBridge::RemoteDevice::~RemoteDevice() {
 }
 
 
 // DevToolsAdbBridge::RefCountedAdbThread -------------------------------------
 
 DevToolsAdbBridge::RefCountedAdbThread*
 DevToolsAdbBridge::RefCountedAdbThread::instance_ = NULL;
 
 // static
@@ skipping 96 matching lines @@
 
   if (listeners_.empty())
     return;
 
   BrowserThread::PostDelayedTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&DevToolsAdbBridge::RequestRemoteDevices, this),
       base::TimeDelta::FromMilliseconds(kAdbPollingIntervalMs));
 }