[ServiceWorker] Mojofy InstallEvent of Service Worker

content/renderer/service_worker/service_worker_context_client.cc

 // Copyright 2015 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/renderer/service_worker/service_worker_context_client.h"
 
 #include <map>
 #include <memory>
 #include <utility>
 
@@ skipping 226 matching lines @@
   std::vector<blink::WebString> cors_exposed_header_names;
   for (const auto& name : response.cors_exposed_header_names)
     cors_exposed_header_names.push_back(blink::WebString::FromUTF8(name));
 
   web_response->SetCorsExposedHeaderNames(
       blink::WebVector<blink::WebString>(cors_exposed_header_names));
 }
 
 // Use this template in willDestroyWorkerContext to abort all the pending
 // events callbacks.
-template <typename T>
-void AbortPendingEventCallbacks(T& callbacks) {
+template <typename T, class... TArgs>
+void AbortPendingEventCallbacks(T& callbacks, TArgs... args) {
   for (typename T::iterator it(&callbacks); !it.IsAtEnd(); it.Advance()) {
     std::move(*it.GetCurrentValue())
-        .Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
+        .Run(SERVICE_WORKER_ERROR_ABORT, args..., base::Time::Now());
   }
 }
 
 template <typename Key, typename Callback>
 void AbortPendingEventCallbacks(std::map<Key, Callback>& callbacks) {
   for (auto& item : callbacks)
     std::move(item.second).Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
 }
 
 }  // namespace
 
 // Holding data that needs to be bound to the worker context on the
 // worker thread.
 struct ServiceWorkerContextClient::WorkerContextData {
   using SimpleEventCallback =
       base::OnceCallback<void(ServiceWorkerStatusCode, base::Time)>;
   using ClientsCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerClientsCallbacks>>;
   using ClaimClientsCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerClientsClaimCallbacks>>;
   using ClientCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerClientCallbacks>>;
   using SkipWaitingCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerSkipWaitingCallbacks>>;
+  using InstallEventCallbacksMap =
+      IDMap<std::unique_ptr<DispatchInstallEventCallback>>;
   using ActivateEventCallbacksMap =
       IDMap<std::unique_ptr<DispatchActivateEventCallback>>;
   using BackgroundFetchAbortEventCallbacksMap =
       IDMap<std::unique_ptr<DispatchBackgroundFetchAbortEventCallback>>;
   using BackgroundFetchClickEventCallbacksMap =
       IDMap<std::unique_ptr<DispatchBackgroundFetchClickEventCallback>>;
   using BackgroundFetchFailEventCallbacksMap =
       IDMap<std::unique_ptr<DispatchBackgroundFetchFailEventCallback>>;
   using BackgroundFetchedEventCallbacksMap =
       IDMap<std::unique_ptr<DispatchBackgroundFetchedEventCallback>>;
   using SyncEventCallbacksMap = IDMap<std::unique_ptr<SyncCallback>>;
   using NotificationClickEventCallbacksMap =
       IDMap<std::unique_ptr<DispatchNotificationClickEventCallback>>;
   using NotificationCloseEventCallbacksMap =
       IDMap<std::unique_ptr<DispatchNotificationCloseEventCallback>>;
   using PushEventCallbacksMap =
       IDMap<std::unique_ptr<DispatchPushEventCallback>>;
   using ExtendableMessageEventCallbacksMap =
       IDMap<std::unique_ptr<DispatchExtendableMessageEventCallback>>;
   using NavigationPreloadRequestsMap = IDMap<
       std::unique_ptr<ServiceWorkerContextClient::NavigationPreloadRequest>>;
+  using InstallEventMethodsMap =
+      std::map<int, mojom::ServiceWorkerInstallEventMethodsAssociatedPtr>;
 
   explicit WorkerContextData(ServiceWorkerContextClient* owner)
       : event_dispatcher_binding(owner),
         weak_factory(owner),
         proxy_weak_factory(owner->proxy_) {}
 
   ~WorkerContextData() {
     DCHECK(thread_checker.CalledOnValidThread());
   }
 
   mojo::Binding<mojom::ServiceWorkerEventDispatcher> event_dispatcher_binding;
 
   // Pending callbacks for GetClientDocuments().
   ClientsCallbacksMap clients_callbacks;
 
   // Pending callbacks for OpenWindow() and FocusClient().
   ClientCallbacksMap client_callbacks;
 
   // Pending callbacks for SkipWaiting().
   SkipWaitingCallbacksMap skip_waiting_callbacks;
 
   // Pending callbacks for ClaimClients().
   ClaimClientsCallbacksMap claim_clients_callbacks;
 
+  // Pending callbacks for Install Events.
+  InstallEventCallbacksMap install_event_callbacks;
+
   // Pending callbacks for Activate Events.
   ActivateEventCallbacksMap activate_event_callbacks;
 
   // Pending callbacks for Background Fetch Abort Events.
   BackgroundFetchAbortEventCallbacksMap background_fetch_abort_event_callbacks;
 
   // Pending callbacks for Background Fetch Click Events.
   BackgroundFetchClickEventCallbacksMap background_fetch_click_event_callbacks;
 
   // Pending callbacks for Background Fetch Fail Events.
@@ skipping 30 matching lines @@
   std::map<int /* fetch_event_id */,
            mojom::ServiceWorkerFetchResponseCallbackPtr>
       fetch_response_callbacks;
 
   // Pending callbacks for Extendable Message Events.
   ExtendableMessageEventCallbacksMap message_event_callbacks;
 
   // Pending navigation preload requests.
   NavigationPreloadRequestsMap preload_requests;
 
+  // Maps every install event id with its corresponding
+  // mojom::ServiceWorkerInstallEventMethodsAssociatedPt.
+  InstallEventMethodsMap install_methods_map;
+
   base::ThreadChecker thread_checker;
   base::WeakPtrFactory<ServiceWorkerContextClient> weak_factory;
   base::WeakPtrFactory<blink::WebServiceWorkerContextProxy> proxy_weak_factory;
 };
 
 class ServiceWorkerContextClient::NavigationPreloadRequest final
     : public mojom::URLLoaderClient {
  public:
   NavigationPreloadRequest(int fetch_event_id,
                            const GURL& url,
@@ skipping 175 matching lines @@
 
 ServiceWorkerContextClient::~ServiceWorkerContextClient() {}
 
 void ServiceWorkerContextClient::OnMessageReceived(
     int thread_id,
     int embedded_worker_id,
     const IPC::Message& message) {
   CHECK_EQ(embedded_worker_id_, embedded_worker_id);
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerContextClient, message)
-    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetClient, OnDidGetClient)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetClients, OnDidGetClients)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_OpenWindowResponse,
                         OnOpenWindowResponse)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_OpenWindowError,
                         OnOpenWindowError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FocusClientResponse,
                         OnFocusClientResponse)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_NavigateClientResponse,
                         OnNavigateClientResponse)
