ServiceWorker: Keep the worker alive until FetchEvent.waitUntil settles

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 <utility>
 
 #include "base/bind.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/service_worker_messages.h"
+#include "content/common/service_worker/service_worker_utils.h"
 
 namespace content {
 
 namespace {
 using EventType = ServiceWorkerMetrics::EventType;
 EventType ResourceTypeToEventType(ResourceType resource_type) {
   switch (resource_type) {
     case RESOURCE_TYPE_MAIN_FRAME:
       return EventType::FETCH_MAIN_FRAME;
     case RESOURCE_TYPE_SUB_FRAME:
       return EventType::FETCH_SUB_FRAME;
     case RESOURCE_TYPE_SHARED_WORKER:
       return EventType::FETCH_SHARED_WORKER;
     case RESOURCE_TYPE_SERVICE_WORKER:
     case RESOURCE_TYPE_LAST_TYPE:
       NOTREACHED() << resource_type;
       return EventType::FETCH_SUB_RESOURCE;
     default:
       return EventType::FETCH_SUB_RESOURCE;
   }
 }
+
+ServiceWorkerMetrics::EventType FetchTypeToWaitUntilEventType(
+    ServiceWorkerFetchType type) {
+  if (type == ServiceWorkerFetchType::FOREIGN_FETCH)
+    return ServiceWorkerMetrics::EventType::FOREIGN_FETCH_WAITUNTIL;
+  return ServiceWorkerMetrics::EventType::FETCH_WAITUNTIL;
+}
 }  // namespace
 
 ServiceWorkerFetchDispatcher::ServiceWorkerFetchDispatcher(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     ServiceWorkerVersion* version,
     ResourceType resource_type,
     const base::Closure& prepare_callback,
     const FetchCallback& fetch_callback)
     : version_(version),
       prepare_callback_(prepare_callback),
@@ skipping 43 matching lines @@
 }
 
 void ServiceWorkerFetchDispatcher::DispatchFetchEvent() {
   DCHECK_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status())
       << "Worker stopped too soon after it was started.";
 
   DCHECK(!prepare_callback_.is_null());
   base::Closure prepare_callback = prepare_callback_;
   prepare_callback.Run();
 
-  int request_id = version_->StartRequest(
+  int response_id = version_->StartRequest(
       GetEventType(), base::Bind(&ServiceWorkerFetchDispatcher::DidFail,
                                  weak_factory_.GetWeakPtr()));
-  version_->DispatchEvent<ServiceWorkerHostMsg_FetchEventFinished>(
-      request_id, ServiceWorkerMsg_FetchEvent(request_id, *request_.get()),
-      base::Bind(&ServiceWorkerFetchDispatcher::DidFinish,
-                 weak_factory_.GetWeakPtr()));
+  int event_finish_id = version_->StartRequest(
+      FetchTypeToWaitUntilEventType(request_->fetch_type),
+      base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
+
+  version_->RegisterRequestCallback<ServiceWorkerHostMsg_FetchEventResponse>(
+      response_id, base::Bind(&ServiceWorkerFetchDispatcher::DidFinish,
+                              weak_factory_.GetWeakPtr()));
+  version_->RegisterSimpleRequest<ServiceWorkerHostMsg_FetchEventFinished>(
+      event_finish_id);
+  version_->DispatchEvent({response_id, event_finish_id},
+                          ServiceWorkerMsg_FetchEvent(
+                              response_id, event_finish_id, *request_.get()));
 }
 
 void ServiceWorkerFetchDispatcher::DidPrepare() {
   DCHECK(!prepare_callback_.is_null());
   base::Closure prepare_callback = prepare_callback_;
   prepare_callback.Run();
 }
 
 void ServiceWorkerFetchDispatcher::DidFail(ServiceWorkerStatusCode status) {
   DCHECK(!fetch_callback_.is_null());
@@ skipping 19 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