Use mojo for Chrome Loading, Part 1

content/browser/loader/async_resource_handler.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.
 
 #include "content/browser/loader/async_resource_handler.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 11 matching lines @@
 #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/browser/resource_context_impl.h"
 #include "content/common/resource_messages.h"
 #include "content/common/resource_request_completion_status.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/resource_response.h"
+#include "mojo/message_pump/handle_watcher.h"
+#include "mojo/public/cpp/system/data_pipe.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/log/net_log.h"
 #include "net/url_request/redirect_info.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace content {
 namespace {
@@ skipping 142 matching lines @@
  public:
   DependentIOBuffer(ResourceBuffer* backing, char* memory)
       : net::WrappedIOBuffer(memory),
         backing_(backing) {
   }
  private:
   ~DependentIOBuffer() override {}
   scoped_refptr<ResourceBuffer> backing_;
 };
 
-AsyncResourceHandler::AsyncResourceHandler(
-    net::URLRequest* request,
-    ResourceDispatcherHostImpl* rdh)
+// This class is used when the resource is being loaded via mojo. This class
+// uses mojo data pipe instead of shared memory transferred via ChromeIPC.
+class AsyncResourceHandler::MojoHelper final {

[mmenke, 2016/05/24 20:01:35]

Long term, is the plan to merge this into AsyncResourceHandler?  Once we're just
using mojo, doesn't seem like there'll be much left there.

[yhirano, 2016/05/25 12:47:05]

Yes, our plan is replacing ChromeIPC with mojo.

+ public:
+  explicit MojoHelper(AsyncResourceHandler* owner) : owner_(owner) {}
+  // Called from AsyncResourceHandler::OnWillRead.
+  bool OnWillRead(scoped_refptr<net::IOBuffer>* buf,
+                  int* buf_size,
+                  int min_size) {
+    void* buffer = nullptr;
+    uint32_t available = 0;
+    if (!writer_.is_valid()) {
+      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 = kMaxAllocationSize;
+      mojo::DataPipe data_pipe(options);
+
+      writer_ = std::move(data_pipe.producer_handle);
+      ResourceMessageFilter* filter = owner_->GetRequestInfo()->filter();
+      if (filter) {
+        filter->OnStartLoadingResponseBodyWithMojo(
+            owner_->GetRequestInfo()->GetGlobalRequestID(),
+            std::move(data_pipe.consumer_handle));
+      }
+    }
+    if (!writer_.is_valid()) {
+      owner_->controller()->CancelWithError(net::ERR_FAILED);
+      return false;
+    }
+
+    MojoResult result = mojo::BeginWriteDataRaw(
+        writer_.get(), &buffer, &available, MOJO_WRITE_DATA_FLAG_NONE);
+    // Note that SHOULD_WAIT should be handled in OnReadCompleted.
+    if (result == MOJO_RESULT_OK) {
+      *buf = new net::WrappedIOBuffer(static_cast<const char*>(buffer));
+      *buf_size = available;
+      return true;
+    }
+    return false;

[mmenke, 2016/05/24 20:01:35]

This case is currently a fatal error?

[yhirano, 2016/05/25 12:47:05]

Done.

+  }
+
+  // Called from AsyncResourceHandler::OnReadCompleted.
+  bool OnReadCompleted(int bytes_read, bool* defer) {
+    MojoResult result = mojo::EndWriteDataRaw(writer_.get(), bytes_read);
+    if (result != MOJO_RESULT_OK)
+      return false;
+    void* buffer = nullptr;
+    uint32_t available = 0;
+    // To see if the handle is still writable.
+    result = mojo::BeginWriteDataRaw(writer_.get(), &buffer, &available,
+                                     MOJO_WRITE_DATA_FLAG_NONE);
+    if (result == MOJO_RESULT_SHOULD_WAIT ||
+        (result == MOJO_RESULT_OK && available == 0)) {
+      *defer = owner_->did_defer_ = true;
+      owner_->OnDefer();
+      handle_watcher_.Start(
+          writer_.get(), MOJO_HANDLE_SIGNAL_WRITABLE, MOJO_DEADLINE_INDEFINITE,
+          base::Bind(&MojoHelper::OnWritable, base::Unretained(this)));
+    }
+    if (result == MOJO_RESULT_OK)
+      mojo::EndWriteDataRaw(writer_.get(), 0);
+    return true;
+  }
+
+ private:
+  void OnWritable(MojoResult result) { owner_->ResumeIfDeferred(); }
+
+  mojo::ScopedDataPipeProducerHandle writer_;
+  mojo::common::HandleWatcher handle_watcher_;
+  AsyncResourceHandler* owner_;
+
+  DISALLOW_COPY_AND_ASSIGN(MojoHelper);
+};
+
+AsyncResourceHandler::AsyncResourceHandler(net::URLRequest* request,
+                                           ResourceDispatcherHostImpl* rdh,
+                                           bool using_mojo_data_handle)
     : ResourceHandler(request),
       ResourceMessageDelegate(request),
       rdh_(rdh),
       pending_data_count_(0),
       allocation_size_(0),
       did_defer_(false),
       has_checked_for_sufficient_resources_(false),
       sent_received_response_msg_(false),
       sent_data_buffer_msg_(false),
       inlining_helper_(new InliningHelper),
       last_upload_position_(0),
       waiting_for_upload_progress_ack_(false),
