chrome/browser/devtools/devtools_adb_bridge.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/devtools/devtools_adb_bridge.h"
   6
   7 #include <map>
   8 #include <vector>
   9
  10 #include "base/base64.h"
  11 #include "base/bind.h"
  12 #include "base/command_line.h"
  13 #include "base/compiler_specific.h"
  14 #include "base/json/json_reader.h"
  15 #include "base/lazy_instance.h"
  16 #include "base/logging.h"
  17 #include "base/memory/singleton.h"
  18 #include "base/message_loop/message_loop.h"
  19 #include "base/strings/string_number_conversions.h"
  20 #include "base/strings/string_util.h"
  21 #include "base/strings/stringprintf.h"
  22 #include "base/strings/utf_string_conversions.h"
  23 #include "base/threading/thread.h"
  24 #include "base/values.h"
  25 #include "chrome/browser/devtools/adb/android_rsa.h"
  26 #include "chrome/browser/devtools/adb_client_socket.h"
  27 #include "chrome/browser/devtools/adb_web_socket.h"
  28 #include "chrome/browser/devtools/devtools_protocol.h"
  29 #include "chrome/browser/devtools/devtools_target_impl.h"
  30 #include "chrome/browser/devtools/devtools_window.h"
  31 #include "chrome/browser/profiles/profile.h"
  32 #include "components/browser_context_keyed_service/browser_context_dependency_manager.h"
  33 #include "content/public/browser/devtools_agent_host.h"
  34 #include "content/public/browser/devtools_client_host.h"
  35 #include "content/public/browser/devtools_external_agent_proxy.h"
  36 #include "content/public/browser/devtools_external_agent_proxy_delegate.h"
  37 #include "content/public/browser/devtools_manager.h"
  38 #include "content/public/browser/user_metrics.h"
  39 #include "crypto/rsa_private_key.h"
  40 #include "net/base/escape.h"
  41 #include "net/base/net_errors.h"
  42
  43 using content::BrowserThread;
  44
  45 namespace {
  46
  47 const char kDeviceModelCommand[] = "shell:getprop ro.product.model";
  48 const char kInstalledChromePackagesCommand[] = "shell:pm list packages";
  49 const char kOpenedUnixSocketsCommand[] = "shell:cat /proc/net/unix";
  50 const char kListProcessesCommand[] = "shell:ps";
  51 const char kDumpsysCommand[] = "shell:dumpsys window policy";
  52 const char kDumpsysScreenSizePrefix[] = "mStable=";
  53
  54 const char kUnknownModel[] = "Offline";
  55
  56 const char kPageListRequest[] = "GET /json HTTP/1.1\r\n\r\n";
  57 const char kVersionRequest[] = "GET /json/version HTTP/1.1\r\n\r\n";
  58 const char kClosePageRequest[] = "GET /json/close/%s HTTP/1.1\r\n\r\n";
  59 const char kNewPageRequest[] = "GET /json/new HTTP/1.1\r\n\r\n";
  60 const char kNewPageRequestWithURL[] = "GET /json/new?%s HTTP/1.1\r\n\r\n";
  61 const char kActivatePageRequest[] =
  62     "GET /json/activate/%s HTTP/1.1\r\n\r\n";
  63 const int kAdbPollingIntervalMs = 1000;
  64
  65 const char kUrlParam[] = "url";
  66 const char kPageReloadCommand[] = "Page.reload";
  67 const char kPageNavigateCommand[] = "Page.navigate";
  68
  69 const char kChromeDefaultName[] = "Chrome";
  70 const char kChromeDefaultSocket[] = "chrome_devtools_remote";
  71 const int kMinVersionNewWithURL = 32;
  72 const int kNewPageNavigateDelayMs = 500;
  73
  74 const char kWebViewSocketPrefix[] = "webview_devtools_remote";
  75 const char kWebViewNameTemplate[] = "WebView in %s";
  76
  77 typedef DevToolsAdbBridge::Callback Callback;
  78 typedef std::vector<scoped_refptr<AndroidDevice> >
  79     AndroidDevices;
  80 typedef base::Callback<void(const AndroidDevices&)> AndroidDevicesCallback;
  81
  82
  83 struct BrowserDescriptor {
  84   const char* package;
  85   const char* socket;
  86   const char* display_name;
  87 };
  88
  89 const BrowserDescriptor kBrowserDescriptors[] = {
  90   {
  91     "com.android.chrome",
  92     kChromeDefaultSocket,
  93     kChromeDefaultName
  94   },
  95   {
  96     "com.chrome.beta",
  97     kChromeDefaultSocket,
  98     "Chrome Beta"
  99   },
 100   {
 101     "com.google.android.apps.chrome_dev",
 102     kChromeDefaultSocket,
 103     "Chrome Dev"
 104   },
 105   {
 106     "com.google.android.apps.chrome",
 107     kChromeDefaultSocket,
 108     "Chromium"
 109   },
 110   {
 111     "org.chromium.content_shell_apk",
 112     "content_shell_devtools_remote",
 113     "Content Shell"
 114   },
 115   {
 116     "org.chromium.chrome.testshell",
 117     "chromium_testshell_devtools_remote",
 118     "Chromium Test Shell"
 119   },
 120   {
 121     "org.chromium.android_webview.shell",
 122     "webview_devtools_remote",
 123     "WebView Test Shell"
 124   }
 125 };
 126
 127 const BrowserDescriptor* FindBrowserDescriptor(const std::string& package) {
 128   int count = sizeof(kBrowserDescriptors) / sizeof(kBrowserDescriptors[0]);
 129   for (int i = 0; i < count; i++)
 130     if (kBrowserDescriptors[i].package == package)
 131       return &kBrowserDescriptors[i];
 132   return NULL;
 133 }
 134
 135 typedef std::map<std::string, const BrowserDescriptor*> DescriptorMap;
 136
 137 static DescriptorMap FindInstalledBrowserPackages(
 138     const std::string& response) {
 139   // Parse 'pm list packages' output which on Android looks like this:
 140   //
 141   // package:com.android.chrome
 142   // package:com.chrome.beta
 143   // package:com.example.app
 144   //
 145   DescriptorMap package_to_descriptor;
 146   const std::string package_prefix = "package:";
 147   std::vector<std::string> entries;
 148   Tokenize(response, "'\r\n", &entries);
 149   for (size_t i = 0; i < entries.size(); ++i) {
 150     if (entries[i].find(package_prefix) != 0)
 151       continue;
 152     std::string package = entries[i].substr(package_prefix.size());
 153     const BrowserDescriptor* descriptor = FindBrowserDescriptor(package);
 154     if (!descriptor)
 155       continue;
 156     package_to_descriptor[descriptor->package] = descriptor;
 157   }
 158   return package_to_descriptor;
 159 }
 160
 161 typedef std::map<std::string, std::string> StringMap;
 162
 163 static void MapProcessesToPackages(const std::string& response,
 164                                    StringMap& pid_to_package,
 165                                    StringMap& package_to_pid) {
 166   // Parse 'ps' output which on Android looks like this:
 167   //
 168   // USER PID PPID VSIZE RSS WCHAN PC ? NAME
 169   //
 170   std::vector<std::string> entries;
 171   Tokenize(response, "\n", &entries);
 172   for (size_t i = 1; i < entries.size(); ++i) {
 173     std::vector<std::string> fields;
 174     Tokenize(entries[i], " \r", &fields);
 175     if (fields.size() < 9)
 176       continue;
 177     std::string pid = fields[1];
 178     std::string package = fields[8];
 179     pid_to_package[pid] = package;
 180     package_to_pid[package] = pid;
 181   }
 182 }
 183
 184 typedef std::map<std::string,
 185                  scoped_refptr<DevToolsAdbBridge::RemoteBrowser> > BrowserMap;
 186
 187 static StringMap MapSocketsToProcesses(const std::string& response,
 188                                        const std::string& channel_pattern) {
 189   // Parse 'cat /proc/net/unix' output which on Android looks like this:
 190   //
 191   // Num       RefCount Protocol Flags    Type St Inode Path
 192   // 00000000: 00000002 00000000 00010000 0001 01 331813 /dev/socket/zygote
 193   // 00000000: 00000002 00000000 00010000 0001 01 358606 @xxx_devtools_remote
 194   // 00000000: 00000002 00000000 00010000 0001 01 347300 @yyy_devtools_remote
 195   //
 196   // We need to find records with paths starting from '@' (abstract socket)
 197   // and containing the channel pattern ("_devtools_remote").
 198   StringMap socket_to_pid;
 199   std::vector<std::string> entries;
 200   Tokenize(response, "\n", &entries);
 201   for (size_t i = 1; i < entries.size(); ++i) {
 202     std::vector<std::string> fields;
 203     Tokenize(entries[i], " \r", &fields);
 204     if (fields.size() < 8)
 205       continue;
 206     if (fields[3] != "00010000" || fields[5] != "01")
 207       continue;
 208     std::string path_field = fields[7];
 209     if (path_field.size() < 1 || path_field[0] != '@')
 210       continue;
 211     size_t socket_name_pos = path_field.find(channel_pattern);
 212     if (socket_name_pos == std::string::npos)
 213       continue;
 214
 215     std::string socket = path_field.substr(1);
 216
 217     std::string pid;
 218     size_t socket_name_end = socket_name_pos + channel_pattern.size();
 219     if (socket_name_end < path_field.size() &&
 220         path_field[socket_name_end] == '_') {
 221       pid = path_field.substr(socket_name_end + 1);
 222     }
 223     socket_to_pid[socket] = pid;
 224   }
 225   return socket_to_pid;
 226 }
 227
 228 // AdbPagesCommand ------------------------------------------------------------
 229
 230 class AdbPagesCommand : public base::RefCountedThreadSafe<
 231     AdbPagesCommand,
 232     BrowserThread::DeleteOnUIThread> {
 233  public:
 234   typedef base::Callback<void(DevToolsAdbBridge::RemoteDevices*)> Callback;
 235
 236   AdbPagesCommand(
 237       scoped_refptr<RefCountedAdbThread> adb_thread,
 238       const DevToolsAdbBridge::DeviceProviders& device_providers,
 239       const Callback& callback);
 240
 241  private:
 242   friend struct BrowserThread::DeleteOnThread<
 243       BrowserThread::UI>;
 244   friend class base::DeleteHelper<AdbPagesCommand>;
 245
 246   virtual ~AdbPagesCommand();
 247   void ProcessDeviceProviders();
 248   void ReceivedDevices(const AndroidDevices& devices);
 249
 250   void ProcessSerials();
 251   void ReceivedModel(int result, const std::string& response);
 252   void ReceivedDumpsys(int result, const std::string& response);
 253   void ReceivedPackages(int result, const std::string& response);
 254   void ReceivedProcesses(
 255       const std::string& packages_response,
 256       int result,
 257       const std::string& processes_response);
 258   void ReceivedSockets(
 259       const std::string& packages_response,
 260       const std::string& processes_response,
 261       int result,
 262       const std::string& sockets_response);
 263   void ProcessSockets();
 264   void ReceivedVersion(int result, const std::string& response);
 265   void ReceivedPages(int result, const std::string& response);
 266
 267   scoped_refptr<AndroidDevice> current_device() const {
 268     return devices_.back();
 269   }
 270
 271   scoped_refptr<DevToolsAdbBridge::RemoteBrowser> current_browser() const {
 272     return browsers_.back();
 273   }
 274
 275   void NextBrowser();
 276   void NextDevice();
 277
 278   void Respond();
 279
 280   void CreateBrowsers(const std::string& packages_response,
 281                       const std::string& processes_response,
 282                       const std::string& sockets_response);
 283
 284   void ParseDumpsysResponse(const std::string& response);
 285   void ParseScreenSize(const std::string& str);
 286
 287   scoped_refptr<RefCountedAdbThread> adb_thread_;
 288   Callback callback_;
 289   AndroidDevices devices_;
 290   DevToolsAdbBridge::RemoteBrowsers browsers_;
 291   scoped_ptr<DevToolsAdbBridge::RemoteDevices> remote_devices_;
 292   DevToolsAdbBridge::DeviceProviders device_providers_;
 293 };
 294
 295 AdbPagesCommand::AdbPagesCommand(
 296     scoped_refptr<RefCountedAdbThread> adb_thread,
 297     const DevToolsAdbBridge::DeviceProviders& device_providers,
 298     const Callback& callback)
 299     : adb_thread_(adb_thread),
 300       callback_(callback),
 301       device_providers_(device_providers) {
 302   remote_devices_.reset(new DevToolsAdbBridge::RemoteDevices());
 303
 304   ProcessDeviceProviders();
 305 }
 306
 307 AdbPagesCommand::~AdbPagesCommand() {
 308   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 309 }
 310
 311 void AdbPagesCommand::ProcessDeviceProviders() {
 312   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 313   if (device_providers_.empty()) {
 314     adb_thread_->message_loop()->PostTask(
 315               FROM_HERE, base::Bind(&AdbPagesCommand::ProcessSerials, this));
 316     return;
 317   }
 318
 319   const scoped_refptr<AndroidDeviceProvider>& device_provider =
 320       device_providers_.back();
 321
 322   device_provider->QueryDevices(
 323       base::Bind(&AdbPagesCommand::ReceivedDevices, this));
 324 }
 325
 326 void AdbPagesCommand::ReceivedDevices(const AndroidDevices& devices) {
 327   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 328   DCHECK(!device_providers_.empty());
 329   device_providers_.pop_back();
 330
 331   devices_.insert(devices_.end(), devices.begin(), devices.end());
 332
 333   if (!device_providers_.empty()) {
 334     ProcessDeviceProviders();
 335   } else {
 336     adb_thread_->message_loop()->PostTask(
 337           FROM_HERE, base::Bind(&AdbPagesCommand::ProcessSerials, this));
 338   }
 339 }
 340
 341 void AdbPagesCommand::ProcessSerials() {
 342   DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
 343   if (devices_.size() == 0) {
 344     BrowserThread::PostTask(
 345         BrowserThread::UI, FROM_HERE,
 346         base::Bind(&AdbPagesCommand::Respond, this));
 347     return;
 348   }
 349
 350   scoped_refptr<AndroidDevice> device = current_device();
 351
 352   if (device->is_connected()) {
 353     device->RunCommand(kDeviceModelCommand,
 354                        base::Bind(&AdbPagesCommand::ReceivedModel, this));
 355   } else {
 356     device->set_model(kUnknownModel);
 357     remote_devices_->push_back(new DevToolsAdbBridge::RemoteDevice(device));
 358     NextDevice();
 359   }
 360 }
 361
 362 void AdbPagesCommand::ReceivedModel(int result, const std::string& response) {
 363   DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
 364   if (result < 0) {
 365     NextDevice();
 366     return;
 367   }
 368   scoped_refptr<AndroidDevice> device = current_device();
 369   device->set_model(response);
 370   remote_devices_->push_back(new DevToolsAdbBridge::RemoteDevice(device));
 371   device->RunCommand(kDumpsysCommand,
 372                      base::Bind(&AdbPagesCommand::ReceivedDumpsys, this));
 373 }
 374
 375 void AdbPagesCommand::ReceivedDumpsys(int result,
 376                                       const std::string& response) {
 377   DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
 378   if (result >= 0)
 379     ParseDumpsysResponse(response);
 380
 381   current_device()->RunCommand(
 382       kInstalledChromePackagesCommand,
 383       base::Bind(&AdbPagesCommand::ReceivedPackages, this));
 384 }
 385
 386 void AdbPagesCommand::ReceivedPackages(int result,
 387                                        const std::string& packages_response) {
 388   DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
 389   if (result < 0) {
 390     NextDevice();
 391     return;
 392   }
 393   current_device()->RunCommand(
 394       kListProcessesCommand,
 395       base::Bind(&AdbPagesCommand::ReceivedProcesses, this, packages_response));
 396 }
 397
 398 void AdbPagesCommand::ReceivedProcesses(
 399     const std::string& packages_response,
 400     int result,
 401     const std::string& processes_response) {
 402   DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
 403   if (result < 0) {
 404     NextDevice();
 405     return;
 406   }
 407   current_device()->RunCommand(
 408       kOpenedUnixSocketsCommand,
 409       base::Bind(&AdbPagesCommand::ReceivedSockets,
 410                  this,
 411                  packages_response,
 412                  processes_response));
 413 }
 414
 415 void AdbPagesCommand::ReceivedSockets(
 416     const std::string& packages_response,
 417     const std::string& processes_response,
 418     int result,
 419     const std::string& sockets_response) {
 420   DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
 421   if (result >= 0)
 422     CreateBrowsers(packages_response, processes_response, sockets_response);
 423   ProcessSockets();
 424 }
 425
 426 void AdbPagesCommand::ProcessSockets() {
 427   DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
 428   if (browsers_.size() == 0) {
 429     NextDevice();
 430     return;
 431   }
 432
 433   current_device()->HttpQuery(
 434       current_browser()->socket(),
 435       kVersionRequest,
 436       base::Bind(&AdbPagesCommand::ReceivedVersion, this));
 437 }
 438
 439 void AdbPagesCommand::ReceivedVersion(int result,
 440                                       const std::string& response) {
 441   DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
 442   if (result < 0) {
 443     NextBrowser();
 444     return;
 445   }
 446
 447   // Parse version, append to package name if available,
 448   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
 449   base::DictionaryValue* dict;
 450   if (value && value->GetAsDictionary(&dict)) {
 451     std::string browser;
 452     if (dict->GetString("Browser", &browser)) {
 453       std::vector<std::string> parts;
 454       Tokenize(browser, "/", &parts);
 455       if (parts.size() == 2)
 456         current_browser()->set_version(parts[1]);
 457       else
 458         current_browser()->set_version(browser);
 459     }
 460     std::string package;
 461     if (dict->GetString("Android-Package", &package)) {
 462       const BrowserDescriptor* descriptor = FindBrowserDescriptor(package);
 463       if (descriptor)
 464         current_browser()->set_display_name(descriptor->display_name);
 465     }
 466   }
 467
 468   current_device()->HttpQuery(
 469       current_browser()->socket(),
 470       kPageListRequest,
 471       base::Bind(&AdbPagesCommand::ReceivedPages, this));
 472 }
 473
 474 void AdbPagesCommand::ReceivedPages(int result,
 475                                     const std::string& response) {
 476   DCHECK_EQ(adb_thread_->message_loop(), base::MessageLoop::current());
 477   if (result >= 0) {
 478     scoped_ptr<base::Value> value(base::JSONReader::Read(response));
 479     base::ListValue* list_value;
 480     if (value && value->GetAsList(&list_value))
 481       current_browser()->SetPageDescriptors(*list_value);
 482   }
 483   NextBrowser();
 484 }
 485
 486 void AdbPagesCommand::NextBrowser() {
 487   browsers_.pop_back();
 488   ProcessSockets();
 489 }
 490
 491 void AdbPagesCommand::NextDevice() {
 492   devices_.pop_back();
 493   ProcessSerials();
 494 }
 495
 496 void AdbPagesCommand::Respond() {
 497   callback_.Run(remote_devices_.release());
 498 }
 499
 500 void AdbPagesCommand::CreateBrowsers(
 501     const std::string& packages_response,
 502     const std::string& processes_response,
 503     const std::string& sockets_response) {
 504   DescriptorMap package_to_descriptor =
 505       FindInstalledBrowserPackages(packages_response);
 506
 507   StringMap pid_to_package;
 508   StringMap package_to_pid;
 509   MapProcessesToPackages(processes_response, pid_to_package, package_to_pid);
 510
 511   const std::string channel_pattern =
 512       base::StringPrintf(kDevToolsChannelNameFormat, "");
 513
 514   StringMap socket_to_pid = MapSocketsToProcesses(sockets_response,
 515                                                   channel_pattern);
 516
 517   scoped_refptr<DevToolsAdbBridge::RemoteDevice> remote_device =
 518       remote_devices_->back();
 519
 520   // Create RemoteBrowser instances.
 521   BrowserMap package_to_running_browser;
 522   BrowserMap socket_to_unnamed_browser;
 523   for (StringMap::iterator it = socket_to_pid.begin();
 524       it != socket_to_pid.end(); ++it) {
 525     std::string socket = it->first;
 526     std::string pid = it->second;
 527
 528     scoped_refptr<DevToolsAdbBridge::RemoteBrowser> browser =
 529         new DevToolsAdbBridge::RemoteBrowser(
 530             adb_thread_, remote_device->device(), socket);
 531
 532     StringMap::iterator pit = pid_to_package.find(pid);
 533     if (pit != pid_to_package.end()) {
 534       std::string package = pit->second;
 535       package_to_running_browser[package] = browser;
 536       const BrowserDescriptor* descriptor = FindBrowserDescriptor(package);
 537       if (descriptor) {
 538         browser->set_display_name(descriptor->display_name);
 539       } else if (socket.find(kWebViewSocketPrefix) == 0) {
 540         browser->set_display_name(
 541             base::StringPrintf(kWebViewNameTemplate, package.c_str()));
 542       } else {
 543         browser->set_display_name(package);
 544       }
 545     } else {
 546       // Set fallback display name.
 547       std::string name = socket.substr(0, socket.find(channel_pattern));
 548       name[0] = base::ToUpperASCII(name[0]);
 549       browser->set_display_name(name);
 550
 551       socket_to_unnamed_browser[socket] = browser;
 552     }
 553     remote_device->AddBrowser(browser);
 554   }
 555
 556   browsers_ = remote_device->browsers();
 557
 558   // Find installed packages not mapped to browsers.
 559   typedef std::multimap<std::string, const BrowserDescriptor*>
 560       DescriptorMultimap;
 561   DescriptorMultimap socket_to_descriptor;
 562   for (DescriptorMap::iterator it = package_to_descriptor.begin();
 563       it != package_to_descriptor.end(); ++it) {
 564     std::string package = it->first;
 565     const BrowserDescriptor* descriptor = it->second;
 566
 567     if (package_to_running_browser.find(package) !=
 568         package_to_running_browser.end())
 569       continue;  // This package is already mapped to a browser.
 570
 571     if (package_to_pid.find(package) != package_to_pid.end()) {
 572       // This package is running but not mapped to a browser.
 573       socket_to_descriptor.insert(
 574           DescriptorMultimap::value_type(descriptor->socket, descriptor));
 575       continue;
 576     }
 577   }
 578
 579   // Try naming remaining unnamed browsers.
 580   for (DescriptorMultimap::iterator it = socket_to_descriptor.begin();
 581       it != socket_to_descriptor.end(); ++it) {
 582     std::string socket = it->first;
 583     const BrowserDescriptor* descriptor = it->second;
 584
 585     if (socket_to_descriptor.count(socket) != 1)
 586       continue;  // No definitive match.
 587
 588     BrowserMap::iterator bit = socket_to_unnamed_browser.find(socket);
 589     if (bit != socket_to_unnamed_browser.end())
 590       bit->second->set_display_name(descriptor->display_name);
 591   }
 592 }
 593
 594 void AdbPagesCommand::ParseDumpsysResponse(const std::string& response) {
 595   std::vector<std::string> lines;
 596   Tokenize(response, "\r", &lines);
 597   for (size_t i = 0; i < lines.size(); ++i) {
 598     std::string line = lines[i];
 599     size_t pos = line.find(kDumpsysScreenSizePrefix);
 600     if (pos != std::string::npos) {
 601       ParseScreenSize(
 602           line.substr(pos + std::string(kDumpsysScreenSizePrefix).size()));
 603       break;
 604     }
 605   }
 606 }
 607
 608 void AdbPagesCommand::ParseScreenSize(const std::string& str) {
 609   std::vector<std::string> pairs;
 610   Tokenize(str, "-", &pairs);
 611   if (pairs.size() != 2)
 612     return;
 613
 614   int width;
 615   int height;
 616   std::vector<std::string> numbers;
 617   Tokenize(pairs[1].substr(1, pairs[1].size() - 2), ",", &numbers);
 618   if (numbers.size() != 2 ||
 619       !base::StringToInt(numbers[0], &width) ||
 620       !base::StringToInt(numbers[1], &height))
 621     return;
 622
 623   remote_devices_->back()->set_screen_size(gfx::Size(width, height));
 624 }
 625
 626
 627 // AdbProtocolCommand ---------------------------------------------------------
 628
 629 class AdbProtocolCommand : public AdbWebSocket::Delegate {
 630  public:
 631   AdbProtocolCommand(
 632       scoped_refptr<RefCountedAdbThread> adb_thread,
 633       scoped_refptr<AndroidDevice> device,
 634       const std::string& socket_name,
 635       const std::string& debug_url,
 636       const std::string& command);
 637
 638  private:
 639   virtual void OnSocketOpened() OVERRIDE;
 640   virtual void OnFrameRead(const std::string& message) OVERRIDE;
 641   virtual void OnSocketClosed(bool closed_by_device) OVERRIDE;
 642   virtual bool ProcessIncomingMessage(const std::string& message) OVERRIDE;
 643
 644   scoped_refptr<RefCountedAdbThread> adb_thread_;
 645   const std::string command_;
 646   scoped_refptr<AdbWebSocket> web_socket_;
 647
 648   DISALLOW_COPY_AND_ASSIGN(AdbProtocolCommand);
 649 };
 650
 651 AdbProtocolCommand::AdbProtocolCommand(
 652     scoped_refptr<RefCountedAdbThread> adb_thread,
 653     scoped_refptr<AndroidDevice> device,
 654     const std::string& socket_name,
 655     const std::string& debug_url,
 656     const std::string& command)
 657     : adb_thread_(adb_thread),
 658       command_(command) {
 659   web_socket_ = new AdbWebSocket(
 660       device, socket_name, debug_url, adb_thread_->message_loop(), this);
 661 }
 662
 663 void AdbProtocolCommand::OnSocketOpened() {
 664   web_socket_->SendFrame(command_);
 665   web_socket_->Disconnect();
 666 }
 667
 668 void AdbProtocolCommand::OnFrameRead(const std::string& message) {}
 669
 670 void AdbProtocolCommand::OnSocketClosed(bool closed_by_device) {
 671   delete this;
 672 }
 673
 674 bool AdbProtocolCommand::ProcessIncomingMessage(const std::string& message) {
 675   return false;
 676 }
 677
 678 }  // namespace
 679
 680 const char kDevToolsChannelNameFormat[] = "%s_devtools_remote";
 681
 682 class AgentHostDelegate;
 683
 684 typedef std::map<std::string, AgentHostDelegate*> AgentHostDelegates;
 685
 686 base::LazyInstance<AgentHostDelegates>::Leaky g_host_delegates =
 687     LAZY_INSTANCE_INITIALIZER;
 688
 689 DevToolsAdbBridge::Wrapper::Wrapper() {
 690   bridge_ = new DevToolsAdbBridge();
 691 }
 692
 693 DevToolsAdbBridge::Wrapper::~Wrapper() {
 694 }
 695
 696 DevToolsAdbBridge* DevToolsAdbBridge::Wrapper::Get() {
 697   return bridge_.get();
 698 }
 699
 700 // static
 701 DevToolsAdbBridge::Factory* DevToolsAdbBridge::Factory::GetInstance() {
 702   return Singleton<DevToolsAdbBridge::Factory>::get();
 703 }
 704
 705 // static
 706 DevToolsAdbBridge* DevToolsAdbBridge::Factory::GetForProfile(
 707     Profile* profile) {
 708   DevToolsAdbBridge::Wrapper* wrapper =
 709       static_cast<DevToolsAdbBridge::Wrapper*>(GetInstance()->
 710           GetServiceForBrowserContext(profile, true));
 711   return wrapper ? wrapper->Get() : NULL;
 712 }
 713
 714 DevToolsAdbBridge::Factory::Factory()
 715     : BrowserContextKeyedServiceFactory(
 716           "DevToolsAdbBridge",
 717           BrowserContextDependencyManager::GetInstance()) {}
 718
 719 DevToolsAdbBridge::Factory::~Factory() {}
 720
 721 BrowserContextKeyedService*
 722 DevToolsAdbBridge::Factory::BuildServiceInstanceFor(
 723     content::BrowserContext* context) const {
 724   return new DevToolsAdbBridge::Wrapper();
 725 }
 726
 727
 728 // AgentHostDelegate ----------------------------------------------------------
 729
 730 class AgentHostDelegate : public content::DevToolsExternalAgentProxyDelegate,
 731                           public AdbWebSocket::Delegate {
 732  public:
 733   static void Create(const std::string& id,
 734                      scoped_refptr<DevToolsAdbBridge::RemoteBrowser> browser,
 735                      const std::string& debug_url,
 736                      const std::string& frontend_url,
 737                      Profile* profile) {
 738     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 739     AgentHostDelegates::iterator it =
 740         g_host_delegates.Get().find(id);
 741     if (it != g_host_delegates.Get().end()) {
 742       it->second->OpenFrontend();
 743     } else if (!frontend_url.empty()) {
 744       new AgentHostDelegate(
 745           id, browser->device(), browser->socket(), debug_url,
 746           frontend_url, browser->adb_thread()->message_loop(), profile);
 747     }
 748   }
 749
 750  private:
 751   AgentHostDelegate(
 752       const std::string& id,
 753       scoped_refptr<AndroidDevice> device,
 754       const std::string& socket_name,
 755       const std::string& debug_url,
 756       const std::string& frontend_url,
 757       base::MessageLoop* adb_message_loop,
 758       Profile* profile)
 759       : id_(id),
 760         frontend_url_(frontend_url),
 761         profile_(profile) {
 762     web_socket_ = new AdbWebSocket(
 763         device, socket_name, debug_url, adb_message_loop, this);
 764     g_host_delegates.Get()[id] = this;
 765
 766     if (socket_name.find(kWebViewSocketPrefix) == 0) {
 767       content::RecordAction(
 768           base::UserMetricsAction("DevTools_InspectAndroidWebView"));
 769     } else {
 770       content::RecordAction(
 771           base::UserMetricsAction("DevTools_InspectAndroidPage"));
 772     }
 773   }
 774
 775   void OpenFrontend() {
 776     if (!proxy_)
 777       return;
 778     DevToolsWindow::OpenExternalFrontend(
 779         profile_, frontend_url_, proxy_->GetAgentHost().get());
 780   }
 781
 782   virtual ~AgentHostDelegate() {
 783     g_host_delegates.Get().erase(id_);
 784   }
 785
 786   virtual void Attach() OVERRIDE {}
 787
 788   virtual void Detach() OVERRIDE {
 789     web_socket_->Disconnect();
 790   }
 791
 792   virtual void SendMessageToBackend(const std::string& message) OVERRIDE {
 793     web_socket_->SendFrame(message);
 794   }
 795
 796   virtual void OnSocketOpened() OVERRIDE {
 797     proxy_.reset(content::DevToolsExternalAgentProxy::Create(this));
 798     OpenFrontend();
 799   }
 800
 801   virtual void OnFrameRead(const std::string& message) OVERRIDE {
 802     proxy_->DispatchOnClientHost(message);
 803   }
 804
 805   virtual void OnSocketClosed(bool closed_by_device) OVERRIDE {
 806     if (proxy_ && closed_by_device)
 807       proxy_->ConnectionClosed();
 808     delete this;
 809   }
 810
 811   virtual bool ProcessIncomingMessage(const std::string& message) OVERRIDE {
 812     return false;
 813   }
 814
 815   const std::string id_;
 816   const std::string frontend_url_;
 817   Profile* profile_;
 818
 819   scoped_ptr<content::DevToolsExternalAgentProxy> proxy_;
 820   scoped_refptr<AdbWebSocket> web_socket_;
 821   DISALLOW_COPY_AND_ASSIGN(AgentHostDelegate);
 822 };
 823
 824 //// RemotePageTarget ----------------------------------------------
 825
 826 class RemotePageTarget : public DevToolsTargetImpl {
 827  public:
 828   RemotePageTarget(scoped_refptr<DevToolsAdbBridge::RemoteBrowser> browser,
 829                    const base::DictionaryValue& value);
 830   virtual ~RemotePageTarget();
 831
 832   // content::DevToolsTarget overrides:
 833   virtual bool IsAttached() const OVERRIDE;
 834   virtual bool Activate() const OVERRIDE;
 835   virtual bool Close() const OVERRIDE;
 836
 837   // DevToolsTargetImpl overrides:
 838   virtual void Inspect(Profile* profile) const OVERRIDE;
 839   virtual void Reload() const OVERRIDE;
 840
 841   void Navigate(const std::string& url) const;
 842
 843  private:
 844   scoped_refptr<DevToolsAdbBridge::RemoteBrowser> browser_;
 845   std::string debug_url_;
 846   std::string frontend_url_;
 847   std::string remote_id_;
 848   DISALLOW_COPY_AND_ASSIGN(RemotePageTarget);
 849 };
 850
 851 RemotePageTarget::RemotePageTarget(
 852     scoped_refptr<DevToolsAdbBridge::RemoteBrowser> browser,
 853     const base::DictionaryValue& value)
 854     : browser_(browser) {
 855   type_ = "adb_page";
 856   value.GetString("id", &remote_id_);
 857   std::string url;
 858   value.GetString("url", &url);
 859   url_ = GURL(url);
 860   value.GetString("title", &title_);
 861   title_ = base::UTF16ToUTF8(net::UnescapeForHTML(base::UTF8ToUTF16(title_)));
 862   value.GetString("description", &description_);
 863   std::string favicon_url;
 864   value.GetString("faviconUrl", &favicon_url);
 865   favicon_url_ = GURL(favicon_url);
 866   value.GetString("webSocketDebuggerUrl", &debug_url_);
 867   value.GetString("devtoolsFrontendUrl", &frontend_url_);
 868
 869   if (remote_id_.empty() && !debug_url_.empty())  {
 870     // Target id is not available until Chrome 26. Use page id at the end of
 871     // debug_url_ instead. For attached targets the id will remain empty.
 872     std::vector<std::string> parts;
 873     Tokenize(debug_url_, "/", &parts);
 874     remote_id_ = parts[parts.size()-1];
 875   }
 876
 877   if (debug_url_.find("ws://") == 0)
 878     debug_url_ = debug_url_.substr(5);
 879   else
 880     debug_url_ = "";
 881
 882   size_t ws_param = frontend_url_.find("?ws");
 883   if (ws_param != std::string::npos)
 884     frontend_url_ = frontend_url_.substr(0, ws_param);
 885   if (frontend_url_.find("http:") == 0)
 886     frontend_url_ = "https:" + frontend_url_.substr(5);
 887
 888   id_ = base::StringPrintf("%s:%s:%s",
 889       browser_->device()->serial().c_str(),
 890       browser_->socket().c_str(),
 891       remote_id_.c_str());
 892 }
 893
 894 RemotePageTarget::~RemotePageTarget() {
 895 }
 896
 897 bool RemotePageTarget::IsAttached() const {
 898   return debug_url_.empty();
 899 }
 900
 901 void RemotePageTarget::Inspect(Profile* profile) const {
 902   std::string request = base::StringPrintf(kActivatePageRequest,
 903                                            remote_id_.c_str());
 904   base::Closure inspect_callback = base::Bind(&AgentHostDelegate::Create,
 905       id_, browser_, debug_url_, frontend_url_, profile);
 906   browser_->SendJsonRequest(request, inspect_callback);
 907 }
 908
 909 bool RemotePageTarget::Activate() const {
 910   std::string request = base::StringPrintf(kActivatePageRequest,
 911                                            remote_id_.c_str());
 912   browser_->SendJsonRequest(request, base::Closure());
 913   return true;
 914 }
 915
 916 bool RemotePageTarget::Close() const {
 917   if (IsAttached())
 918     return false;
 919   std::string request = base::StringPrintf(kClosePageRequest,
 920                                            remote_id_.c_str());
 921   browser_->SendJsonRequest(request, base::Closure());
 922   return true;
 923 }
 924
 925 void RemotePageTarget::Reload() const {
 926   browser_->SendProtocolCommand(debug_url_, kPageReloadCommand, NULL);
 927 }
 928
 929 void RemotePageTarget::Navigate(const std::string& url) const {
 930   base::DictionaryValue params;
 931   params.SetString(kUrlParam, url);
 932   browser_->SendProtocolCommand(debug_url_, kPageNavigateCommand, &params);
 933 }
 934
 935 // DevToolsAdbBridge::RemoteBrowser -------------------------------------------
 936
 937 DevToolsAdbBridge::RemoteBrowser::RemoteBrowser(
 938     scoped_refptr<RefCountedAdbThread> adb_thread,
 939     scoped_refptr<AndroidDevice> device,
 940     const std::string& socket)
 941     : adb_thread_(adb_thread),
 942       device_(device),
 943       socket_(socket),
 944       page_descriptors_(new base::ListValue()) {
 945 }
 946
 947 bool DevToolsAdbBridge::RemoteBrowser::IsChrome() const {
 948   return socket_.find(kChromeDefaultSocket) == 0;
 949 }
 950
 951 DevToolsAdbBridge::RemoteBrowser::ParsedVersion
 952 DevToolsAdbBridge::RemoteBrowser::GetParsedVersion() const {
 953   ParsedVersion result;
 954   std::vector<std::string> parts;
 955   Tokenize(version_, ".", &parts);
 956   for (size_t i = 0; i != parts.size(); ++i) {
 957     int value = 0;
 958     base::StringToInt(parts[i], &value);
 959     result.push_back(value);
 960   }
 961   return result;
 962 }
 963
 964 std::vector<DevToolsTargetImpl*>
 965 DevToolsAdbBridge::RemoteBrowser::CreatePageTargets() {
 966   std::vector<DevToolsTargetImpl*> result;
 967   for (size_t i = 0; i < page_descriptors_->GetSize(); ++i) {
 968     base::Value* item;
 969     page_descriptors_->Get(i, &item);
 970     if (!item)
 971       continue;
 972     base::DictionaryValue* dict;
 973     if (!item->GetAsDictionary(&dict))
 974       continue;
 975     result.push_back(new RemotePageTarget(this, *dict));
 976   }
 977   return result;
 978 }
 979
 980 void DevToolsAdbBridge::RemoteBrowser::SetPageDescriptors(
 981     const base::ListValue& list) {
 982   page_descriptors_.reset(list.DeepCopy());
 983 }
 984
 985 static void RespondOnUIThread(base::Closure callback, int, const std::string&) {
 986   if (!callback.is_null())
 987     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
 988 }
 989
 990 void DevToolsAdbBridge::RemoteBrowser::SendJsonRequest(
 991     const std::string& request, base::Closure callback) {
 992   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 993   adb_thread_->message_loop()->PostTask(FROM_HERE,
 994       base::Bind(&AndroidDevice::HttpQuery, device_, socket_, request,
 995           base::Bind(&RespondOnUIThread, callback)));
 996 }
 997
 998 void DevToolsAdbBridge::RemoteBrowser::SendProtocolCommand(
 999     const std::string& debug_url,
1000     const std::string& method,
1001     base::DictionaryValue* params) {
1002   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1003   if (debug_url.empty())
1004     return;
1005   DevToolsProtocol::Command command(1, method, params);
1006   new AdbProtocolCommand(
1007       adb_thread_, device_, socket_, debug_url, command.Serialize());
1008 }
1009
1010 static void NoOp(int, const std::string&) {}
1011
1012 void DevToolsAdbBridge::RemoteBrowser::Open(const std::string& input_url) {
1013   GURL gurl(input_url);
1014   if (!gurl.is_valid()) {
1015     gurl = GURL("http://" + input_url);
1016     if (!gurl.is_valid())
1017      return;
1018   }
1019   std::string url = gurl.spec();
1020
1021   ParsedVersion parsed_version = GetParsedVersion();
1022   if (IsChrome() &&
1023       !parsed_version.empty() &&
1024       parsed_version[0] >= kMinVersionNewWithURL) {
1025     std::string query = net::EscapeQueryParamValue(url, false /* use_plus */);
1026     std::string request =
1027         base::StringPrintf(kNewPageRequestWithURL, query.c_str());
1028     adb_thread_->message_loop()->PostTask(FROM_HERE,
1029         base::Bind(&AndroidDevice::HttpQuery,
1030             device_, socket_, request, base::Bind(&NoOp)));
1031   } else {
1032     adb_thread_->message_loop()->PostTask(FROM_HERE,
1033         base::Bind(&AndroidDevice::HttpQuery,
1034             device_, socket_, kNewPageRequest,
1035             base::Bind(&RemoteBrowser::PageCreatedOnHandlerThread, this, url)));
1036   }
1037 }
1038
1039 void DevToolsAdbBridge::RemoteBrowser::PageCreatedOnHandlerThread(
1040     const std::string& url, int result, const std::string& response) {
1041   if (result < 0)
1042     return;
1043   // Navigating too soon after the page creation breaks navigation history
1044   // (crbug.com/311014). This can be avoided by adding a moderate delay.
1045   BrowserThread::PostDelayedTask(
1046       BrowserThread::UI, FROM_HERE,
1047       base::Bind(&RemoteBrowser::PageCreatedOnUIThread, this, response, url),
1048       base::TimeDelta::FromMilliseconds(kNewPageNavigateDelayMs));
1049 }
1050
1051 void DevToolsAdbBridge::RemoteBrowser::PageCreatedOnUIThread(
1052     const std::string& response, const std::string& url) {
1053   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
1054   base::DictionaryValue* dict;
1055   if (value && value->GetAsDictionary(&dict)) {
1056     RemotePageTarget new_page(this, *dict);
1057     new_page.Navigate(url);
1058   }
1059 }
1060
1061 DevToolsAdbBridge::RemoteBrowser::~RemoteBrowser() {
1062 }
1063
1064
1065 // DevToolsAdbBridge::RemoteDevice --------------------------------------------
1066
1067 DevToolsAdbBridge::RemoteDevice::RemoteDevice(
1068     scoped_refptr<AndroidDevice> device)
1069     : device_(device) {
1070 }
1071
1072 std::string DevToolsAdbBridge::RemoteDevice::GetSerial() {
1073   return device_->serial();
1074 }
1075
1076 std::string DevToolsAdbBridge::RemoteDevice::GetModel() {
1077   return device_->model();
1078 }
1079
1080 bool DevToolsAdbBridge::RemoteDevice::IsConnected() {
1081   return device_->is_connected();
1082 }
1083
1084 void DevToolsAdbBridge::RemoteDevice::AddBrowser(
1085     scoped_refptr<RemoteBrowser> browser) {
1086   browsers_.push_back(browser);
1087 }
1088
1089 DevToolsAdbBridge::RemoteDevice::~RemoteDevice() {
1090 }
1091
1092
1093 // DevToolsAdbBridge ----------------------------------------------------------
1094
1095 DevToolsAdbBridge::DevToolsAdbBridge()
1096     : adb_thread_(RefCountedAdbThread::GetInstance()),
1097       has_message_loop_(adb_thread_->message_loop() != NULL) {
1098 }
1099
1100 void DevToolsAdbBridge::AddListener(Listener* listener) {
1101   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1102   if (listeners_.empty())
1103     RequestRemoteDevices();
1104   listeners_.push_back(listener);
1105 }
1106
1107 void DevToolsAdbBridge::RemoveListener(Listener* listener) {
1108   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1109   Listeners::iterator it =
1110       std::find(listeners_.begin(), listeners_.end(), listener);
1111   DCHECK(it != listeners_.end());
1112   listeners_.erase(it);
1113 }
1114
1115 bool DevToolsAdbBridge::HasDevToolsWindow(const std::string& agent_id) {
1116   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1117   return g_host_delegates.Get().find(agent_id) != g_host_delegates.Get().end();
1118 }
1119
1120 DevToolsAdbBridge::~DevToolsAdbBridge() {
1121   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1122   DCHECK(listeners_.empty());
1123 }
1124
1125 void DevToolsAdbBridge::RequestRemoteDevices() {
1126   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1127   if (!has_message_loop_)
1128     return;
1129
1130   new AdbPagesCommand(
1131       adb_thread_, device_providers_,
1132       base::Bind(&DevToolsAdbBridge::ReceivedRemoteDevices, this));
1133 }
1134
1135 void DevToolsAdbBridge::ReceivedRemoteDevices(RemoteDevices* devices_ptr) {
1136   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1137
1138   scoped_ptr<RemoteDevices> devices(devices_ptr);
1139
1140   Listeners copy(listeners_);
1141   for (Listeners::iterator it = copy.begin(); it != copy.end(); ++it)
1142     (*it)->RemoteDevicesChanged(devices.get());
1143
1144   if (listeners_.empty())
1145     return;
1146
1147   BrowserThread::PostDelayedTask(
1148       BrowserThread::UI,
1149       FROM_HERE,
1150       base::Bind(&DevToolsAdbBridge::RequestRemoteDevices, this),
1151       base::TimeDelta::FromMilliseconds(kAdbPollingIntervalMs));
1152 }