Get rid of URLLoaderFactory in browser-side case

content/browser/blob_storage/blob_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/blob_storage/blob_url_loader_factory.h"
 
 #include <stddef.h>
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 16 matching lines @@
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/blob_url_request_job.h"
 #include "storage/browser/fileapi/file_system_context.h"
 
 namespace content {
 
 namespace {
 constexpr size_t kDefaultAllocationSize = 512 * 1024;
 
 // This class handles a request for a blob:// url. It self-destructs (see
-// DeleteIfNeeded) when it has finished responding.
+// DeleteIfNeeded) when it has finished responding once Start() is called.
 // Note: some of this code is duplicated from storage::BlobURLRequestJob.
 class BlobURLLoader : public mojom::URLLoader {
  public:
-  BlobURLLoader(mojom::URLLoaderAssociatedRequest url_loader_request,
-                const ResourceRequest& request,
-                mojom::URLLoaderClientPtr client,
+  BlobURLLoader(const ResourceRequest& request,
                 storage::BlobStorageContext* blob_storage_context,
                 scoped_refptr<storage::FileSystemContext> file_system_context)
-      : binding_(this, std::move(url_loader_request)),
+      : binding_(this),
         request_(request),
-        client_(std::move(client)),
         writable_handle_watcher_(FROM_HERE,
                                  mojo::SimpleWatcher::ArmingPolicy::MANUAL),
         peer_closed_handle_watcher_(FROM_HERE,
                                     mojo::SimpleWatcher::ArmingPolicy::MANUAL),
         weak_factory_(this) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
     if (blob_storage_context) {
       blob_handle_ =
           blob_storage_context->GetBlobDataFromPublicURL(request.url);
     }
 
+    if (blob_handle_) {
+      base::SequencedTaskRunner* file_task_runner =
+          BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE).get();
+      blob_reader_ = blob_handle_->CreateReader(file_system_context.get(),
+                                                file_task_runner);
+    }
+  }
+
+  ~BlobURLLoader() override {}
+
+  // mojom::URLLoader implementation:
+  void Start(mojom::URLLoaderAssociatedRequest url_loader_request,
+             mojom::URLLoaderClientPtr client) override {
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
+    DCHECK(!binding_.is_bound());
+    binding_.Bind(std::move(url_loader_request));
+    client_ = std::move(client);
+
     // PostTask since it might destruct.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&BlobURLLoader::Start, weak_factory_.GetWeakPtr(),
-                              request, file_system_context));
+        FROM_HERE,
+        base::Bind(&BlobURLLoader::StartRequest, weak_factory_.GetWeakPtr()));
   }
 
-  void Start(const ResourceRequest& request,
-             scoped_refptr<storage::FileSystemContext> file_system_context) {
+ private:
+  // mojom::URLLoader implementation:
+  void FollowRedirect() override { NOTREACHED(); }
+
+  void SetPriority(net::RequestPriority priority,
+                   int32_t intra_priority_value) override {}
+
+  void StartRequest() {
     if (!blob_handle_) {
       NotifyCompleted(net::ERR_FILE_NOT_FOUND);
       return;
     }
 
-    base::SequencedTaskRunner* file_task_runner =
-        BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE).get();
-    blob_reader_ =
-        blob_handle_->CreateReader(file_system_context.get(), file_task_runner);
-
     // We only support GET request per the spec.
-    if (request.method != "GET") {
+    if (request_.method != "GET") {
       NotifyCompleted(net::ERR_METHOD_NOT_SUPPORTED);
       return;
     }
 
     if (blob_reader_->net_error()) {
       NotifyCompleted(blob_reader_->net_error());
       return;
     }
 
     net::HttpRequestHeaders request_headers;
-    request_headers.AddHeadersFromString(request.headers);
+    request_headers.AddHeadersFromString(request_.headers);
     std::string range_header;
     if (request_headers.GetHeader(net::HttpRequestHeaders::kRange,
                                   &range_header)) {
       // We only care about "Range" header here.
       std::vector<net::HttpByteRange> ranges;
       if (net::HttpUtil::ParseRangeHeader(range_header, &ranges)) {
         if (ranges.size() == 1) {
           byte_range_set_ = true;
           byte_range_ = ranges[0];
         } else {
@@ skipping 15 matching lines @@
       case storage::BlobReader::Status::IO_PENDING:
         return;
       case storage::BlobReader::Status::DONE:
         DidCalculateSize(net::OK);
         return;
     }
 
     NOTREACHED();
   }
 
-  ~BlobURLLoader() override {}
-
- private:
-  // mojom::URLLoader implementation:
-  void FollowRedirect() override { NOTREACHED(); }
-
-  void SetPriority(net::RequestPriority priority,
-                   int32_t intra_priority_value) override {}
 
   // Notifies the client that the request completed. Takes care of deleting this
   // object now if possible (i.e. no outstanding data pipe), otherwise this
   // object will be deleted when the data pipe is closed.
   void NotifyCompleted(int error_code) {
     if (error_code != net::OK && !sent_headers_) {
       net::HttpStatusCode status_code =
           storage::BlobURLRequestJob::NetErrorToHttpStatusCode(error_code);
       ResourceResponseHead response;
       response.headers = storage::BlobURLRequestJob::GenerateHeaders(
@@ skipping 240 matching lines @@
 }
 
 void BlobURLLoaderFactory::CreateLoaderAndStart(
     mojom::URLLoaderAssociatedRequest loader,
     int32_t routing_id,
     int32_t request_id,
     uint32_t options,
     const ResourceRequest& request,
     mojom::URLLoaderClientPtr client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  new BlobURLLoader(std::move(loader), request, std::move(client),
-                    blob_storage_context_.get(), file_system_context_);
+  BlobURLLoader* url_loader = new BlobURLLoader(
+      request, blob_storage_context_.get(), file_system_context_);
+  url_loader->Start(std::move(loader), std::move(client));
 }
 
 void BlobURLLoaderFactory::SyncLoad(int32_t routing_id,
                                     int32_t request_id,
                                     const ResourceRequest& request,
                                     SyncLoadCallback callback) {
   NOTREACHED();
 }
 
 }  // namespace content