[shared storage] Hook up to DevTools debugger

Pass a mojom::WorkletGlobalScopeCreationParams to the renderer that
contains necessary information to initialize the DevTools
connection.

For reference:
Follow-up CL to add to chrome://inspect page:
https://crrev.com/v/4776116
Sibling CL for the //front_end change: https://crrev.com/c/4752777
Screenshots demonstrating it's working end-to-end: https://crbug.com/1469983#c1

Bug: 1469983
Change-Id: Ib4089e76cdb35af92f5347e483efd672636892fc
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4748704
Commit-Queue: Yao Xiao <yaoxia@chromium.org>
Reviewed-by: Dominic Farolino <dom@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1188379}

content/browser/renderer_host/agent_scheduling_group_host.cc

@@ -23,6 +23,7 @@
 #include "ipc/ipc_channel_mojo.h"
 #include "ipc/ipc_message.h"
 #include "third_party/blink/public/mojom/shared_storage/shared_storage_worklet_service.mojom.h"
+#include "third_party/blink/public/mojom/worker/worklet_global_scope_creation_params.mojom.h"
 
 namespace content {
 
@@ -332,11 +333,14 @@ void AgentSchedulingGroupHost::CreateView(mojom::CreateViewParamsPtr params) {
 }
 
 void AgentSchedulingGroupHost::CreateSharedStorageWorkletService(
-    mojo::PendingReceiver<blink::mojom::SharedStorageWorkletService> receiver) {
+    mojo::PendingReceiver<blink::mojom::SharedStorageWorkletService> receiver,
+    blink::mojom::WorkletGlobalScopeCreationParamsPtr
+        global_scope_creation_params) {
   DCHECK_EQ(state_, LifecycleState::kBound);
   DCHECK(process_->IsInitializedAndNotDead());
   DCHECK(mojo_remote_.is_bound());
-  mojo_remote_.get()->CreateSharedStorageWorkletService(std::move(receiver));
+  mojo_remote_.get()->CreateSharedStorageWorkletService(
+      std::move(receiver), std::move(global_scope_creation_params));
 }
 
 void AgentSchedulingGroupHost::ReportNoBinderForInterface(

content/browser/renderer_host/agent_scheduling_group_host.h

@@ -29,6 +29,7 @@
 #include "third_party/blink/public/mojom/browser_interface_broker.mojom.h"
 #include "third_party/blink/public/mojom/frame/frame_replication_state.mojom-forward.h"
 #include "third_party/blink/public/mojom/shared_storage/shared_storage_worklet_service.mojom-forward.h"
+#include "third_party/blink/public/mojom/worker/worklet_global_scope_creation_params.mojom-forward.h"
 
 namespace IPC {
 class ChannelProxy;
@@ -102,8 +103,9 @@ class CONTENT_EXPORT AgentSchedulingGroupHost
   void CreateFrame(mojom::CreateFrameParamsPtr params);
   void CreateView(mojom::CreateViewParamsPtr params);
   void CreateSharedStorageWorkletService(
-      mojo::PendingReceiver<blink::mojom::SharedStorageWorkletService>
-          receiver);
+      mojo::PendingReceiver<blink::mojom::SharedStorageWorkletService> receiver,
+      blink::mojom::WorkletGlobalScopeCreationParamsPtr
+          global_scope_creation_params);
 
   void ReportNoBinderForInterface(const std::string& error);
 

content/browser/shared_storage/shared_storage_render_thread_worklet_driver.cc

@@ -8,6 +8,7 @@
 #include "content/common/renderer.mojom.h"
 #include "content/public/browser/render_process_host.h"
 #include "third_party/blink/public/mojom/shared_storage/shared_storage_worklet_service.mojom.h"
+#include "third_party/blink/public/mojom/worker/worklet_global_scope_creation_params.mojom.h"
 
 namespace content {
 
@@ -36,15 +37,17 @@ SharedStorageRenderThreadWorkletDriver::
 
 void SharedStorageRenderThreadWorkletDriver::StartWorkletService(
     mojo::PendingReceiver<blink::mojom::SharedStorageWorkletService>
-        pending_receiver) {
+        pending_receiver,
+    blink::mojom::WorkletGlobalScopeCreationParamsPtr
+        global_scope_creation_params) {
   // `StartWorkletService` will be called right after the driver is created when
   // the document is still alive, as the driver is created on-demand on the
   // first worklet operation. Thus, the `agent_scheduling_group_host_` should
   // always be valid at this point.
   DCHECK(agent_scheduling_group_host_);
 
   agent_scheduling_group_host_->CreateSharedStorageWorkletService(
-      std::move(pending_receiver));
+      std::move(pending_receiver), std::move(global_scope_creation_params));
 }
 
 RenderProcessHost* SharedStorageRenderThreadWorkletDriver::GetProcessHost() {

content/browser/shared_storage/shared_storage_render_thread_worklet_driver.h

@@ -31,7 +31,9 @@ class SharedStorageRenderThreadWorkletDriver
   // SharedStorageWorkletDriver overrides
   void StartWorkletService(
       mojo::PendingReceiver<blink::mojom::SharedStorageWorkletService>
-          pending_receiver) override;
+          pending_receiver,
+      blink::mojom::WorkletGlobalScopeCreationParamsPtr
+          global_scope_creation_params) override;
   RenderProcessHost* GetProcessHost() override;
 
   // RenderProcessHostObserver overrides

content/browser/shared_storage/shared_storage_worklet_driver.h

@@ -7,6 +7,7 @@
 
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "third_party/blink/public/mojom/shared_storage/shared_storage_worklet_service.mojom-forward.h"
+#include "third_party/blink/public/mojom/worker/worklet_global_scope_creation_params.mojom-forward.h"
 
 namespace content {
 
@@ -20,7 +21,9 @@ class SharedStorageWorkletDriver {
   // Called when starting the worklet service.
   virtual void StartWorkletService(
       mojo::PendingReceiver<blink::mojom::SharedStorageWorkletService>
-          pending_receiver) = 0;
+          pending_receiver,
+      blink::mojom::WorkletGlobalScopeCreationParamsPtr
+          global_scope_creation_params) = 0;
 
   // Returns the process host associated with the worklet. Returns nullptr if
   // the process has gone.

content/browser/shared_storage/shared_storage_worklet_host.cc

@@ -15,6 +15,7 @@
 #include "components/services/storage/shared_storage/shared_storage_manager.h"
 #include "content/browser/attribution_reporting/attribution_manager.h"
 #include "content/browser/devtools/devtools_instrumentation.h"
+#include "content/browser/devtools/shared_storage_worklet_devtools_manager.h"
 #include "content/browser/fenced_frame/fenced_frame_reporter.h"
 #include "content/browser/private_aggregation/private_aggregation_budget_key.h"
 #include "content/browser/private_aggregation/private_aggregation_host.h"
@@ -34,6 +35,7 @@
 #include "third_party/blink/public/mojom/private_aggregation/private_aggregation_host.mojom.h"
 #include "third_party/blink/public/mojom/shared_storage/shared_storage_worklet_service.mojom.h"
 #include "third_party/blink/public/mojom/use_counter/metrics/web_feature.mojom.h"
+#include "third_party/blink/public/mojom/worker/worklet_global_scope_creation_params.mojom.h"
 #include "url/origin.h"
 
 namespace content {
@@ -96,6 +98,50 @@ SharedStorageURNMappingResult CreateSharedStorageURNMappingResult(
 
 }  // namespace
 
+class SharedStorageWorkletHost::ScopedDevToolsHandle
+    : blink::mojom::WorkletDevToolsHost {
+ public:
+  explicit ScopedDevToolsHandle(SharedStorageWorkletHost& owner)
+      : owner_(owner), devtools_token_(base::UnguessableToken::Create()) {
+    SharedStorageWorkletDevToolsManager::GetInstance()->WorkletCreated(
+        owner, devtools_token_);
+  }
+
+  ScopedDevToolsHandle(const ScopedDevToolsHandle&) = delete;
+  ScopedDevToolsHandle& operator=(const ScopedDevToolsHandle&) = delete;
+
+  ~ScopedDevToolsHandle() override {
+    SharedStorageWorkletDevToolsManager::GetInstance()->WorkletDestroyed(
+        *owner_);
+  }
+
+  // blink::mojom::WorkletDevToolsHost:
+  void OnReadyForInspection(
+      mojo::PendingRemote<blink::mojom::DevToolsAgent> agent_remote,
+      mojo::PendingReceiver<blink::mojom::DevToolsAgentHost>
+          agent_host_receiver) override {
+    SharedStorageWorkletDevToolsManager::GetInstance()
+        ->WorkletReadyForInspection(*owner_, std::move(agent_remote),
+                                    std::move(agent_host_receiver));
+  }
+
+  const base::UnguessableToken& devtools_token() const {
+    return devtools_token_;
+  }
+
+  mojo::PendingRemote<blink::mojom::WorkletDevToolsHost>
+  BindNewPipeAndPassRemote() {
+    return host_.BindNewPipeAndPassRemote();
+  }
+
+ private:
+  raw_ref<SharedStorageWorkletHost> owner_;
+
+  mojo::Receiver<blink::mojom::WorkletDevToolsHost> host_{this};
+
+  const base::UnguessableToken devtools_token_;
+};
+
 SharedStorageWorkletHost::SharedStorageWorkletHost(
     std::unique_ptr<SharedStorageWorkletDriver> driver,
     SharedStorageDocumentServiceImpl& document_service)
@@ -187,6 +233,8 @@ void SharedStorageWorkletHost::AddModuleOnWorklet(
   add_module_state_ = AddModuleState::kInitiated;
   script_source_url_ = script_source_url;
 
+  devtools_handle_ = std::make_unique<ScopedDevToolsHandle>(*this);
+
   mojo::PendingRemote<network::mojom::URLLoaderFactory> url_loader_factory;
 
   url_loader_factory_proxy_ =
@@ -907,8 +955,15 @@ SharedStorageWorkletHost::GetAndConnectToSharedStorageWorkletService() {
     bool private_aggregation_permissions_policy_allowed =
         document_service_->render_frame_host().IsFeatureEnabled(
             blink::mojom::PermissionsPolicyFeature::kPrivateAggregation);
+
+    auto global_scope_creation_params =
+        blink::mojom::WorkletGlobalScopeCreationParams::New(
+            script_source_url_, devtools_handle_->devtools_token(),
+            devtools_handle_->BindNewPipeAndPassRemote());
+
     driver_->StartWorkletService(
-        shared_storage_worklet_service_.BindNewPipeAndPassReceiver());
+        shared_storage_worklet_service_.BindNewPipeAndPassReceiver(),
+        std::move(global_scope_creation_params));
 
     auto embedder_context = static_cast<RenderFrameHostImpl&>(
                                 document_service_->render_frame_host())

content/browser/shared_storage/shared_storage_worklet_host.h

@@ -170,6 +170,8 @@ class CONTENT_EXPORT SharedStorageWorkletHost
   }
 
  private:
+  class ScopedDevToolsHandle;
+
   void OnRunURLSelectionOperationOnWorkletScriptExecutionFinished(
       const GURL& urn_uuid,
       base::TimeTicks start_time,
@@ -206,6 +208,9 @@ class CONTENT_EXPORT SharedStorageWorkletHost
 
   bool IsSharedStorageAllowed();
 
+  // RAII helper object for talking to `SharedStorageWorkletDevToolsManager`.
+  std::unique_ptr<ScopedDevToolsHandle> devtools_handle_;
+
   AddModuleState add_module_state_ = AddModuleState::kNotInitiated;
 
   // The URL of the module script. Set when `AddModuleOnWorklet` is invoked.

content/common/agent_scheduling_group.mojom

@@ -11,6 +11,7 @@ import "third_party/blink/public/mojom/frame/frame_replication_state.mojom";
 import "third_party/blink/public/mojom/frame/tree_scope_type.mojom";
 import "third_party/blink/public/mojom/shared_storage/shared_storage_worklet_service.mojom";
 import "third_party/blink/public/mojom/tokens/tokens.mojom";
+import "third_party/blink/public/mojom/worker/worklet_global_scope_creation_params.mojom";
 
 // Interface for general communication between the renderer process's
 // AgentSchedulingGroup and the browser process's AgentSchedulingGroupHost.
@@ -72,5 +73,6 @@ interface AgentSchedulingGroup {
   // Tells the renderer process to create a thread that exclusively hosts the
   // shared storage worklet service.
   CreateSharedStorageWorkletService(
-      pending_receiver<blink.mojom.SharedStorageWorkletService> receiver);
+      pending_receiver<blink.mojom.SharedStorageWorkletService> receiver,
+      blink.mojom.WorkletGlobalScopeCreationParams global_scope_creation_params);
 };

content/renderer/agent_scheduling_group.cc

@@ -27,6 +27,7 @@
 #include "third_party/blink/public/mojom/frame/frame.mojom.h"
 #include "third_party/blink/public/mojom/page/page.mojom.h"
 #include "third_party/blink/public/mojom/shared_storage/shared_storage_worklet_service.mojom.h"
+#include "third_party/blink/public/mojom/worker/worklet_global_scope_creation_params.mojom.h"
 #include "third_party/blink/public/platform/scheduler/web_thread_scheduler.h"
 #include "third_party/blink/public/web/web_remote_frame.h"
 #include "third_party/blink/public/web/web_shared_storage_worklet_thread.h"
@@ -407,9 +408,12 @@ void AgentSchedulingGroup::CreateFrame(mojom::CreateFrameParamsPtr params) {
 }
 
 void AgentSchedulingGroup::CreateSharedStorageWorkletService(
-    mojo::PendingReceiver<blink::mojom::SharedStorageWorkletService> receiver) {
+    mojo::PendingReceiver<blink::mojom::SharedStorageWorkletService> receiver,
+    blink::mojom::WorkletGlobalScopeCreationParamsPtr
+        global_scope_creation_params) {
   blink::WebSharedStorageWorkletThread::Start(
-      agent_group_scheduler_->DefaultTaskRunner(), std::move(receiver));
+      agent_group_scheduler_->DefaultTaskRunner(), std::move(receiver),
+      std::move(global_scope_creation_params));
 }
 
 void AgentSchedulingGroup::BindAssociatedInterfaces(

content/renderer/agent_scheduling_group.h

@@ -25,6 +25,7 @@
 #include "third_party/blink/public/mojom/browser_interface_broker.mojom.h"
 #include "third_party/blink/public/mojom/frame/frame_replication_state.mojom-forward.h"
 #include "third_party/blink/public/mojom/shared_storage/shared_storage_worklet_service.mojom-forward.h"
+#include "third_party/blink/public/mojom/worker/worklet_global_scope_creation_params.mojom-forward.h"
 #include "third_party/blink/public/platform/scheduler/web_agent_group_scheduler.h"
 
 namespace IPC {
@@ -103,8 +104,9 @@ class CONTENT_EXPORT AgentSchedulingGroup
   void CreateView(mojom::CreateViewParamsPtr params) override;
   void CreateFrame(mojom::CreateFrameParamsPtr params) override;
   void CreateSharedStorageWorkletService(
-      mojo::PendingReceiver<blink::mojom::SharedStorageWorkletService> receiver)
-      override;
+      mojo::PendingReceiver<blink::mojom::SharedStorageWorkletService> receiver,
+      blink::mojom::WorkletGlobalScopeCreationParamsPtr
+          global_scope_creation_params) override;
 
   // mojom::RouteProvider
   void GetRoute(

third_party/blink/PRESUBMIT.py

@@ -78,12 +78,11 @@ def source_file_filter(path):
         'third_party/blink/public/mojom/loader/resource_load_info',
         'third_party/blink/public/mojom/loader/resource_load_info_notifier',
         'third_party/blink/public/mojom/worker/subresource_loader_updater',
+        'third_party/blink/public/mojom/worker/worklet_global_scope_creation_params',
         'third_party/blink/public/mojom/loader/transferrable_url_loader',
         'third_party/blink/public/mojom/loader/code_cache',
-        'media/mojo/mojom/interface_factory',
-        'media/mojo/mojom/audio_decoder',
-        'media/mojo/mojom/audio_encoder',
-        'media/mojo/mojom/video_decoder',
+        'media/mojo/mojom/interface_factory', 'media/mojo/mojom/audio_decoder',
+        'media/mojo/mojom/audio_encoder', 'media/mojo/mojom/video_decoder',
         'media/mojo/mojom/media_metrics_provider')
 
     for f in input_api.AffectedFiles(file_filter=source_file_filter):

third_party/blink/public/mojom/BUILD.gn

@@ -244,6 +244,7 @@ mojom("mojom_platform") {
     "worker/worker_content_settings_proxy.mojom",
     "worker/worker_main_script_load_params.mojom",
     "worker/worker_options.mojom",
+    "worker/worklet_global_scope_creation_params.mojom",
   ]
 
   if (is_android) {

third_party/blink/public/mojom/worker/worklet_global_scope_creation_params.mojom

@@ -0,0 +1,27 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+module blink.mojom;
+
+import "third_party/blink/public/mojom/devtools/devtools_agent.mojom";
+import "mojo/public/mojom/base/unguessable_token.mojom";
+import "url/mojom/url.mojom";
+
+// Interface implemented in the browser for the worklets to forward
+// ready-for-inspection notification.
+interface WorkletDevToolsHost {
+  // Indicates that the worklet is ready for inspection, passes a DevToolsAgent
+  // interface for this worklet and requests a corresponding host.
+  OnReadyForInspection(
+    pending_remote<blink.mojom.DevToolsAgent> agent,
+    pending_receiver<blink.mojom.DevToolsAgentHost> agent_host);
+};
+
+// Parameters for initializing WorkerOrWorkletGlobalScope. This is suitable for
+// worklets starting from a different process.
+struct WorkletGlobalScopeCreationParams {
+  url.mojom.Url script_url;
+  mojo_base.mojom.UnguessableToken devtools_token;
+  pending_remote<WorkletDevToolsHost> devtools_host;
+};

third_party/blink/public/web/web_shared_storage_worklet_thread.h

@@ -8,6 +8,7 @@
 #include "base/memory/scoped_refptr.h"
 #include "base/task/single_thread_task_runner.h"
 #include "third_party/blink/public/mojom/shared_storage/shared_storage_worklet_service.mojom-forward.h"
+#include "third_party/blink/public/mojom/worker/worklet_global_scope_creation_params.mojom-forward.h"
 #include "third_party/blink/public/platform/cross_variant_mojo_util.h"
 #include "third_party/blink/public/platform/web_common.h"
 
@@ -19,7 +20,8 @@ class BLINK_EXPORT WebSharedStorageWorkletThread {
   static void Start(
       scoped_refptr<base::SingleThreadTaskRunner> main_thread_runner,
       CrossVariantMojoReceiver<mojom::SharedStorageWorkletServiceInterfaceBase>
-          receiver);
+          receiver,
+      mojom::WorkletGlobalScopeCreationParamsPtr global_scope_creation_params);
 
   virtual ~WebSharedStorageWorkletThread() = default;
 };

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

@@ -12,7 +12,6 @@
 #include "third_party/blink/renderer/core/dom/document.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/workers/global_scope_creation_params.h"
 #include "third_party/blink/renderer/core/workers/worker_global_scope.h"
@@ -70,7 +69,8 @@ void ThreadedMessagingProxyBase::Trace(Visitor* visitor) const {
 void ThreadedMessagingProxyBase::InitializeWorkerThread(
     std::unique_ptr<GlobalScopeCreationParams> global_scope_creation_params,
     const absl::optional<WorkerBackingThreadStartupData>& thread_startup_data,
-    const absl::optional<const blink::DedicatedWorkerToken>& token) {
+    const absl::optional<const blink::DedicatedWorkerToken>& token,
+    std::unique_ptr<WorkerDevToolsParams> client_provided_devtools_params) {
   DCHECK(IsParentContextThread());
 
   KURL script_url = global_scope_creation_params->script_url;
@@ -82,9 +82,12 @@ void ThreadedMessagingProxyBase::InitializeWorkerThread(
 
   worker_thread_ = CreateWorkerThread();
 
-  auto devtools_params = DevToolsAgent::WorkerThreadCreated(
-      execution_context_.Get(), worker_thread_.get(), script_url,
-      global_scope_creation_params->global_scope_name, token);
+  auto devtools_params =
+      client_provided_devtools_params
+          ? std::move(client_provided_devtools_params)
+          : DevToolsAgent::WorkerThreadCreated(
+                execution_context_.Get(), worker_thread_.get(), script_url,
+                global_scope_creation_params->global_scope_name, token);
 
   worker_thread_->Start(std::move(global_scope_creation_params),
                         thread_startup_data, std::move(devtools_params));