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

chrome/browser/devtools/devtools_adb_bridge.cc

Index: chrome/browser/devtools/devtools_adb_bridge.cc
diff --git a/chrome/browser/devtools/devtools_adb_bridge.cc b/chrome/browser/devtools/devtools_adb_bridge.cc
index 2973fa266f732573079e73e283980ce3c66854ec..70166fdf207edc13a005d02368a0aedebfdc6a0e 100644
--- a/chrome/browser/devtools/devtools_adb_bridge.cc
+++ b/chrome/browser/devtools/devtools_adb_bridge.cc
@@ -47,7 +47,8 @@ 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";
@@ -212,10 +213,14 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
     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(), kChrome);
+      remote_devices_->back()->AddBrowser(remote_browser);
+      browsers_.push_back(remote_browser);

[pfeldman, 2013/08/08 16:25:14]

Why do you still need browsers_ given that device has them?

[Vladislav Kaznacheev, 2013/08/09 08:56:10]

We still need to iterate the browsers the same way we needed to iterate sockets.
On 2013/08/08 16:25:14, pfeldman wrote:

       device->HttpQuery(
           std::string(), kVersionRequest,
           base::Bind(&AdbPagesCommand::ReceivedVersion, this));
@@ -253,7 +258,7 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
     }
 
     ParseSocketsList(response);
-    if (sockets_.size() == 0) {
+    if (browsers_.size() == 0) {
       devices_.pop_back();
       ProcessSerials();
     } else {
@@ -263,12 +268,12 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
 
   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));
     }
   }
@@ -277,7 +282,7 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
                        const std::string& response) {
     DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
     if (result < 0) {
-      sockets_.pop_back();
+      browsers_.pop_back();
       ProcessSockets();
       return;
     }
@@ -287,23 +292,20 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
     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());
-      }
+      if (dict->GetString("Browser", &browser))
+        browsers_.back()->SetVersion(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;
@@ -316,21 +318,15 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
       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();
   }
@@ -351,7 +347,9 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
     // 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 =
@@ -370,22 +368,22 @@ class AdbPagesCommand : public base::RefCountedThreadSafe<
       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;
+      remote_device->AddBrowser(new DevToolsAdbBridge::RemoteBrowser(
+          bridge_, remote_device->device(), socket, package));
     }
+    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_;
 };