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/browser/service_worker/service_worker_version.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/browser_thread.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"
 #include "mojo/public/cpp/bindings/strong_associated_binding.h"
 #include "net/base/io_buffer.h"
 #include "storage/browser/blob/blob_storage_context.h"
 
 namespace content {
 
 namespace {
 
 class URLLoaderImpl : public mojom::URLLoader {
  public:
+  static void Start(
+      const ServiceWorkerResponse& response,
+      blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream,
+      base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
+      mojom::URLLoaderAssociatedRequest request,
+      mojom::URLLoaderClientPtr client) {
+    mojo::MakeStrongAssociatedBinding(
+        base::MakeUnique<URLLoaderImpl>(response, std::move(body_as_stream),
+                                        blob_storage_context,
+                                        std::move(client)),
+        std::move(request));
+  }
+
   URLLoaderImpl(const ServiceWorkerResponse& response,
                 blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream,
                 base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
                 mojom::URLLoaderClientPtr url_loader_client)
       : blob_storage_context_(blob_storage_context),
         url_loader_client_(std::move(url_loader_client)),
         weak_factory_(this) {
     ResourceResponseHead head;
     // TODO(scottmg): More fields in |head| required?
     head.headers = new net::HttpResponseHeaders("");
@@ skipping 60 matching lines @@
   std::unique_ptr<storage::BlobReader> blob_reader_;
   mojo::DataPipe data_pipe_;
 
   base::WeakPtrFactory<URLLoaderImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(URLLoaderImpl);
 };
 
 }  // namespace
 
-class ServiceWorkerURLJobWrapper::Factory : public mojom::URLLoaderFactory {
- public:
-  Factory(const ServiceWorkerResponse& response,
-          blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream,
-          base::WeakPtr<storage::BlobStorageContext> blob_storage_context)
-      : response_(response),
-        body_as_stream_(std::move(body_as_stream)),
-        blob_storage_context_(blob_storage_context) {}
-
-  void CreateLoaderAndStart(mojom::URLLoaderAssociatedRequest request,
-                            int32_t routing_id,
-                            int32_t request_id,
-                            uint32_t options,
-                            const ResourceRequest& url_request,
-                            mojom::URLLoaderClientPtr client) override {
-    // Note that url_request is ignored here, as we've already processed the
-    // fetch before even creating the factory.
-    // TODO(scottmg): Use options.
-    mojo::MakeStrongAssociatedBinding(
-        base::MakeUnique<URLLoaderImpl>(response_, std::move(body_as_stream_),
-                                        blob_storage_context_,
-                                        std::move(client)),
-        std::move(request));
-  }
-
-  void SyncLoad(int32_t routing_id,
-                int32_t request_id,
-                const ResourceRequest& url_request,
-                SyncLoadCallback callback) override {
-    NOTREACHED();
-  }
-
- private:
-  ServiceWorkerResponse response_;
-  blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream_;
-  base::WeakPtr<storage::BlobStorageContext> blob_storage_context_;
-
-  DISALLOW_COPY_AND_ASSIGN(Factory);
-};
-
 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,
+    LoaderCallback callback,
     Delegate* delegate,
     const ResourceRequest& resource_request,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context)
     : job_type_(JobType::kURLLoader),
-      loader_factory_callback_(std::move(callback)),
+      loader_callback_(std::move(callback)),
       delegate_(delegate),
       resource_request_(resource_request),
       blob_storage_context_(blob_storage_context),
       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_);
 
   ServiceWorkerMetrics::URLRequestJobResult result =
       ServiceWorkerMetrics::REQUEST_JOB_ERROR_BAD_DELEGATE;
@@ skipping 41 matching lines @@
 void ServiceWorkerURLJobWrapper::DidPrepareFetchEvent(
     scoped_refptr<ServiceWorkerVersion> version) {}
 
 void ServiceWorkerURLJobWrapper::DidDispatchFetchEvent(
     ServiceWorkerStatusCode status,
     ServiceWorkerFetchEventResult fetch_result,
     const ServiceWorkerResponse& response,
     blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream,
     const scoped_refptr<ServiceWorkerVersion>& version) {
   if (fetch_result == SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK) {
-    std::move(loader_factory_callback_).Run(nullptr);
+    std::move(loader_callback_).Run(StartLoaderCallback());
     return;
   }
   DCHECK_EQ(fetch_result, SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE);
-
-  factory_ = base::MakeUnique<Factory>(response, std::move(body_as_stream),
-                                       blob_storage_context_);
-  std::move(loader_factory_callback_).Run(factory_.get());
+  std::move(loader_callback_)
+      .Run(base::Bind(&URLLoaderImpl::Start, response,
+                      base::Passed(std::move(body_as_stream)),
+                      blob_storage_context_));
 }
 
 }  // namespace content