Mojoify FetchEvent of Service Worker.

content/browser/service_worker/service_worker_fetch_dispatcher.cc

 // Copyright 2014 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_fetch_dispatcher.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_version.h"
+#include "content/common/service_worker/fetch_event_dispatcher.mojom.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "net/log/net_log_event_type.h"
 
 namespace content {
 
 namespace {
 
 using EventType = ServiceWorkerMetrics::EventType;
 EventType ResourceTypeToEventType(ResourceType resource_type) {
@@ skipping 39 matching lines @@
                    base::Bind(&NetLogServiceWorkerStatusCallback, status));
 }
 
 ServiceWorkerMetrics::EventType FetchTypeToWaitUntilEventType(
     ServiceWorkerFetchType type) {
   if (type == ServiceWorkerFetchType::FOREIGN_FETCH)
     return ServiceWorkerMetrics::EventType::FOREIGN_FETCH_WAITUNTIL;
   return ServiceWorkerMetrics::EventType::FETCH_WAITUNTIL;
 }
 
+void OnFetchEventFinished(scoped_refptr<ServiceWorkerVersion> active_version,

[shimazu, 2016/09/23 03:26:11]

If I understand correctly, I'm worried that this scoped_refptr<> could make a
cyclic reference as below:
version -(owns)-> dispatcher -(owns)-> callback -(retains)-> version

I think this callback won't be called after SWVersion is destructed, so it's
okay to have a raw pointer, or WeakPtr might be fine.

WDYT?

[horo, 2016/09/23 05:57:56]

Done.

+                          int event_finish_id,
+                          blink::mojom::ServiceWorkerEventStatus status,
+                          base::Time dispatch_event_time) {
+  active_version->FinishRequest(
+      event_finish_id,
+      status == blink::mojom::ServiceWorkerEventStatus::COMPLETED,
+      dispatch_event_time);
+}
+
 }  // namespace
 
 // Helper to receive the fetch event response even if
 // ServiceWorkerFetchDispatcher has been destroyed.
 class ServiceWorkerFetchDispatcher::ResponseCallback {
  public:
   ResponseCallback(base::WeakPtr<ServiceWorkerFetchDispatcher> fetch_dispatcher,
                    ServiceWorkerVersion* version)
       : fetch_dispatcher_(fetch_dispatcher), version_(version) {}
 
@@ skipping 117 matching lines @@
   int event_finish_id = version_->StartRequest(
       FetchTypeToWaitUntilEventType(request_->fetch_type),
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 
   ResponseCallback* response_callback =
       new ResponseCallback(weak_factory_.GetWeakPtr(), version_.get());
   version_->RegisterRequestCallback<ServiceWorkerHostMsg_FetchEventResponse>(
       response_id,
       base::Bind(&ServiceWorkerFetchDispatcher::ResponseCallback::Run,
                  base::Owned(response_callback)));
-  version_->RegisterSimpleRequest<ServiceWorkerHostMsg_FetchEventFinished>(
-      event_finish_id);
-  version_->DispatchEvent({response_id, event_finish_id},
-                          ServiceWorkerMsg_FetchEvent(
-                              response_id, event_finish_id, *request_.get()));
+
+  base::WeakPtr<mojom::FetchEventDispatcher> dispatcher =
+      version_->GetMojoServiceForRequest<mojom::FetchEventDispatcher>(
+          event_finish_id);
+  dispatcher->DispatchFetchEvent(
+      response_id, *request_.get(),
+      base::Bind(&OnFetchEventFinished, version_, event_finish_id));
 }
 
 void ServiceWorkerFetchDispatcher::DidFailToDispatch(
     ServiceWorkerStatusCode status) {
   EndNetLogEventWithServiceWorkerStatus(
       net_log_, net::NetLogEventType::SERVICE_WORKER_FETCH_EVENT, status);
   DidFail(status);
 }
 
 void ServiceWorkerFetchDispatcher::DidFail(ServiceWorkerStatusCode status) {
@@ skipping 27 matching lines @@
 }
 
 ServiceWorkerMetrics::EventType ServiceWorkerFetchDispatcher::GetEventType()
     const {
   if (request_->fetch_type == ServiceWorkerFetchType::FOREIGN_FETCH)
     return ServiceWorkerMetrics::EventType::FOREIGN_FETCH;
   return ResourceTypeToEventType(resource_type_);
 }
 
 }  // namespace content