chrome://inspect: Better support for multiple browsers and older versions of mobile Chrome

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 29 matching lines @@
 
 using content::BrowserThread;
 
 namespace {
 
 static const char kDevToolsAdbBridgeThreadName[] = "Chrome_DevToolsADBThread";
 static const char kHostDevicesCommand[] = "host:devices";
 static const char kHostTransportCommand[] = "host:transport:%s|%s";
 static const char kLocalAbstractCommand[] = "localabstract:%s";
 static const char kDeviceModelCommand[] = "shell:getprop ro.product.model";
-static const char kUnknownModel[] = "Unknown";
+static const char kLocalChrome[] = "Local Chrome";
+static const char kChrome[] = "Chrome";
 static const char kOpenedUnixSocketsCommand[] = "shell:cat /proc/net/unix";
 
 static const char kPageListRequest[] = "GET /json HTTP/1.1\r\n\r\n";
 static const char kVersionRequest[] = "GET /json/version HTTP/1.1\r\n\r\n";
 static const char kClosePageRequest[] = "GET /json/close/%s HTTP/1.1\r\n\r\n";
 static const char kNewPageRequest[] = "GET /json/new HTTP/1.1\r\n\r\n";
 const int kAdbPort = 5037;
 const int kBufferSize = 16 * 1024;
 const int kAdbPollingIntervalMs = 1000;
 
@@ skipping 144 matching lines @@
           BrowserThread::UI, FROM_HERE,
           base::Bind(&AdbPagesCommand::Respond, this));
       return;
     }
 
 #if defined(DEBUG_DEVTOOLS)
     // For desktop remote debugging.
     if (devices_.back()->serial().empty()) {
       scoped_refptr<DevToolsAdbBridge::AndroidDevice> device =
           devices_.back();
-      sockets_.push_back(std::string());
-      device->set_model(kUnknownModel);
+      device->set_model(kLocalChrome);
       remote_devices_->push_back(
           new DevToolsAdbBridge::RemoteDevice(bridge_, device));
+      scoped_refptr<DevToolsAdbBridge::RemoteBrowser> remote_browser =
+          new DevToolsAdbBridge::RemoteBrowser(bridge_, device, std::string());
+      remote_browser->set_product(kChrome);
+      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));
@@ skipping 17 matching lines @@
   void ReceivedSockets(int result,
                        const std::string& response) {
     DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
     if (result < 0) {
       devices_.pop_back();
       ProcessSerials();
       return;
     }
 
     ParseSocketsList(response);
-    if (sockets_.size() == 0) {
+    if (browsers_.size() == 0) {
       devices_.pop_back();
       ProcessSerials();
     } else {
       ProcessSockets();
     }
   }
 
   void ProcessSockets() {
     DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
-    if (sockets_.size() == 0) {
+    if (browsers_.size() == 0) {
       devices_.pop_back();
       ProcessSerials();
     } else {
       scoped_refptr<DevToolsAdbBridge::AndroidDevice> device = devices_.back();
-      device->HttpQuery(sockets_.back(), kVersionRequest,
+      device->HttpQuery(browsers_.back()->socket(), kVersionRequest,
                         base::Bind(&AdbPagesCommand::ReceivedVersion, this));
     }
   }
 
   void ReceivedVersion(int result,
                        const std::string& response) {
     DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
     if (result < 0) {
-      sockets_.pop_back();
+      browsers_.pop_back();
       ProcessSockets();
       return;
     }
 
     // Parse version, append to package name if available,
     scoped_ptr<base::Value> value(base::JSONReader::Read(response));
     base::DictionaryValue* dict;
     if (value && value->GetAsDictionary(&dict)) {
       std::string browser;
       if (dict->GetString("Browser", &browser)) {
-        socket_to_package_[sockets_.back()] = base::StringPrintf(
-            "%s (%s)", socket_to_package_[sockets_.back()].c_str(),
-            browser.c_str());
+        std::vector<std::string> parts;
+        Tokenize(browser, "/", &parts);
+        if (parts.size() == 2) {
+          if (parts[0] != "Version")  // WebView has this for legacy reasons.
+            browsers_.back()->set_product(parts[0]);
+          browsers_.back()->set_version(parts[1]);
+        } else {
+          browsers_.back()->set_version(browser);
+        }
       }
     }
 
     scoped_refptr<DevToolsAdbBridge::AndroidDevice> device = devices_.back();
-    device->HttpQuery(sockets_.back(), kPageListRequest,
+    device->HttpQuery(browsers_.back()->socket(), kPageListRequest,
                       base::Bind(&AdbPagesCommand::ReceivedPages, this));
   }
 
   void ReceivedPages(int result,
                      const std::string& response) {
     DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
-    std::string socket = sockets_.back();
-    sockets_.pop_back();
+    scoped_refptr<DevToolsAdbBridge::RemoteBrowser> browser = browsers_.back();
+    browsers_.pop_back();
     if (result < 0) {
       ProcessSockets();
       return;
     }
 
     scoped_ptr<base::Value> value(base::JSONReader::Read(response));
     base::ListValue* list_value;
     if (!value || !value->GetAsList(&list_value)) {
       ProcessSockets();
       return;
     }
 
-    scoped_refptr<DevToolsAdbBridge::AndroidDevice> device = devices_.back();
     base::Value* item;
 
-    scoped_refptr<DevToolsAdbBridge::RemoteBrowser> remote_browser =
-        new DevToolsAdbBridge::RemoteBrowser(
-            bridge_, device, socket, socket_to_package_[socket]);
-    remote_devices_->back()->AddBrowser(remote_browser);
-
     for (size_t i = 0; i < list_value->GetSize(); ++i) {
       list_value->Get(i, &item);
       base::DictionaryValue* dict;
       if (!item || !item->GetAsDictionary(&dict))
         continue;
-      remote_browser->AddPage(new DevToolsAdbBridge::RemotePage(
-          bridge_, device, remote_browser->socket(), *dict));
+      browser->AddPage(new DevToolsAdbBridge::RemotePage(
+          bridge_, browser->device(), browser->socket(), *dict));
     }
     ProcessSockets();
   }
 
   void Respond() {
     callback_.Run(remote_devices_.release());
   }
 
   void ParseSocketsList(const std::string& response) {
     // On Android, '/proc/net/unix' looks like this:
     //
     // Num       RefCount Protocol Flags    Type St Inode Path
     // 00000000: 00000002 00000000 00010000 0001 01 331813 /dev/socket/zygote
     // 00000000: 00000002 00000000 00010000 0001 01 358606 @xxx_devtools_remote
     // 00000000: 00000002 00000000 00010000 0001 01 347300 @yyy_devtools_remote
     //
     // We need to find records with paths starting from '@' (abstract socket)
     // and containing "devtools_remote". We have to extract the inode number
     // in order to find the owning process name.
 
-    socket_to_package_.clear();
+    scoped_refptr<DevToolsAdbBridge::RemoteDevice> remote_device =
+        remote_devices_->back();
+
     std::vector<std::string> entries;
     Tokenize(response, "\n", &entries);
     const std::string channel_pattern =
         base::StringPrintf(kDevToolsChannelNameFormat, "");
     for (size_t i = 1; i < entries.size(); ++i) {
       std::vector<std::string> fields;
       Tokenize(entries[i], " ", &fields);
       if (fields.size() < 8)
         continue;
       if (fields[3] != "00010000" || fields[5] != "01")
         continue;
       std::string path_field = fields[7];
       if (path_field.size() < 1 || path_field[0] != '@')
         continue;
       size_t socket_name_pos = path_field.find(channel_pattern);
       if (socket_name_pos == std::string::npos)
         continue;
       std::string socket = path_field.substr(1, path_field.size() - 2);
-      sockets_.push_back(socket);
       std::string package = path_field.substr(1, socket_name_pos - 1);
       if (socket_name_pos + channel_pattern.size() < path_field.size() - 1) {
         package += path_field.substr(
             socket_name_pos + channel_pattern.size(), path_field.size() - 1);
       }
       package[0] = base::ToUpperASCII(package[0]);
-      socket_to_package_[socket] = package;
+      scoped_refptr<DevToolsAdbBridge::RemoteBrowser> remote_browser =
+          new DevToolsAdbBridge::RemoteBrowser(
+              bridge_, remote_device->device(), socket);
+      remote_browser->set_product(package);
+      remote_device->AddBrowser(remote_browser);
     }
+    browsers_ = remote_device->browsers();
   }
 
   scoped_refptr<DevToolsAdbBridge> bridge_;
   Callback callback_;
   AndroidDevices devices_;
-  std::vector<std::string> sockets_;
-  std::map<std::string, std::string> socket_to_package_;
+  DevToolsAdbBridge::RemoteBrowsers browsers_;
   scoped_ptr<DevToolsAdbBridge::RemoteDevices> remote_devices_;
 };
 
 // AdbProtocolCommand ---------------------------------------------------------
 
 class AdbProtocolCommand : public AdbWebSocket::Delegate {
  public:
   AdbProtocolCommand(
       scoped_refptr<DevToolsAdbBridge> bridge_,
       scoped_refptr<DevToolsAdbBridge::AndroidDevice> device,
@@ skipping 277 matching lines @@
   new AdbProtocolCommand(
       bridge_, device_, socket_, debug_url_, command.Serialize());
 }
 
 DevToolsAdbBridge::RemotePage::~RemotePage() {
 }
 
 DevToolsAdbBridge::RemoteBrowser::RemoteBrowser(
     scoped_refptr<DevToolsAdbBridge> bridge,
     scoped_refptr<AndroidDevice> device,
-    const std::string& socket,
-    const std::string& name)
+    const std::string& socket)
     : bridge_(bridge),
       device_(device),
-      socket_(socket),
-      name_(name) {
+      socket_(socket) {
 }
 
 void DevToolsAdbBridge::RemoteBrowser::Open(const std::string& url) {
   bridge_->GetAdbMessageLoop()->PostTask(FROM_HERE,
       base::Bind(&AndroidDevice::HttpQuery,
           device_, socket_, kNewPageRequest,
           base::Bind(&RemoteBrowser::PageCreatedOnHandlerThread, this, url)));
 }
 
 void DevToolsAdbBridge::RemoteBrowser::PageCreatedOnHandlerThread(
@@ skipping 187 matching lines @@
 
   if (listeners_.empty())
     return;
 
   BrowserThread::PostDelayedTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&DevToolsAdbBridge::RequestRemoteDevices, this),
       base::TimeDelta::FromMilliseconds(kAdbPollingIntervalMs));
 }