[Task Manager] Support asynchronously determined worker's URL

Bug: 1041093
Change-Id: Idc9c23461a794c736f230d79391f7f37e738f8c5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2065313
Commit-Queue: Patrick Monette <pmonette@chromium.org>
Reviewed-by: Ahmed Fakhry <afakhry@chromium.org>
Cr-Commit-Position: refs/heads/master@{#744062}

chrome/browser/task_manager/providers/per_profile_worker_task_tracker.cc

@@ -53,10 +53,8 @@ void PerProfileWorkerTaskTracker::OnWorkerStarted(
     content::DedicatedWorkerId dedicated_worker_id,
     int worker_process_id,
     content::GlobalFrameRoutingId ancestor_render_frame_host_id) {
-  // TODO(https://crbug.com/1047787): Make use of the worker's URL when it is
-  //                                  available.
   CreateWorkerTask(dedicated_worker_id, Task::Type::DEDICATED_WORKER,
-                   worker_process_id, GURL(), &dedicated_worker_tasks_);
+                   worker_process_id, &dedicated_worker_tasks_);
 }
 
 void PerProfileWorkerTaskTracker::OnBeforeWorkerTerminated(
@@ -65,14 +63,18 @@ void PerProfileWorkerTaskTracker::OnBeforeWorkerTerminated(
   DeleteWorkerTask(dedicated_worker_id, &dedicated_worker_tasks_);
 }
 
+void PerProfileWorkerTaskTracker::OnFinalResponseURLDetermined(
+    content::DedicatedWorkerId dedicated_worker_id,
+    const GURL& url) {
+  SetWorkerTaskScriptUrl(dedicated_worker_id, url, &dedicated_worker_tasks_);
+}
+
 void PerProfileWorkerTaskTracker::OnWorkerStarted(
     content::SharedWorkerId shared_worker_id,
     int worker_process_id,
     const base::UnguessableToken& dev_tools_token) {
-  // TODO(https://crbug.com/1047787): Make use of the worker's URL when it is
-  //                                  available.
   CreateWorkerTask(shared_worker_id, Task::Type::SHARED_WORKER,
-                   worker_process_id, GURL(), &shared_worker_tasks_);
+                   worker_process_id, &shared_worker_tasks_);
 }
 
 void PerProfileWorkerTaskTracker::OnBeforeWorkerTerminated(
@@ -80,12 +82,19 @@ void PerProfileWorkerTaskTracker::OnBeforeWorkerTerminated(
   DeleteWorkerTask(shared_worker_id, &shared_worker_tasks_);
 }
 
+void PerProfileWorkerTaskTracker::OnFinalResponseURLDetermined(
+    content::SharedWorkerId shared_worker_id,
+    const GURL& url) {
+  SetWorkerTaskScriptUrl(shared_worker_id, url, &shared_worker_tasks_);
+}
+
 void PerProfileWorkerTaskTracker::OnVersionStartedRunning(
     int64_t version_id,
     const content::ServiceWorkerRunningInfo& running_info) {
   CreateWorkerTask(version_id, Task::Type::SERVICE_WORKER,
-                   running_info.render_process_id, running_info.script_url,
-                   &service_worker_tasks_);
+                   running_info.render_process_id, &service_worker_tasks_);
+  SetWorkerTaskScriptUrl(version_id, running_info.script_url,
+                         &service_worker_tasks_);
 }
 
 void PerProfileWorkerTaskTracker::OnVersionStoppedRunning(int64_t version_id) {
@@ -97,14 +106,13 @@ void PerProfileWorkerTaskTracker::CreateWorkerTask(
     const WorkerId& worker_id,
     Task::Type task_type,
     int worker_process_id,
-    const GURL& script_url,
     base::flat_map<WorkerId, std::unique_ptr<WorkerTask>>* out_worker_tasks) {
   auto* worker_process_host =
       content::RenderProcessHost::FromID(worker_process_id);
   auto insertion_result = out_worker_tasks->emplace(
       worker_id,
       std::make_unique<WorkerTask>(worker_process_host->GetProcess().Handle(),
-                                   script_url, task_type, worker_process_id));
+                                   task_type, worker_process_id));
   DCHECK(insertion_result.second);
   worker_task_provider_->OnWorkerTaskAdded(
       insertion_result.first->second.get());
@@ -120,4 +128,14 @@ void PerProfileWorkerTaskTracker::DeleteWorkerTask(
   out_worker_tasks->erase(it);
 }
 
+template <typename WorkerId>
+void PerProfileWorkerTaskTracker::SetWorkerTaskScriptUrl(
+    const WorkerId& worker_id,
+    const GURL& script_url,
+    base::flat_map<WorkerId, std::unique_ptr<WorkerTask>>* out_worker_tasks) {
+  auto it = out_worker_tasks->find(worker_id);
+  DCHECK(it != out_worker_tasks->end());
+  it->second->SetScriptUrl(script_url);
+}
+
 }  // namespace task_manager

chrome/browser/task_manager/providers/per_profile_worker_task_tracker.h

