ServiceWorker: Implement navigator.serviceWorker.getRegistration [2/3]

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 37 matching lines @@
          document_url.GetOrigin() == script_url.GetOrigin();
 }
 
 bool CanUnregisterServiceWorker(const GURL& document_url,
                                 const GURL& pattern) {
   // TODO: Respect Chrome's content settings, if we add a setting for
   // controlling whether Service Worker is allowed.
   return document_url.GetOrigin() == pattern.GetOrigin();
 }
 
+bool CanGetRegistration(const GURL& document_url,
+                        const GURL& given_document_url) {
+  // TODO: Respect Chrome's content settings, if we add a setting for
+  // controlling whether Service Worker is allowed.
+  return document_url.GetOrigin() == given_document_url.GetOrigin();
+}
+
 }  // namespace
 
 ServiceWorkerDispatcherHost::ServiceWorkerDispatcherHost(
     int render_process_id,
     MessagePortMessageFilter* message_port_message_filter)
     : BrowserMessageFilter(kFilteredMessageClasses,
                            arraysize(kFilteredMessageClasses)),
       render_process_id_(render_process_id),
       message_port_message_filter_(message_port_message_filter),
       channel_ready_(false) {
@@ skipping 38 matching lines @@
 }
 
 bool ServiceWorkerDispatcherHost::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerDispatcherHost, message)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_RegisterServiceWorker,
                         OnRegisterServiceWorker)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_UnregisterServiceWorker,
                         OnUnregisterServiceWorker)
+    IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_GetRegistration,
+                        OnGetRegistration)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_ProviderCreated,
                         OnProviderCreated)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_ProviderDestroyed,
                         OnProviderDestroyed)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_SetVersionId,
                         OnSetHostedVersionId)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_PostMessageToWorker,
                         OnPostMessageToWorker)
     IPC_MESSAGE_HANDLER(EmbeddedWorkerHostMsg_WorkerReadyForInspection,
                         OnWorkerReadyForInspection)
@@ skipping 170 matching lines @@
       request_id,
       "Pattern", pattern.spec());
   GetContext()->UnregisterServiceWorker(
       pattern,
       base::Bind(&ServiceWorkerDispatcherHost::UnregistrationComplete,
                  this,
                  thread_id,
                  request_id));
 }
 
+void ServiceWorkerDispatcherHost::OnGetRegistration(
+    int thread_id,
+    int request_id,
+    int provider_id,
+    const GURL& document_url) {
+  TRACE_EVENT0("ServiceWorker",
+               "ServiceWorkerDispatcherHost::OnGetRegistration");
+  if (!GetContext()) {
+    Send(new ServiceWorkerMsg_ServiceWorkerGetRegistrationError(
+        thread_id,
+        request_id,
+        blink::WebServiceWorkerError::ErrorTypeAbort,
+        base::ASCIIToUTF16(kShutdownErrorMessage)));
+    return;
+  }
+
+  ServiceWorkerProviderHost* provider_host = GetContext()->GetProviderHost(
+      render_process_id_, provider_id);
+  if (!provider_host) {
+    BadMessageReceived();
+    return;
+  }
+  if (!provider_host->IsContextAlive()) {
+    Send(new ServiceWorkerMsg_ServiceWorkerGetRegistrationError(
+        thread_id,
+        request_id,
+        blink::WebServiceWorkerError::ErrorTypeAbort,
+        base::ASCIIToUTF16(kShutdownErrorMessage)));
+    return;
+  }
+
+  if (!CanGetRegistration(provider_host->document_url(), document_url)) {
+    BadMessageReceived();
+    return;
+  }
+
+  TRACE_EVENT_ASYNC_BEGIN1(
+      "ServiceWorker",
+      "ServiceWorkerDispatcherHost::GetRegistration",
+      request_id,
+      "Document URL", document_url.spec());
+  GetContext()->GetRegistration(
+      document_url,
+      base::Bind(&ServiceWorkerDispatcherHost::GetRegistrationComplete,
+                 this,
+                 thread_id,
+                 provider_id,
+                 request_id));
+}
+
 void ServiceWorkerDispatcherHost::OnPostMessageToWorker(
     int handle_id,
     const base::string16& message,
     const std::vector<int>& sent_message_port_ids) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcherHost::OnPostMessageToWorker");
   if (!GetContext())
     return;
 
   ServiceWorkerHandle* handle = handles_.Lookup(handle_id);
@@ skipping 67 matching lines @@
     ServiceWorkerRegistrationHandle* handle = iter.GetCurrentValue();
     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,
