[DevTools] Implement Target.setDiscoverTargets method.

content/browser/devtools/protocol/target_handler.cc

 // Copyright 2016 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/protocol/target_handler.h"
 
 #include "content/browser/devtools/service_worker_devtools_agent_host.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
@@ skipping 157 matching lines @@
 
 void TargetHandler::ReattachTargetsOfType(
     const HostsMap& new_hosts,
     const std::string& type,
     bool waiting_for_debugger) {
   HostsMap old_hosts = attached_hosts_;
   for (const auto& pair : old_hosts) {
     if (pair.second->GetType() == type &&
         new_hosts.find(pair.first) == new_hosts.end()) {
       DetachFromTargetInternal(pair.second.get());
-      TargetRemovedInternal(pair.second.get());
+      TargetDestroyedInternal(pair.second.get(), true);
     }
   }
   for (const auto& pair : new_hosts) {
     if (old_hosts.find(pair.first) == old_hosts.end()) {
       TargetCreatedInternal(pair.second.get());
       AttachToTargetInternal(pair.second.get(), waiting_for_debugger);
     }
   }
 }
 
 void TargetHandler::TargetCreatedInternal(DevToolsAgentHost* host) {
+  if (reported_hosts_.find(host->GetId()) != reported_hosts_.end())
+    return;
   client_->TargetCreated(
       TargetCreatedParams::Create()->set_target_info(
           TargetInfo::Create()->set_target_id(host->GetId())
                               ->set_title(host->GetTitle())
                               ->set_url(host->GetURL().spec())
                               ->set_type(host->GetType())));
+  reported_hosts_[host->GetId()] = host;
 }
 
