Service Worker: Add ServiceWorkerContainer.getRegistrations() method.

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/thread_task_runner_handle.h"
 #include "base/threading/thread_local.h"
@@ skipping 51 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_DidGetRegistrations,
+                        OnDidGetRegistrations)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetRegistrationForReady,
                         OnDidGetRegistrationForReady)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerRegistrationError,
                         OnRegistrationError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerUnregistrationError,
                         OnUnregistrationError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerGetRegistrationError,
                         OnGetRegistrationError)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerGetRegistrationsError,
+                        OnGetRegistrationsError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerStateChanged,
                         OnServiceWorkerStateChanged)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SetVersionAttributes,
                         OnSetVersionAttributes)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_UpdateFound,
                         OnUpdateFound)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SetControllerServiceWorker,
                         OnSetControllerServiceWorker)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_MessageToDocument,
                         OnPostMessage)
@@ skipping 83 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::GetRegistrations(
+    int provider_id,
+    WebServiceWorkerGetRegistrationsCallbacks* callbacks) {
+  DCHECK(callbacks);
+
+  int request_id = pending_get_registrations_callbacks_.Add(callbacks);
+  TRACE_EVENT_ASYNC_BEGIN0("ServiceWorker",
+                           "ServiceWorkerDispatcher::GetRegistrations",
+                           request_id);
+  thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetRegistrations(
+      CurrentWorkerId(), request_id, provider_id));
+}
+
 void ServiceWorkerDispatcher::GetRegistrationForReady(
     int provider_id,
     WebServiceWorkerGetRegistrationForReadyCallbacks* callbacks) {
   int request_id = get_for_ready_callbacks_.Add(callbacks);
   TRACE_EVENT_ASYNC_BEGIN0("ServiceWorker",
                            "ServiceWorkerDispatcher::GetRegistrationForReady",
                            request_id);
   thread_safe_sender_->Send(new ServiceWorkerHostMsg_GetRegistrationForReady(
       CurrentWorkerId(), request_id, provider_id));
 }
@@ skipping 217 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::OnDidGetRegistrations(
+    int thread_id,
+    int request_id,
+    const std::vector<ServiceWorkerRegistrationObjectInfo>& infos,
+    const std::vector<ServiceWorkerVersionAttributes>& attrs) {
+  TRACE_EVENT_ASYNC_STEP_INTO0(
+      "ServiceWorker",
+      "ServiceWorkerDispatcher::GetRegistrations",
+      request_id,
+      "OnDidGetRegistrations");
+  TRACE_EVENT_ASYNC_END0("ServiceWorker",
+                         "ServiceWorkerDispatcher::GetRegistrations",
+                         request_id);
+
+  WebServiceWorkerGetRegistrationsCallbacks* callbacks =
+      pending_get_registrations_callbacks_.Lookup(request_id);
+  DCHECK(callbacks);
+  if (!callbacks)
+    return;
+
+  typedef blink::WebVector<blink::WebServiceWorkerRegistration*>
+      WebServiceWorkerRegistrationArray;
+  scoped_ptr<WebServiceWorkerRegistrationArray>
+      registrations(new WebServiceWorkerRegistrationArray(infos.size()));
+  for (size_t i = 0; i < infos.size(); ++i) {
+    if (infos[i].handle_id != kInvalidServiceWorkerHandleId) {
+      ServiceWorkerRegistrationObjectInfo info(infos[i]);
+      ServiceWorkerVersionAttributes attr(attrs[i]);
+      (*registrations)[i] = FindOrCreateRegistration(info, attr);
+    }
+  }
+
+  callbacks->onSuccess(registrations.release());
+  pending_get_registrations_callbacks_.Remove(request_id);
+}
+
 void ServiceWorkerDispatcher::OnDidGetRegistrationForReady(
     int thread_id,
     int request_id,
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerDispatcher::GetRegistrationForReady",
       request_id,
       "OnDidGetRegistrationForReady");
@@ skipping 80 matching lines @@
   DCHECK(callbacks);
   if (!callbacks)
     return;
 
   scoped_ptr<WebServiceWorkerError> error(
       new WebServiceWorkerError(error_type, message));
   callbacks->onError(error.release());
   pending_get_registration_callbacks_.Remove(request_id);
 }
 
+void ServiceWorkerDispatcher::OnGetRegistrationsError(
+    int thread_id,
+    int request_id,
+    WebServiceWorkerError::ErrorType error_type,
+    const base::string16& message) {
+  TRACE_EVENT_ASYNC_STEP_INTO0(
+      "ServiceWorker",
+      "ServiceWorkerDispatcher::GetRegistrations",
+      request_id,
+      "OnGetRegistrationsError");
+  TRACE_EVENT_ASYNC_END0("ServiceWorker",
+                         "ServiceWorkerDispatcher::GetRegistrations",
+                         request_id);
+  WebServiceWorkerGetRegistrationsCallbacks* callbacks =
+      pending_get_registrations_callbacks_.Lookup(request_id);
+  DCHECK(callbacks);
+  if (!callbacks)
+    return;
+
+  scoped_ptr<WebServiceWorkerError> error(
+      new WebServiceWorkerError(error_type, message));
+  callbacks->onError(error.release());
+  pending_get_registrations_callbacks_.Remove(request_id);
+}
+
 void ServiceWorkerDispatcher::OnServiceWorkerStateChanged(
     int thread_id,
     int handle_id,
     blink::WebServiceWorkerState state) {
   TRACE_EVENT2("ServiceWorker",
                "ServiceWorkerDispatcher::OnServiceWorkerStateChanged",
                "Thread ID", thread_id,
                "State", state);
   WorkerObjectMap::iterator worker = service_workers_.find(handle_id);
   if (worker != service_workers_.end())
@@ skipping 158 matching lines @@
   bool adopt_handle = true;
   WebServiceWorkerRegistrationImpl* registration =
       CreateServiceWorkerRegistration(info, adopt_handle);
   registration->SetInstalling(GetServiceWorker(attrs.installing, adopt_handle));
   registration->SetWaiting(GetServiceWorker(attrs.waiting, adopt_handle));
   registration->SetActive(GetServiceWorker(attrs.active, adopt_handle));
   return registration;
 }
 
 }  // namespace content