network service: Add job wrapper to SWControlleeRequestHandler

content/browser/service_worker/service_worker_controllee_request_handler.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_controllee_request_handler.h"
 
 #include <memory>
 #include <set>
 #include <string>
 
 #include "base/trace_event/trace_event.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
+#include "content/browser/service_worker/service_worker_job_wrapper.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_response_info.h"
 #include "content/browser/service_worker/service_worker_url_request_job.h"
 #include "content/common/resource_request_body_impl.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/resource_response_info.h"
 #include "net/base/load_flags.h"
 #include "net/base/url_util.h"
 #include "net/url_request/url_request.h"
 #include "ui/base/page_transition_types.h"
 
 namespace content {
 
 namespace {
 
-bool MaybeForwardToServiceWorker(ServiceWorkerURLRequestJob* job,
+bool MaybeForwardToServiceWorker(ServiceWorkerJobWrapper* job,
                                  const ServiceWorkerVersion* version) {
   DCHECK(job);
   DCHECK(version);
   DCHECK_NE(version->fetch_handler_existence(),
             ServiceWorkerVersion::FetchHandlerExistence::UNKNOWN);
   if (version->fetch_handler_existence() ==
       ServiceWorkerVersion::FetchHandlerExistence::EXISTS) {
     job->ForwardToServiceWorker();
     return true;
   }
 
   job->FallbackToNetworkOrRenderer();
   return false;
 }
 
-ui::PageTransition GetPageTransition(net::URLRequest* request) {
-  const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
-  // ResourceRequestInfo may not be set in some tests.
-  if (!info)
-    return ui::PAGE_TRANSITION_LINK;
-  return info->GetPageTransition();
-}
-
 }  // namespace
 
 ServiceWorkerControlleeRequestHandler::ServiceWorkerControlleeRequestHandler(
     base::WeakPtr<ServiceWorkerContextCore> context,
     base::WeakPtr<ServiceWorkerProviderHost> provider_host,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
     FetchRequestMode request_mode,
     FetchCredentialsMode credentials_mode,
     FetchRedirectMode redirect_mode,
     ResourceType resource_type,
@@ skipping 62 matching lines @@
   }
 
   // It's for original request (A) or redirect case (B-a or B-b).
   std::unique_ptr<ServiceWorkerURLRequestJob> job(
       new ServiceWorkerURLRequestJob(
           request, network_delegate, provider_host_->client_uuid(),
           blob_storage_context_, resource_context, request_mode_,
           credentials_mode_, redirect_mode_, resource_type_,
           request_context_type_, frame_type_, body_,
           ServiceWorkerFetchType::FETCH, base::nullopt, this));
-  job_ = job->GetWeakPtr();
+  job_ = base::MakeUnique<ServiceWorkerJobWrapper>(job->GetWeakPtr());
 
   resource_context_ = resource_context;
 
   if (is_main_resource_load_)
-    PrepareForMainResource(request);
+    PrepareForMainResource(request->url(), request->first_party_for_cookies());
   else
     PrepareForSubResource();
 
   if (job_->ShouldFallbackToNetwork()) {
     // If we know we can fallback to network at this point (in case
     // the storage lookup returned immediately), just destroy the job and return
     // NULL here to fallback to network.
 
     // If this is a subresource request, all subsequent requests should also use
     // the network.
     if (!is_main_resource_load_)
       use_network_ = true;
 
     job.reset();
     ClearJob();
   }
 
   return job.release();
 }
 
 void ServiceWorkerControlleeRequestHandler::PrepareForMainResource(
-    const net::URLRequest* request) {
+    const GURL& url,
+    const GURL& first_party_for_cookies) {
   DCHECK(job_.get());
   DCHECK(context_);
   DCHECK(provider_host_);
   TRACE_EVENT_ASYNC_BEGIN1(
       "ServiceWorker",
       "ServiceWorkerControlleeRequestHandler::PrepareForMainResource",
-      job_.get(),
-      "URL", request->url().spec());
+      job_.get(), "URL", url.spec());
   // The corresponding provider_host may already have associated a registration
   // in redirect case, unassociate it now.
   provider_host_->DisassociateRegistration();
 
   // Also prevent a registrater job for establishing an association to a new
   // registration while we're finding an existing registration.
   provider_host_->SetAllowAssociation(false);
 
-  stripped_url_ = net::SimplifyUrlForRequest(request->url());
+  stripped_url_ = net::SimplifyUrlForRequest(url);
   provider_host_->SetDocumentUrl(stripped_url_);
-  provider_host_->SetTopmostFrameUrl(request->first_party_for_cookies());
+  provider_host_->SetTopmostFrameUrl(first_party_for_cookies);
   context_->storage()->FindRegistrationForDocument(
       stripped_url_, base::Bind(&self::DidLookupRegistrationForMainResource,
                                 weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerControlleeRequestHandler::
     DidLookupRegistrationForMainResource(
         ServiceWorkerStatusCode status,
         scoped_refptr<ServiceWorkerRegistration> registration) {
   // The job may have been canceled and then destroyed before this was invoked.
-  if (!job_)
+  if (job_->WasCanceled())
     return;
 
   const bool need_to_update = !force_update_started_ && registration &&
                               context_->force_update_on_page_load();
 
   if (provider_host_ && !need_to_update)
     provider_host_->SetAllowAssociation(true);
   if (status != SERVICE_WORKER_OK || !provider_host_ || !context_) {
     job_->FallbackToNetwork();
     TRACE_EVENT_ASYNC_END1(
@@ skipping 94 matching lines @@
         "Status", status,
         "Info",
         "ServiceWorkerVersion is not available, so falling back to network");
     return;
   }
 
   DCHECK_NE(active_version->fetch_handler_existence(),
             ServiceWorkerVersion::FetchHandlerExistence::UNKNOWN);
   ServiceWorkerMetrics::CountControlledPageLoad(
       active_version->site_for_uma(), stripped_url_, is_main_frame_load_,
-      GetPageTransition(job_->request()), job_->request()->url_chain().size());
+      job_->GetPageTransition(), job_->GetURLChainSize());
 
   bool is_forwarded =
       MaybeForwardToServiceWorker(job_.get(), active_version.get());
 
   TRACE_EVENT_ASYNC_END2(
       "ServiceWorker",
       "ServiceWorkerControlleeRequestHandler::PrepareForMainResource",
       job_.get(), "Status", status, "Info",
       (is_forwarded) ? "Forwarded to the ServiceWorker"
                      : "Skipped the ServiceWorker which has no fetch handler");
 }
 
 void ServiceWorkerControlleeRequestHandler::OnVersionStatusChanged(
     ServiceWorkerRegistration* registration,
     ServiceWorkerVersion* version) {
   // The job may have been canceled and then destroyed before this was invoked.
-  if (!job_)
+  if (job_->WasCanceled())
     return;
 
   if (provider_host_)
     provider_host_->SetAllowAssociation(true);
   if (version != registration->active_version() ||
       version->status() != ServiceWorkerVersion::ACTIVATED ||
       !provider_host_) {
     job_->FallbackToNetwork();
     return;
   }
 
   DCHECK_NE(version->fetch_handler_existence(),
             ServiceWorkerVersion::FetchHandlerExistence::UNKNOWN);
   ServiceWorkerMetrics::CountControlledPageLoad(
       version->site_for_uma(), stripped_url_, is_main_frame_load_,
-      GetPageTransition(job_->request()), job_->request()->url_chain().size());
+      job_->GetPageTransition(), job_->GetURLChainSize());
 
   provider_host_->AssociateRegistration(registration,
                                         false /* notify_controllerchange */);
 
   MaybeForwardToServiceWorker(job_.get(), version);
 }
 
 void ServiceWorkerControlleeRequestHandler::DidUpdateRegistration(
     const scoped_refptr<ServiceWorkerRegistration>& original_registration,
     ServiceWorkerStatusCode status,
     const std::string& status_message,
     int64_t registration_id) {
   DCHECK(force_update_started_);
 
   // The job may have been canceled and then destroyed before this was invoked.
-  if (!job_)
+  if (job_->WasCanceled())
     return;
 
   if (!context_) {
     job_->FallbackToNetwork();
     return;
   }
   if (status != SERVICE_WORKER_OK ||
       !original_registration->installing_version()) {
     // Update failed. Look up the registration again since the original
     // registration was possibly unregistered in the meantime.
     context_->storage()->FindRegistrationForDocument(
         stripped_url_, base::Bind(&self::DidLookupRegistrationForMainResource,
                                   weak_factory_.GetWeakPtr()));
     return;
   }
   DCHECK_EQ(original_registration->id(), registration_id);
   scoped_refptr<ServiceWorkerVersion> new_version =
       original_registration->installing_version();
   new_version->ReportForceUpdateToDevTools();
   new_version->set_skip_waiting(true);
   new_version->RegisterStatusChangeCallback(base::Bind(
       &self::OnUpdatedVersionStatusChanged, weak_factory_.GetWeakPtr(),
       original_registration, new_version));
 }
 
 void ServiceWorkerControlleeRequestHandler::OnUpdatedVersionStatusChanged(
     const scoped_refptr<ServiceWorkerRegistration>& registration,
     const scoped_refptr<ServiceWorkerVersion>& version) {
   // The job may have been canceled and then destroyed before this was invoked.
-  if (!job_)
+  if (job_->WasCanceled())
     return;
 
   if (!context_) {
     job_->FallbackToNetwork();
     return;
   }
   if (version->status() == ServiceWorkerVersion::ACTIVATED ||
       version->status() == ServiceWorkerVersion::REDUNDANT) {
     // When the status is REDUNDANT, the update failed (eg: script error), we
     // continue with the incumbent version.
@@ skipping 59 matching lines @@
   return true;
 }
 
 void ServiceWorkerControlleeRequestHandler::MainResourceLoadFailed() {
   DCHECK(provider_host_);
   // Detach the controller so subresource requests also skip the worker.
   provider_host_->NotifyControllerLost();
 }
 
 void ServiceWorkerControlleeRequestHandler::ClearJob() {
   job_.reset();

[kinuko, 2017/05/11 12:48:53]

This and job_->WasCanceled() don't look to work together

[scottmg, 2017/05/16 18:28:51]

Done.

 }
 
 }  // namespace content