Move URLLoaderClientImpl to a separate file

content/child/url_loader_client_impl.cc

+// Copyright 2016 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/child/url_loader_client_impl.h"
+
+#include "base/callback.h"
+#include "base/single_thread_task_runner.h"
+#include "content/child/resource_dispatcher.h"
+#include "content/child/url_response_body_consumer.h"
+#include "content/common/resource_messages.h"
+#include "mojo/public/cpp/bindings/associated_group.h"
+#include "net/url_request/redirect_info.h"
+
+namespace content {
+
+URLLoaderClientImpl::URLLoaderClientImpl(
+    int request_id,
+    ResourceDispatcher* resource_dispatcher,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+    : binding_(this),
+      request_id_(request_id),
+      resource_dispatcher_(resource_dispatcher),
+      is_destroyed_(new SharedBoolean()),
+      task_runner_(std::move(task_runner)) {}
+
+URLLoaderClientImpl::~URLLoaderClientImpl() {
+  if (body_consumer_)
+    body_consumer_->Cancel();
+  is_destroyed_->set(true);
+}
+
+void URLLoaderClientImpl::OnReceiveResponse(
+    const ResourceResponseHead& response_head,
+    mojom::DownloadedTempFilePtr downloaded_file) {
+  has_received_response_ = true;
+  if (body_consumer_)
+    body_consumer_->Start();
+  downloaded_file_ = std::move(downloaded_file);
+  Dispatch(ResourceMsg_ReceivedResponse(request_id_, response_head));
+}
+
+void URLLoaderClientImpl::OnReceiveRedirect(
+    const net::RedirectInfo& redirect_info,
+    const ResourceResponseHead& response_head) {
+  DCHECK(!has_received_response_);
+  DCHECK(!body_consumer_);
+  Dispatch(
+      ResourceMsg_ReceivedRedirect(request_id_, redirect_info, response_head));
+}
+
+void URLLoaderClientImpl::OnDataDownloaded(int64_t data_len,
+                                           int64_t encoded_data_len) {
+  Dispatch(ResourceMsg_DataDownloaded(request_id_, data_len, encoded_data_len));
+}
+
+void URLLoaderClientImpl::OnTransferSizeUpdated(int32_t transfer_size_diff) {
+  if (is_deferred_) {
+    accumulated_transfer_size_diff_during_deferred_ += transfer_size_diff;
+  } else {
+    resource_dispatcher_->OnTransferSizeUpdated(request_id_,
+                                                transfer_size_diff);
+  }
+}
+
+void URLLoaderClientImpl::OnStartLoadingResponseBody(
+    mojo::ScopedDataPipeConsumerHandle body) {
+  DCHECK(!body_consumer_);
+  body_consumer_ = new URLResponseBodyConsumer(
+      request_id_, resource_dispatcher_, std::move(body), task_runner_);
+  if (has_received_response_)
+    body_consumer_->Start();
+  if (is_deferred_)
+    body_consumer_->SetDefersLoading();
+}
+
+void URLLoaderClientImpl::OnComplete(
+    const ResourceRequestCompletionStatus& status) {
+  if (!body_consumer_) {
+    Dispatch(ResourceMsg_RequestComplete(request_id_, status));
+    return;
+  }
+  body_consumer_->OnComplete(status);
+}
+
+void URLLoaderClientImpl::FlushDeferredMessages() {
+  DCHECK(!is_deferred_);
+  std::vector<IPC::Message> messages;
+  messages.swap(deferred_messages_);
+  bool has_completion_message = false;
+  scoped_refptr<SharedBoolean> is_destroyed = is_destroyed_;
+  size_t index = 0;
+  // First, dispatch all messages excluding the followings:
+  //  - response body (dispatched by |body_consumer_|)
+  //  - transfer size change (dispatched later)
+  //  - completion (dispatched by |body_consumer_| or dispatched later)
+  for (index = 0; index < messages.size(); ++index) {
+    if (messages[index].type() == ResourceMsg_RequestComplete::ID) {
+      // The completion message arrives at the end of the message queue.
+      DCHECK(!has_completion_message);
+      DCHECK_EQ(index, messages.size() - 1);
+      has_completion_message = true;
+    } else {
+      Dispatch(messages[index]);
+    }
+    if (is_destroyed->value())
+      return;
+    if (is_deferred_) {
+      deferred_messages_.insert(deferred_messages_.begin(),
+                                messages.begin() + index + 1, messages.end());
+      return;
+    }
+  }
+
+  // Dispatch the transfer size update.
+  if (accumulated_transfer_size_diff_during_deferred_ > 0) {
+    auto transfer_size_diff = accumulated_transfer_size_diff_during_deferred_;
+    accumulated_transfer_size_diff_during_deferred_ = 0;
+    resource_dispatcher_->OnTransferSizeUpdated(request_id_,
+                                                transfer_size_diff);
+    if (is_destroyed->value())
+      return;
+    if (is_deferred_) {
+      deferred_messages_.insert(deferred_messages_.begin(),
+                                messages.begin() + index, messages.end());
+      return;
+    }
+  }
+
+  if (body_consumer_) {
+    // Dispatch the response body.
+    body_consumer_->UnsetDefersLoading();
+    if (is_destroyed->value())
+      return;
+    if (is_deferred_) {
+      deferred_messages_.insert(deferred_messages_.begin(),
+                                messages.begin() + index, messages.end());
+      return;
+    }
+  }
+
+  // Dispatch the completion message.
+  if (has_completion_message) {
+    DCHECK_GT(messages.size(), 0u);
+    DCHECK_EQ(messages.back().type(),
+              static_cast<uint32_t>(ResourceMsg_RequestComplete::ID));
+    Dispatch(messages.back());
+  }
+}
+
+void URLLoaderClientImpl::SetDefersLoading() {

[kinuko, 2016/12/22 06:34:18]

Any reason we don't make this take a boolean flag as
ResourceDispatcher::SetDefersLoading does?

+  is_deferred_ = true;
+  if (body_consumer_)
+    body_consumer_->SetDefersLoading();
+}
+
+void URLLoaderClientImpl::UnsetDefersLoading() {
+  is_deferred_ = false;
+}
+
+void URLLoaderClientImpl::Bind(
+    mojom::URLLoaderClientAssociatedPtrInfo* client_ptr_info,
+    mojo::AssociatedGroup* associated_group) {
+  binding_.Bind(client_ptr_info, associated_group);
+}
+
+void URLLoaderClientImpl::Dispatch(const IPC::Message& message) {
+  if (is_deferred_) {
+    deferred_messages_.push_back(message);
+  } else if (deferred_messages_.size() > 0) {
+    deferred_messages_.push_back(message);
+    FlushDeferredMessages();
+  } else {
+    resource_dispatcher_->OnMessageReceived(message);
+  }
+}
+
+}  // namespace content