Increase the lifetime of Navigation Preload related objects.

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 57 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(DelegatingURLLoader);
 };
 
 // This class wraps a mojo::InterfacePtr<URLLoaderClient>. It also is a
 // URLLoaderClient implementation and delegates URLLoaderClient calls to the
 // wrapped client.
 class DelegatingURLLoaderClient final : public mojom::URLLoaderClient {
  public:
   explicit DelegatingURLLoaderClient(mojom::URLLoaderClientPtr client)
       : binding_(this), client_(std::move(client)) {}
-  ~DelegatingURLLoaderClient() override {}
+  ~DelegatingURLLoaderClient() override {
+    if (!completed_) {
+      // Let the service worker know that the request has been canceled.
+      ResourceRequestCompletionStatus status;
+      status.error_code = net::ERR_ABORTED;
+      client_->OnComplete(status);
+    }
+  }
 
   void OnDataDownloaded(int64_t data_length, int64_t encoded_length) override {
     client_->OnDataDownloaded(data_length, encoded_length);
   }
   void OnTransferSizeUpdated(int32_t transfer_size_diff) override {
     client_->OnTransferSizeUpdated(transfer_size_diff);
   }
   void OnReceiveResponse(
       const ResourceResponseHead& head,
       mojom::DownloadedTempFilePtr downloaded_file) override {
     client_->OnReceiveResponse(head, std::move(downloaded_file));
   }
   void OnReceiveRedirect(const net::RedirectInfo& redirect_info,
                          const ResourceResponseHead& head) override {
     client_->OnReceiveRedirect(redirect_info, head);
   }
   void OnStartLoadingResponseBody(
       mojo::ScopedDataPipeConsumerHandle body) override {
     client_->OnStartLoadingResponseBody(std::move(body));
   }
   void OnComplete(
       const ResourceRequestCompletionStatus& completion_status) override {
     client_->OnComplete(completion_status);
+    completed_ = true;
   }
 
   void Bind(mojom::URLLoaderClientAssociatedPtrInfo* ptr_info,
             mojo::AssociatedGroup* associated_group) {
     binding_.Bind(ptr_info, associated_group);
   }
 
  private:
   mojo::AssociatedBinding<mojom::URLLoaderClient> binding_;
   mojom::URLLoaderClientPtr client_;
+  bool completed_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(DelegatingURLLoaderClient);
 };
 
 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:
@@ skipping 35 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(
-    ServiceWorkerVersion* version,
-    int event_finish_id,
-    mojom::URLLoaderFactoryPtr url_loader_factory,
-    std::unique_ptr<mojom::URLLoader> url_loader,
-    std::unique_ptr<mojom::URLLoaderClient> url_loader_client,
-    ServiceWorkerStatusCode status,
-    base::Time dispatch_event_time) {
-  version->FinishRequest(event_finish_id, status != SERVICE_WORKER_ERROR_ABORT,
-                         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 12 matching lines @@
   }
 
  private:
   base::WeakPtr<ServiceWorkerFetchDispatcher> fetch_dispatcher_;
   // Owns |this|.
   ServiceWorkerVersion* version_;
 
   DISALLOW_COPY_AND_ASSIGN(ResponseCallback);
 };
 
+// This class keeps the URL loader related assets alive while the FetchEvent is
+// onging in the service worker.
+class ServiceWorkerFetchDispatcher::URLLoaderAssets
+    : public base::RefCounted<ServiceWorkerFetchDispatcher::URLLoaderAssets> {
+ public:
+  URLLoaderAssets(mojom::URLLoaderFactoryPtr url_loader_factory,
+                  std::unique_ptr<mojom::URLLoader> url_loader,
+                  std::unique_ptr<mojom::URLLoaderClient> url_loader_client)
+      : url_loader_factory_(std::move(url_loader_factory)),
+        url_loader_(std::move(url_loader)),
+        url_loader_client_(std::move(url_loader_client)) {}
+
+ private:
+  friend class base::RefCounted<URLLoaderAssets>;
+  virtual ~URLLoaderAssets() {}
+
+  mojom::URLLoaderFactoryPtr url_loader_factory_;
+  std::unique_ptr<mojom::URLLoader> url_loader_;
+  std::unique_ptr<mojom::URLLoaderClient> url_loader_client_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLLoaderAssets);
+};
+
 ServiceWorkerFetchDispatcher::ServiceWorkerFetchDispatcher(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     ServiceWorkerVersion* version,
     ResourceType resource_type,
     const base::Optional<base::TimeDelta>& timeout,
     const net::NetLogWithSource& net_log,
     const base::Closure& prepare_callback,
     const FetchCallback& fetch_callback)
     : version_(version),
       net_log_(net_log),
