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_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_allocation_size = MojoAsyncResourceHandler::kDefaultAllocationSize;
+// 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_allocation_size);
+}
+
+}  // namespace
+
+// This class is for sharing the ownership of a ScopedDataPipeProducerHandle.
+class MojoAsyncResourceHandler::SharedWriter final
+    : 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);
+};
+
+// This class is a IOBuffer subclass for data gotten from a
+// ScopedDataPipeProducerHandle.
+class MojoAsyncResourceHandler::WriterIOBuffer final
+    : public net::IOBufferWithSize {
+ public:
+  // |data| and |size| should be gotten from |writer| via BeginWriteDataRaw.
+  // They will be accesible via IOBuffer methods. As |writer| is stored in this
+  // instance, |data| will be kept valid as long as the following conditions
+  // hold:
+  //  1. |data| is not invalidated via EndWriteDataRaw.
+  //  2. |this| instance is alive.
+  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,
+    mojo::InterfaceRequest<mojom::URLLoader> mojo_request,
+    mojom::URLLoaderClientPtr url_loader_client)
+    : ResourceHandler(request),
+      rdh_(rdh),
+      binding_(this, std::move(mojo_request)),
+      url_loader_client_(std::move(url_loader_client)) {
+  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 (rdh_->delegate()) {
+    rdh_->delegate()->OnResponseStarted(request(), info->GetContext(),
+                                        response);
+  }
+
+  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_allocation_size;
+    mojo::DataPipe data_pipe(options);
+
+    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 = BeginWrite(&data, &available);
+
+    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;
+    }

[mmenke, 2016/07/19 20:50:27]

Can we just use AllocateBuffer here?

[yhirano, 2016/07/20 13:38:36]

Done.

+
+    if (result == MOJO_RESULT_OK) {
+      // The allocated buffer is too small.
+      if (EndWrite(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);
+  }
+
+  DCHECK_EQ(0u, buffer_offset_);
+  *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) {

[mmenke, 2016/07/19 21:58:51]

BUG (Erm...Or something?):  It turns out some code cannot handle a defer here,
on the first read (See MimeTypeResourceHandler::UseAlternateNextHandler - this
is only the result of the first read).  So...erm...yea...  Also, it's being
refactored in another CL I'm currently reviewing:
https://codereview.chromium.org/2005273002/ (Which currently maintains the same
limitation, though moves it to another ResourceHandler).

[yhirano, 2016/07/20 13:38:36]

Thank you. Basically I want MimeTypeResourceHandler to accept such valid input.
I will try to modify it tomorrow.

[mmenke, 2016/07/20 14:58:37]

Here's how I suggest you proceed, to minimize total work done, and chance of
regression:

Do it in another CL, to be landed before that (This CL is pretty big, smaller
CLs are easier for me to review), and build that CL on top of
https://codereview.chromium.org/2005273002/ (So Camille doesn't have to port
your changes over to new major refactor of MimeTypeResourceHandler).

It does mean you can't land these until Camille's CL lands, but I'm happy to
review other CLs built on top of them in the meantime, if her CL takes longer
than these to be ready to land.

[yhirano, 2016/07/21 14:50:20]

Then I will wait for a while because when your comment
https://codereview.chromium.org/2005273002/diff/340001/content/browser/loader...
is addressed, my change will be affected largely.

