ServiceWorker: Make "ready" fetches registration from browser process(2/3).

content/child/service_worker/service_worker_dispatcher.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/child/service_worker/service_worker_dispatcher.h"
 
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_local.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 50 matching lines @@
                         OnAssociateRegistrationWithServiceWorker)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_AssociateRegistration,
                         OnAssociateRegistration)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DisassociateRegistration,
                         OnDisassociateRegistration)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerRegistered, OnRegistered)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerUnregistered,
                         OnUnregistered)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetRegistration,
                         OnDidGetRegistration)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetReadyRegistration,
+                        OnDidGetReadyRegistration)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerRegistrationError,
                         OnRegistrationError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerUnregistrationError,
                         OnUnregistrationError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerGetRegistrationError,
                         OnGetRegistrationError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerStateChanged,
                         OnServiceWorkerStateChanged)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SetVersionAttributes,
                         OnSetVersionAttributes)
@@ skipping 89 matching lines @@
 
   int request_id = pending_get_registration_callbacks_.Add(callbacks);
   TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker",
                            "ServiceWorkerDispatcher::GetRegistration",
                            request_id,
                            "Document URL", document_url.spec());
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetRegistration(
       CurrentWorkerId(), request_id, provider_id, document_url));
 }
 
+void ServiceWorkerDispatcher::GetReadyRegistration(
+    int provider_id,
+    WebServiceWorkerGetReadyRegistrationCallbacks* callbacks) {
+  int request_id = ready_registration_callbacks_.Add(callbacks);
+  TRACE_EVENT_ASYNC_BEGIN0("ServiceWorker",
+                           "ServiceWorkerDispatcher::GetReadyRegistration",
+                           request_id);
+  thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetReadyRegistration(
+      CurrentWorkerId(), request_id, provider_id));
+}
+
 void ServiceWorkerDispatcher::AddProviderContext(
     ServiceWorkerProviderContext* provider_context) {
   DCHECK(provider_context);
   int provider_id = provider_context->provider_id();
   DCHECK(!ContainsKey(provider_contexts_, provider_id));
   provider_contexts_[provider_id] = provider_context;
 }
 
 void ServiceWorkerDispatcher::RemoveProviderContext(
     ServiceWorkerProviderContext* provider_context) {
@@ skipping 223 matching lines @@
     return;
 
   WebServiceWorkerRegistrationImpl* registration = NULL;
   if (info.handle_id != kInvalidServiceWorkerHandleId)
     registration = FindOrCreateRegistration(info, attrs);
 
   callbacks->onSuccess(registration);
   pending_get_registration_callbacks_.Remove(request_id);
 }
 
+void ServiceWorkerDispatcher::OnDidGetReadyRegistration(
+    int thread_id,
+    int request_id,
+    const ServiceWorkerRegistrationObjectInfo& info,
+    const ServiceWorkerVersionAttributes& attrs) {
+  TRACE_EVENT_ASYNC_STEP_INTO0(
+      "ServiceWorker",
+      "ServiceWorkerDispatcher::GetReadyRegistration",
+      request_id,
+      "OnDidGetReadyRegistration");
+  TRACE_EVENT_ASYNC_END0("ServiceWorker",
+                         "ServiceWorkerDispatcher::GetReadyRegistration",
+                         request_id);
+  WebServiceWorkerGetReadyRegistrationCallbacks* callbacks =
+      ready_registration_callbacks_.Lookup(request_id);
+  DCHECK(callbacks);
+  if (!callbacks)
+    return;
+
+  WebServiceWorkerRegistrationImpl* registration = NULL;
+  DCHECK(info.handle_id != kInvalidServiceWorkerHandleId);
+  registration = FindOrCreateRegistration(info, attrs);
+  callbacks->onSuccess(registration);
+  ready_registration_callbacks_.Remove(request_id);
+}
+
 void ServiceWorkerDispatcher::OnRegistrationError(
     int thread_id,
     int request_id,
     WebServiceWorkerError::ErrorType error_type,
     const base::string16& message) {
   TRACE_EVENT_ASYNC_STEP_INTO0("ServiceWorker",
                                "ServiceWorkerDispatcher::RegisterServiceWorker",
                                request_id,
                                "OnRegistrationError");
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
@@ skipping 114 matching lines @@
       registrations_.find(registration_handle_id);
   if (found != registrations_.end()) {
     // Populate the version fields (eg. .installing) with new worker objects.
     if (mask.installing_changed())
       found->second->SetInstalling(GetServiceWorker(attrs.installing, false));
     if (mask.waiting_changed())
       found->second->SetWaiting(GetServiceWorker(attrs.waiting, false));
     if (mask.active_changed())
       found->second->SetActive(GetServiceWorker(attrs.active, false));
   }
-
-  if (mask.active_changed())
-    SetReadyRegistration(provider_id, registration_handle_id);
 }
 
 void ServiceWorkerDispatcher::OnUpdateFound(
     int thread_id,
     const ServiceWorkerRegistrationObjectInfo& info) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcher::OnUpdateFound");
   RegistrationObjectMap::iterator found = registrations_.find(info.handle_id);
   if (found != registrations_.end())
     found->second->OnUpdateFound();
 }
 
-void ServiceWorkerDispatcher::SetReadyRegistration(
-    int provider_id,
-    int registration_handle_id) {
-  ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
-  if (provider == provider_contexts_.end() ||
-      provider->second->registration_handle_id() != registration_handle_id ||
-      provider->second->active_handle_id() == kInvalidServiceWorkerHandleId) {
-    return;
-  }
-
-  ProviderClientMap::iterator client = provider_clients_.find(provider_id);
-  if (client == provider_clients_.end())
-    return;
-
-  ServiceWorkerRegistrationObjectInfo info;
-  ServiceWorkerVersionAttributes attrs;
-  bool found =
-      provider->second->GetRegistrationInfoAndVersionAttributes(&info, &attrs);
-  DCHECK(found);
-
-  WebServiceWorkerRegistrationImpl* registration =
-      FindServiceWorkerRegistration(info, false);
-  if (!registration) {
-    registration = CreateServiceWorkerRegistration(info, false);
-    registration->SetInstalling(GetServiceWorker(attrs.installing, false));
-    registration->SetWaiting(GetServiceWorker(attrs.waiting, false));
-    registration->SetActive(GetServiceWorker(attrs.active, false));
-  }
-
-  // Resolve the .ready promise with the registration object.
-  client->second->setReadyRegistration(registration);
-}
-
 void ServiceWorkerDispatcher::OnSetControllerServiceWorker(
     int thread_id,
     int provider_id,
     const ServiceWorkerObjectInfo& info,
     bool should_notify_controllerchange) {
   TRACE_EVENT2("ServiceWorker",
                "ServiceWorkerDispatcher::OnSetControllerServiceWorker",
                "Thread ID", thread_id,
                "Provider ID", provider_id);
 
@@ skipping 88 matching lines @@
         attrs.installing, thread_safe_sender_.get());
     ServiceWorkerHandleReference::Adopt(
         attrs.waiting, thread_safe_sender_.get());
     ServiceWorkerHandleReference::Adopt(
         attrs.active, thread_safe_sender_.get());
   }
   return registration;
 }
 
 }  // namespace content