Use mojo for Chrome Loading, Part 1

content/browser/loader/mojo_async_resource_handler.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/browser/loader/mojo_async_resource_handler.h"
+
+#include <utility>
+
+#include "base/command_line.h"
+#include "base/containers/hash_tables.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/time/time.h"
+#include "content/browser/loader/netlog_observer.h"
+#include "content/browser/loader/resource_dispatcher_host_impl.h"
+#include "content/browser/loader/resource_message_filter.h"
+#include "content/browser/loader/resource_request_info_impl.h"
+#include "content/common/resource_request_completion_status.h"
+#include "content/public/browser/resource_dispatcher_host_delegate.h"
+#include "content/public/common/resource_response.h"
+#include "mojo/public/c/system/data_pipe.h"
+#include "mojo/public/cpp/system/data_pipe.h"
+#include "net/base/io_buffer.h"
+#include "net/base/load_flags.h"
+#include "net/base/mime_sniffer.h"
+#include "net/log/net_log.h"
+#include "net/url_request/redirect_info.h"
+
+namespace content {
+namespace {
+
+int g_max_allocation_size = 1024 * 32;
+// MimeTypeResourceHandler *implicitly* requires that the buffer size
+// returned from OnWillRead should be larger than certain size.
+// TODO(yhirano): Fix MimeTypeResourceHandler.
+size_t kMinAllocationSize = 2 * net::kMaxBytesToSniff;
+
+void GetNumericArg(const std::string& name, int* result) {
+  const std::string& value =
+      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(name);
+  if (!value.empty())
+    base::StringToInt(value, result);
+}
+
+void InitializeResourceBufferConstants() {
+  static bool did_init = false;
+  if (did_init)
+    return;
+  did_init = true;
+
+  GetNumericArg("resource-buffer-max-allocation-size", &g_max_allocation_size);
+}
+
+}  // namespace
+
+class MojoAsyncResourceHandler::SharedWriter final

[mmenke, 2016/06/13 20:56:58]

This class needs to be documented.

[yhirano, 2016/07/12 10:49:11]

Done.

+    : public base::RefCountedThreadSafe<SharedWriter> {
+ public:
+  explicit SharedWriter(mojo::ScopedDataPipeProducerHandle writer)
+      : writer_(std::move(writer)) {}
+  mojo::DataPipeProducerHandle writer() { return writer_.get(); }
+
+ private:
+  friend class base::RefCountedThreadSafe<SharedWriter>;
+  ~SharedWriter() {}
+
+  const mojo::ScopedDataPipeProducerHandle writer_;
+
+  DISALLOW_COPY_AND_ASSIGN(SharedWriter);
+};
+
+class MojoAsyncResourceHandler::WriterIOBuffer final

[mmenke, 2016/06/13 20:56:58]

This class needs to be documented.

[yhirano, 2016/07/12 10:49:11]

Done.

+    : public net::IOBufferWithSize {
+ public:
+  WriterIOBuffer(scoped_refptr<MojoAsyncResourceHandler::SharedWriter> writer,
+                 void* data,
+                 size_t size)
+      : net::IOBufferWithSize(static_cast<char*>(data), size),
+        writer_(std::move(writer)) {}
+
+ private:
+  ~WriterIOBuffer() override {
+    // Avoid deleting |data_| in the IOBuffer destructor.
+    data_ = nullptr;
+  }
+
+  // This member is for keeping the writer alive.
+  scoped_refptr<MojoAsyncResourceHandler::SharedWriter> writer_;
+
+  DISALLOW_COPY_AND_ASSIGN(WriterIOBuffer);
+};
+
+MojoAsyncResourceHandler::MojoAsyncResourceHandler(
+    net::URLRequest* request,
+    ResourceDispatcherHostImpl* rdh,
+    std::unique_ptr<mojom::URLLoader> url_loader,
+    mojom::URLLoaderClientPtr url_loader_client)
+    : ResourceHandler(request),
+      rdh_(rdh),
+      url_loader_(std::move(url_loader)),
+      url_loader_client_(std::move(url_loader_client)) {
+  DCHECK(url_loader_);
+  DCHECK(url_loader_client_);
+  InitializeResourceBufferConstants();
+}
+
+MojoAsyncResourceHandler::~MojoAsyncResourceHandler() {
+  if (has_checked_for_sufficient_resources_)
+    rdh_->FinishedWithResourcesForRequest(request());
+}
+
+bool MojoAsyncResourceHandler::OnRequestRedirected(
+    const net::RedirectInfo& redirect_info,
+    ResourceResponse* response,
+    bool* defer) {
+  // Not implemented.
+  return false;
+}
+
+bool MojoAsyncResourceHandler::OnResponseStarted(ResourceResponse* response,
+                                                 bool* defer) {
+  const ResourceRequestInfoImpl* info = GetRequestInfo();
+  if (!info->filter())
+    return false;
+
+  if (rdh_->delegate()) {
+    rdh_->delegate()->OnResponseStarted(request(), info->GetContext(), response,
+                                        info->filter());
+  }
+
+  NetLogObserver::PopulateResponseInfo(request(), response);
+
+  response->head.request_start = request()->creation_time();
+  response->head.response_start = base::TimeTicks::Now();
+  sent_received_response_message_ = true;
+  url_loader_client_->OnReceiveResponse(response->head);
+  return true;
+}
+
+bool MojoAsyncResourceHandler::OnWillStart(const GURL& url, bool* defer) {
+  return true;
+}
+
+bool MojoAsyncResourceHandler::OnBeforeNetworkStart(const GURL& url,
+                                                    bool* defer) {
+  return true;
+}
+
+bool MojoAsyncResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
+                                          int* buf_size,
+                                          int min_size) {
+  DCHECK_EQ(-1, min_size);
+
+  if (!CheckForSufficientResource())
+    return false;
+
+  if (!shared_writer_) {
+    MojoCreateDataPipeOptions options;
+    options.struct_size = sizeof(MojoCreateDataPipeOptions);
+    options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
+    options.element_num_bytes = 1;
+    options.capacity_num_bytes = g_max_allocation_size;
+    mojo::DataPipe data_pipe(options);
+
+    ResourceMessageFilter* filter = GetRequestInfo()->filter();
+    if (filter) {

[mmenke, 2016/06/13 20:56:58]

All these filter checks, except possibly the one in
MojoAsyncResourceHandler::OnResponseStarted, don't seem to get us anything, when
we're not actually sending anything via the filter.

[yhirano, 2016/07/12 10:49:11]

I tried to mimic AsyncResourceHandler's behavior, but OK, let's remove them.

Regarding OnResponseStarted, I'm removing the parameter at
https://codereview.chromium.org/2136223003/ and so we can remove the branch as
well.

[mmenke, 2016/07/12 15:10:45]

My opinion here (And it's certainly something that is reasonable to disagree on)
is that we should try and make the new code as clean as possible, instead of
trying mirroring the old code (Though mirroring the old code was a great way to
start the CL).  Downside is we have more chance of breaking stuff that way. 
Upside is that it makes maintenance easier, and there's a good chance no one is
going to do a cleanup pass here.

+      url_loader_client_->OnStartLoadingResponseBody(
+          std::move(data_pipe.consumer_handle));
+    }
+    if (!data_pipe.producer_handle.is_valid())
+      return false;
+
+    shared_writer_ = new SharedWriter(std::move(data_pipe.producer_handle));
+
+    void* data = nullptr;
+    uint32_t available = 0;
+    MojoResult result = mojo::BeginWriteDataRaw(
+        shared_writer_->writer(), &data, &available, MOJO_WRITE_DATA_FLAG_NONE);
+
+    if (result != MOJO_RESULT_OK && result != MOJO_RESULT_SHOULD_WAIT)
+      return false;
+    if (result == MOJO_RESULT_OK && available >= kMinAllocationSize) {
+      *buf = buffer_ = new WriterIOBuffer(shared_writer_, data, available);
+      *buf_size = buffer_->size();
+      return true;
+    }
+
+    if (result == MOJO_RESULT_OK) {
+      // The allocated buffer is too small.
+      if (mojo::EndWriteDataRaw(shared_writer_->writer(), 0) != MOJO_RESULT_OK)
+        return false;
+    }
+    DCHECK(!is_using_io_buffer_not_from_writer_);
+    is_using_io_buffer_not_from_writer_ = true;
+    buffer_ = new net::IOBufferWithSize(kMinAllocationSize);
+  }
+
+  if (is_using_io_buffer_not_from_writer_) {
+    DCHECK_EQ(0u, buffer_offset_);
+    *buf = new net::WrappedIOBuffer(buffer_->data());
+    *buf_size = buffer_->size();
+    return true;
+  }
+
+  *buf = buffer_;
+  *buf_size = buffer_->size();
+  return true;
+}
+
+bool MojoAsyncResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
+  DCHECK_GE(bytes_read, 0);
+  DCHECK(buffer_);
+
+  if (!bytes_read)
+    return true;
+
+  if (is_using_io_buffer_not_from_writer_) {
+    // Couldn't allocate a buffer on the data pipe in OnWillRead.
+    DCHECK(!did_defer_);
+    DCHECK_EQ(0u, buffer_bytes_read_);
+    buffer_bytes_read_ = bytes_read;
+    if (!CopyReadData(defer))
+      return false;
+    if (*defer) {
+      did_defer_ = true;
+      OnDefer();
+    }
+    return true;
+  }
+
+  MojoResult result =
+      mojo::EndWriteDataRaw(shared_writer_->writer(), bytes_read);
+  if (result != MOJO_RESULT_OK)
+    return false;
+  if (!AllocateBuffer(defer))
+    return false;
+  if (*defer) {
+    did_defer_ = true;
+    OnDefer();
+  }
+  return true;
+}
+
+void MojoAsyncResourceHandler::OnDataDownloaded(int bytes_downloaded) {
+  // Not implemented.
+}
+
+void MojoAsyncResourceHandler::SetAllocationSizeForTesting(size_t size) {
+  g_max_allocation_size = size;
+}
+
+void MojoAsyncResourceHandler::OnResponseCompleted(
+    const net::URLRequestStatus& status,
+    const std::string& security_info,
+    bool* defer) {
+  const ResourceRequestInfoImpl* info = GetRequestInfo();
+  if (!info->filter())
+    return;
+
+  // TODO(gavinp): Remove this CHECK when we figure out the cause of
+  // http://crbug.com/124680 . This check mirrors closely check in
+  // WebURLLoaderImpl::OnCompletedRequest that routes this message to a WebCore
+  // ResourceHandleInternal which asserts on its state and crashes. By crashing
+  // when the message is sent, we should get better crash reports.
+  CHECK(status.status() != net::URLRequestStatus::SUCCESS ||
+        sent_received_response_message_);
+
+  int error_code = status.error();
+  bool was_ignored_by_handler = info->WasIgnoredByHandler();
+
+  DCHECK(status.status() != net::URLRequestStatus::IO_PENDING);
+  // If this check fails, then we're in an inconsistent state because all
+  // requests ignored by the handler should be canceled (which should result in
+  // the ERR_ABORTED error code).
+  DCHECK(!was_ignored_by_handler || error_code == net::ERR_ABORTED);
+
+  // TODO(mkosiba): Fix up cases where we create a URLRequestStatus
+  // with a status() != SUCCESS and an error_code() == net::OK.
+  if (status.status() == net::URLRequestStatus::CANCELED &&
+      error_code == net::OK) {
+    error_code = net::ERR_ABORTED;
+  } else if (status.status() == net::URLRequestStatus::FAILED &&
+             error_code == net::OK) {
+    error_code = net::ERR_FAILED;
+  }
+
+  ResourceRequestCompletionStatus request_complete_data;
+  request_complete_data.error_code = error_code;
+  request_complete_data.was_ignored_by_handler = was_ignored_by_handler;
+  request_complete_data.exists_in_cache = request()->response_info().was_cached;
+  request_complete_data.security_info = security_info;
+  request_complete_data.completion_time = base::TimeTicks::Now();
+  request_complete_data.encoded_data_length =
+      request()->GetTotalReceivedBytes();
+
+  url_loader_client_->OnComplete(request_complete_data);
+}
+
+bool MojoAsyncResourceHandler::CopyReadData(bool* defer) {
+  while (true) {
+    void* data = nullptr;
+    uint32_t available = 0;
+    MojoResult result = mojo::BeginWriteDataRaw(
+        shared_writer_->writer(), &data, &available, MOJO_WRITE_DATA_FLAG_NONE);
+    if (result == MOJO_RESULT_SHOULD_WAIT) {
+      *defer = true;
+      return true;
+    }
+    if (result != MOJO_RESULT_OK)
+      return false;
+
+    if (buffer_bytes_read_ == 0) {
+      buffer_ = new WriterIOBuffer(shared_writer_, data, available);
+      return true;
+    }
+
+    size_t copied_size =
+        std::min(static_cast<uint32_t>(buffer_bytes_read_), available);
+    memcpy(data, buffer_->data() + buffer_offset_, copied_size);
+    buffer_offset_ += copied_size;
+    buffer_bytes_read_ -= copied_size;
+    result = mojo::EndWriteDataRaw(shared_writer_->writer(), copied_size);
+    if (result != MOJO_RESULT_OK)
+      return false;
+    if (buffer_bytes_read_ == 0) {

[mmenke, 2016/06/13 20:56:58]

I think it's clearer (And less code) if you move this to the start of this
method, make it return true, and remove the other "buffer_bytes_read_ == 0"
line.  Then you can unconditionally call AllocateBuffer in
MojoAsyncResourceHandler::ResumeIfDeferred.

[yhirano, 2016/07/12 10:49:11]

Sorry I don't understand. Do you mean "the start of this loop"?

[mmenke, 2016/07/12 15:10:45]

Yes

[yhirano, 2016/07/13 12:04:57]

Done.

+      // All bytes are copied.
+      buffer_offset_ = 0;
+      is_using_io_buffer_not_from_writer_ = false;
+    }
+  }
+  NOTREACHED();
+  return false;

[mmenke, 2016/06/13 20:56:58]

There's no break in the loop.  These two lines shouldn't be needed.

[yhirano, 2016/07/12 10:49:11]

Done.

+}
+
+bool MojoAsyncResourceHandler::AllocateBuffer(bool* defer) {
+  void* data = nullptr;
+  uint32_t available = 0;
+  MojoResult result = mojo::BeginWriteDataRaw(
+      shared_writer_->writer(), &data, &available, MOJO_WRITE_DATA_FLAG_NONE);
+  if (result == MOJO_RESULT_SHOULD_WAIT) {
+    *defer = true;
+    return true;
+  }
+  if (result != MOJO_RESULT_OK)
+    return false;
+  buffer_ = new WriterIOBuffer(shared_writer_, data, available);
+  return true;
+}
+
+void MojoAsyncResourceHandler::ResumeIfDeferred() {
+  if (did_defer_) {

[mmenke, 2016/06/13 20:56:58]

Can this ever be called if did_defer_ is false?

[yhirano, 2016/07/12 10:49:11]

Currently not.

+    // did_defer_ is set only in OnReadCompleted (and here).
+    did_defer_ = false;
+    if (is_using_io_buffer_not_from_writer_) {
+      DCHECK_GT(buffer_bytes_read_, 0u);
+      if (!CopyReadData(&did_defer_)) {
+        controller()->CancelWithError(net::ERR_FAILED);
+        return;
+      }
+    } else {
+      if (!AllocateBuffer(&did_defer_)) {
+        controller()->CancelWithError(net::ERR_FAILED);
+        return;
+      }
+    }
+    if (did_defer_) {
+      // Continue waiting.
+      handle_watcher_.Start(shared_writer_->writer(),
+                            MOJO_HANDLE_SIGNAL_WRITABLE,
+                            MOJO_DEADLINE_INDEFINITE,
+                            base::Bind(&MojoAsyncResourceHandler::OnWritable,
+                                       base::Unretained(this)));
+      return;
+    }
+    request()->LogUnblocked();
+    controller()->Resume();
+  }
+}
+
+void MojoAsyncResourceHandler::OnDefer() {
+  request()->LogBlockedBy("MojoAsyncResourceHandler");
+  handle_watcher_.Start(shared_writer_->writer(), MOJO_HANDLE_SIGNAL_WRITABLE,
+                        MOJO_DEADLINE_INDEFINITE,
+                        base::Bind(&MojoAsyncResourceHandler::OnWritable,
+                                   base::Unretained(this)));
+}
+
+bool MojoAsyncResourceHandler::CheckForSufficientResource() {
+  if (has_checked_for_sufficient_resources_)
+    return true;
+  has_checked_for_sufficient_resources_ = true;
+
+  if (rdh_->HasSufficientResourcesForRequest(request()))
+    return true;
+
+  controller()->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
+  return false;
+}
+
+void MojoAsyncResourceHandler::OnWritable(MojoResult unused) {
+  ResumeIfDeferred();
+}
+
+}  // namespace content