ServiceWorker: Send state change events via SWProviderHost

content/browser/service_worker/service_worker_dispatcher_host.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_dispatcher_host.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/message_port_message_filter.h"
@@ skipping 197 matching lines @@
   if (channel_ready_) {
     BrowserMessageFilter::Send(message);
     // Don't bother passing through Send()'s result: it's not reliable.
     return true;
   }
 
   pending_messages_.push_back(message);
   return true;
 }
 
+void ServiceWorkerDispatcherHost::RegisterServiceWorkerHandle(
+    scoped_ptr<ServiceWorkerHandle> handle) {
+  int handle_id = handle->handle_id();
+  handles_.AddWithID(handle.release(), handle_id);
+}
+
+void ServiceWorkerDispatcherHost::RegisterServiceWorkerRegistrationHandle(
+    scoped_ptr<ServiceWorkerRegistrationHandle> handle) {
+  int handle_id = handle->handle_id();
+  registration_handles_.AddWithID(handle.release(), handle_id);
+}
+
 ServiceWorkerRegistrationHandle*
 ServiceWorkerDispatcherHost::GetOrCreateRegistrationHandle(
-    int provider_id,
+    base::WeakPtr<ServiceWorkerProviderHost> provider_host,
     ServiceWorkerRegistration* registration) {
+  DCHECK(provider_host);
   ServiceWorkerRegistrationHandle* handle =
-      FindRegistrationHandle(provider_id, registration->id());
+      FindRegistrationHandle(provider_host->provider_id(), registration->id());
   if (handle) {
     handle->IncrementRefCount();
     return handle;
   }
 
   scoped_ptr<ServiceWorkerRegistrationHandle> new_handle(
       new ServiceWorkerRegistrationHandle(
-          GetContext()->AsWeakPtr(), this, provider_id, registration));
+          GetContext()->AsWeakPtr(), provider_host, registration));
   handle = new_handle.get();
   RegisterServiceWorkerRegistrationHandle(new_handle.Pass());
   return handle;
 }
 
-ServiceWorkerObjectInfo
-ServiceWorkerDispatcherHost::CreateAndRegisterServiceWorkerHandle(
-    ServiceWorkerVersion* version) {
-  ServiceWorkerObjectInfo info;
-  if (GetContext() && version) {
-    scoped_ptr<ServiceWorkerHandle> handle =
-        ServiceWorkerHandle::Create(GetContext()->AsWeakPtr(), this, version);
-    info = handle->GetObjectInfo();
-    RegisterServiceWorkerHandle(handle.Pass());
-  }
-  return info;
-}
-
 void ServiceWorkerDispatcherHost::OnRegisterServiceWorker(
     int thread_id,
     int request_id,
     int provider_id,
     const GURL& pattern,
     const GURL& script_url) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcherHost::OnRegisterServiceWorker");
   if (!GetContext()) {
     Send(new ServiceWorkerMsg_ServiceWorkerRegistrationError(
@@ skipping 305 matching lines @@
     DCHECK(handle);
     if (handle->provider_id() == provider_id && handle->registration() &&
         handle->registration()->id() == registration_id) {
       return handle;
     }
   }
   return NULL;
 }
 
 void ServiceWorkerDispatcherHost::GetRegistrationObjectInfoAndVersionAttributes(
-    int provider_id,
+    base::WeakPtr<ServiceWorkerProviderHost> provider_host,
     ServiceWorkerRegistration* registration,
     ServiceWorkerRegistrationObjectInfo* info,
     ServiceWorkerVersionAttributes* attrs) {
   ServiceWorkerRegistrationHandle* handle =
-    GetOrCreateRegistrationHandle(provider_id, registration);
+    GetOrCreateRegistrationHandle(provider_host, registration);
   *info = handle->GetObjectInfo();
 
-  attrs->installing = CreateAndRegisterServiceWorkerHandle(
-      registration->installing_version());
-  attrs->waiting = CreateAndRegisterServiceWorkerHandle(
-      registration->waiting_version());
-  attrs->active = CreateAndRegisterServiceWorkerHandle(
-      registration->active_version());
+  attrs->installing =
+      provider_host->CreateAndRegisterServiceWorkerHandle(
+          registration->installing_version());
+  attrs->waiting =
+      provider_host->CreateAndRegisterServiceWorkerHandle(
+          registration->waiting_version());
+  attrs->active =
+      provider_host->CreateAndRegisterServiceWorkerHandle(
+          registration->active_version());
 }
 
 void ServiceWorkerDispatcherHost::RegistrationComplete(
     int thread_id,
     int provider_id,
     int request_id,
     ServiceWorkerStatusCode status,
     const std::string& status_message,
     int64 registration_id) {
   if (!GetContext())
     return;
 
+  ServiceWorkerProviderHost* provider_host =
+      GetContext()->GetProviderHost(render_process_id_, provider_id);
+  if (!provider_host)
+    return;  // The provider has already been destroyed.
+
   if (status != SERVICE_WORKER_OK) {
     SendRegistrationError(thread_id, request_id, status, status_message);
     return;
   }
 
   ServiceWorkerRegistration* registration =
       GetContext()->GetLiveRegistration(registration_id);
   DCHECK(registration);
 
   ServiceWorkerRegistrationObjectInfo info;
   ServiceWorkerVersionAttributes attrs;
   GetRegistrationObjectInfoAndVersionAttributes(
-      provider_id, registration, &info, &attrs);
+      provider_host->AsWeakPtr(), registration, &info, &attrs);
 
   Send(new ServiceWorkerMsg_ServiceWorkerRegistered(
       thread_id, request_id, info, attrs));
   TRACE_EVENT_ASYNC_END1("ServiceWorker",
                          "ServiceWorkerDispatcherHost::RegisterServiceWorker",
                          request_id,
                          "Registration ID",
                          registration_id);
 }
 
