DevTools: Extract ADB specific requests from DevToolsAndroidBridge into a separate class.

BUG=None

Review URL: https://codereview.chromium.org/274573002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@271071 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/devtools/device/adb/adb_device_info_query.h

+// Copyright 2014 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.
+
+#ifndef CHROME_BROWSER_DEVTOOLS_DEVICE_ADB_ADB_DEVICE_INFO_QUERY_H_
+#define CHROME_BROWSER_DEVTOOLS_DEVICE_ADB_ADB_DEVICE_INFO_QUERY_H_
+
+#include "base/threading/non_thread_safe.h"
+#include "chrome/browser/devtools/device/android_device_manager.h"
+
+class AdbDeviceInfoQuery : public base::NonThreadSafe {
+ public:
+  static AndroidDeviceManager::BrowserInfo::Type GetBrowserType(
+      const std::string& socket);
+
+  static std::string GetDisplayName(const std::string& socket,
+                                    const std::string& package);
+
+  typedef AndroidDeviceManager::CommandCallback CommandCallback;
+  typedef AndroidDeviceManager::DeviceInfoCallback DeviceInfoCallback;
+
+  typedef base::Callback<
+      void(const std::string&, const CommandCallback&)> RunCommandCallback;
+
+  static void Start(const RunCommandCallback& command_callback,
+                    const DeviceInfoCallback& callback);
+
+ private:
+  AdbDeviceInfoQuery(const RunCommandCallback& command_callback,
+                     const DeviceInfoCallback& callback);
+
+  virtual ~AdbDeviceInfoQuery();
+
+  void ReceivedModel(int result, const std::string& response);
+
+  void ReceivedDumpsys(int result, const std::string& response);
+
+  void ParseDumpsysResponse(const std::string& response);
+
+  void ParseScreenSize(const std::string& str);
+
+  void ReceivedPackages(int result, const std::string& response);
+
+  void ReceivedProcesses(const std::string& packages_response,
+                         int result,
+                         const std::string& processes_response);
+
+  void ReceivedSockets(const std::string& packages_response,
+                       const std::string& processes_response,
+                       int result,
+                       const std::string& sockets_response);
+
+  void ParseBrowserInfo(const std::string& packages_response,
+                        const std::string& processes_response,
+                        const std::string& sockets_response);
+
+  void Respond();
+
+  RunCommandCallback command_callback_;
+  DeviceInfoCallback callback_;
+  AndroidDeviceManager::DeviceInfo device_info_;
+
+  DISALLOW_COPY_AND_ASSIGN(AdbDeviceInfoQuery);
+};
+
+#endif  // CHROME_BROWSER_DEVTOOLS_DEVICE_ADB_ADB_DEVICE_INFO_QUERY_H_

chrome/browser/devtools/device/adb/adb_device_provider.cc

