[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 254 matching lines @@
   using SimpleEventCallback =
       base::Callback<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<const DispatchInstallEventCallback>>;
   using ActivateEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchActivateEventCallback>>;
   using BackgroundFetchAbortEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchBackgroundFetchAbortEventCallback>>;
   using BackgroundFetchClickEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchBackgroundFetchClickEventCallback>>;
   using BackgroundFetchFailEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchBackgroundFetchFailEventCallback>>;
   using BackgroundFetchedEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchBackgroundFetchedEventCallback>>;
@@ skipping 25 matching lines @@
 
   // 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 226 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 141 matching lines @@
           context, service_worker_version_id_, script_url_);
 }
 
 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.
+  // Clear all install event methods.
+  install_methods_map_.clear();
+
+  // Aborts the all pending install event callbacks which has three
+  // parameters so that here can't use AbortPendingEventCallbacks.
+  for (WorkerContextData::InstallEventCallbacksMap::iterator it(
+           &context_->install_event_callbacks);
+       !it.IsAtEnd(); it.Advance()) {
+    it.GetCurrentValue()->Run(SERVICE_WORKER_ERROR_ABORT, false,
+                              base::Time::Now());
+  }
+  // Aborts all other pending events callbacks.
   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 149 matching lines @@
   DCHECK(callback);
   callback->Run(EventResultToStatus(result),
                 base::Time::FromDoubleT(event_dispatch_time));
   context_->message_event_callbacks.Remove(request_id);
 }
 
 void ServiceWorkerContextClient::DidHandleInstallEvent(
     int request_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
-  Send(new ServiceWorkerHostMsg_InstallEventFinished(
-      GetRoutingID(), request_id, result, proxy_->HasFetchEventHandler(),
-      base::Time::FromDoubleT(event_dispatch_time)));
+  const DispatchInstallEventCallback* callback =
+      context_->install_event_callbacks.Lookup(request_id);
+  DCHECK(callback);
+  callback->Run(EventResultToStatus(result), proxy_->HasFetchEventHandler(),
+                base::Time::FromDoubleT(event_dispatch_time));
+  context_->install_event_callbacks.Remove(request_id);
+  install_methods_map_.erase(request_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 201 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(
+    const int event_id,

[leonhsl(Using Gerrit), 2017/04/23 03:33:10]

No need to use 'const'.

[xiaofengzhang, 2017/04/24 05:02:41]

Done.

     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())));
+  std::vector<GURL> urls;
+  for (const auto& url : sub_scopes)
+    urls.push_back(url);
+
+  std::vector<url::Origin> url_origins;
+  for (const auto& origin : origins)
+    url_origins.push_back(origin);
+
+  install_methods_map_[event_id]->RegisterForeignFetchScopes(urls, url_origins);

[leonhsl(Using Gerrit), 2017/04/23 03:33:10]

Need to DCHECK that install_methods_map_[event_id] exists and is bound.

And, can we use 'std::vector<GURL>(sub_scopes.begin(), sub_scopes.end())' here
directly instead of a local variable 'urls'?

[xiaofengzhang, 2017/04/24 05:02:41]

Done.

 }
 
 void ServiceWorkerContextClient::DispatchSyncEvent(
     const std::string& tag,
     blink::mojom::BackgroundSyncEventLastChance last_chance,
     const DispatchSyncEventCallback& callback) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::DispatchSyncEvent");
   int request_id = context_->sync_event_callbacks.Add(
       base::MakeUnique<SyncCallback>(callback));
@@ skipping 127 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,
+    const DispatchInstallEventCallback& callback) {
+  TRACE_EVENT0("ServiceWorker",
+               "ServiceWorkerContextClient::DispatchInstallEvent");
+
+  int request_id = context_->install_event_callbacks.Add(

[leonhsl(Using Gerrit), 2017/04/23 03:33:10]

Better to uniform the naming as 'event_id' with Line.1141?

[xiaofengzhang, 2017/04/24 05:02:41]

Done.

+      base::MakeUnique<DispatchInstallEventCallback>(callback));
+
+  auto it = install_methods_map_.find(request_id);

[shimazu, 2017/04/24 05:00:13]

DCHECK(install_methods_map_.find(request_id) == install_methods_map.end());

+  DCHECK(it == install_methods_map_.end());
+  mojom::ServiceWorkerInstallEventMethodsAssociatedPtr install_method_client_;

[leonhsl(Using Gerrit), 2017/04/23 03:33:10]

install_method_client_  --> install_methods ?

[xiaofengzhang, 2017/04/24 05:02:41]

Done.

+  install_method_client_.Bind(std::move(client));
+  install_methods_map_[request_id] = std::move(install_method_client_);
+
+  proxy_->DispatchInstallEvent(request_id);
+}
+
 void ServiceWorkerContextClient::DispatchExtendableMessageEvent(
     mojom::ExtendableMessageEventPtr event,
     const DispatchExtendableMessageEventCallback& callback) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::DispatchExtendableMessageEvent");
   int request_id = context_->message_event_callbacks.Add(
       base::MakeUnique<DispatchExtendableMessageEventCallback>(callback));
 
   blink::WebMessagePortChannelArray ports =
       WebMessagePortChannelImpl::CreateFromMessagePipeHandles(
@@ skipping 15 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,
     const DispatchFetchEventCallback& callback) {
   std::unique_ptr<NavigationPreloadRequest> preload_request =
       preload_handle
           ? base::MakeUnique<NavigationPreloadRequest>(
                 fetch_event_id, request.url, std::move(preload_handle))
@@ skipping 281 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content