@@ skipping 201 matching lines @@
   TRACE_EVENT_ASYNC_END1("ServiceWorker",
                          "ServiceWorkerDispatcherHost::GetRegistration",
                          request_id,
                          "Registration ID",
                          registration.get() ? registration->id()
                              : kInvalidServiceWorkerRegistrationId);
 
   if (!GetContext())
     return;
 
+  ServiceWorkerProviderHost* provider_host =
+      GetContext()->GetProviderHost(render_process_id_, provider_id);
+  if (!provider_host)
+    return;  // The provider has already been destroyed.
+
   if (status != SERVICE_WORKER_OK && status != SERVICE_WORKER_ERROR_NOT_FOUND) {
     SendGetRegistrationError(thread_id, request_id, status);
     return;
   }
 
   ServiceWorkerRegistrationObjectInfo info;
   ServiceWorkerVersionAttributes attrs;
   if (status == SERVICE_WORKER_OK) {
     DCHECK(registration.get());
     if (!registration->is_uninstalling()) {
       GetRegistrationObjectInfoAndVersionAttributes(
-          provider_id, registration.get(), &info, &attrs);
+          provider_host->AsWeakPtr(), registration.get(), &info, &attrs);
     }
   }
 
   Send(new ServiceWorkerMsg_DidGetRegistration(
       thread_id, request_id, info, attrs));
 }
 
 void ServiceWorkerDispatcherHost::SendRegistrationError(
     int thread_id,
     int request_id,
@@ skipping 44 matching lines @@
 void ServiceWorkerDispatcherHost::OnTerminateWorker(int handle_id) {
   ServiceWorkerHandle* handle = handles_.Lookup(handle_id);
   if (!handle) {
     BadMessageReceived();
     return;
   }
   handle->version()->StopWorker(
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
-void ServiceWorkerDispatcherHost::RegisterServiceWorkerHandle(
-    scoped_ptr<ServiceWorkerHandle> handle) {
-  int handle_id = handle->handle_id();
-  handles_.AddWithID(handle.release(), handle_id);
-}
-
-void ServiceWorkerDispatcherHost::RegisterServiceWorkerRegistrationHandle(
-    scoped_ptr<ServiceWorkerRegistrationHandle> handle) {
-  int handle_id = handle->handle_id();
-  registration_handles_.AddWithID(handle.release(), handle_id);
-}
-
 }  // namespace content