DevTools: allow to pass list of remote debugging targets as command line argument

chrome/browser/devtools/device/self_device_provider.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/self_device_provider.h"
 
+#include <algorithm>
+
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/socket/tcp_client_socket.h"
 
 namespace {
 
 const char kDeviceModel[] = "Local Chrome";

[dgozman, 2015/07/06 10:08:34]

It's not Chrome anymore, let's update.

[yurys, 2015/07/06 12:49:00]

Done.

 const char kBrowserName[] = "Chrome";

[dgozman, 2015/07/06 10:08:34]

ditto

[yurys, 2015/07/06 12:49:00]

Done.

-const char kLocalhost[] = "127.0.0.1";
-const char kSerial[] = "local";
 
 static void RunSocketCallback(
     const AndroidDeviceManager::SocketCallback& callback,
     scoped_ptr<net::StreamSocket> socket,
     int result) {
   callback.Run(result, socket.Pass());
 }
 
 }  // namespace
 
-SelfAsDeviceProvider::SelfAsDeviceProvider(int port) : port_(port) {
+SelfAsDeviceProvider::SelfAsDeviceProvider(const RemoteTargets& targets)
+    : targets_(targets) {
 }
 
 void SelfAsDeviceProvider::QueryDevices(const SerialsCallback& callback) {
   std::vector<std::string> result;
-  result.push_back(kSerial);
+  for (const net::HostPortPair& target : targets_) {
+    const std::string& host = target.host();
+    if (std::find(result.begin(), result.end(), host) != result.end()) {

[dgozman, 2015/07/06 10:08:34]

nit: we don't usually wrap one-liners with {}

[yurys, 2015/07/06 12:49:00]

Done.

+      continue;
+    }
+    result.push_back(host);
+  }
   callback.Run(result);
 }
 
 void SelfAsDeviceProvider::QueryDeviceInfo(const std::string& serial,
                                            const DeviceInfoCallback& callback) {
   AndroidDeviceManager::DeviceInfo device_info;
   device_info.model = kDeviceModel;
   device_info.connected = true;
 
-  AndroidDeviceManager::BrowserInfo browser_info;
-  browser_info.socket_name = base::IntToString(port_);
-  browser_info.display_name = kBrowserName;
-  browser_info.type = AndroidDeviceManager::BrowserInfo::kTypeChrome;
+  for (const net::HostPortPair& target : targets_) {
+    if (serial != target.host()) {

[pfeldman, 2015/07/06 10:10:04]

ditto

[yurys, 2015/07/06 12:49:00]

Done.

+      continue;
+    }
+    AndroidDeviceManager::BrowserInfo browser_info;
+    browser_info.socket_name = base::IntToString(target.port());
+    browser_info.display_name = kBrowserName;
+    browser_info.type = AndroidDeviceManager::BrowserInfo::kTypeChrome;
 
-  device_info.browser_info.push_back(browser_info);
+    device_info.browser_info.push_back(browser_info);
+  }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, device_info));
 }
 
 void SelfAsDeviceProvider::OpenSocket(const std::string& serial,
                                       const std::string& socket_name,
                                       const SocketCallback& callback) {
   // Use plain socket for remote debugging and port forwarding on Desktop
   // (debugging purposes).
   net::IPAddressNumber ip_number;
-  net::ParseIPLiteralToNumber(kLocalhost, &ip_number);
+  if (!net::ParseIPLiteralToNumber(serial, &ip_number)) {

[pfeldman, 2015/07/06 10:10:04]

ditto

[yurys, 2015/07/06 12:49:00]

Done.

+    LOG(ERROR) << "Failed to parse IP address: " << serial;

[dgozman, 2015/07/06 10:08:34]

We should |callback(nullptr)| probably.

[yurys, 2015/07/06 12:49:00]

Done.

+  }
   int port;
   base::StringToInt(socket_name, &port);
   net::AddressList address_list =
       net::AddressList::CreateFromIPAddress(ip_number, port);
   scoped_ptr<net::StreamSocket> socket(new net::TCPClientSocket(
       address_list, NULL, net::NetLog::Source()));
   socket->Connect(
       base::Bind(&RunSocketCallback, callback, base::Passed(&socket)));
 }
 
 void SelfAsDeviceProvider::ReleaseDevice(const std::string& serial) {
-  DCHECK(serial == kSerial);
   if (!release_callback_.is_null())
     release_callback_.Run();
 }
 
 void SelfAsDeviceProvider::set_release_callback_for_test(
     const base::Closure& callback) {
   release_callback_ = callback;
 }
 
 SelfAsDeviceProvider::~SelfAsDeviceProvider() {
 }