@@ skipping 142 matching lines @@
 }
 
 void ServiceWorkerContextClient::WillDestroyWorkerContext(
     v8::Local<v8::Context> context) {
   // At this point WillStopCurrentWorkerThread is already called, so
   // worker_task_runner_->RunsTasksOnCurrentThread() returns false
   // (while we're still on the worker thread).
   proxy_ = NULL;
 
   // Aborts all the pending events callbacks.
+  AbortPendingEventCallbacks(context_->install_event_callbacks,
+                             false /* has_fetch_handler */);
   AbortPendingEventCallbacks(context_->activate_event_callbacks);
   AbortPendingEventCallbacks(context_->background_fetch_abort_event_callbacks);
   AbortPendingEventCallbacks(context_->background_fetch_click_event_callbacks);
   AbortPendingEventCallbacks(context_->background_fetch_fail_event_callbacks);
   AbortPendingEventCallbacks(context_->background_fetched_event_callbacks);
   AbortPendingEventCallbacks(context_->sync_event_callbacks);
   AbortPendingEventCallbacks(context_->notification_click_event_callbacks);
   AbortPendingEventCallbacks(context_->notification_close_event_callbacks);
   AbortPendingEventCallbacks(context_->push_event_callbacks);
   AbortPendingEventCallbacks(context_->fetch_event_callbacks);
@@ skipping 152 matching lines @@
   DispatchExtendableMessageEventCallback* callback =
       context_->message_event_callbacks.Lookup(request_id);
   DCHECK(callback);
   DCHECK(*callback);
   std::move(*callback).Run(EventResultToStatus(result),
                            base::Time::FromDoubleT(event_dispatch_time));
   context_->message_event_callbacks.Remove(request_id);
 }
 
 void ServiceWorkerContextClient::DidHandleInstallEvent(
-    int request_id,
+    int event_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
-  Send(new ServiceWorkerHostMsg_InstallEventFinished(
-      GetRoutingID(), request_id, result, proxy_->HasFetchEventHandler(),
-      base::Time::FromDoubleT(event_dispatch_time)));
+  DispatchInstallEventCallback* callback =
+      context_->install_event_callbacks.Lookup(event_id);
+  DCHECK(callback);
+  DCHECK(*callback);
+  std::move(*callback).Run(EventResultToStatus(result),
+                           proxy_->HasFetchEventHandler(),
+                           base::Time::FromDoubleT(event_dispatch_time));
+  context_->install_event_callbacks.Remove(event_id);
+  context_->install_methods_map.erase(event_id);
 }
 
 void ServiceWorkerContextClient::RespondToFetchEventWithNoResponse(
     int fetch_event_id,
     double event_dispatch_time) {
   const mojom::ServiceWorkerFetchResponseCallbackPtr& response_callback =
       context_->fetch_response_callbacks[fetch_event_id];
   DCHECK(response_callback.is_bound());
   response_callback->OnFallback(base::Time::FromDoubleT(event_dispatch_time));
   context_->fetch_response_callbacks.erase(fetch_event_id);
@@ skipping 202 matching lines @@
 }
 
 void ServiceWorkerContextClient::Claim(
     std::unique_ptr<blink::WebServiceWorkerClientsClaimCallbacks> callbacks) {
   DCHECK(callbacks);
   int request_id = context_->claim_clients_callbacks.Add(std::move(callbacks));
   Send(new ServiceWorkerHostMsg_ClaimClients(GetRoutingID(), request_id));
 }
 
 void ServiceWorkerContextClient::RegisterForeignFetchScopes(
+    int install_event_id,
     const blink::WebVector<blink::WebURL>& sub_scopes,
     const blink::WebVector<blink::WebSecurityOrigin>& origins) {
-  Send(new ServiceWorkerHostMsg_RegisterForeignFetchScopes(
-      GetRoutingID(), std::vector<GURL>(sub_scopes.begin(), sub_scopes.end()),
-      std::vector<url::Origin>(origins.begin(), origins.end())));
+  DCHECK(context_->install_methods_map[install_event_id].is_bound());
+  context_->install_methods_map[install_event_id]->RegisterForeignFetchScopes(
+      std::vector<GURL>(sub_scopes.begin(), sub_scopes.end()),
+      std::vector<url::Origin>(origins.begin(), origins.end()));
 }
 
 void ServiceWorkerContextClient::DispatchSyncEvent(
     const std::string& tag,
     blink::mojom::BackgroundSyncEventLastChance last_chance,
     DispatchSyncEventCallback callback) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::DispatchSyncEvent");
   int request_id = context_->sync_event_callbacks.Add(
       base::MakeUnique<SyncCallback>(std::move(callback)));
