[DevTools] Put worker initalization params to WorkerDevToolsParams

This simple struct is being used to initialize DevTools in workers.

Bug: 882467
Change-Id: I4d7fa582913b3be9a8466de24d727289a34f6ce0
Reviewed-on: https://chromium-review.googlesource.com/c/1308073
Commit-Queue: Dmitry Gozman <dgozman@chromium.org>
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Cr-Commit-Position: refs/heads/master@{#604495}

third_party/blink/renderer/core/exported/web_shared_worker_impl.cc

@@ -47,6 +47,7 @@
 #include "third_party/blink/renderer/core/dom/document.h"
 #include "third_party/blink/renderer/core/events/message_event.h"
 #include "third_party/blink/renderer/core/inspector/console_message.h"
+#include "third_party/blink/renderer/core/inspector/worker_devtools_params.h"
 #include "third_party/blink/renderer/core/loader/frame_load_request.h"
 #include "third_party/blink/renderer/core/loader/frame_loader.h"
 #include "third_party/blink/renderer/core/loader/worker_fetch_context.h"
@@ -105,8 +106,8 @@ void WebSharedWorkerImpl::TerminateWorkerThread() {
   }
   if (worker_thread_) {
     worker_thread_->Terminate();
-    if (DevToolsAgent* agent = DevToolsAgent::From(shadow_page_->GetDocument()))
-      agent->ChildWorkerThreadTerminated(worker_thread_.get());
+    DevToolsAgent::WorkerThreadTerminated(shadow_page_->GetDocument(),
+                                          worker_thread_.get());
   }
 }
 
