Network service: Implement URLLoader chaining for interceptors

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>
 
@@ skipping 141 matching lines @@
     if (!is_main_resource_load_)
       use_network_ = true;
 
     job.reset();
     ClearJob();
   }
 
   return job.release();
 }
 
+void ServiceWorkerControlleeRequestHandler::Start(
+    const ResourceRequest& resource_request,
+    URLLoaderRequestHandler::Controller* controller,
+    ResourceContext* resource_context,
+    mojom::URLLoaderAssociatedRequest loader_request,
+    mojom::URLLoaderClientPtr loader_client_ptr) {
+  DCHECK(is_main_resource_load_);
+  ClearJob();
+
+  // TODO(kinuko): Keep ServiceWorkerResponseInfo somewhere around
+  // and reset the data every time we restart.
+
+  if (!context_ || !provider_host_) {
+    // We can't do anything other than to fall back to network.
+    controller->Forward(std::move(loader_request),
+                        std::move(loader_client_ptr));
+    return;
+  }
+
+  // In fallback cases we basically 'forward' the request, so we should
+  // never see use_network_ gets true.
+  DCHECK(!use_network_);
+
+  // It's for original request (A) or redirect case (B-a or B-b).
+  url_job_ = base::MakeUnique<ServiceWorkerURLJobWrapper>(
+      controller, std::move(loader_request), std::move(loader_client_ptr));
+
+  resource_context_ = resource_context;
+
+  PrepareForMainResource(resource_request.url,
+                         resource_request.first_party_for_cookies);
+
+  if (url_job_->ShouldFallbackToNetwork()) {
+    // We're falling back to the next URLLoaderRequestHandler, forward
+    // the request and clear job now.
+    url_job_->FallbackToNetwork();
+    ClearJob();
+    return;
+  }
+
+  // We will asynchronously continue on DidLookupRegistrationForMainResource.
+}
+
 void ServiceWorkerControlleeRequestHandler::PrepareForMainResource(
     const GURL& url,
     const GURL& first_party_for_cookies) {
   DCHECK(!JobWasCanceled());
   DCHECK(context_);
   DCHECK(provider_host_);
   TRACE_EVENT_ASYNC_BEGIN1(
       "ServiceWorker",
       "ServiceWorkerControlleeRequestHandler::PrepareForMainResource",
       url_job_.get(), "URL", url.spec());
@@ skipping 287 matching lines @@
 
 void ServiceWorkerControlleeRequestHandler::ClearJob() {
   url_job_.reset();
 }
 
 bool ServiceWorkerControlleeRequestHandler::JobWasCanceled() const {
   return !url_job_ || url_job_->WasCanceled();
 }
 
 }  // namespace content