[DevTools] Implement Target.setDiscoverTargets method.

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/bind.h"
@@ skipping 24 matching lines @@
 }  // namespace
 
 char DevToolsAgentHost::kTypePage[] = "page";
 char DevToolsAgentHost::kTypeFrame[] = "iframe";
 char DevToolsAgentHost::kTypeSharedWorker[] = "shared_worker";
 char DevToolsAgentHost::kTypeServiceWorker[] = "service_worker";
 char DevToolsAgentHost::kTypeExternal[] = "external";
 char DevToolsAgentHost::kTypeBrowser[] = "browser";
 char DevToolsAgentHost::kTypeOther[] = "other";
 int DevToolsAgentHostImpl::s_attached_count_ = 0;
+int DevToolsAgentHostImpl::s_force_creation_count_ = 0;
 
 // static
 std::string DevToolsAgentHost::GetProtocolVersion() {
   return std::string(devtools::kProtocolVersion);
 }
 
 // static
 bool DevToolsAgentHost::IsSupportedProtocolVersion(const std::string& version) {
   return devtools::IsSupportedProtocolVersion(version);
 }
 
 // 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);
+
+#if DCHECK_IS_ON()
+  for (auto it : result) {
+    DevToolsAgentHostImpl* host = static_cast<DevToolsAgentHostImpl*>(it.get());
+    DCHECK(g_instances.Get().find(host->id_) != g_instances.Get().end());
+  }
+#endif
+
   return result;
 }
 
 // static
 void DevToolsAgentHost::DiscoverAllHosts(const DiscoveryCallback& callback) {
   DevToolsManager* manager = DevToolsManager::GetInstance();
   if (!manager->delegate() || !manager->delegate()->DiscoverTargets(callback))
     callback.Run(DevToolsAgentHost::GetOrCreateAll());
 }
 
@@ skipping 10 matching lines @@
   }
   return ServiceWorkerDevToolsManager::GetInstance()
       ->GetDevToolsAgentHostForWorker(worker_process_id, worker_route_id);
 }
 
 DevToolsAgentHostImpl::DevToolsAgentHostImpl(const std::string& id)
     : id_(id),
       session_id_(0),
       client_(NULL) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK(g_instances.Get().find(id_) == g_instances.Get().end());
-  g_instances.Get()[id_] = this;
 }
 
 DevToolsAgentHostImpl::~DevToolsAgentHostImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  g_instances.Get().erase(g_instances.Get().find(id_));
+  NotifyDestroyed();
 }
 
 // static
 scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::GetForId(
     const std::string& id) {
   if (g_instances == NULL)
     return NULL;
   Instances::iterator it = g_instances.Get().find(id);
   if (it == g_instances.Get().end())
     return NULL;
@@ skipping 170 matching lines @@
       DevToolsAgentHostClient* client = agent_host->client_;
       agent_host->client_ = NULL;
       client->AgentHostClosed(agent_host, true);
       agent_host->InnerDetach();
     }
   }
 }
 
 // static
 void DevToolsAgentHost::AddObserver(DevToolsAgentHostObserver* observer) {
+  if (observer->ShouldForceDevToolsAgentHostCreation()) {
+    if (!DevToolsAgentHostImpl::s_force_creation_count_) {
+      // Force all agent hosts when first observer is added.
+      DevToolsAgentHost::GetOrCreateAll();
+    }
+    DevToolsAgentHostImpl::s_force_creation_count_++;
+  }
+
   g_observers.Get().AddObserver(observer);
+  for (const auto& id_host : g_instances.Get())
+    observer->DevToolsAgentHostCreated(id_host.second);
 }
 
 // static
 void DevToolsAgentHost::RemoveObserver(DevToolsAgentHostObserver* observer) {
+  if (observer->ShouldForceDevToolsAgentHostCreation())
+    DevToolsAgentHostImpl::s_force_creation_count_--;
   g_observers.Get().RemoveObserver(observer);
 }
 
+// static
+bool DevToolsAgentHostImpl::ShouldForceCreation() {
+  return !!s_force_creation_count_;
+}
+
+void DevToolsAgentHostImpl::NotifyCreated() {
+  DCHECK(g_instances.Get().find(id_) == g_instances.Get().end());
+  g_instances.Get()[id_] = this;
+  for (auto& observer : g_observers.Get())
+    observer.DevToolsAgentHostCreated(this);
+}
+
 void DevToolsAgentHostImpl::NotifyAttached() {
   if (!s_attached_count_) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&NetLogObserver::Attach,
                    GetContentClient()->browser()->GetNetLog()));
   }
   ++s_attached_count_;
 
   for (auto& observer : g_observers.Get())
     observer.DevToolsAgentHostAttached(this);
 }
 
 void DevToolsAgentHostImpl::NotifyDetached() {
   --s_attached_count_;
   if (!s_attached_count_) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&NetLogObserver::Detach));
   }
 
   for (auto& observer : g_observers.Get())
     observer.DevToolsAgentHostDetached(this);
 }
 
+void DevToolsAgentHostImpl::NotifyDestroyed() {
+  DCHECK(g_instances.Get().find(id_) != g_instances.Get().end());
+  for (auto& observer : g_observers.Get())
+    observer.DevToolsAgentHostDestroyed(this);
+  g_instances.Get().erase(id_);
+}
+
 // DevToolsMessageChunkProcessor -----------------------------------------------
 
 DevToolsMessageChunkProcessor::DevToolsMessageChunkProcessor(
     const SendMessageCallback& callback)
     : callback_(callback),
       message_buffer_size_(0),
       last_call_id_(0) {
 }
 
 DevToolsMessageChunkProcessor::~DevToolsMessageChunkProcessor() {
@@ skipping 27 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