Network service: Implement URLLoader chaining for interceptors

content/browser/service_worker/service_worker_url_job_wrapper.cc

Index: content/browser/service_worker/service_worker_url_job_wrapper.cc
diff --git a/content/browser/service_worker/service_worker_url_job_wrapper.cc b/content/browser/service_worker/service_worker_url_job_wrapper.cc
index 7761fc753b79c9cc14588588c03b6b1e77ffb51d..41dbc205fec6c1ccdef88da63eac7de9b9a4ba08 100644
--- a/content/browser/service_worker/service_worker_url_job_wrapper.cc
+++ b/content/browser/service_worker/service_worker_url_job_wrapper.cc
@@ -5,6 +5,7 @@
 #include "content/browser/service_worker/service_worker_url_job_wrapper.h"
 
 #include "base/command_line.h"
+#include "content/browser/service_worker/service_worker_response_type.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/content_switches.h"
@@ -13,11 +14,15 @@ namespace content {
 
 ServiceWorkerURLJobWrapper::ServiceWorkerURLJobWrapper(
     base::WeakPtr<ServiceWorkerURLRequestJob> url_request_job)
-    : url_request_job_(std::move(url_request_job)), url_loader_(nullptr) {}
+    : job_type_(JobType::kURLRequest),
+      url_request_job_(std::move(url_request_job)),
+      weak_factory_(this) {}
 
 ServiceWorkerURLJobWrapper::ServiceWorkerURLJobWrapper(
-    ServiceWorkerControlleeURLLoader* url_loader)
-    : url_loader_(url_loader) {
+    LoaderFactoryCallback callback)
+    : job_type_(JobType::kURLLoader),
+      loader_factory_callback_(std::move(callback)),
+      weak_factory_(this) {
   DCHECK(IsBrowserSideNavigationEnabled() &&
          base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kEnableNetworkService));
@@ -26,40 +31,48 @@ ServiceWorkerURLJobWrapper::ServiceWorkerURLJobWrapper(
 ServiceWorkerURLJobWrapper::~ServiceWorkerURLJobWrapper() {}
 
 void ServiceWorkerURLJobWrapper::FallbackToNetwork() {
-  if (url_loader_) {
-    NOTIMPLEMENTED();
+  if (job_type_ == JobType::kURLLoader) {
+    response_type_ = FALLBACK_TO_NETWORK;
+    // This could be called multiple times in some cases because we simply
+    // call this synchronously here and don't wait for a separate async
+    // StartRequest cue like what URLRequestJob case does.
+    // TODO(kinuko): Make sure this is ok or we need to make this async.
+    if (!loader_factory_callback_.is_null()) {
+      std::move(loader_factory_callback_).Run(nullptr);
+    }
   } else {
     url_request_job_->FallbackToNetwork();
   }
 }
 
 void ServiceWorkerURLJobWrapper::FallbackToNetworkOrRenderer() {
-  if (url_loader_) {
-    NOTIMPLEMENTED();
+  if (job_type_ == JobType::kURLLoader) {
+    // TODO(kinuko): Implement this. Now we always fallback to network.
+    FallbackToNetwork();
   } else {
     url_request_job_->FallbackToNetworkOrRenderer();
   }
 }
 
 void ServiceWorkerURLJobWrapper::ForwardToServiceWorker() {
-  if (url_loader_) {
-    NOTIMPLEMENTED();
+  if (job_type_ == JobType::kURLLoader) {
+    response_type_ = FORWARD_TO_SERVICE_WORKER;
+    StartRequest();
   } else {
     url_request_job_->ForwardToServiceWorker();
   }
 }
 
 bool ServiceWorkerURLJobWrapper::ShouldFallbackToNetwork() {
-  if (url_loader_) {
-    NOTIMPLEMENTED();
-    return false;
+  if (job_type_ == JobType::kURLLoader) {
+    return response_type_ == FALLBACK_TO_NETWORK;
   } else {
     return url_request_job_->ShouldFallbackToNetwork();
   }
 }
 
 ui::PageTransition ServiceWorkerURLJobWrapper::GetPageTransition() {
-  if (url_loader_) {
+  if (job_type_ == JobType::kURLLoader) {
     NOTIMPLEMENTED();
     return ui::PAGE_TRANSITION_LINK;
   } else {
@@ -73,7 +86,7 @@ ui::PageTransition ServiceWorkerURLJobWrapper::GetPageTransition() {
 }
 
 size_t ServiceWorkerURLJobWrapper::GetURLChainSize() const {
-  if (url_loader_) {
+  if (job_type_ == JobType::kURLLoader) {
     NOTIMPLEMENTED();
     return 0;
   } else {
@@ -82,7 +95,7 @@ size_t ServiceWorkerURLJobWrapper::GetURLChainSize() const {
 }
 
 void ServiceWorkerURLJobWrapper::FailDueToLostController() {
-  if (url_loader_) {
+  if (job_type_ == JobType::kURLLoader) {
     NOTIMPLEMENTED();
   } else {
     url_request_job_->FailDueToLostController();
@@ -90,12 +103,20 @@ void ServiceWorkerURLJobWrapper::FailDueToLostController() {
 }
 
 bool ServiceWorkerURLJobWrapper::WasCanceled() const {
-  if (url_loader_) {
-    NOTIMPLEMENTED();
-    return true;
+  if (job_type_ == JobType::kURLLoader) {
+    return loader_factory_callback_.is_null();
   } else {
     return !url_request_job_;
   }
 }
 
+void ServiceWorkerURLJobWrapper::StartRequest() {
+  DCHECK_EQ(FORWARD_TO_SERVICE_WORKER, response_type_);
+  // TODO(kinuko): Implement. For now we just exercise async fall back path
+  // to the network.
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&ServiceWorkerURLJobWrapper::FallbackToNetwork,
+                            weak_factory_.GetWeakPtr()));
+}
+
 }  // namespace content