-      reported_transfer_size_(0) {
+      reported_transfer_size_(0),
+      mojo_helper_(using_mojo_data_handle ? new MojoHelper(this) : nullptr) {
   InitializeResourceBufferConstants();
 }
 
 AsyncResourceHandler::~AsyncResourceHandler() {
   if (has_checked_for_sufficient_resources_)
     rdh_->FinishedWithResourcesForRequest(request());
 }
 
 bool AsyncResourceHandler::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
@@ skipping 169 matching lines @@
 }
 
 bool AsyncResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                                       int* buf_size,
                                       int min_size) {
   DCHECK_EQ(-1, min_size);
 
   if (!CheckForSufficientResource())
     return false;
 
+  if (mojo_helper_)
+    return mojo_helper_->OnWillRead(buf, buf_size, min_size);
+
   // Return early if InliningHelper allocates the buffer, so that we should
   // inline the data into the IPC message without allocating SharedMemory.
   if (inlining_helper_->PrepareInlineBufferIfApplicable(buf, buf_size))
     return true;
 
   if (!EnsureResourceBufferIsInitialized())
     return false;
 
   DCHECK(buffer_->CanAllocate());
   char* memory = buffer_->Allocate(&allocation_size_);
   CHECK(memory);
 
   *buf = new DependentIOBuffer(buffer_.get(), memory);
   *buf_size = allocation_size_;
 
   return true;
 }
 
 bool AsyncResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
   DCHECK_GE(bytes_read, 0);
 
   if (!bytes_read)
     return true;
 
+  if (mojo_helper_)
+    return mojo_helper_->OnReadCompleted(bytes_read, defer);
+
   ResourceMessageFilter* filter = GetFilter();
   if (!filter)
     return false;
 
   int encoded_data_length = CalculateEncodedDataLengthToReport();
 
   // Return early if InliningHelper handled the received data.
   if (inlining_helper_->SendInlinedDataIfApplicable(
           bytes_read, encoded_data_length, filter, GetRequestID()))
     return true;
@@ skipping 28 matching lines @@
 void AsyncResourceHandler::OnDataDownloaded(int bytes_downloaded) {
   int encoded_data_length = CalculateEncodedDataLengthToReport();
 
   ResourceMessageFilter* filter = GetFilter();
   if (filter) {
     filter->Send(new ResourceMsg_DataDownloaded(
         GetRequestID(), bytes_downloaded, encoded_data_length));
   }
 }
 
 void AsyncResourceHandler::OnResponseCompleted(

[mmenke, 2016/05/24 20:01:35]

There's no mojo response completed successfully or request failed message?

[yhirano, 2016/05/25 12:47:05]

There is. In PS25, ResourceMessageFilter traps IPC messages and send them via
mojo if it's appropriate.

     const net::URLRequestStatus& status,
     const std::string& security_info,
     bool* defer) {
   const ResourceRequestInfoImpl* info = GetRequestInfo();
   if (!info->filter())
     return;
 
   // If we crash here, figure out what URL the renderer was requesting.
   // http://crbug.com/107692
   char url_buf[128];
@@ skipping 105 matching lines @@
   } else {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Net.ResourceLoader.ResponseStartToEnd.Over_512kB",
         elapsed_time, 1, 100000, 100);
   }
 
   inlining_helper_->RecordHistogram(elapsed_time);
 }
 
 }  // namespace content