@@ skipping 131 matching lines @@
       fetches.size());
   for (size_t i = 0; i < fetches.size(); ++i) {
     ToWebServiceWorkerRequest(fetches[i].request, &web_fetches[i].request);
     ToWebServiceWorkerResponse(fetches[i].response, &web_fetches[i].response);
   }
 
   proxy_->DispatchBackgroundFetchedEvent(
       request_id, blink::WebString::FromUTF8(tag), web_fetches);
 }
 
+void ServiceWorkerContextClient::DispatchInstallEvent(
+    mojom::ServiceWorkerInstallEventMethodsAssociatedPtrInfo client,
+    DispatchInstallEventCallback callback) {
+  TRACE_EVENT0("ServiceWorker",
+               "ServiceWorkerContextClient::DispatchInstallEvent");
+
+  int event_id = context_->install_event_callbacks.Add(
+      base::MakeUnique<DispatchInstallEventCallback>(std::move(callback)));
+
+  DCHECK(!context_->install_methods_map.count(event_id));
+  mojom::ServiceWorkerInstallEventMethodsAssociatedPtr install_methods;
+  install_methods.Bind(std::move(client));
+  context_->install_methods_map[event_id] = std::move(install_methods);
+
+  proxy_->DispatchInstallEvent(event_id);
+}
+
 void ServiceWorkerContextClient::DispatchExtendableMessageEvent(
     mojom::ExtendableMessageEventPtr event,
     DispatchExtendableMessageEventCallback callback) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::DispatchExtendableMessageEvent");
   int request_id = context_->message_event_callbacks.Add(
       base::MakeUnique<DispatchExtendableMessageEventCallback>(
           std::move(callback)));
 
   blink::WebMessagePortChannelArray ports =
@@ skipping 16 matching lines @@
       ServiceWorkerDispatcher::GetOrCreateThreadSpecificInstance(
           sender_.get(), main_thread_task_runner_.get());
   scoped_refptr<WebServiceWorkerImpl> worker =
       dispatcher->GetOrCreateServiceWorker(std::move(handle));
   proxy_->DispatchExtendableMessageEvent(
       request_id, blink::WebString::FromUTF16(event->message),
       event->source_origin, std::move(ports),
       WebServiceWorkerImpl::CreateHandle(worker));
 }
 
-void ServiceWorkerContextClient::OnInstallEvent(int request_id) {
-  TRACE_EVENT0("ServiceWorker",
-               "ServiceWorkerContextClient::OnInstallEvent");
-  proxy_->DispatchInstallEvent(request_id);
-}
-
 void ServiceWorkerContextClient::DispatchFetchEvent(
     int fetch_event_id,
     const ServiceWorkerFetchRequest& request,
     mojom::FetchEventPreloadHandlePtr preload_handle,
     mojom::ServiceWorkerFetchResponseCallbackPtr response_callback,
     DispatchFetchEventCallback callback) {
   std::unique_ptr<NavigationPreloadRequest> preload_request =
       preload_handle
           ? base::MakeUnique<NavigationPreloadRequest>(
                 fetch_event_id, request.url, std::move(preload_handle))
@@ skipping 283 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content