@@ skipping 104 matching lines @@
 
   ResponseCallback* response_callback =
       new ResponseCallback(weak_factory_.GetWeakPtr(), version_.get());
   version_->RegisterRequestCallback<ServiceWorkerHostMsg_FetchEventResponse>(
       fetch_event_id,
       base::Bind(&ServiceWorkerFetchDispatcher::ResponseCallback::Run,
                  base::Owned(response_callback)));
 
   // |event_dispatcher| is owned by |version_|. So it is safe to pass the
   // unretained raw pointer of |version_| to OnFetchEventFinished callback.
-  // Pass |url_loader_factory_|, |url_Loader_| and |url_loader_client_| to the
-  // callback to keep them alive while the FetchEvent is onging in the service
-  // worker.
+  // Pass |url_loader_assets_| to the callback to keep the URL loader related
+  // assets alive while the FetchEvent is onging in the service worker.

[falken, 2017/01/19 05:26:47]

ongoing

[horo, 2017/01/19 05:48:57]

Done.

   version_->event_dispatcher()->DispatchFetchEvent(
       fetch_event_id, *request_, std::move(preload_handle_),
-      base::Bind(&OnFetchEventFinished, base::Unretained(version_.get()),
-                 event_finish_id, base::Passed(std::move(url_loader_factory_)),
-                 base::Passed(std::move(url_loader_)),
-                 base::Passed(std::move(url_loader_client_))));
+      base::Bind(&ServiceWorkerFetchDispatcher::OnFetchEventFinished,
+                 base::Unretained(version_.get()), event_finish_id,
+                 url_loader_assets_));
 }
 
 void ServiceWorkerFetchDispatcher::DidFailToDispatch(
     ServiceWorkerStatusCode status) {
   EndNetLogEventWithServiceWorkerStatus(
       net_log_, net::NetLogEventType::SERVICE_WORKER_FETCH_EVENT, status);
   DidFail(status);
 }
 
 void ServiceWorkerFetchDispatcher::DidFail(ServiceWorkerStatusCode status) {
@@ skipping 19 matching lines @@
   did_complete_ = true;
   net_log_.EndEvent(
       net::NetLogEventType::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);
 }
 