+      did_defer_ = true;
+      OnDefer();
+    }
+    return true;
+  }
+
+  if (EndWrite(bytes_read) != MOJO_RESULT_OK)
+    return false;
+  // Allocate a buffer for the next OnWillRead call here, because OnWillRead
+  // doesn't have |defer| parameter.
+  if (!AllocateBuffer(defer))
+    return false;
+  if (*defer) {
+    did_defer_ = true;
+    OnDefer();
+  }
+  return true;
+}
+
+void MojoAsyncResourceHandler::OnDataDownloaded(int bytes_downloaded) {
+  // Not implemented.
+}
+
+void MojoAsyncResourceHandler::FollowRedirect() {
+  NOTIMPLEMENTED();
+}
+
+void MojoAsyncResourceHandler::Cancel() {
+  NOTIMPLEMENTED();
+}
+
+void MojoAsyncResourceHandler::SetAllocationSizeForTesting(size_t size) {
+  g_allocation_size = size;
+}
+
+MojoResult MojoAsyncResourceHandler::BeginWrite(void** data,
+                                                uint32_t* available) {
+  return mojo::BeginWriteDataRaw(shared_writer_->writer(), data, available,
+                                 MOJO_WRITE_DATA_FLAG_NONE);
+}
+
+MojoResult MojoAsyncResourceHandler::EndWrite(uint32_t written) {
+  return mojo::EndWriteDataRaw(shared_writer_->writer(), written);
+}
+
+void MojoAsyncResourceHandler::OnResponseCompleted(
+    const net::URLRequestStatus& status,
+    const std::string& security_info,
+    bool* defer) {
+  shared_writer_ = nullptr;
+  buffer_ = nullptr;
+  handle_watcher_.Stop();
+
+  const ResourceRequestInfoImpl* info = GetRequestInfo();
+
+  // 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);
+
+  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 = BeginWrite(&data, &available);

[mmenke, 2016/07/19 20:50:26]

Hrm...This is just like AllocateBuffer, except it doesn't write to buffer_.

Here's my suggestion:  Use AllocateBuffer here, and instead of using the bool
"is_using_io_buffer_not_from_writer_" and storing the GrowableIOBuffer in that
case in buffer_, use a separate IOBuffer for it - non_writer_io_buffer_?  Could
even use a DrainableIOBuffer, and have it take care of tracking how much data is
left in it.

Then when we've copied it all, just release that buffer.  WDYT?

[yhirano, 2016/07/20 13:38:36]

I added |buffer| parameter to AllocateBuffer.

Regarding GlowableIOBuffer and DrainableIOBuffer, are you suggesting having
three buffers in this class (The GlowableIOBuffer should be held as a member as
we need data() in CopyReadData, and the DrainableIOBuffer should be held as a
member too because CopyReadData need not be done synchronously)?

+    if (result == MOJO_RESULT_SHOULD_WAIT) {
+      *defer = true;
+      return true;
+    }
+    if (result != MOJO_RESULT_OK)
+      return false;
+    if (buffer_bytes_read_ == 0) {

[mmenke, 2016/07/19 20:50:27]

The fact that this is after the BeginWrite is a bit unexpected (Though the code
is certainly correct) - maybe a comment here about it, and in CopyReadData's
declaration as well?

[yhirano, 2016/07/20 13:38:36]

Done.

+      buffer_ = new WriterIOBuffer(shared_writer_, data, available);
+      return true;
+    }

[mmenke, 2016/07/19 20:50:26]

Maybe add a blank line here?  This methods seems a bit short of them.

[yhirano, 2016/07/20 13:38:36]

Done.

+    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;
+  if (EndWrite(copied_size) != MOJO_RESULT_OK)

[mmenke, 2016/07/19 20:50:26]

Fix indent.

[yhirano, 2016/07/20 13:38:36]

Done.

+      return false;
+    if (buffer_bytes_read_ == 0) {
+      // All bytes are copied.
+      buffer_offset_ = 0;
+      is_using_io_buffer_not_from_writer_ = false;
+    }
+  }
+}
+
+bool MojoAsyncResourceHandler::AllocateBuffer(bool* defer) {
+  void* data = nullptr;
+  uint32_t available = 0;
+  MojoResult result = BeginWrite(&data, &available);
+  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() {
+  DCHECK(did_defer_);

[mmenke, 2016/07/19 20:50:26]

Hrm...did_defer_ is only used between function calls in this one DCHECK.  Should
we get rid of it, as a class variable, and just use locals instead?

[yhirano, 2016/07/20 13:38:36]

Done.

+  // did_defer_ is set only in OnReadCompleted (and here).
+  did_defer_ = false;
+  if (is_using_io_buffer_not_from_writer_) {
+    // |buffer_| is set to a net::IOBufferWithSize. Write the buffer contents
+    // to the data pipe. Note that |did_defer_| remains true until it's done.
+    DCHECK_GT(buffer_bytes_read_, 0u);
+    if (!CopyReadData(&did_defer_)) {
+      controller()->CancelWithError(net::ERR_FAILED);
+      return;
+    }
+  } else {
+    // Allocate a buffer for the next OnWillRead call here.
+    if (!AllocateBuffer(&did_defer_)) {
+      controller()->CancelWithError(net::ERR_FAILED);
+      return;
+    }
+  }

[mmenke, 2016/07/19 20:50:26]

Suggest a blank line here.

[yhirano, 2016/07/20 13:38:36]

Done.

+  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