Introduce ServiceWorkerHandle for tracking WebServiceWorkerImpl reference

content/browser/service_worker/service_worker_version.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/service_worker_version.h"
 
 #include "base/stl_util.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
@@ skipping 149 matching lines @@
   callback.Run(status);
 }
 
 }  // namespace
 
 ServiceWorkerVersion::ServiceWorkerVersion(
     ServiceWorkerRegistration* registration,
     int64 version_id,
     base::WeakPtr<ServiceWorkerContextCore> context)
     : version_id_(version_id),
+      registration_id_(kInvalidServiceWorkerVersionId),
       status_(NEW),
-      is_shutdown_(false),
-      registration_(registration),
       weak_factory_(this),
       context_(context) {
   DCHECK(context_);
+  if (registration) {
+    registration_id_ = registration->id();
+    script_url_ = registration->script_url();
+  }
   context_->AddLiveVersion(this);
   embedded_worker_ = context_->embedded_worker_registry()->CreateWorker();
   embedded_worker_->AddObserver(this);
 }
 
 ServiceWorkerVersion::~ServiceWorkerVersion() {
-  DCHECK(is_shutdown_);
-}
-
-void ServiceWorkerVersion::Shutdown() {
-  is_shutdown_ = true;
-  registration_ = NULL;
   status_change_callbacks_.clear();
   if (embedded_worker_) {
     embedded_worker_->RemoveObserver(this);
     embedded_worker_.reset();
   }
   if (context_)
     context_->RemoveLiveVersion(version_id_);
 }
 
 void ServiceWorkerVersion::SetStatus(Status status) {
@@ skipping 14 matching lines @@
 
 ServiceWorkerVersionInfo ServiceWorkerVersion::GetInfo() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return ServiceWorkerVersionInfo(running_status(),
                                   status(),
                                   embedded_worker()->process_id(),
                                   embedded_worker()->thread_id());
 }
 
 void ServiceWorkerVersion::StartWorker(const StatusCallback& callback) {
-  DCHECK(!is_shutdown_);
   DCHECK(embedded_worker_);
-  DCHECK(registration_);
   if (running_status() == RUNNING) {
     RunSoon(base::Bind(callback, SERVICE_WORKER_OK));
     return;
   }
   if (running_status() == STOPPING) {
     RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_START_WORKER_FAILED));
     return;
   }
   if (start_callbacks_.empty()) {
     ServiceWorkerStatusCode status = embedded_worker_->Start(
         version_id_,
-        registration_->script_url());
+        script_url_);
     if (status != SERVICE_WORKER_OK) {
       RunSoon(base::Bind(callback, status));
       return;
     }
   }
   start_callbacks_.push_back(callback);
 }
 
 void ServiceWorkerVersion::StopWorker(const StatusCallback& callback) {
-  DCHECK(!is_shutdown_);
   DCHECK(embedded_worker_);
   if (running_status() == STOPPED) {
     RunSoon(base::Bind(callback, SERVICE_WORKER_OK));
     return;
   }
   if (stop_callbacks_.empty()) {
     ServiceWorkerStatusCode status = embedded_worker_->Stop();
     if (status != SERVICE_WORKER_OK) {
       RunSoon(base::Bind(callback, status));
       return;
     }
   }
   stop_callbacks_.push_back(callback);
 }
 
 void ServiceWorkerVersion::SendMessage(
     const IPC::Message& message, const StatusCallback& callback) {
-  DCHECK(!is_shutdown_);
   DCHECK(embedded_worker_);
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(&RunTaskAfterStartWorker,
                            weak_factory_.GetWeakPtr(), callback,
                            base::Bind(&self::SendMessage,
                                       weak_factory_.GetWeakPtr(),
                                       message, callback)));
     return;
   }
 
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       kInvalidServiceWorkerRequestId, message);
   RunSoon(base::Bind(callback, status));
 }
 
 void ServiceWorkerVersion::SendMessageAndRegisterCallback(
     const IPC::Message& message, const MessageCallback& callback) {
-  DCHECK(!is_shutdown_);
   DCHECK(embedded_worker_);
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(&RunTaskAfterStartWorker,
                            weak_factory_.GetWeakPtr(),
                            base::Bind(&RunEmptyMessageCallback, callback),
                            base::Bind(&self::SendMessageAndRegisterCallback,
                                       weak_factory_.GetWeakPtr(),
                                       message, callback)));
     return;
@@ skipping 56 matching lines @@
 }
 
 void ServiceWorkerVersion::DispatchSyncEvent(const StatusCallback& callback) {
   DCHECK_EQ(ACTIVE, status()) << status();
   SendMessageAndRegisterCallback(
       ServiceWorkerMsg_SyncEvent(),
       base::Bind(&HandleSyncEventFinished, callback));
 }
 
 void ServiceWorkerVersion::AddProcessToWorker(int process_id) {
-  DCHECK(!is_shutdown_);
   embedded_worker_->AddProcessReference(process_id);
 }
 
-void ServiceWorkerVersion::RemoveProcessToWorker(int process_id) {
-  // We may have been shutdown.
-  if (embedded_worker_)
-    embedded_worker_->ReleaseProcessReference(process_id);
+void ServiceWorkerVersion::RemoveProcessFromWorker(int process_id) {
+  embedded_worker_->ReleaseProcessReference(process_id);
 }
 
 void ServiceWorkerVersion::OnStarted() {
   DCHECK_EQ(RUNNING, running_status());
   // Fire all start callbacks.
   RunCallbacks(this, &start_callbacks_, SERVICE_WORKER_OK);
 }
 
 void ServiceWorkerVersion::OnStopped() {
   DCHECK_EQ(STOPPED, running_status());
@@ skipping 25 matching lines @@
     scoped_refptr<ServiceWorkerVersion> protect(this);
     callback->Run(SERVICE_WORKER_OK, message);
     message_callbacks_.Remove(request_id);
     return;
   }
   NOTREACHED() << "Got unexpected message: " << request_id
                << " " << message.type();
 }
 
 }  // namespace content