DevTools: discover default port node servers for debugging (behind experiment)

chrome/browser/devtools/chrome_devtools_manager_delegate.cc

Index: chrome/browser/devtools/chrome_devtools_manager_delegate.cc
diff --git a/chrome/browser/devtools/chrome_devtools_manager_delegate.cc b/chrome/browser/devtools/chrome_devtools_manager_delegate.cc
index e72dc3a5206db283ffc6c1663588bbfffea2992b..7afa40a50a1cd9611b9f5f7491d9faf1fc91660d 100644
--- a/chrome/browser/devtools/chrome_devtools_manager_delegate.cc
+++ b/chrome/browser/devtools/chrome_devtools_manager_delegate.cc
@@ -4,9 +4,13 @@
 
 #include "chrome/browser/devtools/chrome_devtools_manager_delegate.h"
 
+#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
+#include "chrome/browser/devtools/device/android_device_manager.h"
+#include "chrome/browser/devtools/device/tcp_device_provider.h"
 #include "chrome/browser/devtools/devtools_network_protocol_handler.h"
+#include "chrome/browser/devtools/devtools_protocol_constants.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
@@ -22,12 +26,19 @@
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/process_manager.h"
+#include "net/base/host_port_pair.h"
 #include "ui/base/resource/resource_bundle.h"
 
+using content::DevToolsAgentHost;
+
 char ChromeDevToolsManagerDelegate::kTypeApp[] = "app";
 char ChromeDevToolsManagerDelegate::kTypeBackgroundPage[] = "background_page";
 char ChromeDevToolsManagerDelegate::kTypeWebView[] = "webview";
 
+char kLocationsParam[] = "locations";
+char kHostParam[] = "host";
+char kPortParam[] = "port";
+
 ChromeDevToolsManagerDelegate::ChromeDevToolsManagerDelegate()
     : network_protocol_handler_(new DevToolsNetworkProtocolHandler()) {
 }
@@ -40,9 +51,50 @@ void ChromeDevToolsManagerDelegate::Inspect(
   DevToolsWindow::OpenDevToolsWindow(agent_host, nullptr);
 }
 
+void ChromeDevToolsManagerDelegate::DevicesAvailable(
+    const DevToolsAgentHost::DiscoveryCallback& callback,
+    const DevToolsAndroidBridge::CompleteDevices& devices) {
+  DevToolsAgentHost::List result = DevToolsAgentHost::GetOrCreateAll();
+  for (const auto& complete : devices) {
+    for (const auto& browser : complete.second->browsers()) {
+      for (const auto& page : browser->pages())
+        result.push_back(page->CreateTarget());
+    }
+  }
+  callback.Run(std::move(result));
+}
+
+bool ChromeDevToolsManagerDelegate::DiscoverTargets(
+    const DevToolsAgentHost::DiscoveryCallback& callback) {
+  if (!device_manager_) {
+    device_manager_ = AndroidDeviceManager::Create();
+  }
+
+  AndroidDeviceManager::DeviceProviders providers;
+  providers.push_back(new TCPDeviceProvider(tcp_locations_));
+  device_manager_->SetDeviceProviders(providers);
+
+  DevToolsAndroidBridge::QueryCompleteDevices(
+      device_manager_.get(),
+      base::Bind(&ChromeDevToolsManagerDelegate::DevicesAvailable,
+                 base::Unretained(this),
+                 callback));
+  return true;

[dgozman, 2016/09/23 20:57:22]

Let's skip all the work and callback synchronously when tcp_locations_ is empty.

[pfeldman, 2016/09/23 21:05:21]

Done.

+}
+
 base::DictionaryValue* ChromeDevToolsManagerDelegate::HandleCommand(
-    content::DevToolsAgentHost* agent_host,
+    DevToolsAgentHost* agent_host,
     base::DictionaryValue* command_dict) {
+
+  int id = 0;
+  std::string method;
+  base::DictionaryValue* params = nullptr;
+  if (!DevToolsProtocol::ParseCommand(command_dict, &id, &method, &params))
+    return nullptr;
+
+  if (method == chrome::devtools::Browser::setRemoteLocations::kName)
+    return SetRemoteLocations(agent_host, id, params).release();
+
   return network_protocol_handler_->HandleCommand(agent_host, command_dict);
 }
 