@@ -47,6 +47,9 @@ class PerProfileWorkerTaskTracker
   void OnBeforeWorkerTerminated(
       content::DedicatedWorkerId dedicated_worker_id,
       content::GlobalFrameRoutingId ancestor_render_frame_host_id) override;
+  void OnFinalResponseURLDetermined(
+      content::DedicatedWorkerId dedicated_worker_id,
+      const GURL& url) override;
 
   // content::SharedWorkerService::Observer:
   void OnWorkerStarted(content::SharedWorkerId shared_worker_id,
@@ -54,6 +57,8 @@ class PerProfileWorkerTaskTracker
                        const base::UnguessableToken& dev_tools_token) override;
   void OnBeforeWorkerTerminated(
       content::SharedWorkerId shared_worker_id) override;
+  void OnFinalResponseURLDetermined(content::SharedWorkerId shared_worker_id,
+                                    const GURL& url) override;
   void OnClientAdded(
       content::SharedWorkerId shared_worker_id,
       content::GlobalFrameRoutingId render_frame_host_id) override {}
@@ -78,16 +83,28 @@ class PerProfileWorkerTaskTracker
       const WorkerId& worker_id,
       Task::Type task_type,
       int worker_process_id,
-      const GURL& script_url,
       base::flat_map<WorkerId, std::unique_ptr<WorkerTask>>* out_worker_tasks);
 
   // Deletes an existing WorkerTask from |out_worker_tasks| and notifies
   // |worker_task_provider_| about the deletion of the task.
+  //
+  // Note that this function is templated because each worker type uses a
+  // different type as its ID.
   template <typename WorkerId>
   void DeleteWorkerTask(
       const WorkerId& worker_id,
       base::flat_map<WorkerId, std::unique_ptr<WorkerTask>>* out_worker_tasks);
 
+  // Sets the script URL of an existing WorkerTask.
+  //
+  // Note that this function is templated because each worker type uses a
+  // different type as its ID.
+  template <typename WorkerId>
+  void SetWorkerTaskScriptUrl(
+      const WorkerId& worker_id,
+      const GURL& script_url,
+      base::flat_map<WorkerId, std::unique_ptr<WorkerTask>>* out_worker_tasks);
+
   // The provider that gets notified when a WorkerTask is created/deleted.
   WorkerTaskProvider* const worker_task_provider_;  // Owner.
 

chrome/browser/task_manager/providers/worker_task.cc

@@ -4,12 +4,17 @@
 
 #include "chrome/browser/task_manager/providers/worker_task.h"
 
+#include <string>
+
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "url/gurl.h"
 
 namespace task_manager {
 
+namespace {
+
 int GetTaskTitlePrefixMessageId(Task::Type task_type) {
   switch (task_type) {
     case Task::Type::DEDICATED_WORKER:
@@ -24,14 +29,19 @@ int GetTaskTitlePrefixMessageId(Task::Type task_type) {
   }
 }
 
+base::string16 GetTaskTitle(const GURL& script_url, Task::Type task_type) {
+  return l10n_util::GetStringFUTF16(GetTaskTitlePrefixMessageId(task_type),
+                                    base::UTF8ToUTF16(script_url.spec()));
+}
+
+}  // namespace
+
 WorkerTask::WorkerTask(base::ProcessHandle handle,
-                       const GURL& script_url,
                        Task::Type task_type,
                        int render_process_id)
-    : Task(l10n_util::GetStringFUTF16(GetTaskTitlePrefixMessageId(task_type),
-                                      base::UTF8ToUTF16(script_url.spec())),
-           script_url.spec(),
-           nullptr /* icon */,
+    : Task(GetTaskTitle(/*script_url=*/GURL(), task_type),
+           /*rappor_sample=*/std::string(),
+           /*icon=*/nullptr,
            handle),
       task_type_(task_type),
       render_process_id_(render_process_id) {}
@@ -46,4 +56,9 @@ int WorkerTask::GetChildProcessUniqueID() const {
   return render_process_id_;
 }
 
+void WorkerTask::SetScriptUrl(const GURL& script_url) {
+  set_title(GetTaskTitle(script_url, task_type_));
+  set_rappor_sample_name(script_url.spec());
+}
+
 }  // namespace task_manager

chrome/browser/task_manager/providers/worker_task.h

@@ -6,7 +6,8 @@
 #define CHROME_BROWSER_TASK_MANAGER_PROVIDERS_WORKER_TASK_H_
 
 #include "chrome/browser/task_manager/providers/task.h"
-#include "url/gurl.h"
+
+class GURL;
 
 namespace task_manager {
 
@@ -17,7 +18,6 @@ namespace task_manager {
 class WorkerTask : public Task {
  public:
   WorkerTask(base::ProcessHandle handle,
-             const GURL& script_url,
              Task::Type task_type,
              int render_process_id);
   ~WorkerTask() override;
@@ -30,6 +30,9 @@ class WorkerTask : public Task {
   Task::Type GetType() const override;
   int GetChildProcessUniqueID() const override;
 
+  // Invoked when the final response URL of the worker script is determined.
+  void SetScriptUrl(const GURL& script_url);
+
  private:
   // The type of this worker task. Can be one of DEDICATED_WORKER, SHARED_WORKER
   // or SERVICE_WORKER.