Use Independent URLLoader

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 20 matching lines @@
 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.
 // Note: some of this code is duplicated from storage::BlobURLRequestJob.
 class BlobURLLoader : public mojom::URLLoader {
  public:
-  BlobURLLoader(mojom::URLLoaderAssociatedRequest url_loader_request,
+  BlobURLLoader(mojom::URLLoaderRequest url_loader_request,
                 const ResourceRequest& request,
                 mojom::URLLoaderClientPtr client,
                 std::unique_ptr<storage::BlobDataHandle> blob_handle,
                 storage::FileSystemContext* file_system_context)
       : binding_(this, std::move(url_loader_request)),
         client_(std::move(client)),
         blob_handle_(std::move(blob_handle)),
         writable_handle_watcher_(FROM_HERE,
                                  mojo::SimpleWatcher::ArmingPolicy::MANUAL),
         peer_closed_handle_watcher_(FROM_HERE,
@@ skipping 266 matching lines @@
     ReadMore();
   }
 
   void DeleteIfNeeded() {
     bool has_data_pipe =
         pending_write_.get() || response_body_stream_.is_valid();
     if (!has_data_pipe)
       delete this;
   }
 
-  mojo::AssociatedBinding<mojom::URLLoader> binding_;
+  mojo::Binding<mojom::URLLoader> binding_;
   mojom::URLLoaderClientPtr client_;
 
   bool byte_range_set_ = false;
   net::HttpByteRange byte_range_;
 
   bool sent_headers_ = false;
 
   std::unique_ptr<storage::BlobDataHandle> blob_handle_;
   std::unique_ptr<storage::BlobReader> blob_reader_;
 
@@ skipping 39 matching lines @@
 }
 
 void BlobURLLoaderFactory::BindOnIO(mojom::URLLoaderFactoryRequest request) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   loader_factory_bindings_.AddBinding(this, std::move(request));
 }
 
 // static
 void BlobURLLoaderFactory::CreateLoaderAndStart(
-    mojom::URLLoaderAssociatedRequest loader,
+    mojom::URLLoaderRequest loader,
     const ResourceRequest& request,
     mojom::URLLoaderClientPtr client,
     std::unique_ptr<storage::BlobDataHandle> blob_handle,
     storage::FileSystemContext* file_system_context) {
   new BlobURLLoader(std::move(loader), request, std::move(client),
                     std::move(blob_handle), file_system_context);
 }
 
 void BlobURLLoaderFactory::CreateLoaderAndStart(
-    mojom::URLLoaderAssociatedRequest loader,
+    mojom::URLLoaderRequest loader,
     int32_t routing_id,
     int32_t request_id,
     uint32_t options,
     const ResourceRequest& request,
     mojom::URLLoaderClientPtr client,
     const net::MutableNetworkTrafficAnnotationTag& traffic_annotation) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   std::unique_ptr<storage::BlobDataHandle> blob_handle;
   if (blob_storage_context_) {
     blob_handle = blob_storage_context_->GetBlobDataFromPublicURL(request.url);
   }
   CreateLoaderAndStart(std::move(loader), request, std::move(client),
                        std::move(blob_handle), file_system_context_.get());
 }
 
 void BlobURLLoaderFactory::SyncLoad(int32_t routing_id,
                                     int32_t request_id,
                                     const ResourceRequest& request,
                                     SyncLoadCallback callback) {
   NOTREACHED();
 }
 
 }  // namespace content