DevTools: Stop asking Android devices for installed packages list

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

 // 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.
 
 #include "chrome/browser/devtools/device/adb/adb_device_info_query.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 
 namespace {
 
 
 const char kDeviceModelCommand[] = "shell:getprop ro.product.model";
-const char kInstalledChromePackagesCommand[] = "shell:pm list packages";
 const char kOpenedUnixSocketsCommand[] = "shell:cat /proc/net/unix";
 const char kListProcessesCommand[] = "shell:ps";
 const char kDumpsysCommand[] = "shell:dumpsys window policy";
 const char kDumpsysScreenSizePrefix[] = "mStable=";
 
 const char kDevToolsSocketSuffix[] = "_devtools_remote";
 
 const char kChromeDefaultName[] = "Chrome";
 const char kChromeDefaultSocket[] = "chrome_devtools_remote";
 
@@ skipping 50 matching lines @@
 };
 
 const BrowserDescriptor* FindBrowserDescriptor(const std::string& package) {
   int count = sizeof(kBrowserDescriptors) / sizeof(kBrowserDescriptors[0]);
   for (int i = 0; i < count; i++)
     if (kBrowserDescriptors[i].package == package)
       return &kBrowserDescriptors[i];
   return NULL;
 }
 
-typedef std::map<std::string, const BrowserDescriptor*> DescriptorMap;
-
-static DescriptorMap FindInstalledBrowserPackages(const std::string& response) {
-  // Parse 'pm list packages' output which on Android looks like this:
-  //
-  // package:com.android.chrome
-  // package:com.chrome.beta
-  // package:com.example.app
-  //
-  DescriptorMap package_to_descriptor;
-  const std::string package_prefix = "package:";
-  std::vector<std::string> entries;
-  Tokenize(response, "'\r\n", &entries);
-  for (size_t i = 0; i < entries.size(); ++i) {
-    if (entries[i].find(package_prefix) != 0)
-      continue;
-    std::string package = entries[i].substr(package_prefix.size());
-    const BrowserDescriptor* descriptor = FindBrowserDescriptor(package);
-    if (!descriptor)
-      continue;
-    package_to_descriptor[descriptor->package] = descriptor;
-  }
-  return package_to_descriptor;
-}
-
 typedef std::map<std::string, std::string> StringMap;
 
 static void MapProcessesToPackages(const std::string& response,
                                    StringMap& pid_to_package,
                                    StringMap& package_to_pid) {
   // Parse 'ps' output which on Android looks like this:
   //
   // USER PID PPID VSIZE RSS WCHAN PC ? NAME
   //
   std::vector<std::string> entries;
@@ skipping 119 matching lines @@
       base::Bind(&AdbDeviceInfoQuery::ReceivedDumpsys, base::Unretained(this)));
 }
 
 void AdbDeviceInfoQuery::ReceivedDumpsys(int result,
                                          const std::string& response) {
   DCHECK(CalledOnValidThread());
   if (result >= 0)
     ParseDumpsysResponse(response);
 
   command_callback_.Run(
-      kInstalledChromePackagesCommand,
-      base::Bind(&AdbDeviceInfoQuery::ReceivedPackages,
+      kListProcessesCommand,
+      base::Bind(&AdbDeviceInfoQuery::ReceivedProcesses,
                  base::Unretained(this)));
 }
 
 void AdbDeviceInfoQuery::ParseDumpsysResponse(const std::string& response) {
   std::vector<std::string> lines;
   Tokenize(response, "\r", &lines);
   for (size_t i = 0; i < lines.size(); ++i) {
     std::string line = lines[i];
     size_t pos = line.find(kDumpsysScreenSizePrefix);
     if (pos != std::string::npos) {
@@ skipping 16 matching lines @@
   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;
 
   device_info_.screen_size = gfx::Size(width, height);
 }
 
 
-void AdbDeviceInfoQuery::ReceivedPackages(
-    int result,
-    const std::string& packages_response) {
-  DCHECK(CalledOnValidThread());
-  if (result < 0) {
-    Respond();
-    return;
-  }
-  command_callback_.Run(
-      kListProcessesCommand,
-      base::Bind(&AdbDeviceInfoQuery::ReceivedProcesses,
-                 base::Unretained(this), packages_response));
-}
-
 void AdbDeviceInfoQuery::ReceivedProcesses(
-    const std::string& packages_response,
     int result,
     const std::string& processes_response) {
   DCHECK(CalledOnValidThread());
   if (result < 0) {
     Respond();
     return;
   }
   command_callback_.Run(
       kOpenedUnixSocketsCommand,
       base::Bind(&AdbDeviceInfoQuery::ReceivedSockets,
                  base::Unretained(this),
-                 packages_response,
                  processes_response));
 }
 
 void AdbDeviceInfoQuery::ReceivedSockets(
-    const std::string& packages_response,
     const std::string& processes_response,
     int result,
     const std::string& sockets_response) {
   DCHECK(CalledOnValidThread());
   if (result >= 0)
-    ParseBrowserInfo(packages_response, processes_response, sockets_response);
+    ParseBrowserInfo(processes_response, sockets_response);
   Respond();
 }
 
 void AdbDeviceInfoQuery::ParseBrowserInfo(
-    const std::string& packages_response,
     const std::string& processes_response,
     const std::string& sockets_response) {
   DCHECK(CalledOnValidThread());
-  DescriptorMap package_to_descriptor =
-      FindInstalledBrowserPackages(packages_response);
   StringMap pid_to_package;
   StringMap package_to_pid;
   MapProcessesToPackages(processes_response, pid_to_package, package_to_pid);
 
   StringMap socket_to_pid = MapSocketsToProcesses(sockets_response,
                                                   kDevToolsSocketSuffix);
 
   std::set<std::string> packages_for_running_browsers;
 
   typedef std::map<std::string, int> BrowserMap;
@@ skipping 13 matching lines @@
       socket_to_unnamed_browser_index[socket] =
           device_info_.browser_info.size();
     }
 
     AndroidDeviceManager::BrowserInfo browser_info;
     browser_info.socket_name = socket;
     browser_info.type = GetBrowserType(socket);
     browser_info.display_name = GetDisplayName(socket, package);
     device_info_.browser_info.push_back(browser_info);
   }
-
-  // Find installed packages not mapped to browsers.
-  typedef std::multimap<std::string, const BrowserDescriptor*>
-      DescriptorMultimap;
-  DescriptorMultimap socket_to_descriptor;
-  for (DescriptorMap::iterator it = package_to_descriptor.begin();
-      it != package_to_descriptor.end(); ++it) {
-    std::string package = it->first;
-    const BrowserDescriptor* descriptor = it->second;
-
-    if (packages_for_running_browsers.count(package))
-      continue;  // This package is already mapped to a browser.
-
-    if (package_to_pid.find(package) != package_to_pid.end()) {
-      // This package is running but not mapped to a browser.
-      socket_to_descriptor.insert(
-          DescriptorMultimap::value_type(descriptor->socket, descriptor));
-      continue;
-    }
-  }
-
-  // Try naming remaining unnamed browsers.
-  for (DescriptorMultimap::iterator it = socket_to_descriptor.begin();
-      it != socket_to_descriptor.end(); ++it) {
-    std::string socket = it->first;
-    const BrowserDescriptor* descriptor = it->second;
-
-    if (socket_to_descriptor.count(socket) != 1)
-      continue;  // No definitive match.
-
-    BrowserMap::iterator bit = socket_to_unnamed_browser_index.find(socket);
-    if (bit != socket_to_unnamed_browser_index.end()) {
-      device_info_.browser_info[bit->second].display_name =
-          descriptor->display_name;
-    }
-  }
 }
 
 void AdbDeviceInfoQuery::Respond() {
   DCHECK(CalledOnValidThread());
   callback_.Run(device_info_);
   delete this;
 }