Get rid of URLLoaderFactory in browser-side case

content/browser/appcache/appcache_url_loader_factory.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/appcache/appcache_url_loader_factory.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "content/browser/appcache/appcache_entry.h"
 #include "content/browser/appcache/appcache_policy.h"
@@ skipping 12 matching lines @@
 
 namespace content {
 
 namespace {
 
 // Handles AppCache URL loads for the network service.
 class AppCacheURLLoader : public AppCacheStorage::Delegate,
                           public mojom::URLLoader {
  public:
   AppCacheURLLoader(const ResourceRequest& request,
-                    mojom::URLLoaderAssociatedRequest url_loader_request,
                     int32_t routing_id,
                     int32_t request_id,
-                    mojom::URLLoaderClientPtr client_info,
                     ChromeAppCacheService* appcache_service,
                     URLLoaderFactoryGetter* factory_getter)
       : request_(request),
         routing_id_(routing_id),
         request_id_(request_id),
-        client_info_(std::move(client_info)),
         appcache_service_(appcache_service),
         factory_getter_(factory_getter),
-        binding_(this, std::move(url_loader_request)) {
-    binding_.set_connection_error_handler(base::Bind(
-        &AppCacheURLLoader::OnConnectionError, base::Unretained(this)));
-  }
+        binding_(this) {}
 
   ~AppCacheURLLoader() override {}
 
-  void Start() {
+  void Start(mojom::URLLoaderAssociatedRequest url_loader_request,
+             mojom::URLLoaderClientPtr client_info) override {
+    binding_.Bind(std::move(url_loader_request));
+    binding_.set_connection_error_handler(base::Bind(
+        &AppCacheURLLoader::OnConnectionError, base::Unretained(this)));
+    client_info_ = std::move(client_info);
     // If the origin does not exist in the AppCache usage map, then we can
     // safely call the network service here.
     if (appcache_service_->storage()->usage_map()->find(
             request_.url.GetOrigin()) ==
         appcache_service_->storage()->usage_map()->end()) {
       factory_getter_->GetNetworkFactory()->get()->CreateLoaderAndStart(
           mojo::MakeRequest(&network_loader_request_), routing_id_, request_id_,
           mojom::kURLLoadOptionSendSSLInfo, request_, std::move(client_info_));
       return;
     }
@@ skipping 99 matching lines @@
 void AppCacheURLLoaderFactory::CreateLoaderAndStart(
     mojom::URLLoaderAssociatedRequest url_loader_request,
     int32_t routing_id,
     int32_t request_id,
     uint32_t options,
     const ResourceRequest& request,
     mojom::URLLoaderClientPtr client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // This will get deleted when the connection is dropped by the client.
-  AppCacheURLLoader* loader = new AppCacheURLLoader(
-      request, std::move(url_loader_request), routing_id, request_id,
-      std::move(client), appcache_service_.get(), factory_getter_.get());
-  loader->Start();
+  AppCacheURLLoader* loader =
+      new AppCacheURLLoader(request, routing_id, request_id,
+                            appcache_service_.get(), factory_getter_.get());
+  loader->Start(std::move(url_loader_request), std::move(client));
 }
 
 void AppCacheURLLoaderFactory::SyncLoad(int32_t routing_id,
                                         int32_t request_id,
                                         const ResourceRequest& request,
                                         SyncLoadCallback callback) {
   NOTREACHED();
 }
 
-}  // namespace content
+}  // namespace content