[DevTools] Implement Target.setDiscoverTargets method.

content/browser/devtools/devtools_manager.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_manager.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "content/browser/devtools/devtools_agent_host_impl.h"
 #include "content/browser/devtools/devtools_http_handler.h"
 #include "content/browser/loader/netlog_observer.h"
+#include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/devtools_socket_factory.h"
 
 namespace content {
 
 // static
 void DevToolsAgentHost::StartRemoteDebuggingServer(
       std::unique_ptr<DevToolsSocketFactory> server_socket_factory,
       const std::string& frontend_url,
       const base::FilePath& active_port_output_directory,
       const base::FilePath& debug_frontend_dir,
       const std::string& product_name,
       const std::string& user_agent) {
   DevToolsManager* manager = DevToolsManager::GetInstance();
-  if (!manager->delegate())
+  if (!manager->GetDelegate())
     return;
   manager->SetHttpHandler(base::WrapUnique(new DevToolsHttpHandler(
-      manager->delegate(), std::move(server_socket_factory), frontend_url,
+      manager->GetDelegate(), std::move(server_socket_factory), frontend_url,
       active_port_output_directory, debug_frontend_dir, product_name,
       user_agent)));
 }
 
 // static
 void DevToolsAgentHost::StopRemoteDebuggingServer() {
   DevToolsManager* manager = DevToolsManager::GetInstance();
   manager->SetHttpHandler(nullptr);
 }
 
 // static
 DevToolsManager* DevToolsManager::GetInstance() {
   return base::Singleton<DevToolsManager>::get();
 }
 
 DevToolsManager::DevToolsManager()
-    : delegate_(GetContentClient()->browser()->GetDevToolsManagerDelegate()),
+    : delegate_initialized_(false),
       attached_hosts_count_(0) {
 }
 
 DevToolsManager::~DevToolsManager() {
+  for (DevToolsAgentHostImpl* agent_host : agent_hosts_) {

[pfeldman, 2016/10/12 23:11:18]

How can this happen?

[dgozman, 2016/10/12 23:23:12]

Service workers shutdown later (I think on IO) than this singleton is destroyed
on UI thread, keeping their agent hosts alive longer.

[pfeldman, 2016/10/13 17:58:10]

Could you mention it the comments here? Also, what if their destructors access
the manager? Btw, we already have g_instances in the DevToolsAgentHostImpl.

I'd rather make sure that devtoolsmanager outlives the hosts and stored pointers
to them in the manager, hence removing the g_instances. If that is not feasible,
I'd at least reuse the g_instances here.

+    for (auto& observer : observers_)
+      observer.AgentHostDestroyed(agent_host);
+  }
+  agent_hosts_.clear();
   DCHECK(!attached_hosts_count_);
 }
 
+DevToolsManagerDelegate* DevToolsManager::GetDelegate() {
+  if (!delegate_initialized_) {

[pfeldman, 2016/10/12 23:11:18]

What is wrong with !delegate_ ?

[dgozman, 2016/10/12 23:23:12]

Client can pass a null one, I don't want to ask for it again.

+    delegate_initialized_ = true;
+    delegate_.reset(
+        GetContentClient()->browser()->GetDevToolsManagerDelegate());
+  }
+  return delegate_.get();
+}
+
+void DevToolsManager::AddObserver(Observer* observer) {
+  if (!observers_.might_have_observers()) {
+    // Force all agent hosts when first observer is added.
+    DevToolsAgentHost::GetOrCreateAll();
+  }
+  observers_.AddObserver(observer);
+  for (DevToolsAgentHostImpl* agent_host : agent_hosts_)
+    observer->AgentHostCreated(agent_host);
+}
+
+void DevToolsManager::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+void DevToolsManager::WebContentsCreated(WebContentsImpl* web_contents) {
+  if (observers_.might_have_observers()) {
+    // Force agent host.
+    DevToolsAgentHost::GetOrCreateFor(web_contents);
+  }
+}
+
+void DevToolsManager::AgentHostCreated(DevToolsAgentHostImpl* agent_host) {
+  agent_hosts_.insert(agent_host);
+  for (auto& observer : observers_)
+    observer.AgentHostCreated(agent_host);
+}
+
+void DevToolsManager::AgentHostDestroyed(DevToolsAgentHostImpl* agent_host) {
+  for (auto& observer : observers_)
+    observer.AgentHostDestroyed(agent_host);
+  agent_hosts_.erase(agent_host);
+}
+
 void DevToolsManager::AgentHostStateChanged(
     DevToolsAgentHostImpl* agent_host, bool attached) {
   if (attached) {
     if (!attached_hosts_count_) {
       BrowserThread::PostTask(
           BrowserThread::IO,
           FROM_HERE,
           base::Bind(&NetLogObserver::Attach,
                      GetContentClient()->browser()->GetNetLog()));
     }
     ++attached_hosts_count_;
   } else {
     --attached_hosts_count_;
     if (!attached_hosts_count_) {
       BrowserThread::PostTask(
           BrowserThread::IO,
           FROM_HERE,
           base::Bind(&NetLogObserver::Detach));
     }
   }
 }
 
 void DevToolsManager::SetHttpHandler(
     std::unique_ptr<DevToolsHttpHandler> http_handler) {
   http_handler_ = std::move(http_handler);
 }
 
 }  // namespace content