+    int64 registration_id,
+    ServiceWorkerRegistrationObjectInfo* info,
+    ServiceWorkerVersionAttributes* attrs) {
+  ServiceWorkerRegistration* registration =
+      GetContext()->GetLiveRegistration(registration_id);
+  DCHECK(registration);
+
+  ServiceWorkerRegistrationHandle* handle =
+    GetOrCreateRegistrationHandle(provider_id, registration);
+  *info = handle->GetObjectInfo();
+
+  attrs->installing = handle->CreateServiceWorkerHandleAndPass(
+      registration->installing_version());
+  attrs->waiting = handle->CreateServiceWorkerHandleAndPass(
+      registration->waiting_version());
+  attrs->active = handle->CreateServiceWorkerHandleAndPass(
+      registration->active_version());
+}
+
 void ServiceWorkerDispatcherHost::RegistrationComplete(
     int thread_id,
     int provider_id,
     int request_id,
     ServiceWorkerStatusCode status,
     int64 registration_id,
     int64 version_id) {
   if (!GetContext())
     return;
 
   if (status != SERVICE_WORKER_OK) {
     SendRegistrationError(thread_id, request_id, status);
     return;
   }
 
-  ServiceWorkerRegistration* registration =
-      GetContext()->GetLiveRegistration(registration_id);
-  DCHECK(registration);
-
-  ServiceWorkerRegistrationHandle* handle =
-      GetOrCreateRegistrationHandle(provider_id, registration);
-
+  ServiceWorkerRegistrationObjectInfo info;
   ServiceWorkerVersionAttributes attrs;
-  attrs.installing = handle->CreateServiceWorkerHandleAndPass(
-      registration->installing_version());
-  attrs.waiting = handle->CreateServiceWorkerHandleAndPass(
-      registration->waiting_version());
-  attrs.active = handle->CreateServiceWorkerHandleAndPass(
-      registration->active_version());
+  GetRegistrationObjectInfoAndVersionAttributes(
+      provider_id, registration_id, &info, &attrs);
 
   Send(new ServiceWorkerMsg_ServiceWorkerRegistered(
-      thread_id, request_id, handle->GetObjectInfo(), attrs));
+      thread_id, request_id, info, attrs));
   TRACE_EVENT_ASYNC_END2("ServiceWorker",
                          "ServiceWorkerDispatcherHost::RegisterServiceWorker",
                          request_id,
                          "Registration ID", registration_id,
                          "Version ID", version_id);
 }
 
 void ServiceWorkerDispatcherHost::OnWorkerReadyForInspection(
     int embedded_worker_id) {
   TRACE_EVENT0("ServiceWorker",
@@ skipping 166 matching lines @@
   }
 
   Send(new ServiceWorkerMsg_ServiceWorkerUnregistered(thread_id, request_id));
   TRACE_EVENT_ASYNC_END1(
       "ServiceWorker",
       "ServiceWorkerDispatcherHost::UnregisterServiceWorker",
       request_id,
       "Status", status);
 }
 
+void ServiceWorkerDispatcherHost::GetRegistrationComplete(
+    int thread_id,
+    int provider_id,
+    int request_id,
+    ServiceWorkerStatusCode status,
+    int64 registration_id) {

[michaeln, 2014/09/10 23:52:24]

This method is relying on a 'live' registration object with this id actually
being there, a const scoped_refptr<T>& return value would ensure that (like
FindRegForDocument provides).

(i see RegistrationComplete() has the same kind of hidden
dependency/requirement, but that doesn't make it right)

[Kunihiko Sakamoto, 2014/09/11 02:54:05]

Done (as a consequence of using FindRegistrationForDocument directly).

+  if (!GetContext())
+    return;
+
+  if (status != SERVICE_WORKER_OK) {
+    SendGetRegistrationError(thread_id, request_id, status);
+    return;
+  }
+
+  ServiceWorkerRegistrationObjectInfo info;
+  ServiceWorkerVersionAttributes attrs;
+  if (registration_id != kInvalidServiceWorkerRegistrationId) {
+    GetRegistrationObjectInfoAndVersionAttributes(
+        provider_id, registration_id, &info, &attrs);
+  }
+
+  Send(new ServiceWorkerMsg_DidGetRegistration(
+      thread_id, request_id, info, attrs));
+  TRACE_EVENT_ASYNC_END1("ServiceWorker",
+                         "ServiceWorkerDispatcherHost::GetRegistration",
+                         request_id,
+                         "Registration ID", registration_id);
+}
+
 void ServiceWorkerDispatcherHost::SendRegistrationError(
     int thread_id,
     int request_id,
     ServiceWorkerStatusCode status) {
   base::string16 error_message;
   blink::WebServiceWorkerError::ErrorType error_type;
   GetServiceWorkerRegistrationStatusResponse(
       status, &error_type, &error_message);
   Send(new ServiceWorkerMsg_ServiceWorkerRegistrationError(
       thread_id, request_id, error_type, error_message));
 }
 
 void ServiceWorkerDispatcherHost::SendUnregistrationError(
     int thread_id,
     int request_id,
     ServiceWorkerStatusCode status) {
   base::string16 error_message;
   blink::WebServiceWorkerError::ErrorType error_type;
   GetServiceWorkerRegistrationStatusResponse(
       status, &error_type, &error_message);
   Send(new ServiceWorkerMsg_ServiceWorkerUnregistrationError(
       thread_id, request_id, error_type, error_message));
 }
 
+void ServiceWorkerDispatcherHost::SendGetRegistrationError(
+    int thread_id,
+    int request_id,
+    ServiceWorkerStatusCode status) {
+  base::string16 error_message;
+  blink::WebServiceWorkerError::ErrorType error_type;
+  GetServiceWorkerRegistrationStatusResponse(
+      status, &error_type, &error_message);
+  Send(new ServiceWorkerMsg_ServiceWorkerGetRegistrationError(
+      thread_id, request_id, error_type, error_message));
+}
+
 ServiceWorkerContextCore* ServiceWorkerDispatcherHost::GetContext() {
   return context_wrapper_->context();
 }
 
 }  // namespace content