-void ServiceWorkerFetchDispatcher::MaybeStartNavigationPreload(
+bool ServiceWorkerFetchDispatcher::MaybeStartNavigationPreload(
     net::URLRequest* original_request) {
   if (resource_type_ != RESOURCE_TYPE_MAIN_FRAME &&
       resource_type_ != RESOURCE_TYPE_SUB_FRAME) {
-    return;
+    return false;
   }
   if (!version_->navigation_preload_state().enabled)
-    return;
+    return false;
   // TODO(horo): Currently NavigationPreload doesn't support request body.
   if (!request_->blob_uuid.empty())
-    return;
+    return false;
 
   ServiceWorkerVersion::NavigationPreloadSupportStatus support_status =
       version_->GetNavigationPreloadSupportStatus();
   if (support_status !=
       ServiceWorkerVersion::NavigationPreloadSupportStatus::SUPPORTED) {
-    return;
+    return false;
   }
 
   ResourceRequestInfoImpl* original_info =
       ResourceRequestInfoImpl::ForRequest(original_request);
   ResourceRequesterInfo* requester_info = original_info->requester_info();
   if (IsBrowserSideNavigationEnabled()) {
     DCHECK(requester_info->IsBrowserSideNavigation());
   } else {
     DCHECK(requester_info->IsRenderer());
     if (!requester_info->filter())
-      return;
+      return false;
   }
 
-  DCHECK(!url_loader_factory_);
-  mojom::URLLoaderFactoryPtr factory;
+  DCHECK(!url_loader_assets_);
+
+  mojom::URLLoaderFactoryPtr url_loader_factory;
   URLLoaderFactoryImpl::Create(
       ResourceRequesterInfo::CreateForNavigationPreload(requester_info),
-      mojo::MakeRequest(&url_loader_factory_));
+      mojo::MakeRequest(&url_loader_factory));
 
   preload_handle_ = mojom::FetchEventPreloadHandle::New();
 
   ResourceRequest request;
   request.method = original_request->method();
   request.url = original_request->url();
   // TODO(horo): Set first_party_for_cookies to support Same-site Cookies.
   request.request_initiator = original_request->initiator().has_value()
                                   ? original_request->initiator()
                                   : url::Origin(original_request->url());
@@ skipping 22 matching lines @@
   DCHECK_LT(request_id, -1);
 
   preload_handle_ = mojom::FetchEventPreloadHandle::New();
   mojom::URLLoaderClientPtr url_loader_client_ptr;
   preload_handle_->url_loader_client_request =
       mojo::MakeRequest(&url_loader_client_ptr);
   auto url_loader_client = base::MakeUnique<DelegatingURLLoaderClient>(
       std::move(url_loader_client_ptr));
   mojom::URLLoaderClientAssociatedPtrInfo url_loader_client_associated_ptr_info;
   url_loader_client->Bind(&url_loader_client_associated_ptr_info,
-                          url_loader_factory_.associated_group());
+                          url_loader_factory.associated_group());
   mojom::URLLoaderAssociatedPtr url_loader_associated_ptr;
 
-  url_loader_factory_->CreateLoaderAndStart(
+  url_loader_factory->CreateLoaderAndStart(
       mojo::MakeRequest(&url_loader_associated_ptr,
-                        url_loader_factory_.associated_group()),
+                        url_loader_factory.associated_group()),
       original_info->GetRouteID(), request_id, request,
       std::move(url_loader_client_associated_ptr_info));
 
   std::unique_ptr<DelegatingURLLoader> url_loader(
       new DelegatingURLLoader(std::move(url_loader_associated_ptr)));

[falken, 2017/01/19 05:26:46]

nit: this could be MakeUnique(std::move())

[horo, 2017/01/19 05:48:57]

Done.

   preload_handle_->url_loader = url_loader->CreateInterfacePtrAndBind();
-  url_loader_ = std::move(url_loader);
-  url_loader_client_ = std::move(url_loader_client);
+
+  url_loader_assets_ =
+      new URLLoaderAssets(std::move(url_loader_factory), std::move(url_loader),
+                          std::move(url_loader_client));

[falken, 2017/01/19 05:26:47]

nit MakeUnique

[horo, 2017/01/19 05:48:57]

It's not a unique_ptr.

+
+  return true;
 }
 
 ServiceWorkerMetrics::EventType ServiceWorkerFetchDispatcher::GetEventType()
     const {
   if (request_->fetch_type == ServiceWorkerFetchType::FOREIGN_FETCH)
     return ServiceWorkerMetrics::EventType::FOREIGN_FETCH;
   return ResourceTypeToEventType(resource_type_);
 }
 
+// static
+void ServiceWorkerFetchDispatcher::OnFetchEventFinished(
+    ServiceWorkerVersion* version,
+    int event_finish_id,
+    scoped_refptr<URLLoaderAssets> url_loader_assets,
+    ServiceWorkerStatusCode status,
+    base::Time dispatch_event_time) {
+  version->FinishRequest(event_finish_id, status != SERVICE_WORKER_ERROR_ABORT,
+                         dispatch_event_time);
+}
+
 }  // namespace content