@@ -7,6 +7,7 @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/devtools/device/adb/adb_client_socket.h"
+#include "chrome/browser/devtools/device/adb/adb_device_info_query.h"
 
 namespace {
 
@@ -19,26 +20,24 @@ const int kAdbPort = 5037;
 class AdbDeviceImpl : public AndroidDeviceManager::Device {
  public:
   AdbDeviceImpl(const std::string& serial, bool is_connected);
-
-  virtual void RunCommand(const std::string& command,
-                          const CommandCallback& callback) OVERRIDE;
+  virtual void QueryDeviceInfo(const DeviceInfoCallback& callback) OVERRIDE;
 
   virtual void OpenSocket(const std::string& name,
                           const SocketCallback& callback) OVERRIDE;
  private:
   virtual ~AdbDeviceImpl() {}
+
+  void RunCommand(const std::string& command,
+                  const CommandCallback& callback);
 };
 
 AdbDeviceImpl::AdbDeviceImpl(const std::string& serial, bool is_connected)
     : Device(serial, is_connected) {
 }
 
-void AdbDeviceImpl::RunCommand(const std::string& command,
-                               const CommandCallback& callback) {
-  DCHECK(CalledOnValidThread());
-  std::string query = base::StringPrintf(kHostTransportCommand,
-                                         serial().c_str(), command.c_str());
-  AdbClientSocket::AdbQuery(kAdbPort, query, callback);
+void AdbDeviceImpl::QueryDeviceInfo(const DeviceInfoCallback& callback) {
+  AdbDeviceInfoQuery::Start(
+      base::Bind(&AdbDeviceImpl::RunCommand, this), callback);
 }
 
 void AdbDeviceImpl::OpenSocket(const std::string& name,
@@ -49,6 +48,14 @@ void AdbDeviceImpl::OpenSocket(const std::string& name,
   AdbClientSocket::TransportQuery(kAdbPort, serial(), socket_name, callback);
 }
 
+void AdbDeviceImpl::RunCommand(const std::string& command,
+                               const CommandCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  std::string query = base::StringPrintf(kHostTransportCommand,
+                                         serial().c_str(), command.c_str());
+  AdbClientSocket::AdbQuery(kAdbPort, query, callback);
+}
+
 // static
 void ReceivedAdbDevices(
     const AdbDeviceProvider::QueryDevicesCallback& callback,

chrome/browser/devtools/device/android_device_manager.cc

@@ -11,8 +11,6 @@
 #include "net/base/net_errors.h"
 #include "net/socket/stream_socket.h"
 
-using content::BrowserThread;
-
 namespace {
 
 const int kBufferSize = 16 * 1024;
@@ -176,6 +174,16 @@ class HttpRequest {
 
 } // namespace
 
+AndroidDeviceManager::BrowserInfo::BrowserInfo()
+    : type(kTypeOther) {
+}
+
+AndroidDeviceManager::DeviceInfo::DeviceInfo() {
+}
+
+AndroidDeviceManager::DeviceInfo::~DeviceInfo() {
+}
+
 AndroidDeviceManager::Device::Device(const std::string& serial,
                                      bool is_connected)
     : serial_(serial),
@@ -217,16 +225,14 @@ bool AndroidDeviceManager::IsConnected(const std::string& serial) {
   return device && device->is_connected();
 }
 
-void AndroidDeviceManager::RunCommand(
-    const std::string& serial,
-    const std::string& command,
-    const CommandCallback& callback) {
+void AndroidDeviceManager::QueryDeviceInfo(const std::string& serial,
+                                           const DeviceInfoCallback& callback) {
   DCHECK(CalledOnValidThread());
   Device* device = FindDevice(serial);
   if (device)
-    device->RunCommand(command, callback);
+    device->QueryDeviceInfo(callback);
   else
-    callback.Run(net::ERR_CONNECTION_FAILED, std::string());
+    callback.Run(DeviceInfo());
 }
 
 void AndroidDeviceManager::OpenSocket(

chrome/browser/devtools/device/android_device_manager.h

@@ -11,6 +11,7 @@
 #include "base/threading/non_thread_safe.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
+#include "ui/gfx/size.h"
 
 namespace net {
 class StreamSocket;
@@ -23,6 +24,31 @@ class AndroidDeviceManager
   typedef base::Callback<void(int, const std::string&)> CommandCallback;
   typedef base::Callback<void(int result, net::StreamSocket*)> SocketCallback;
 
+  struct BrowserInfo {
+    BrowserInfo();
+
+    enum Type {
+      kTypeChrome,
+      kTypeWebView,
+      kTypeOther
+    };
+
+    std::string socket_name;
+    std::string display_name;
+    Type type;
+  };
+
+  struct DeviceInfo {
+    DeviceInfo();
+    ~DeviceInfo();
+
+    std::string model;
+    gfx::Size screen_size;
+    std::vector<BrowserInfo> browser_info;
+  };
+
+  typedef base::Callback<void(const DeviceInfo&)> DeviceInfoCallback;
+
   class Device : public base::RefCounted<Device>,
                  public base::NonThreadSafe {
    protected:
@@ -30,11 +56,12 @@ class AndroidDeviceManager
 
     typedef AndroidDeviceManager::CommandCallback CommandCallback;
     typedef AndroidDeviceManager::SocketCallback SocketCallback;
+    typedef AndroidDeviceManager::DeviceInfoCallback DeviceInfoCallback;
 
     Device(const std::string& serial, bool is_connected);
 
-    virtual void RunCommand(const std::string& command,
-                            const CommandCallback& callback) = 0;
+    virtual void QueryDeviceInfo(const DeviceInfoCallback& callback) = 0;
+
     virtual void OpenSocket(const std::string& socket_name,
                             const SocketCallback& callback) = 0;
 
@@ -87,9 +114,8 @@ class AndroidDeviceManager
 
   bool IsConnected(const std::string& serial);
 
-  void RunCommand(const std::string& serial,
-                  const std::string& command,
-                  const CommandCallback& callback);
+  void QueryDeviceInfo(const std::string& serial,
+                       const DeviceInfoCallback& callback);
 
   void OpenSocket(const std::string& serial,
                   const std::string& socket_name,

chrome/browser/devtools/device/devtools_android_bridge.h

@@ -113,7 +113,7 @@ class DevToolsAndroidBridge
     RemoteBrowser(
         scoped_refptr<DevToolsAndroidBridge> android_bridge,
         const std::string& serial,
-        const std::string& socket);
+        const AndroidDeviceManager::BrowserInfo& browser_info);
 
     std::string serial() { return serial_; }
     std::string socket() { return socket_; }
@@ -125,6 +125,7 @@ class DevToolsAndroidBridge
     void set_version(const std::string& version) { version_ = version; }
 
     bool IsChrome() const;
+    bool IsWebView() const;
 
     typedef std::vector<int> ParsedVersion;
     ParsedVersion GetParsedVersion() const;
@@ -174,6 +175,7 @@ class DevToolsAndroidBridge
     const std::string serial_;
     const std::string socket_;
     std::string display_name_;
+    const AndroidDeviceManager::BrowserInfo::Type type_;
     std::string version_;
     scoped_ptr<base::ListValue> page_descriptors_;
 
@@ -186,17 +188,14 @@ class DevToolsAndroidBridge
    public:
     RemoteDevice(scoped_refptr<DevToolsAndroidBridge> android_bridge,
                  const std::string& serial,
-                 const std::string& model,
+                 const AndroidDeviceManager::DeviceInfo& device_info,
                  bool connected);
 
     std::string serial() { return serial_; }
     std::string model() { return model_; }
     bool is_connected() { return connected_; }
-    void AddBrowser(scoped_refptr<RemoteBrowser> browser);
-
     RemoteBrowsers& browsers() { return browsers_; }
     gfx::Size screen_size() { return screen_size_; }
-    void set_screen_size(const gfx::Size& size) { screen_size_ = size; }
 
     void OpenSocket(const std::string& socket_name,
                     const AndroidDeviceManager::SocketCallback& callback);

chrome/browser/devtools/device/self_device_provider.cc

@@ -10,32 +10,19 @@
 
 namespace {
 
-const char kDeviceModelCommand[] = "shell:getprop ro.product.model";
-const char kOpenedUnixSocketsCommand[] = "shell:cat /proc/net/unix";
-const char kOpenedUnixSocketsResponse[] =
-    "Num       RefCount Protocol Flags    Type St Inode Path\n"
-    "00000000: 00000002 00000000 00010000 0001 01 20894 @%s\n";
-const char kRemoteDebuggingSocket[] = "chrome_devtools_remote";
-
 const char kDeviceModel[] = "Local Chrome";
+const char kBrowserName[] = "Chrome";
 const char kLocalhost[] = "127.0.0.1";
 
 class SelfAsDevice : public AndroidDeviceManager::Device {
  public:
   explicit SelfAsDevice(int port);
 
-  virtual void RunCommand(const std::string& command,
-                          const CommandCallback& callback) OVERRIDE;
+  virtual void QueryDeviceInfo(const DeviceInfoCallback& callback) OVERRIDE;
+
   virtual void OpenSocket(const std::string& socket_name,
                           const SocketCallback& callback) OVERRIDE;
  private:
-  void RunCommandCallback(const CommandCallback& callback,
-                          const std::string& response,
-                          int result);
-
-  void RunSocketCallback(const SocketCallback& callback,
-                         net::StreamSocket* socket,
-                         int result);
   virtual ~SelfAsDevice() {}
 
   int port_;
@@ -46,32 +33,26 @@ SelfAsDevice::SelfAsDevice(int port)
       port_(port)
 {}
 
-void SelfAsDevice::RunCommandCallback(const CommandCallback& callback,
-                                      const std::string& response,
-                                      int result) {
-  callback.Run(result, response);
-}
+void SelfAsDevice::QueryDeviceInfo(const DeviceInfoCallback& callback) {
+  AndroidDeviceManager::DeviceInfo device_info;
+  device_info.model = kDeviceModel;
 
-void SelfAsDevice::RunSocketCallback(const SocketCallback& callback,
-                                     net::StreamSocket* socket,
-                                     int result) {
-  callback.Run(result, socket);
+  AndroidDeviceManager::BrowserInfo browser_info;
+  browser_info.socket_name = base::IntToString(port_);
+  browser_info.display_name = kBrowserName;
+  browser_info.type = AndroidDeviceManager::BrowserInfo::kTypeChrome;
+
+  device_info.browser_info.push_back(browser_info);
+
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, device_info));
 }
 
-void SelfAsDevice::RunCommand(const std::string& command,
-                              const CommandCallback& callback) {
-  DCHECK(CalledOnValidThread());
-  std::string response;
-  if (command == kDeviceModelCommand) {
-    response = kDeviceModel;
-  } else if (command == kOpenedUnixSocketsCommand) {
-    response = base::StringPrintf(kOpenedUnixSocketsResponse,
-                                  kRemoteDebuggingSocket);
-  }
-
-  base::MessageLoop::current()->PostTask(FROM_HERE,
-                base::Bind(&SelfAsDevice::RunCommandCallback, this, callback,
-                           response, 0));
+static void RunSocketCallback(
+    const AndroidDeviceManager::SocketCallback& callback,
+    net::StreamSocket* socket,
+    int result) {
+  callback.Run(result, socket);
 }
 
 void SelfAsDevice::OpenSocket(const std::string& socket_name,
@@ -81,19 +62,13 @@ void SelfAsDevice::OpenSocket(const std::string& socket_name,
   // (debugging purposes).
   net::IPAddressNumber ip_number;
   net::ParseIPLiteralToNumber(kLocalhost, &ip_number);
-
-  int port = 0;
-  if (socket_name == kRemoteDebuggingSocket)
-    port = port_;
-  else
-    base::StringToInt(socket_name, &port);
-
+  int port;
+  base::StringToInt(socket_name, &port);
   net::AddressList address_list =
       net::AddressList::CreateFromIPAddress(ip_number, port);
   net::TCPClientSocket* socket = new net::TCPClientSocket(
       address_list, NULL, net::NetLog::Source());
-  socket->Connect(base::Bind(&SelfAsDevice::RunSocketCallback, this, callback,
-                             socket));
+  socket->Connect(base::Bind(&RunSocketCallback, callback, socket));
 }
 
 } // namespace

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

@@ -5,6 +5,7 @@
 #include "chrome/browser/devtools/device/usb/usb_device_provider.h"
 
 #include "base/strings/stringprintf.h"
+#include "chrome/browser/devtools/device/adb/adb_device_info_query.h"
 #include "chrome/browser/devtools/device/usb/android_rsa.h"
 #include "chrome/browser/devtools/device/usb/android_usb_device.h"
 #include "crypto/rsa_private_key.h"
@@ -21,8 +22,7 @@ class UsbDeviceImpl : public AndroidDeviceManager::Device {
  public:
   explicit UsbDeviceImpl(AndroidUsbDevice* device);
 
-  virtual void RunCommand(const std::string& command,
-                          const CommandCallback& callback) OVERRIDE;
+  virtual void QueryDeviceInfo(const DeviceInfoCallback& callback) OVERRIDE;
 
   virtual void OpenSocket(const std::string& name,
                           const SocketCallback& callback) OVERRIDE;
@@ -30,6 +30,8 @@ class UsbDeviceImpl : public AndroidDeviceManager::Device {
   void OnOpenSocket(const SocketCallback& callback,
                     net::StreamSocket* socket,
                     int result);
+  void RunCommand(const std::string& command,
+                  const CommandCallback& callback);
   void OpenedForCommand(const CommandCallback& callback,
                         net::StreamSocket* socket,
                         int result);
@@ -50,18 +52,9 @@ UsbDeviceImpl::UsbDeviceImpl(AndroidUsbDevice* device)
   device_->InitOnCallerThread();
 }
 
-void UsbDeviceImpl::RunCommand(const std::string& command,
-                               const CommandCallback& callback) {
-  DCHECK(CalledOnValidThread());
-  net::StreamSocket* socket = device_->CreateSocket(command);
-  if (!socket) {
-    callback.Run(net::ERR_CONNECTION_FAILED, std::string());
-    return;
-  }
-  int result = socket->Connect(base::Bind(&UsbDeviceImpl::OpenedForCommand,
-                                          this, callback, socket));
-  if (result != net::ERR_IO_PENDING)
-    callback.Run(result, std::string());
+void UsbDeviceImpl::QueryDeviceInfo(const DeviceInfoCallback& callback) {
+  AdbDeviceInfoQuery::Start(
+      base::Bind(&UsbDeviceImpl::RunCommand, this), callback);
 }
 
 void UsbDeviceImpl::OpenSocket(const std::string& name,
@@ -86,6 +79,20 @@ void UsbDeviceImpl::OnOpenSocket(const SocketCallback& callback,
   callback.Run(result, result == net::OK ? socket : NULL);
 }
 
+void UsbDeviceImpl::RunCommand(const std::string& command,
+                               const CommandCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  net::StreamSocket* socket = device_->CreateSocket(command);
+  if (!socket) {
+    callback.Run(net::ERR_CONNECTION_FAILED, std::string());
+    return;
+  }
+  int result = socket->Connect(base::Bind(&UsbDeviceImpl::OpenedForCommand,
+                                          this, callback, socket));
+  if (result != net::ERR_IO_PENDING)
+    callback.Run(result, std::string());
+}
+
 void UsbDeviceImpl::OpenedForCommand(const CommandCallback& callback,
                                      net::StreamSocket* socket,
                                      int result) {

chrome/chrome_debugger.gypi

@@ -30,6 +30,8 @@
       'sources': [
         'browser/devtools/device/adb/adb_client_socket.cc',
         'browser/devtools/device/adb/adb_client_socket.h',
+        'browser/devtools/device/adb/adb_device_info_query.cc',
+        'browser/devtools/device/adb/adb_device_info_query.h',
         'browser/devtools/device/adb/adb_device_provider.cc',
         'browser/devtools/device/adb/adb_device_provider.h',
         'browser/devtools/device/android_device_manager.cc',

tools/gn/secondary/chrome/BUILD.gn

@@ -96,6 +96,8 @@ source_set("debugger") {
   sources = [
     "browser/devtools/device/adb/adb_client_socket.cc",
     "browser/devtools/device/adb/adb_client_socket.h",
+    "browser/devtools/device/adb/adb_device_info_query.h",
+    "browser/devtools/device/adb/adb_device_info_query.cc",
     "browser/devtools/device/adb/adb_device_provider.cc",
     "browser/devtools/device/adb/adb_device_provider.h",
     "browser/devtools/device/android_device_manager.cc",