-void TargetHandler::TargetRemovedInternal(DevToolsAgentHost* host) {
-  client_->TargetRemoved(TargetRemovedParams::Create()
+void TargetHandler::TargetDestroyedInternal(
+    DevToolsAgentHost* host,
+    bool keep_for_discovery) {
+  if (discover_ && keep_for_discovery)
+    return;
+  auto it = reported_hosts_.find(host->GetId());
+  if (it == reported_hosts_.end())
+    return;
+  client_->TargetDestroyed(TargetDestroyedParams::Create()
       ->set_target_id(host->GetId()));
+  reported_hosts_.erase(it);
 }
 
 bool TargetHandler::AttachToTargetInternal(
     DevToolsAgentHost* host, bool waiting_for_debugger) {
   if (!host->AttachClient(this))
     return false;
   attached_hosts_[host->GetId()] = host;
   client_->AttachedToTarget(AttachedToTargetParams::Create()
       ->set_target_id(host->GetId())
       ->set_waiting_for_debugger(waiting_for_debugger));
   return true;
 }
 
 void TargetHandler::DetachFromTargetInternal(DevToolsAgentHost* host) {
   auto it = attached_hosts_.find(host->GetId());
   if (it == attached_hosts_.end())
     return;
   host->DetachClient(this);
   client_->DetachedFromTarget(DetachedFromTargetParams::Create()->
       set_target_id(host->GetId()));
   attached_hosts_.erase(it);
 }
 
 // ----------------- Protocol ----------------------
 
 Response TargetHandler::SetDiscoverTargets(bool discover) {
   if (discover_ == discover)
     return Response::OK();
   discover_ = discover;
-  // TODO(dgozman): observe all agent hosts here.
+  if (discover_) {
+    DevToolsManager::GetInstance()->AddObserver(this);
+  } else {
+    DevToolsManager::GetInstance()->RemoveObserver(this);
+    RawHostsMap copy = reported_hosts_;
+    for (const auto& id_host : copy) {
+      if (attached_hosts_.find(id_host.first) == attached_hosts_.end())
+        TargetDestroyedInternal(id_host.second, false);
+    }
+  }
   return Response::OK();
 }
 
 Response TargetHandler::SetAutoAttach(
     bool auto_attach, bool wait_for_debugger_on_start) {
   wait_for_debugger_on_start_ = wait_for_debugger_on_start;
   if (auto_attach_ == auto_attach)
     return Response::OK();
   auto_attach_ = auto_attach;
   if (auto_attach_) {
@@ skipping 17 matching lines @@
     UpdateFrames();
   } else {
     HostsMap empty;
     ReattachTargetsOfType(empty, DevToolsAgentHost::kTypeFrame, false);
   }
   return Response::OK();
 }
 
 Response TargetHandler::AttachToTarget(const std::string& target_id,
                                        bool* out_success) {
-  scoped_refptr<DevToolsAgentHost> agent_host(
-      DevToolsAgentHost::GetForId(target_id));
-  if (!agent_host)
+  auto it = reported_hosts_.find(target_id);
+  if (it == reported_hosts_.end())
     return Response::InvalidParams("No target with such id");
-  *out_success = AttachToTargetInternal(agent_host.get(), false);
+  *out_success = AttachToTargetInternal(it->second, false);
   return Response::OK();
 }
 
 Response TargetHandler::DetachFromTarget(const std::string& target_id) {
   auto it = attached_hosts_.find(target_id);
   if (it == attached_hosts_.end())
     return Response::InternalError("Not attached to the target");
-  DetachFromTargetInternal(it->second.get());
+  DevToolsAgentHost* agent_host = it->second.get();
+  DetachFromTargetInternal(agent_host);
+  TargetDestroyedInternal(agent_host, true);
   return Response::OK();
 }
 
 Response TargetHandler::SendMessageToTarget(
     const std::string& target_id,
     const std::string& message) {
   auto it = attached_hosts_.find(target_id);
   if (it == attached_hosts_.end())
     return Response::InternalError("Not attached to the target");
   it->second->DispatchProtocolMessage(this, message);
   return Response::OK();
 }
 
 Response TargetHandler::GetTargetInfo(
     const std::string& target_id,
     scoped_refptr<TargetInfo>* target_info) {
+  // TODO(dgozman): only allow reported hosts.
   scoped_refptr<DevToolsAgentHost> agent_host(
       DevToolsAgentHost::GetForId(target_id));
   if (!agent_host)
     return Response::InvalidParams("No target with such id");
   *target_info = TargetInfo::Create()
       ->set_target_id(agent_host->GetId())
       ->set_type(agent_host->GetType())
       ->set_title(agent_host->GetTitle())
       ->set_url(agent_host->GetURL().spec());
   return Response::OK();
 }
 
 Response TargetHandler::ActivateTarget(const std::string& target_id) {
+  // TODO(dgozman): only allow reported hosts.
   scoped_refptr<DevToolsAgentHost> agent_host(
       DevToolsAgentHost::GetForId(target_id));
   if (!agent_host)
     return Response::InvalidParams("No target with such id");
   agent_host->Activate();
   return Response::OK();
 }
 
 // ---------------- DevToolsAgentHostClient ----------------
 
 void TargetHandler::DispatchProtocolMessage(
     DevToolsAgentHost* host,
     const std::string& message) {
   auto it = attached_hosts_.find(host->GetId());
   if (it == attached_hosts_.end())
     return;  // Already disconnected.
 
   client_->ReceivedMessageFromTarget(
       ReceivedMessageFromTargetParams::Create()->
           set_target_id(host->GetId())->
           set_message(message));
 }
 
 void TargetHandler::AgentHostClosed(
     DevToolsAgentHost* host,
     bool replaced_with_another_client) {
   client_->DetachedFromTarget(DetachedFromTargetParams::Create()->
       set_target_id(host->GetId()));
   attached_hosts_.erase(host->GetId());
-  TargetRemovedInternal(host);
+  TargetDestroyedInternal(host, false);
+}
+
+// -------------- DevToolsManager::Observer -----------------
+
+void TargetHandler::AgentHostCreated(DevToolsAgentHostImpl* agent_host) {
+  DCHECK(attached_hosts_.find(agent_host->GetId()) == attached_hosts_.end());
+  TargetCreatedInternal(agent_host);
+}
+
+void TargetHandler::AgentHostDestroyed(DevToolsAgentHostImpl* agent_host) {
+  DCHECK(attached_hosts_.find(agent_host->GetId()) == attached_hosts_.end());
+  TargetDestroyedInternal(agent_host, false);
 }
 
 // -------- ServiceWorkerDevToolsManager::Observer ----------
 
 void TargetHandler::WorkerCreated(
     ServiceWorkerDevToolsAgentHost* host) {
   BrowserContext* browser_context = nullptr;
   if (render_frame_host_)
     browser_context = render_frame_host_->GetProcess()->GetBrowserContext();
   auto hosts = GetMatchingServiceWorkers(browser_context, frame_urls_);
@@ skipping 25 matching lines @@
 }
 
 void TargetHandler::WorkerDestroyed(
     ServiceWorkerDevToolsAgentHost* host) {
   UpdateServiceWorkers();
 }
 
 }  // namespace target
 }  // namespace devtools
 }  // namespace content