Call EmbeddedWorkerDevToolsManager::ServiceWorkerCreated, WorkerContextStarted and WorkerDestroyed.

content/browser/devtools/embedded_worker_devtools_manager.cc

 // Copyright 2014 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/devtools/embedded_worker_devtools_manager.h"
 
 #include "content/browser/devtools/devtools_manager_impl.h"
 #include "content/browser/devtools/devtools_protocol.h"
 #include "content/browser/devtools/devtools_protocol_constants.h"
 #include "content/browser/devtools/ipc_devtools_agent_host.h"
@@ skipping 200 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const WorkerId id(worker_process_id, worker_route_id);
   WorkerInfoMap::iterator it = FindExistingServiceWorkerInfo(
       storage_partition_path, service_worker_scope);
   if (it == workers_.end()) {
     scoped_ptr<WorkerInfo> info(
         new WorkerInfo(storage_partition_path, service_worker_scope));
     workers_.set(id, info.Pass());
     return false;
   }
+  if (WORKER_TERMINATED != it->second->state()) {
+    // WorkerDestroyed is called when EmbeddedWorkerInstance is deleted. But in
+    // current code ServiceWorkerStorage::DeleteRegistration doesn't remove the
+    // instance. So WorkerDestroyed could not be called correctly.
+    // TODO(horo): Remove this if statement when it becomes unnecessary.

[kinuko, 2014/05/13 05:45:19]

Um... looks like this is another undesirable effects of the fact that we don't
properly stop workers

[horo, 2014/05/13 09:11:21]

I think so too.
This is a work around code.
In current implementation of ServiceWorker, stopping instance code is not
correctly implemented.

+    DLOG(ERROR) << "WorkerDestroyed has not been called correctly.";
+    WorkerDestroyed(it->first.first, it->first.second);
+    return ServiceWorkerCreated(worker_process_id,
+                                worker_route_id,
+                                storage_partition_path,
+                                service_worker_scope);
+  }
   MoveToPausedState(id, it);
   return true;
 }
 
 void EmbeddedWorkerDevToolsManager::WorkerDestroyed(int worker_process_id,
                                                     int worker_route_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const WorkerId id(worker_process_id, worker_route_id);
   WorkerInfoMap::iterator it = workers_.find(id);
   DCHECK(it != workers_.end());
@@ skipping 88 matching lines @@
   for (; it != workers_.end(); ++it) {
     if (it->second->Matches(storage_partition_path, service_worker_scope))
       break;
   }
   return it;
 }
 
 void EmbeddedWorkerDevToolsManager::MoveToPausedState(
     const WorkerId& id,
     const WorkerInfoMap::iterator& it) {
-  DCHECK_EQ(WORKER_TERMINATED, it->second->state());
+   DCHECK_EQ(WORKER_TERMINATED, it->second->state());
   scoped_ptr<WorkerInfo> info = workers_.take_and_erase(it);
   info->set_state(WORKER_PAUSED);
   workers_.set(id, info.Pass());
 }
 
 void EmbeddedWorkerDevToolsManager::ResetForTesting() {
   workers_.clear();
 }
 
 }  // namespace content