Move URLLoaderClientImpl to a separate file

content/child/resource_dispatcher.cc

 // Copyright (c) 2012 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/child/resource_dispatcher.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/debug/stack_trace.h"
 #include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "content/child/request_extra_data.h"
 #include "content/child/resource_scheduling_filter.h"
 #include "content/child/shared_memory_received_data_factory.h"
 #include "content/child/site_isolation_stats_gatherer.h"
 #include "content/child/sync_load_response.h"
-#include "content/child/url_response_body_consumer.h"
+#include "content/child/url_loader_client_impl.h"
 #include "content/common/inter_process_time_ticks_converter.h"
 #include "content/common/navigation_params.h"
 #include "content/common/resource_messages.h"
 #include "content/common/resource_request.h"
 #include "content/common/resource_request_completion_status.h"
 #include "content/public/child/fixed_received_data.h"
 #include "content/public/child/request_peer.h"
 #include "content/public/child/resource_dispatcher_delegate.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/common/resource_type.h"
-#include "mojo/public/cpp/bindings/associated_binding.h"
 #include "mojo/public/cpp/bindings/associated_group.h"
-#include "mojo/public/cpp/bindings/associated_interface_ptr_info.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_response_headers.h"
 
 namespace content {
 
 namespace {
 
 // Converts |time| from a remote to local TimeTicks, overwriting the original
 // value.
@@ skipping 14 matching lines @@
 
 // Each resource request is assigned an ID scoped to this process.
 int MakeRequestID() {
   // NOTE: The resource_dispatcher_host also needs probably unique
   // request_ids, so they count down from -2 (-1 is a special we're
   // screwed value), while the renderer process counts up.
   static int next_request_id = 0;
   return next_request_id++;
 }
 
-class URLLoaderClientImpl final : public mojom::URLLoaderClient {
- public:
-  URLLoaderClientImpl(int request_id,
-                      ResourceDispatcher* resource_dispatcher,
-                      scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-      : binding_(this),
-        request_id_(request_id),
-        resource_dispatcher_(resource_dispatcher),
-        task_runner_(std::move(task_runner)) {}
-  ~URLLoaderClientImpl() override {
-    if (body_consumer_)
-      body_consumer_->Cancel();
-  }
-
-  void OnReceiveResponse(
-      const ResourceResponseHead& response_head,
-      mojom::DownloadedTempFilePtr downloaded_file) override {
-    has_received_response_ = true;
-    if (body_consumer_)
-      body_consumer_->Start();
-    downloaded_file_ = std::move(downloaded_file);
-    resource_dispatcher_->OnMessageReceived(
-        ResourceMsg_ReceivedResponse(request_id_, response_head));
-  }
-
-  void OnReceiveRedirect(const net::RedirectInfo& redirect_info,
-                         const ResourceResponseHead& response_head) override {
-    DCHECK(!has_received_response_);
-    DCHECK(!body_consumer_);
-    resource_dispatcher_->OnMessageReceived(ResourceMsg_ReceivedRedirect(
-        request_id_, redirect_info, response_head));
-  }
-
-  void OnDataDownloaded(int64_t data_len, int64_t encoded_data_len) override {
-    resource_dispatcher_->OnMessageReceived(
-        ResourceMsg_DataDownloaded(request_id_, data_len, encoded_data_len));
-  }
-
-  void OnTransferSizeUpdated(int32_t transfer_size_diff) override {
-    resource_dispatcher_->OnTransferSizeUpdated(request_id_,
-                                                transfer_size_diff);
-  }
-
-  void OnStartLoadingResponseBody(
-      mojo::ScopedDataPipeConsumerHandle body) override {
-    DCHECK(!body_consumer_);
-    body_consumer_ = new URLResponseBodyConsumer(
-        request_id_, resource_dispatcher_, std::move(body), task_runner_);
-    if (has_received_response_)
-      body_consumer_->Start();
-  }
-
-  void OnComplete(const ResourceRequestCompletionStatus& status) override {
-    if (!body_consumer_) {
-      resource_dispatcher_->OnMessageReceived(
-          ResourceMsg_RequestComplete(request_id_, status));
-      return;
-    }
-    body_consumer_->OnComplete(status);
-  }
-
-  void Bind(mojom::URLLoaderClientAssociatedPtrInfo* client_ptr_info,
-            mojo::AssociatedGroup* associated_group) {
-    binding_.Bind(client_ptr_info, associated_group);
-  }
-
- private:
-  mojo::AssociatedBinding<mojom::URLLoaderClient> binding_;
-  scoped_refptr<URLResponseBodyConsumer> body_consumer_;
-  mojom::DownloadedTempFilePtr downloaded_file_;
-  const int request_id_;
-  bool has_received_response_ = false;
-  ResourceDispatcher* const resource_dispatcher_;
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-};
-
 void CheckSchemeForReferrerPolicy(const ResourceRequest& request) {
   if ((request.referrer_policy == blink::WebReferrerPolicyDefault ||
        request.referrer_policy ==
            blink::WebReferrerPolicyNoReferrerWhenDowngrade) &&
       request.referrer.SchemeIsCryptographic() &&
       !request.url.SchemeIsCryptographic()) {
     LOG(FATAL) << "Trying to send secure referrer for insecure request "
                << "without an appropriate referrer policy.\n"
                << "URL = " << request.url << "\n"
                << "Referrer = " << request.referrer;
@@ skipping 376 matching lines @@
       strncpy(url_copy, info.response_url.spec().c_str(),
               sizeof(url_copy));
       base::debug::Alias(&url_copy);
       base::debug::Alias(&request_time);
       base::debug::DumpWithoutCrashing();
       should_dump = false;
     }
   }
   // Cancel the request if it didn't complete, and clean it up so the bridge
   // will receive no more messages.
-  if (info.completion_time.is_null())
+  if (info.completion_time.is_null() && !info.url_loader)
     message_sender_->Send(new ResourceHostMsg_CancelRequest(request_id));
   RemovePendingRequest(request_id);
 }
 
 void ResourceDispatcher::SetDefersLoading(int request_id, bool value) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info) {
     DLOG(ERROR) << "unknown request";
     return;
   }
   if (value) {
     request_info->is_deferred = value;
+    if (request_info->url_loader_client)
+      request_info->url_loader_client->SetDefersLoading();
   } else if (request_info->is_deferred) {
     request_info->is_deferred = false;
+    if (request_info->url_loader_client)
+      request_info->url_loader_client->UnsetDefersLoading();
 
     FollowPendingRedirect(request_id, request_info);
 
     main_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ResourceDispatcher::FlushDeferredMessages,
                               weak_factory_.GetWeakPtr(), request_id));
   }
 }
 
 void ResourceDispatcher::DidChangePriority(int request_id,
@@ skipping 48 matching lines @@
     IPC_MESSAGE_HANDLER(ResourceMsg_DataReceived, OnReceivedData)
     IPC_MESSAGE_HANDLER(ResourceMsg_DataDownloaded, OnDownloadedData)
     IPC_MESSAGE_HANDLER(ResourceMsg_RequestComplete, OnRequestComplete)
   IPC_END_MESSAGE_MAP()
 }
 
 void ResourceDispatcher::FlushDeferredMessages(int request_id) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info || request_info->is_deferred)
     return;
+
+  if (request_info->url_loader)
+    request_info->url_loader_client->FlushDeferredMessages();
+
   // Because message handlers could result in request_info being destroyed,
   // we need to work with a stack reference to the deferred queue.
   MessageQueue q;
   q.swap(request_info->deferred_message_queue);
   while (!q.empty()) {
     IPC::Message* m = q.front();
     q.pop_front();
     DispatchMessage(*m);
     delete m;
     // We need to find the request again in the list as it may have completed
@@ skipping 233 matching lines @@
     delete message;
   }
 }
 
 void ResourceDispatcher::SetResourceSchedulingFilter(
     scoped_refptr<ResourceSchedulingFilter> resource_scheduling_filter) {
   resource_scheduling_filter_ = resource_scheduling_filter;
 }
 
 }  // namespace content