Call EmbeddedWorkerDevToolsManager::ServiceWorkerCreated, WorkerContextStarted and WorkerDestroyed.

content/browser/service_worker/embedded_worker_instance.cc

 // Copyright 2013 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/service_worker/embedded_worker_instance.h"
 
+#include "content/browser/devtools/embedded_worker_devtools_manager.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_process_host.h"
 #include "ipc/ipc_message.h"
 #include "url/gurl.h"
 
 namespace content {
 
 namespace {

[kinuko, 2014/05/08 11:17:31]

nit: can we have an empty line (to match the end of block)

[horo, 2014/05/08 14:17:46]

Done.

 // Functor to sort by the .second element of a struct.
 struct SecondGreater {
   template <typename Value>
   bool operator()(const Value& lhs, const Value& rhs) {
     return lhs.second > rhs.second;
   }
 };
+
+void RegisterToDevToolsManagerOnUI(
+    int process_id,
+    const base::FilePath& storage_partition_path,
+    const GURL& scope,
+    const base::Callback<void(int worker_devtools_agent_route_id,
+                              bool pause_on_start)>& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  int worker_devtools_agent_route_id = MSG_ROUTING_NONE;
+  bool pause_on_start = false;
+  if (RenderProcessHost* rph = RenderProcessHost::FromID(process_id)) {
+    // |rph| may be NULL in unit tests.
+    worker_devtools_agent_route_id = rph->GetNextRoutingID();
+    pause_on_start =
+        EmbeddedWorkerDevToolsManager::GetInstance()->ServiceWorkerCreated(
+            process_id,
+            worker_devtools_agent_route_id,
+            storage_partition_path,
+            scope);
+  }
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(callback, worker_devtools_agent_route_id, pause_on_start));
+}
+
+void NotifyWorkerContextStartedOnUI(int worker_process_id,
+                                    int worker_route_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  EmbeddedWorkerDevToolsManager::GetInstance()->WorkerContextStarted(
+      worker_process_id, worker_route_id);
+}
+
+void NotifyWorkerDestroyedOnUI(int worker_process_id, int worker_route_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  EmbeddedWorkerDevToolsManager::GetInstance()->WorkerDestroyed(
+      worker_process_id, worker_route_id);
+}
+
 }  // namespace
 
