DevTools: remove devtools_discovery (merged into content).

content/browser/devtools/devtools_agent_host_impl.cc

 // Copyright (c) 2012 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 "content/browser/devtools/devtools_agent_host_impl.h"
 
 #include <map>
 #include <vector>
 
 #include "base/guid.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "content/browser/devtools/devtools_manager.h"
 #include "content/browser/devtools/forwarding_agent_host.h"
 #include "content/browser/devtools/protocol/devtools_protocol_dispatcher.h"
 #include "content/browser/devtools/render_frame_devtools_agent_host.h"
 #include "content/browser/devtools/service_worker_devtools_agent_host.h"
 #include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/browser/devtools/shared_worker_devtools_agent_host.h"
 #include "content/browser/devtools/shared_worker_devtools_manager.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace content {
 
 namespace {
 typedef std::map<std::string, DevToolsAgentHostImpl*> Instances;
 base::LazyInstance<Instances>::Leaky g_instances = LAZY_INSTANCE_INITIALIZER;
 
-typedef std::vector<const DevToolsAgentHost::AgentStateCallback*>
-    AgentStateCallbacks;
+using AgentStateCallbacks =
+    std::vector<const DevToolsAgentHost::AgentStateCallback*>;
 base::LazyInstance<AgentStateCallbacks>::Leaky g_callbacks =
     LAZY_INSTANCE_INITIALIZER;
+using DiscoveryCallbacks =
+    std::vector<DevToolsAgentHost::DiscoveryCallback>;
+base::LazyInstance<DiscoveryCallbacks>::Leaky g_providers =
+    LAZY_INSTANCE_INITIALIZER;
 }  // namespace
 
 char DevToolsAgentHost::kTypePage[] = "page";
 char DevToolsAgentHost::kTypeFrame[] = "frame";
 char DevToolsAgentHost::kTypeSharedWorker[] = "shared_worker";
 char DevToolsAgentHost::kTypeServiceWorker[] = "service_worker";
 char DevToolsAgentHost::kTypeExternal[] = "external";
 char DevToolsAgentHost::kTypeBrowser[] = "browser";
 char DevToolsAgentHost::kTypeOther[] = "other";
 
 // static
+DevToolsManagerDelegate* DevToolsAgentHost::GetDevToolsManagerDelegate() {
+  DevToolsManager* manager = DevToolsManager::GetInstance();
+  return manager->delegate();
+}
+
+// static
 std::string DevToolsAgentHost::GetProtocolVersion() {
   return std::string(devtools::kProtocolVersion);
 }
 
 // static
 bool DevToolsAgentHost::IsSupportedProtocolVersion(const std::string& version) {
   return devtools::IsSupportedProtocolVersion(version);
 }
 
 // static
+void DevToolsAgentHost::AddDiscoveryProvider(
+    const DiscoveryCallback& callback) {
+  g_providers.Get().push_back(callback);
+}
+
+// static
 DevToolsAgentHost::List DevToolsAgentHost::GetOrCreateAll() {
   List result;
   SharedWorkerDevToolsAgentHost::List shared_list;
   SharedWorkerDevToolsManager::GetInstance()->AddAllAgentHosts(&shared_list);
   for (const auto& host : shared_list)
     result.push_back(host);
 
   ServiceWorkerDevToolsAgentHost::List service_list;
   ServiceWorkerDevToolsManager::GetInstance()->AddAllAgentHosts(&service_list);
   for (const auto& host : service_list)
     result.push_back(host);
 
   RenderFrameDevToolsAgentHost::AddAllAgentHosts(&result);
   return result;
 }
 
+// static
+DevToolsAgentHost::List DevToolsAgentHost::DiscoverAllHosts() {
+  content::DevToolsAgentHost::List result;
+  for (auto& provider : g_providers.Get()) {
+    content::DevToolsAgentHost::List partial = provider.Run();
+    result.insert(result.begin(), partial.begin(), partial.end());
+  }
+  return result;
+}
+
 // Called on the UI thread.
 // static
 scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::GetForWorker(
     int worker_process_id,
     int worker_route_id) {
   if (scoped_refptr<DevToolsAgentHost> host =
       SharedWorkerDevToolsManager::GetInstance()
           ->GetDevToolsAgentHostForWorker(worker_process_id,
                                           worker_route_id)) {
     return host;
@@ skipping 267 matching lines @@
     if (message_buffer_.size() != message_buffer_size_)
       return false;
     callback_.Run(chunk.session_id, message_buffer_);
     message_buffer_ = std::string();
     message_buffer_size_ = 0;
   }
   return true;
 }
 
 }  // namespace content