Get rid of URLLoaderFactory in browser-side case

content/browser/service_worker/service_worker_url_job_wrapper.cc

 // Copyright 2017 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_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"
 
 namespace content {
 
 ServiceWorkerURLJobWrapper::ServiceWorkerURLJobWrapper(
     base::WeakPtr<ServiceWorkerURLRequestJob> url_request_job)
     : job_type_(JobType::kURLRequest),
       url_request_job_(std::move(url_request_job)),
       weak_factory_(this) {}
 
-ServiceWorkerURLJobWrapper::ServiceWorkerURLJobWrapper(
-    LoaderFactoryCallback callback)
+ServiceWorkerURLJobWrapper::ServiceWorkerURLJobWrapper(LoaderCallback callback)
     : job_type_(JobType::kURLLoader),
-      loader_factory_callback_(std::move(callback)),
+      loader_callback_(std::move(callback)),
       weak_factory_(this) {
   DCHECK(IsBrowserSideNavigationEnabled() &&
          base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kEnableNetworkService));
 }
 
 ServiceWorkerURLJobWrapper::~ServiceWorkerURLJobWrapper() {}
 
 void ServiceWorkerURLJobWrapper::FallbackToNetwork() {
   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);
+    if (!loader_callback_.is_null()) {
+      std::move(loader_callback_).Run(StartLoaderCallback());
     }
   } else {
     url_request_job_->FallbackToNetwork();
   }
 }
 
 void ServiceWorkerURLJobWrapper::FallbackToNetworkOrRenderer() {
   if (job_type_ == JobType::kURLLoader) {
     // TODO(kinuko): Implement this. Now we always fallback to network.
     FallbackToNetwork();
@@ skipping 45 matching lines @@
 void ServiceWorkerURLJobWrapper::FailDueToLostController() {
   if (job_type_ == JobType::kURLLoader) {
     NOTIMPLEMENTED();
   } else {
     url_request_job_->FailDueToLostController();
   }
 }
 
 bool ServiceWorkerURLJobWrapper::WasCanceled() const {
   if (job_type_ == JobType::kURLLoader) {
-    return loader_factory_callback_.is_null();
+    return loader_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