@@ -350,8 +351,11 @@ void WebSharedWorkerImpl::ContinueOnScriptLoaderFinished() {
   thread_startup_data.atomics_wait_mode =
       WorkerBackingThreadStartupData::AtomicsWaitMode::kAllow;
 
+  auto devtools_params = DevToolsAgent::WorkerThreadCreated(
+      document, GetWorkerThread(), script_response_url);
+
   GetWorkerThread()->Start(std::move(global_scope_creation_params),
-                           thread_startup_data, DevToolsAgent::From(document),
+                           thread_startup_data, std::move(devtools_params),
                            parent_execution_context_task_runners_);
   // TODO(nhiroki): Support module workers (https://crbug.com/680046).
   GetWorkerThread()->EvaluateClassicScript(script_response_url, source_code,

third_party/blink/renderer/core/inspector/BUILD.gn

@@ -99,6 +99,7 @@ blink_core_sources("inspector") {
     "thread_debugger.h",
     "v8_inspector_string.cc",
     "v8_inspector_string.h",
+    "worker_devtools_params.h",
     "worker_inspector_controller.cc",
     "worker_inspector_controller.h",
     "worker_thread_debugger.cc",

third_party/blink/renderer/core/inspector/devtools_agent.cc

@@ -14,6 +14,7 @@
 #include "third_party/blink/renderer/core/inspector/devtools_session.h"
 #include "third_party/blink/renderer/core/inspector/inspected_frames.h"
 #include "third_party/blink/renderer/core/inspector/inspector_task_runner.h"
+#include "third_party/blink/renderer/core/inspector/worker_devtools_params.h"
 #include "third_party/blink/renderer/core/inspector/worker_inspector_controller.h"
 #include "third_party/blink/renderer/core/probe/core_probes.h"
 #include "third_party/blink/renderer/core/workers/worker_global_scope.h"
@@ -23,8 +24,9 @@
 
 namespace blink {
 
-// static
-DevToolsAgent* DevToolsAgent::From(ExecutionContext* execution_context) {
+namespace {
+
+DevToolsAgent* DevToolsAgentFromContext(ExecutionContext* execution_context) {
   if (!execution_context)
     return nullptr;
   if (auto* scope = DynamicTo<WorkerGlobalScope>(execution_context)) {
@@ -45,6 +47,8 @@ DevToolsAgent* DevToolsAgent::From(ExecutionContext* execution_context) {
   return nullptr;
 }
 
+}  // namespace
+
 DevToolsAgent::DevToolsAgent(
     Client* client,
     InspectedFrames* inspected_frames,
@@ -130,29 +134,40 @@ void DevToolsAgent::ReportChildWorkers(bool report, bool wait_for_debugger) {
     ReportChildWorker(std::move(it.value));
 }
 
-void DevToolsAgent::ChildWorkerThreadCreated(
+// static
+std::unique_ptr<WorkerDevToolsParams> DevToolsAgent::WorkerThreadCreated(
+    ExecutionContext* parent_context,
     WorkerThread* worker_thread,
-    const KURL& url,
-    mojom::blink::DevToolsAgentRequest& agent_request,
-    mojom::blink::DevToolsAgentHostPtrInfo& host_ptr_info,
-    bool& wait_for_debugger) {
+    const KURL& url) {
+  auto result = std::make_unique<WorkerDevToolsParams>();
+  result->devtools_worker_token = base::UnguessableToken::Create();
+
+  DevToolsAgent* agent = DevToolsAgentFromContext(parent_context);
+  if (!agent)
+    return result;
+
   auto data = std::make_unique<WorkerData>();
   data->url = url;
-  agent_request = mojo::MakeRequest(&data->agent_ptr);
-  data->host_request = mojo::MakeRequest(&host_ptr_info);
-  data->devtools_worker_token = worker_thread->GetDevToolsWorkerToken();
-  data->waiting_for_debugger = pause_child_workers_on_start_;
-  wait_for_debugger = pause_child_workers_on_start_;
-
-  if (report_child_workers_) {
-    ReportChildWorker(std::move(data));
+  result->agent_request = mojo::MakeRequest(&data->agent_ptr);
+  data->host_request = mojo::MakeRequest(&result->agent_host_ptr_info);
+  data->devtools_worker_token = result->devtools_worker_token;
+  data->waiting_for_debugger = agent->pause_child_workers_on_start_;
+  result->wait_for_debugger = agent->pause_child_workers_on_start_;
+
+  if (agent->report_child_workers_) {
+    agent->ReportChildWorker(std::move(data));
   } else {
-    unreported_child_worker_threads_.insert(worker_thread, std::move(data));
+    agent->unreported_child_worker_threads_.insert(worker_thread,
+                                                   std::move(data));
   }
+  return result;
 }
 
-void DevToolsAgent::ChildWorkerThreadTerminated(WorkerThread* worker_thread) {
-  unreported_child_worker_threads_.erase(worker_thread);
+// static
+void DevToolsAgent::WorkerThreadTerminated(ExecutionContext* parent_context,
+                                           WorkerThread* worker_thread) {
+  if (DevToolsAgent* agent = DevToolsAgentFromContext(parent_context))
+    agent->unreported_child_worker_threads_.erase(worker_thread);
 }
 
 void DevToolsAgent::ReportChildWorker(std::unique_ptr<WorkerData> data) {

third_party/blink/renderer/core/inspector/devtools_agent.h

@@ -25,6 +25,7 @@ class ExecutionContext;
 class InspectedFrames;
 class InspectorTaskRunner;
 class WorkerThread;
+struct WorkerDevToolsParams;
 
 class CORE_EXPORT DevToolsAgent
     : public GarbageCollectedFinalized<DevToolsAgent>,
@@ -40,7 +41,13 @@ class CORE_EXPORT DevToolsAgent
     virtual void DebuggerTaskFinished() = 0;
   };
 
-  static DevToolsAgent* From(ExecutionContext*);
+  static std::unique_ptr<WorkerDevToolsParams> WorkerThreadCreated(
+      ExecutionContext* parent_context,
+      WorkerThread*,
+      const KURL&);
+  static void WorkerThreadTerminated(ExecutionContext* parent_context,
+                                     WorkerThread*);
+
   DevToolsAgent(Client*,
                 InspectedFrames*,
                 CoreProbeSink*,
@@ -56,12 +63,6 @@ class CORE_EXPORT DevToolsAgent
   void BindRequest(mojom::blink::DevToolsAgentHostAssociatedPtrInfo,
                    mojom::blink::DevToolsAgentAssociatedRequest,
                    scoped_refptr<base::SingleThreadTaskRunner>);
-  void ChildWorkerThreadCreated(WorkerThread*,
-                                const KURL&,
-                                mojom::blink::DevToolsAgentRequest&,
-                                mojom::blink::DevToolsAgentHostPtrInfo&,
-                                bool& wait_for_debugger);
-  void ChildWorkerThreadTerminated(WorkerThread*);
   virtual void Trace(blink::Visitor*);
 
  private:

third_party/blink/renderer/core/inspector/worker_devtools_params.h

+// Copyright 2018 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.
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_CORE_INSPECTOR_WORKER_DEVTOOLS_PARAMS_H_
+#define THIRD_PARTY_BLINK_RENDERER_CORE_INSPECTOR_WORKER_DEVTOOLS_PARAMS_H_
+
+#include "base/unguessable_token.h"
+#include "third_party/blink/public/web/devtools_agent.mojom-blink.h"
+
+namespace blink {
+
+struct CORE_EXPORT WorkerDevToolsParams {
+  mojom::blink::DevToolsAgentRequest agent_request;
+  mojom::blink::DevToolsAgentHostPtrInfo agent_host_ptr_info;
+  bool wait_for_debugger = false;
+  base::UnguessableToken devtools_worker_token;
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_CORE_INSPECTOR_WORKER_DEVTOOLS_PARAMS_H_

third_party/blink/renderer/core/inspector/worker_inspector_controller.cc

@@ -38,6 +38,7 @@
 #include "third_party/blink/renderer/core/inspector/inspector_network_agent.h"
 #include "third_party/blink/renderer/core/inspector/inspector_trace_events.h"
 #include "third_party/blink/renderer/core/inspector/protocol/Protocol.h"
+#include "third_party/blink/renderer/core/inspector/worker_devtools_params.h"
 #include "third_party/blink/renderer/core/inspector/worker_thread_debugger.h"
 #include "third_party/blink/renderer/core/loader/worker_fetch_context.h"
 #include "third_party/blink/renderer/core/probe/core_probes.h"
@@ -54,13 +55,12 @@ namespace blink {
 WorkerInspectorController* WorkerInspectorController::Create(
     WorkerThread* thread,
     scoped_refptr<InspectorTaskRunner> inspector_task_runner,
-    mojom::blink::DevToolsAgentRequest agent_request,
-    mojom::blink::DevToolsAgentHostPtrInfo host_ptr_info) {
+    std::unique_ptr<WorkerDevToolsParams> devtools_params) {
   WorkerThreadDebugger* debugger =
       WorkerThreadDebugger::From(thread->GetIsolate());
   return debugger ? new WorkerInspectorController(
                         thread, debugger, std::move(inspector_task_runner),
-                        std::move(agent_request), std::move(host_ptr_info))
+                        std::move(devtools_params))
                   : nullptr;
 }
 
@@ -68,15 +68,14 @@ WorkerInspectorController::WorkerInspectorController(
     WorkerThread* thread,
     WorkerThreadDebugger* debugger,
     scoped_refptr<InspectorTaskRunner> inspector_task_runner,
-    mojom::blink::DevToolsAgentRequest agent_request,
-    mojom::blink::DevToolsAgentHostPtrInfo host_ptr_info)
+    std::unique_ptr<WorkerDevToolsParams> devtools_params)
     : debugger_(debugger),
       thread_(thread),
       inspected_frames_(nullptr),
       probe_sink_(new CoreProbeSink()) {
   probe_sink_->addInspectorTraceEvents(new InspectorTraceEvents());
   if (auto* scope = DynamicTo<WorkerGlobalScope>(thread->GlobalScope())) {
-    worker_devtools_token_ = thread->GetDevToolsWorkerToken();
+    worker_devtools_token_ = devtools_params->devtools_worker_token;
     parent_devtools_token_ = scope->GetParentDevToolsToken();
     url_ = scope->Url();
     worker_thread_id_ = thread->GetPlatformThreadId();
@@ -88,7 +87,8 @@ WorkerInspectorController::WorkerInspectorController(
     agent_ = new DevToolsAgent(this, inspected_frames_.Get(), probe_sink_.Get(),
                                std::move(inspector_task_runner),
                                std::move(io_task_runner));
-    agent_->BindRequest(std::move(host_ptr_info), std::move(agent_request),
+    agent_->BindRequest(std::move(devtools_params->agent_host_ptr_info),
+                        std::move(devtools_params->agent_request),
                         thread->GetTaskRunner(TaskType::kInternalInspector));
   }
   TraceEvent::AddEnabledStateObserver(this);

third_party/blink/renderer/core/inspector/worker_inspector_controller.h

@@ -50,6 +50,7 @@ class CoreProbeSink;
 class InspectedFrames;
 class WorkerThread;
 class WorkerThreadDebugger;
+struct WorkerDevToolsParams;
 
 class WorkerInspectorController final
     : public GarbageCollectedFinalized<WorkerInspectorController>,
@@ -60,8 +61,7 @@ class WorkerInspectorController final
   static WorkerInspectorController* Create(
       WorkerThread*,
       scoped_refptr<InspectorTaskRunner>,
-      mojom::blink::DevToolsAgentRequest,
-      mojom::blink::DevToolsAgentHostPtrInfo);
+      std::unique_ptr<WorkerDevToolsParams>);
   ~WorkerInspectorController() override;
   void Trace(blink::Visitor*);
 
@@ -74,8 +74,7 @@ class WorkerInspectorController final
   WorkerInspectorController(WorkerThread*,
                             WorkerThreadDebugger*,
                             scoped_refptr<InspectorTaskRunner>,
-                            mojom::blink::DevToolsAgentRequest,
-                            mojom::blink::DevToolsAgentHostPtrInfo);
+                            std::unique_ptr<WorkerDevToolsParams>);
 
   // Thread::TaskObserver implementation.
   void WillProcessTask(const base::PendingTask&) override;

third_party/blink/renderer/core/workers/threaded_messaging_proxy_base.cc

@@ -13,6 +13,8 @@
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/frame/local_frame_client.h"
 #include "third_party/blink/renderer/core/inspector/console_message.h"
+#include "third_party/blink/renderer/core/inspector/devtools_agent.h"
+#include "third_party/blink/renderer/core/inspector/worker_devtools_params.h"
 #include "third_party/blink/renderer/core/loader/document_loader.h"
 #include "third_party/blink/renderer/core/loader/worker_fetch_context.h"
 #include "third_party/blink/renderer/core/workers/global_scope_creation_params.h"
@@ -88,9 +90,11 @@ void ThreadedMessagingProxyBase::InitializeWorkerThread(
 
   worker_thread_ = CreateWorkerThread();
 
+  auto devtools_params = DevToolsAgent::WorkerThreadCreated(
+      execution_context_.Get(), worker_thread_.get(), script_url);
+
   worker_thread_->Start(std::move(global_scope_creation_params),
-                        thread_startup_data,
-                        DevToolsAgent::From(execution_context_.Get()),
+                        thread_startup_data, std::move(devtools_params),
                         GetParentExecutionContextTaskRunners());
 
   if (auto* scope = DynamicTo<WorkerGlobalScope>(*execution_context_)) {
@@ -144,8 +148,8 @@ void ThreadedMessagingProxyBase::WorkerThreadTerminated() {
     parent_thread = scope->GetThread();
   std::unique_ptr<WorkerThread> child_thread = std::move(worker_thread_);
   if (child_thread) {
-    if (DevToolsAgent* agent = DevToolsAgent::From(execution_context_.Get()))
-      agent->ChildWorkerThreadTerminated(child_thread.get());
+    DevToolsAgent::WorkerThreadTerminated(execution_context_.Get(),
+                                          child_thread.get());
   }
 
   // If the parent Worker/Worklet object was already destroyed, this will
@@ -168,8 +172,8 @@ void ThreadedMessagingProxyBase::TerminateGlobalScope() {
   if (!worker_thread_)
     return;
   worker_thread_->Terminate();
-  if (DevToolsAgent* agent = DevToolsAgent::From(execution_context_.Get()))
-    agent->ChildWorkerThreadTerminated(worker_thread_.get());
+  DevToolsAgent::WorkerThreadTerminated(execution_context_.Get(),
+                                        worker_thread_.get());
 }
 
 ExecutionContext* ThreadedMessagingProxyBase::GetExecutionContext() const {

third_party/blink/renderer/core/workers/worker_thread.cc

@@ -36,6 +36,7 @@
 #include "third_party/blink/renderer/bindings/core/v8/worker_or_worklet_script_controller.h"
 #include "third_party/blink/renderer/core/inspector/console_message_storage.h"
 #include "third_party/blink/renderer/core/inspector/inspector_task_runner.h"
+#include "third_party/blink/renderer/core/inspector/worker_devtools_params.h"
 #include "third_party/blink/renderer/core/inspector/worker_inspector_controller.h"
 #include "third_party/blink/renderer/core/inspector/worker_thread_debugger.h"
 #include "third_party/blink/renderer/core/probe/core_probes.h"
@@ -123,12 +124,13 @@ WorkerThread::~WorkerThread() {
 void WorkerThread::Start(
     std::unique_ptr<GlobalScopeCreationParams> global_scope_creation_params,
     const base::Optional<WorkerBackingThreadStartupData>& thread_startup_data,
-    DevToolsAgent* devtools_agent,
+    std::unique_ptr<WorkerDevToolsParams> devtools_params,
     ParentExecutionContextTaskRunners* parent_execution_context_task_runners) {
   DCHECK_CALLED_ON_VALID_THREAD(parent_thread_checker_);
   DCHECK(!parent_execution_context_task_runners_);
   parent_execution_context_task_runners_ =
       parent_execution_context_task_runners;
+  devtools_worker_token_ = devtools_params->devtools_worker_token;
 
   // Synchronously initialize the per-global-scope scheduler to prevent someone
   // from posting a task to the thread before the scheduler is ready.
@@ -143,24 +145,12 @@ void WorkerThread::Start(
   inspector_task_runner_ =
       InspectorTaskRunner::Create(GetTaskRunner(TaskType::kInternalInspector));
 
-  bool wait_for_debugger = false;
-  mojom::blink::DevToolsAgentRequest devtools_agent_request;
-  mojom::blink::DevToolsAgentHostPtrInfo devtools_agent_host_ptr_info;
-  if (devtools_agent) {
-    devtools_agent->ChildWorkerThreadCreated(
-        this, global_scope_creation_params->script_url.Copy(),
-        devtools_agent_request, devtools_agent_host_ptr_info,
-        wait_for_debugger);
-  }
-
   GetWorkerBackingThread().BackingThread().PostTask(
       FROM_HERE,
-      CrossThreadBind(&WorkerThread::InitializeOnWorkerThread,
-                      CrossThreadUnretained(this),
-                      WTF::Passed(std::move(global_scope_creation_params)),
-                      thread_startup_data, wait_for_debugger,
-                      WTF::Passed(std::move(devtools_agent_request)),
-                      WTF::Passed(std::move(devtools_agent_host_ptr_info))));
+      CrossThreadBind(
+          &WorkerThread::InitializeOnWorkerThread, CrossThreadUnretained(this),
+          WTF::Passed(std::move(global_scope_creation_params)),
+          thread_startup_data, WTF::Passed(std::move(devtools_params))));
 }
 
 void WorkerThread::EvaluateClassicScript(
@@ -362,7 +352,6 @@ WorkerThread::WorkerThread(WorkerReportingProxy& worker_reporting_proxy)
     : time_origin_(CurrentTimeTicks()),
       worker_thread_id_(GetNextWorkerThreadId()),
       forcible_termination_delay_(kForcibleTerminationDelay),
-      devtools_worker_token_(base::UnguessableToken::Create()),
       worker_reporting_proxy_(worker_reporting_proxy),
       shutdown_event_(RefCountedWaitableEvent::Create()) {
   MutexLocker lock(ThreadSetMutex());
@@ -431,10 +420,9 @@ void WorkerThread::InitializeSchedulerOnWorkerThread(
 void WorkerThread::InitializeOnWorkerThread(
     std::unique_ptr<GlobalScopeCreationParams> global_scope_creation_params,
     const base::Optional<WorkerBackingThreadStartupData>& thread_startup_data,
-    bool wait_for_debugger,
-    mojom::blink::DevToolsAgentRequest devtools_agent_request,
-    mojom::blink::DevToolsAgentHostPtrInfo devtools_agent_host_ptr_info) {
+    std::unique_ptr<WorkerDevToolsParams> devtools_params) {
   DCHECK(IsCurrentThread());
+  bool wait_for_debugger = devtools_params->wait_for_debugger;
   {
     MutexLocker lock(mutex_);
     DCHECK_EQ(ThreadState::kNotStarted, thread_state_);
@@ -455,8 +443,7 @@ void WorkerThread::InitializeOnWorkerThread(
     worker_reporting_proxy_.DidCreateWorkerGlobalScope(GlobalScope());
 
     worker_inspector_controller_ = WorkerInspectorController::Create(
-        this, inspector_task_runner_, std::move(devtools_agent_request),
-        std::move(devtools_agent_host_ptr_info));
+        this, inspector_task_runner_, std::move(devtools_params));
 
     // Since context initialization below may fail, we should notify debugger
     // about the new worker thread separately, so that it can resolve it by id

third_party/blink/renderer/core/workers/worker_thread.h

@@ -39,7 +39,6 @@
 #include "third_party/blink/public/platform/web_thread_type.h"
 #include "third_party/blink/renderer/core/core_export.h"
 #include "third_party/blink/renderer/core/frame/csp/content_security_policy.h"
-#include "third_party/blink/renderer/core/inspector/devtools_agent.h"
 #include "third_party/blink/renderer/core/workers/parent_execution_context_task_runners.h"
 #include "third_party/blink/renderer/core/workers/worker_backing_thread_startup_data.h"
 #include "third_party/blink/renderer/platform/scheduler/public/thread.h"
@@ -62,6 +61,7 @@ class WorkerOrWorkletGlobalScope;
 class WorkerReportingProxy;
 struct CrossThreadFetchClientSettingsObjectData;
 struct GlobalScopeCreationParams;
+struct WorkerDevToolsParams;
 
 // WorkerThread is a kind of WorkerBackingThread client. Each worker mechanism
 // can access the lower thread infrastructure via an implementation of this
@@ -100,7 +100,7 @@ class CORE_EXPORT WorkerThread : public Thread::TaskObserver {
   // (https://crbug.com/710364)
   void Start(std::unique_ptr<GlobalScopeCreationParams>,
              const base::Optional<WorkerBackingThreadStartupData>&,
-             DevToolsAgent*,
+             std::unique_ptr<WorkerDevToolsParams>,
              ParentExecutionContextTaskRunners*);
 
   // Posts a task to evaluate a top-level classic script on the worker thread.
@@ -278,9 +278,7 @@ class CORE_EXPORT WorkerThread : public Thread::TaskObserver {
   void InitializeOnWorkerThread(
       std::unique_ptr<GlobalScopeCreationParams>,
       const base::Optional<WorkerBackingThreadStartupData>&,
-      bool wait_for_debugger,
-      mojom::blink::DevToolsAgentRequest,
-      mojom::blink::DevToolsAgentHostPtrInfo) LOCKS_EXCLUDED(mutex_);
+      std::unique_ptr<WorkerDevToolsParams>) LOCKS_EXCLUDED(mutex_);
 
   void EvaluateClassicScriptOnWorkerThread(
       const KURL& script_url,
@@ -314,7 +312,7 @@ class CORE_EXPORT WorkerThread : public Thread::TaskObserver {
   TimeDelta forcible_termination_delay_;
 
   scoped_refptr<InspectorTaskRunner> inspector_task_runner_;
-  const base::UnguessableToken devtools_worker_token_;
+  base::UnguessableToken devtools_worker_token_;
   int debugger_task_counter_ GUARDED_BY(mutex_) = 0;
 
   WorkerReportingProxy& worker_reporting_proxy_;

third_party/blink/renderer/core/workers/worker_thread_test.cc

@@ -12,6 +12,7 @@
 #include "third_party/blink/renderer/bindings/core/v8/v8_cache_options.h"
 #include "third_party/blink/renderer/core/frame/settings.h"
 #include "third_party/blink/renderer/core/inspector/inspector_task_runner.h"
+#include "third_party/blink/renderer/core/inspector/worker_devtools_params.h"
 #include "third_party/blink/renderer/core/script/script.h"
 #include "third_party/blink/renderer/core/workers/global_scope_creation_params.h"
 #include "third_party/blink/renderer/core/workers/worker_reporting_proxy.h"
@@ -397,11 +398,15 @@ TEST_F(WorkerThreadTest, Terminate_WhileDebuggerTaskIsRunningOnInitialization) {
           std::make_unique<WorkerSettings>(Settings::Create().get()),
           kV8CacheOptionsDefault, nullptr /* worklet_module_responses_map */);
 
-  // Specify PauseOnWorkerStart::kPause so that the worker thread can pause
+  // Set wait_for_debugger so that the worker thread can pause
   // on initialization to run debugger tasks.
+  auto devtools_params = std::make_unique<WorkerDevToolsParams>();
+  devtools_params->wait_for_debugger = true;
+
   worker_thread_->Start(std::move(global_scope_creation_params),
                         WorkerBackingThreadStartupData::CreateDefault(),
-                        nullptr, ParentExecutionContextTaskRunners::Create());
+                        std::move(devtools_params),
+                        ParentExecutionContextTaskRunners::Create());
 
   // Used to wait for worker thread termination in a debugger task on the
   // worker thread.

third_party/blink/renderer/core/workers/worker_thread_test_helper.h

@@ -16,6 +16,7 @@
 #include "third_party/blink/renderer/core/frame/csp/content_security_policy.h"
 #include "third_party/blink/renderer/core/frame/settings.h"
 #include "third_party/blink/renderer/core/inspector/console_message.h"
+#include "third_party/blink/renderer/core/inspector/worker_devtools_params.h"
 #include "third_party/blink/renderer/core/script/script.h"
 #include "third_party/blink/renderer/core/workers/global_scope_creation_params.h"
 #include "third_party/blink/renderer/core/workers/parent_execution_context_task_runners.h"
@@ -100,7 +101,8 @@ class WorkerThreadForTest : public WorkerThread {
         kV8CacheOptionsDefault, nullptr /* worklet_module_responses_map */);
 
     Start(std::move(creation_params),
-          WorkerBackingThreadStartupData::CreateDefault(), nullptr,
+          WorkerBackingThreadStartupData::CreateDefault(),
+          std::make_unique<WorkerDevToolsParams>(),
           parent_execution_context_task_runners);
     EvaluateClassicScript(script_url, source, nullptr /* cached_meta_data */,
                           v8_inspector::V8StackTraceId());

third_party/blink/renderer/modules/animationworklet/animation_worklet_global_scope_test.cc

@@ -13,6 +13,7 @@
 #include "third_party/blink/renderer/bindings/core/v8/v8_cache_options.h"
 #include "third_party/blink/renderer/bindings/core/v8/worker_or_worklet_script_controller.h"
 #include "third_party/blink/renderer/core/dom/document.h"
+#include "third_party/blink/renderer/core/inspector/worker_devtools_params.h"
 #include "third_party/blink/renderer/core/origin_trials/origin_trial_context.h"
 #include "third_party/blink/renderer/core/script/script.h"
 #include "third_party/blink/renderer/core/testing/page_test_base.h"
@@ -85,7 +86,8 @@ class AnimationWorkletGlobalScopeTest : public PageTestBase {
             OriginTrialContext::GetTokens(document).get(),
             base::UnguessableToken::Create(), nullptr /* worker_settings */,
             kV8CacheOptionsDefault, new WorkletModuleResponsesMap),
-        base::nullopt, nullptr, ParentExecutionContextTaskRunners::Create());
+        base::nullopt, std::make_unique<WorkerDevToolsParams>(),
+        ParentExecutionContextTaskRunners::Create());
     return thread;
   }
 

third_party/blink/renderer/modules/exported/web_embedded_worker_impl.cc

@@ -46,6 +46,7 @@
 #include "third_party/blink/renderer/core/execution_context/security_context.h"
 #include "third_party/blink/renderer/core/frame/csp/content_security_policy.h"
 #include "third_party/blink/renderer/core/inspector/console_message.h"
+#include "third_party/blink/renderer/core/inspector/worker_devtools_params.h"
 #include "third_party/blink/renderer/core/loader/frame_load_request.h"
 #include "third_party/blink/renderer/core/loader/worker_fetch_context.h"
 #include "third_party/blink/renderer/core/probe/core_probes.h"
@@ -228,8 +229,8 @@ void WebEmbeddedWorkerImpl::TerminateWorkerContext() {
     return;
   }
   worker_thread_->Terminate();
-  if (DevToolsAgent* agent = DevToolsAgent::From(shadow_page_->GetDocument()))
-    agent->ChildWorkerThreadTerminated(worker_thread_.get());
+  DevToolsAgent::WorkerThreadTerminated(shadow_page_->GetDocument(),
+                                        worker_thread_.get());
 }
 
 void WebEmbeddedWorkerImpl::ResumeAfterDownload() {
@@ -451,12 +452,15 @@ void WebEmbeddedWorkerImpl::StartWorkerThread() {
       ServiceWorkerGlobalScopeProxy::Create(*this, *worker_context_client_),
       std::move(installed_scripts_manager_), std::move(cache_storage_info_));
 
+  auto devtools_params = DevToolsAgent::WorkerThreadCreated(
+      document, worker_thread_.get(), worker_start_data_.script_url);
+
   // We have a dummy document here for loading but it doesn't really represent
   // the document/frame of associated document(s) for this worker. Here we
   // populate the task runners with default task runners of the main thread.
   worker_thread_->Start(std::move(global_scope_creation_params),
                         WorkerBackingThreadStartupData::CreateDefault(),
-                        DevToolsAgent::From(document),
+                        std::move(devtools_params),
                         ParentExecutionContextTaskRunners::Create());
 
   // > Switching on job’s worker type, run these substeps with the following

third_party/blink/renderer/modules/webaudio/audio_worklet_global_scope_test.cc

@@ -21,6 +21,7 @@
 #include "third_party/blink/renderer/bindings/core/v8/v8_gc_controller.h"
 #include "third_party/blink/renderer/bindings/core/v8/worker_or_worklet_script_controller.h"
 #include "third_party/blink/renderer/core/dom/document.h"
+#include "third_party/blink/renderer/core/inspector/worker_devtools_params.h"
 #include "third_party/blink/renderer/core/messaging/message_channel.h"
 #include "third_party/blink/renderer/core/messaging/message_port.h"
 #include "third_party/blink/renderer/core/origin_trials/origin_trial_context.h"
@@ -76,7 +77,8 @@ class AudioWorkletGlobalScopeTest : public PageTestBase {
             OriginTrialContext::GetTokens(document).get(),
             base::UnguessableToken::Create(), nullptr /* worker_settings */,
             kV8CacheOptionsDefault, new WorkletModuleResponsesMap),
-        base::nullopt, nullptr, ParentExecutionContextTaskRunners::Create());
+        base::nullopt, std::make_unique<WorkerDevToolsParams>(),
+        ParentExecutionContextTaskRunners::Create());
     return thread;
   }
 

third_party/blink/renderer/modules/webaudio/audio_worklet_thread_test.cc

@@ -15,6 +15,7 @@
 #include "third_party/blink/renderer/bindings/core/v8/v8_gc_controller.h"
 #include "third_party/blink/renderer/bindings/core/v8/worker_or_worklet_script_controller.h"
 #include "third_party/blink/renderer/core/inspector/console_message.h"
+#include "third_party/blink/renderer/core/inspector/worker_devtools_params.h"
 #include "third_party/blink/renderer/core/origin_trials/origin_trial_context.h"
 #include "third_party/blink/renderer/core/script/script.h"
 #include "third_party/blink/renderer/core/testing/page_test_base.h"
@@ -60,7 +61,8 @@ class AudioWorkletThreadTest : public PageTestBase {
             OriginTrialContext::GetTokens(document).get(),
             base::UnguessableToken::Create(), nullptr /* worker_settings */,
             kV8CacheOptionsDefault, new WorkletModuleResponsesMap),
-        base::nullopt, nullptr, ParentExecutionContextTaskRunners::Create());
+        base::nullopt, std::make_unique<WorkerDevToolsParams>(),
+        ParentExecutionContextTaskRunners::Create());
     return thread;
   }
 

third_party/blink/renderer/modules/worklet/animation_and_paint_worklet_thread_test.cc

@@ -14,6 +14,7 @@
 #include "third_party/blink/renderer/bindings/core/v8/v8_gc_controller.h"
 #include "third_party/blink/renderer/bindings/core/v8/worker_or_worklet_script_controller.h"
 #include "third_party/blink/renderer/core/inspector/console_message.h"
+#include "third_party/blink/renderer/core/inspector/worker_devtools_params.h"
 #include "third_party/blink/renderer/core/origin_trials/origin_trial_context.h"
 #include "third_party/blink/renderer/core/script/script.h"
 #include "third_party/blink/renderer/core/testing/page_test_base.h"
@@ -74,7 +75,8 @@ class AnimationAndPaintWorkletThreadTest : public PageTestBase {
             OriginTrialContext::GetTokens(document).get(),
             base::UnguessableToken::Create(), nullptr /* worker_settings */,
             kV8CacheOptionsDefault, new WorkletModuleResponsesMap),
-        base::nullopt, nullptr, ParentExecutionContextTaskRunners::Create());
+        base::nullopt, std::make_unique<WorkerDevToolsParams>(),
+        ParentExecutionContextTaskRunners::Create());
     return thread;
   }