[DevTools] Support Target.setWaitForDebuggerOnStart.

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 69 matching lines @@
   for (const auto& it : scope_agents_map)
     AddEligibleHosts(*it.second.get(), &result);
 
   return result;
 }
 
 }  // namespace
 
 TargetHandler::TargetHandler()
     : enabled_(false),
+      wait_for_debugger_on_start_(false),
       render_frame_host_(nullptr) {
 }
 
 TargetHandler::~TargetHandler() {
   Disable();
 }
 
 void TargetHandler::SetRenderFrameHost(RenderFrameHostImpl* render_frame_host) {
   render_frame_host_ = render_frame_host;
 }
 
 void TargetHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
 void TargetHandler::Detached() {
   Disable();
 }
 
 void TargetHandler::UpdateServiceWorkers() {
+  UpdateServiceWorkers(false);
+}
+
+void TargetHandler::UpdateServiceWorkers(bool waiting_for_debugger) {
   if (!enabled_)
     return;
 
   frame_urls_.clear();
   BrowserContext* browser_context = nullptr;
   if (render_frame_host_) {
     // TODO(dgozman): do not traverse inside cross-process subframes.
     for (FrameTreeNode* node :
          render_frame_host_->frame_tree_node()->frame_tree()->Nodes()) {
       frame_urls_.insert(node->current_url());
     }
     browser_context = render_frame_host_->GetProcess()->GetBrowserContext();
   }
 
   std::map<std::string, scoped_refptr<DevToolsAgentHost>> old_hosts =
       attached_hosts_;
   ServiceWorkerDevToolsAgentHost::Map new_hosts =
       GetMatchingServiceWorkers(browser_context, frame_urls_);
 
   for (const auto& pair : old_hosts) {
     if (pair.second->GetType() == DevToolsAgentHost::kTypeServiceWorker &&
         new_hosts.find(pair.first) == new_hosts.end()) {
       DetachFromTargetInternal(pair.second.get());
     }
   }
 
   for (const auto& pair : new_hosts) {
     if (old_hosts.find(pair.first) == old_hosts.end())
-      AttachToTargetInternal(pair.second.get(), true);
+      AttachToTargetInternal(pair.second.get(), waiting_for_debugger);
   }
 }
 
 void TargetHandler::AttachToTargetInternal(
     DevToolsAgentHost* host, bool waiting_for_debugger) {
   if (host->IsAttached())
     return;
   attached_hosts_[host->GetId()] = host;
   host->AttachClient(this);
   client_->TargetCreated(TargetCreatedParams::Create()
@@ skipping 21 matching lines @@
   enabled_ = true;
   ServiceWorkerDevToolsManager::GetInstance()->AddObserver(this);
   UpdateServiceWorkers();
   return Response::OK();
 }
 
 Response TargetHandler::Disable() {
   if (!enabled_)
     return Response::OK();
   enabled_ = false;
+  wait_for_debugger_on_start_ = false;
   ServiceWorkerDevToolsManager::GetInstance()->RemoveObserver(this);
   for (const auto& pair : attached_hosts_)
     pair.second->DetachClient(this);
   attached_hosts_.clear();
   return Response::OK();
 }
 
 Response TargetHandler::SetWaitForDebuggerOnStart(bool value) {
-  // TODO(dgozman): implement this.
+  wait_for_debugger_on_start_ = value;
   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);
@@ skipping 49 matching lines @@
 
 // -------- 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_);
   if (hosts.find(host->GetId()) != hosts.end() && !host->IsAttached() &&
-      !host->IsPausedForDebugOnStart()) {
+      !host->IsPausedForDebugOnStart() && wait_for_debugger_on_start_) {
     host->PauseForDebugOnStart();
   }
 }
 
 void TargetHandler::WorkerReadyForInspection(
     ServiceWorkerDevToolsAgentHost* host) {
   if (ServiceWorkerDevToolsManager::GetInstance()
           ->debug_service_worker_on_start()) {
     // When debug_service_worker_on_start is true, a new DevTools window will
     // be opened in ServiceWorkerDevToolsManager::WorkerReadyForInspection.
     return;
   }
-  UpdateServiceWorkers();
+  UpdateServiceWorkers(host->IsPausedForDebugOnStart());
 }
 
 void TargetHandler::WorkerVersionInstalled(
     ServiceWorkerDevToolsAgentHost* host) {
   UpdateServiceWorkers();
 }
 
 void TargetHandler::WorkerVersionDoomed(
     ServiceWorkerDevToolsAgentHost* host) {
   UpdateServiceWorkers();
 }
 
 void TargetHandler::WorkerDestroyed(
     ServiceWorkerDevToolsAgentHost* host) {
   UpdateServiceWorkers();
 }
 
 }  // namespace target
 }  // namespace devtools
 }  // namespace content