DevTools: Expose the name option of workers as the executioncontext name

Bug: 891675
Change-Id: Id1b6cfc1afc1f9afb32bacb43fbd05da2c394a5b
Reviewed-on: https://chromium-review.googlesource.com/c/1344872
Commit-Queue: Joel Einbinder <einbinder@chromium.org>
Reviewed-by: Mustafa Emre Acer <meacer@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#635793}

content/browser/devtools/devtools_renderer_channel.cc

@@ -147,6 +147,7 @@ void DevToolsRendererChannel::ChildWorkerCreated(
     blink::mojom::DevToolsAgentPtr worker_devtools_agent,
     blink::mojom::DevToolsAgentHostRequest host_request,
     const GURL& url,
+    const std::string& name,
     const base::UnguessableToken& devtools_worker_token,
     bool waiting_for_debugger) {
   if (content::DevToolsAgentHost::GetForId(devtools_worker_token.ToString())) {
@@ -160,7 +161,7 @@ void DevToolsRendererChannel::ChildWorkerCreated(
   process->FilterURL(true /* empty_allowed */, &filtered_url);
   auto agent_host = base::MakeRefCounted<WorkerDevToolsAgentHost>(
       process_id_, std::move(worker_devtools_agent), std::move(host_request),
-      filtered_url, devtools_worker_token, owner_->GetId(),
+      filtered_url, std::move(name), devtools_worker_token, owner_->GetId(),
       base::BindOnce(&DevToolsRendererChannel::ChildWorkerDestroyed,
                      weak_factory_.GetWeakPtr()));
   child_workers_.insert(agent_host.get());

content/browser/devtools/devtools_renderer_channel.h

@@ -67,6 +67,7 @@ class CONTENT_EXPORT DevToolsRendererChannel
   void ChildWorkerCreated(blink::mojom::DevToolsAgentPtr worker_devtools_agent,
                           blink::mojom::DevToolsAgentHostRequest host_request,
                           const GURL& url,
+                          const std::string& name,
                           const base::UnguessableToken& devtools_worker_token,
                           bool waiting_for_debugger) override;
   void ChildWorkerDestroyed(DevToolsAgentHostImpl*);

content/browser/devtools/worker_devtools_agent_host.cc

@@ -17,12 +17,14 @@ WorkerDevToolsAgentHost::WorkerDevToolsAgentHost(
     blink::mojom::DevToolsAgentPtr agent_ptr,
     blink::mojom::DevToolsAgentHostRequest host_request,
     const GURL& url,
+    const std::string& name,
     const base::UnguessableToken& devtools_worker_token,
     const std::string& parent_id,
     base::OnceCallback<void(DevToolsAgentHostImpl*)> destroyed_callback)
     : DevToolsAgentHostImpl(devtools_worker_token.ToString()),
       process_id_(process_id),
       url_(url),
+      name_(name),
       parent_id_(parent_id),
       destroyed_callback_(std::move(destroyed_callback)) {
   DCHECK(agent_ptr);
@@ -55,7 +57,7 @@ std::string WorkerDevToolsAgentHost::GetType() {
 }
 
 std::string WorkerDevToolsAgentHost::GetTitle() {
-  return url_.spec();
+  return name_.empty() ? url_.spec() : name_;
 }
 
 std::string WorkerDevToolsAgentHost::GetParentId() {

content/browser/devtools/worker_devtools_agent_host.h

@@ -20,6 +20,7 @@ class WorkerDevToolsAgentHost : public DevToolsAgentHostImpl {
       blink::mojom::DevToolsAgentPtr agent_ptr,
       blink::mojom::DevToolsAgentHostRequest host_request,
       const GURL& url,
+      const std::string& name,
       const base::UnguessableToken& devtools_worker_token,
       const std::string& parent_id,
       base::OnceCallback<void(DevToolsAgentHostImpl*)> destroyed_callback);
@@ -44,6 +45,7 @@ class WorkerDevToolsAgentHost : public DevToolsAgentHostImpl {
 
   const int process_id_;
   const GURL url_;
+  const std::string name_;
   const std::string parent_id_;
   base::OnceCallback<void(DevToolsAgentHostImpl*)> destroyed_callback_;
 

third_party/blink/public/mojom/devtools/devtools_agent.mojom

@@ -100,6 +100,7 @@ interface DevToolsAgentHost {
       DevToolsAgent worker_devtools_agent,
       DevToolsAgentHost& worker_devtools_agent_host,
       url.mojom.Url url,
+      string name,
       mojo_base.mojom.UnguessableToken devtools_worker_token,
       bool waiting_for_debugger);
 };

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

@@ -155,6 +155,7 @@ std::unique_ptr<WorkerDevToolsParams> DevToolsAgent::WorkerThreadCreated(
   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_;
+  data->name = worker_thread->name().IsolatedCopy();
   result->wait_for_debugger = agent->pause_child_workers_on_start_;
 
   if (agent->report_child_workers_) {
@@ -177,13 +178,13 @@ void DevToolsAgent::ReportChildWorker(std::unique_ptr<WorkerData> data) {
   if (host_ptr_.is_bound()) {
     host_ptr_->ChildWorkerCreated(
         std::move(data->agent_ptr), std::move(data->host_request),
-        std::move(data->url), data->devtools_worker_token,
-        data->waiting_for_debugger);
+        std::move(data->url), std::move(data->name),
+        data->devtools_worker_token, data->waiting_for_debugger);
   } else if (associated_host_ptr_.is_bound()) {
     associated_host_ptr_->ChildWorkerCreated(
         std::move(data->agent_ptr), std::move(data->host_request),
-        std::move(data->url), data->devtools_worker_token,
-        data->waiting_for_debugger);
+        std::move(data->url), std::move(data->name),
+        data->devtools_worker_token, data->waiting_for_debugger);
   }
 }
 

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

@@ -85,6 +85,7 @@ class CORE_EXPORT DevToolsAgent
     mojom::blink::DevToolsAgentHostRequest host_request;
     base::UnguessableToken devtools_worker_token;
     bool waiting_for_debugger;
+    String name;
   };
   void ReportChildWorker(std::unique_ptr<WorkerData>);
 

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

@@ -39,6 +39,7 @@
 #include "third_party/blink/renderer/core/inspector/identifiers_factory.h"
 #include "third_party/blink/renderer/core/inspector/v8_inspector_string.h"
 #include "third_party/blink/renderer/core/inspector/worker_inspector_controller.h"
+#include "third_party/blink/renderer/core/workers/dedicated_worker_global_scope.h"
 #include "third_party/blink/renderer/core/workers/worker_global_scope.h"
 #include "third_party/blink/renderer/core/workers/worker_reporting_proxy.h"
 #include "third_party/blink/renderer/core/workers/worker_thread.h"
@@ -109,8 +110,13 @@ void WorkerThreadDebugger::ContextCreated(WorkerThread* worker_thread,
   int worker_context_group_id = ContextGroupId(worker_thread);
   if (!worker_threads_.Contains(worker_context_group_id))
     return;
-  v8_inspector::V8ContextInfo context_info(context, worker_context_group_id,
-                                           v8_inspector::StringView());
+  String human_readable_name = "";
+  WorkerOrWorkletGlobalScope* globalScope = worker_thread->GlobalScope();
+  if (auto* scope = DynamicTo<DedicatedWorkerGlobalScope>(globalScope))
+    human_readable_name = scope->name();
+  v8_inspector::V8ContextInfo context_info(
+      context, worker_context_group_id,
+      ToV8InspectorStringView(human_readable_name));
   String origin = url_for_debugger;
   context_info.origin = ToV8InspectorStringView(origin);
   GetV8Inspector()->contextCreated(context_info);

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

@@ -74,6 +74,10 @@ void DedicatedWorkerThread::ClearWorkerBackingThread() {
   worker_backing_thread_ = nullptr;
 }
 
+String DedicatedWorkerThread::name() const {
+  return name_;
+}
+
 WorkerOrWorkletGlobalScope* DedicatedWorkerThread::CreateWorkerGlobalScope(
     std::unique_ptr<GlobalScopeCreationParams> creation_params) {
   return MakeGarbageCollected<DedicatedWorkerGlobalScope>(

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

@@ -54,6 +54,8 @@ class CORE_EXPORT DedicatedWorkerThread : public WorkerThread {
     return worker_object_proxy_;
   }
 
+  String name() const override;
+
  private:
   friend class DedicatedWorkerThreadForTest;
 

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

@@ -228,6 +228,8 @@ class CORE_EXPORT WorkerThread : public Thread::TaskObserver {
   void ChildThreadStartedOnWorkerThread(WorkerThread*);
   void ChildThreadTerminatedOnWorkerThread(WorkerThread*);
 
+  virtual String name() const { return g_empty_string; }
+
  protected:
   explicit WorkerThread(WorkerReportingProxy&);
 

third_party/blink/renderer/devtools/front_end/sdk/ChildTargetManager.js

@@ -110,7 +110,9 @@ SDK.ChildTargetManager = class extends SDK.SDKModel {
    */
   attachedToTarget(sessionId, targetInfo, waitingForDebugger) {
     let targetName = '';
-    if (targetInfo.type !== 'iframe') {
+    if (targetInfo.type === 'worker' && targetInfo.title && targetInfo.title !== targetInfo.url) {
+      targetName = targetInfo.title;
+    } else if (targetInfo.type !== 'iframe') {
       const parsedURL = targetInfo.url.asParsedURL();
       targetName = parsedURL ? parsedURL.lastPathComponentWithFragment() :
                                '#' + (++SDK.ChildTargetManager._lastAnonymousTargetId);

third_party/blink/web_tests/http/tests/devtools/sources/debugger/navigator-view.js

@@ -36,7 +36,7 @@
   async function addUISourceCode2(url) {
     TestRunner.evaluateInPageAnonymously(`
       window.workers = window.workers || [];
-      window.workers.push(new Worker('${url}', {name: 'mock-target-100'}));
+      window.workers.push(new Worker('${url}'));
     `);
     var uiSourceCode = await waitForUISourceCodeAdded(url);
     uiSourceCodes.push(uiSourceCode);

third_party/blink/web_tests/inspector-protocol/worker/worker-name-expected.txt

+Tests that the worker's name is exposed on its Execution Context.
+
+target title: "the name"
+execution context name: "the name"
+

third_party/blink/web_tests/inspector-protocol/worker/worker-name.js

+(async function(testRunner) {
+  var {page, session, dp} = await testRunner.startBlank(`Tests that the worker's name is exposed on its Execution Context.\n`);
+
+  await session.evaluate(`
+    worker = new Worker('${testRunner.url('../resources/worker-console-worker.js')}', {
+      name: 'the name'
+    });
+  `);
+  let workerCallback;
+  const workerPromise = new Promise(x => workerCallback = x);
+  dp.Target.setAutoAttach({autoAttach: true, waitForDebuggerOnStart: false});
+  let {params: {sessionId, targetInfo}} = await dp.Target.onceAttachedToTarget();
+  testRunner.log(`target title: "${targetInfo.title}"`);
+  let wc = new WorkerProtocol(dp, sessionId);
+  wc.dp.Runtime.enable({});
+  const {context} =  await wc.dp.Runtime.onceExecutionContextCreated();
+  testRunner.log(`execution context name: "${context.name}"`);
+  testRunner.completeTest();
+})