service worker: Clean up fetch event if URLRequest gets cancelled.

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"
@@ skipping 53 matching lines @@
 
 ServiceWorkerMetrics::EventType FetchTypeToWaitUntilEventType(
     ServiceWorkerFetchType type) {
   if (type == ServiceWorkerFetchType::FOREIGN_FETCH)
     return ServiceWorkerMetrics::EventType::FOREIGN_FETCH_WAITUNTIL;
   return ServiceWorkerMetrics::EventType::FETCH_WAITUNTIL;
 }
 
 }  // 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) {}
+
+  void Run(int request_id,
+           ServiceWorkerFetchEventResult fetch_result,
+           const ServiceWorkerResponse& response) {
+    const bool handled =
+        (fetch_result == SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE);
+    if (!version_->FinishRequest(request_id, handled))
+      NOTREACHED() << "Should only receive one reply per event";
+
+    // |fetch_dispatcher| is null if the URLRequest was killed.
+    if (fetch_dispatcher_)
+      fetch_dispatcher_->DidFinish(request_id, fetch_result, response);
+  }
+
+ private:
+  base::WeakPtr<ServiceWorkerFetchDispatcher> fetch_dispatcher_;
+  // Owns |this|.
+  ServiceWorkerVersion* version_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResponseCallback);
+};
+
 ServiceWorkerFetchDispatcher::ServiceWorkerFetchDispatcher(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     ServiceWorkerVersion* version,
     ResourceType resource_type,
     const net::BoundNetLog& net_log,
     const base::Closure& prepare_callback,
     const FetchCallback& fetch_callback)
     : version_(version),
       net_log_(net_log),
       prepare_callback_(prepare_callback),
@@ skipping 77 matching lines @@
 
   net_log_.BeginEvent(net::NetLog::TYPE_SERVICE_WORKER_FETCH_EVENT);
   int response_id = version_->StartRequest(
       GetEventType(),
       base::Bind(&ServiceWorkerFetchDispatcher::DidFailToDispatch,
                  weak_factory_.GetWeakPtr()));
   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::DidFinish,
-                              weak_factory_.GetWeakPtr()));
+      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()));
 }
 
 void ServiceWorkerFetchDispatcher::DidFailToDispatch(
     ServiceWorkerStatusCode status) {
   EndNetLogEventWithServiceWorkerStatus(
       net_log_, net::NetLog::TYPE_SERVICE_WORKER_FETCH_EVENT, status);
   DidFail(status);
 }
 
 void ServiceWorkerFetchDispatcher::DidFail(ServiceWorkerStatusCode status) {
   DCHECK_NE(SERVICE_WORKER_OK, status);
   Complete(status, SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK,
            ServiceWorkerResponse());
 }
 
 void ServiceWorkerFetchDispatcher::DidFinish(
     int request_id,
     ServiceWorkerFetchEventResult fetch_result,
     const ServiceWorkerResponse& response) {
   net_log_.EndEvent(net::NetLog::TYPE_SERVICE_WORKER_FETCH_EVENT);
-
-  const bool handled =
-      (fetch_result == SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE);
-  if (!version_->FinishRequest(request_id, handled))
-    NOTREACHED() << "Should only receive one reply per event";
-
   Complete(SERVICE_WORKER_OK, fetch_result, response);
 }
 
 void ServiceWorkerFetchDispatcher::Complete(
     ServiceWorkerStatusCode status,
     ServiceWorkerFetchEventResult fetch_result,
     const ServiceWorkerResponse& response) {
   DCHECK(!fetch_callback_.is_null());
 
   did_complete_ = true;
   net_log_.EndEvent(
       net::NetLog::TYPE_SERVICE_WORKER_DISPATCH_FETCH_EVENT,
       base::Bind(&NetLogFetchEventCallback, status, fetch_result));
 
   FetchCallback fetch_callback = fetch_callback_;
   scoped_refptr<ServiceWorkerVersion> version = version_;
   fetch_callback.Run(status, fetch_result, response, version);
 }
 
 ServiceWorkerMetrics::EventType ServiceWorkerFetchDispatcher::GetEventType()
     const {
   if (request_->fetch_type == ServiceWorkerFetchType::FOREIGN_FETCH)
     return ServiceWorkerMetrics::EventType::FOREIGN_FETCH;
   return ResourceTypeToEventType(resource_type_);
 }
 
 }  // namespace content