@@ -59,23 +111,23 @@ std::string ChromeDevToolsManagerDelegate::GetTargetType(
     return kTypeWebView;
 
   if (host->GetParent())
-    return content::DevToolsAgentHost::kTypeFrame;
+    return DevToolsAgentHost::kTypeFrame;
 
   for (TabContentsIterator it; !it.done(); it.Next()) {
     if (*it == web_contents)
-      return content::DevToolsAgentHost::kTypePage;
+      return DevToolsAgentHost::kTypePage;
   }
 
   const extensions::Extension* extension = extensions::ExtensionRegistry::Get(
       web_contents->GetBrowserContext())->enabled_extensions().GetByID(
           host->GetLastCommittedURL().host());
   if (!extension)
-    return content::DevToolsAgentHost::kTypeOther;
+    return DevToolsAgentHost::kTypeOther;
 
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   if (!profile)
-    return content::DevToolsAgentHost::kTypeOther;
+    return DevToolsAgentHost::kTypeOther;
 
   extensions::ExtensionHost* extension_host =
       extensions::ProcessManager::Get(profile)
@@ -88,7 +140,7 @@ std::string ChromeDevToolsManagerDelegate::GetTargetType(
              || extension->is_platform_app()) {
     return kTypeApp;
   }
-  return content::DevToolsAgentHost::kTypeOther;
+  return DevToolsAgentHost::kTypeOther;
 }
 
 std::string ChromeDevToolsManagerDelegate::GetTargetTitle(
@@ -109,7 +161,7 @@ std::string ChromeDevToolsManagerDelegate::GetTargetTitle(
   return "";
 }
 
-scoped_refptr<content::DevToolsAgentHost>
+scoped_refptr<DevToolsAgentHost>
 ChromeDevToolsManagerDelegate::CreateNewTarget(const GURL& url) {
   chrome::NavigateParams params(ProfileManager::GetLastUsedProfile(),
       url, ui::PAGE_TRANSITION_AUTO_TOPLEVEL);
@@ -117,7 +169,7 @@ ChromeDevToolsManagerDelegate::CreateNewTarget(const GURL& url) {
   chrome::Navigate(&params);
   if (!params.target_contents)
     return nullptr;
-  return content::DevToolsAgentHost::GetOrCreateFor(params.target_contents);
+  return DevToolsAgentHost::GetOrCreateFor(params.target_contents);
 }
 
 std::string ChromeDevToolsManagerDelegate::GetDiscoveryPageHTML() {
@@ -131,7 +183,42 @@ std::string ChromeDevToolsManagerDelegate::GetFrontendResource(
 }
 
 void ChromeDevToolsManagerDelegate::DevToolsAgentStateChanged(
-    content::DevToolsAgentHost* agent_host,
+    DevToolsAgentHost* agent_host,
     bool attached) {
   network_protocol_handler_->DevToolsAgentStateChanged(agent_host, attached);
 }
+
+std::unique_ptr<base::DictionaryValue>
+ChromeDevToolsManagerDelegate::SetRemoteLocations(
+    content::DevToolsAgentHost* agent_host,
+    int command_id,
+    base::DictionaryValue* params) {
+  tcp_locations_.clear();
+
+  base::ListValue* locations;
+  if (!params->GetList(kLocationsParam, &locations))
+    return DevToolsProtocol::CreateInvalidParamsResponse(command_id,
+                                                         kLocationsParam);
+  for (const auto& item : *locations) {
+    if (!item->IsType(base::Value::TYPE_DICTIONARY)) {
+      return DevToolsProtocol::CreateInvalidParamsResponse(command_id,
+                                                           kLocationsParam);
+    }
+    base::DictionaryValue* dictionary =
+        static_cast<base::DictionaryValue*>(item.get());
+    std::string host;
+    if (!dictionary->GetStringWithoutPathExpansion(kHostParam, &host)) {
+      return DevToolsProtocol::CreateInvalidParamsResponse(command_id,
+                                                           kLocationsParam);
+    }
+    int port = 0;
+    if (!dictionary->GetIntegerWithoutPathExpansion(kPortParam, &port)) {
+      return DevToolsProtocol::CreateInvalidParamsResponse(command_id,
+                                                           kLocationsParam);
+    }
+    tcp_locations_.insert(net::HostPortPair(host, port));
+  }
+  std::unique_ptr<base::DictionaryValue> result(
+      base::MakeUnique<base::DictionaryValue>());
+  return DevToolsProtocol::CreateSuccessResponse(command_id, std::move(result));
+}