+EmbeddedWorkerInstance::DevToolsManagerBridge::DevToolsManagerBridge(
+    int embedded_worker_id,
+    const base::FilePath& storage_partition_path)
+    : embedded_worker_id_(embedded_worker_id),
+      storage_partition_path_(storage_partition_path),
+      worker_process_id_(-1),
+      worker_devtools_agent_route_id_(MSG_ROUTING_NONE) {
+}
+
+EmbeddedWorkerInstance::DevToolsManagerBridge::~DevToolsManagerBridge() {
+}
+
+void EmbeddedWorkerInstance::DevToolsManagerBridge::RegisterToDevToolsManager(
+    int process_id,
+    const base::Callback<void(int worker_devtools_agent_route_id,
+                              bool pause_on_start)>& callback) {
+  worker_process_id_ = process_id;
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(
+          RegisterToDevToolsManagerOnUI,
+          worker_process_id_,
+          storage_partition_path_,
+          scope_,
+          base::Bind(
+              &DevToolsManagerBridge::RegisteredCallback, this, callback)));
+}
+
+void EmbeddedWorkerInstance::DevToolsManagerBridge::RegisteredCallback(
+    const base::Callback<void(int worker_devtools_agent_route_id,
+                              bool pause_on_start)>& callback,
+    int worker_devtools_agent_route_id,
+    bool pause_on_start) {
+  worker_devtools_agent_route_id_ = worker_devtools_agent_route_id;
+  callback.Run(worker_devtools_agent_route_id, pause_on_start);
+}
+
+void EmbeddedWorkerInstance::DevToolsManagerBridge::OnStarted() {
+}
+
+void EmbeddedWorkerInstance::DevToolsManagerBridge::OnStopped() {
+  if (worker_devtools_agent_route_id_ != MSG_ROUTING_NONE) {
+    BrowserThread::PostTask(BrowserThread::UI,
+                            FROM_HERE,
+                            base::Bind(NotifyWorkerDestroyedOnUI,
+                                       worker_process_id_,
+                                       worker_devtools_agent_route_id_));
+  }
+}
+void EmbeddedWorkerInstance::DevToolsManagerBridge::OnScriptLoaded() {
+  if (worker_devtools_agent_route_id_ != MSG_ROUTING_NONE) {
+    BrowserThread::PostTask(BrowserThread::UI,
+                            FROM_HERE,
+                            base::Bind(NotifyWorkerContextStartedOnUI,
+                                       worker_process_id_,
+                                       worker_devtools_agent_route_id_));
+  }
+}
+
+bool EmbeddedWorkerInstance::DevToolsManagerBridge::OnMessageReceived(
+    const IPC::Message& message) {
+  return false;
+}
+
 EmbeddedWorkerInstance::~EmbeddedWorkerInstance() {
+  RemoveListener(dev_tools_manager_bridge_.get());

[kinuko, 2014/05/08 11:17:31]

nit: doesn't feel it's necessary

[horo, 2014/05/08 14:17:46]

Done.

   registry_->RemoveWorker(process_id_, embedded_worker_id_);
 }
 
 void EmbeddedWorkerInstance::Start(int64 service_worker_version_id,
                                    const GURL& scope,
                                    const GURL& script_url,
                                    const std::vector<int>& possible_process_ids,
                                    const StatusCallback& callback) {
   DCHECK(status_ == STOPPED);
+  dev_tools_manager_bridge_->set_scope(scope);

[kinuko, 2014/05/08 11:17:31]

Looks like the scope can be given to ctor of EmbeddedWorkerInstance (as it
doesn't change during the lifetime) and it's probably better to do so for
clarity?

[horo, 2014/05/08 14:17:46]

Done.

   status_ = STARTING;
   std::vector<int> ordered_process_ids = SortProcesses(possible_process_ids);
   registry_->StartWorker(ordered_process_ids,
                          embedded_worker_id_,
                          service_worker_version_id,
                          scope,
                          script_url,
                          callback);
 }
 
@@ skipping 24 matching lines @@
 void EmbeddedWorkerInstance::ReleaseProcessReference(int process_id) {
   ProcessRefMap::iterator found = process_refs_.find(process_id);
   if (found == process_refs_.end()) {
     NOTREACHED() << "Releasing unknown process ref " << process_id;
     return;
   }
   if (--found->second == 0)
     process_refs_.erase(found);
 }
 
-EmbeddedWorkerInstance::EmbeddedWorkerInstance(EmbeddedWorkerRegistry* registry,
-                                               int embedded_worker_id)
+EmbeddedWorkerInstance::EmbeddedWorkerInstance(
+    EmbeddedWorkerRegistry* registry,
+    int embedded_worker_id,
+    const base::FilePath& storage_partition_path)
     : registry_(registry),
       embedded_worker_id_(embedded_worker_id),
       status_(STOPPED),
       process_id_(-1),
       thread_id_(-1),
-      worker_devtools_agent_route_id_(MSG_ROUTING_NONE) {
+      worker_devtools_agent_route_id_(MSG_ROUTING_NONE),
+      dev_tools_manager_bridge_(
+          new DevToolsManagerBridge(embedded_worker_id,
+                                    storage_partition_path)) {

[kinuko, 2014/05/08 11:17:31]

nit: you can get this via registry ptr here rather than via ctor param (as
EmbeddedWorkerInstance itself doesn't need it)

[horo, 2014/05/08 14:17:46]

Done.
Added EmbeddedWorkerRegistry::storage_partition_path().

+  AddListener(dev_tools_manager_bridge_.get());
 }
 
-void EmbeddedWorkerInstance::RecordProcessId(
+void EmbeddedWorkerInstance::WorkerProcessAllocated(
     int process_id,
-    ServiceWorkerStatusCode status,
-    int worker_devtools_agent_route_id) {
+    const base::Callback<void(int worker_devtools_agent_route_id,
+                              bool pause_on_start)>& callback) {
   DCHECK_EQ(process_id_, -1);
-  DCHECK_EQ(worker_devtools_agent_route_id_, MSG_ROUTING_NONE);
-  if (status == SERVICE_WORKER_OK) {
-    process_id_ = process_id;
-    worker_devtools_agent_route_id_ = worker_devtools_agent_route_id;
-  } else {
-    status_ = STOPPED;
-  }
+  process_id_ = process_id;
+  dev_tools_manager_bridge_->RegisterToDevToolsManager(process_id, callback);
+}
+
+void EmbeddedWorkerInstance::WorkerProcessAllocationFailed() {
+  DCHECK_EQ(process_id_, -1);
+  status_ = STOPPED;
 }
 
 void EmbeddedWorkerInstance::OnScriptLoaded() {
-  // TODO(horo): Implement this.
+  FOR_EACH_OBSERVER(Listener, listener_list_, OnScriptLoaded());
 }
 
 void EmbeddedWorkerInstance::OnScriptLoadFailed() {
 }
 
 void EmbeddedWorkerInstance::OnStarted(int thread_id) {
   // Stop is requested before OnStarted is sent back from the worker.
   if (status_ == STOPPING)
     return;
   DCHECK(status_ == STARTING);
@@ skipping 67 matching lines @@
   // Sort descending by the reference count.
   std::sort(counted.begin(), counted.end(), SecondGreater());
 
   std::vector<int> result(counted.size());
   for (size_t i = 0; i < counted.size(); ++i)
     result[i] = counted[i].first;
   return result;
 }
 
 }  // namespace content