Use mojo for Chrome Loading, Part 1

content/browser/loader/resource_dispatcher_host_impl.cc

Index: content/browser/loader/resource_dispatcher_host_impl.cc
diff --git a/content/browser/loader/resource_dispatcher_host_impl.cc b/content/browser/loader/resource_dispatcher_host_impl.cc
index cb64dc8880b575a8b9d68095f688b4de3ade8ef9..ffbfdc1ce29025416a42edb9aa9f1a055fe45a2d 100644
--- a/content/browser/loader/resource_dispatcher_host_impl.cc
+++ b/content/browser/loader/resource_dispatcher_host_impl.cc
@@ -538,6 +538,88 @@ ResourceDispatcherHost* ResourceDispatcherHost::Get() {
   return g_resource_dispatcher_host;
 }
 
+class ResourceDispatcherHostImpl::MojoHelper final {

[mmenke, 2016/05/23 17:34:53]

Add comments.

[yhirano, 2016/05/24 06:40:03]

Done.

+ public:
+  explicit MojoHelper(ResourceDispatcherHostImpl* owner) : owner_(owner) {}
+
+  bool Send(const IPC::Message& message, ResourceMessageFilter* filter) {
+    if (IPC_MESSAGE_ID_CLASS(message.type()) != ResourceMsgStart)
+      return false;
+
+    base::PickleIterator iter(message);
+    int request_id = -1;
+    bool ok = iter.ReadInt(&request_id);
+    DCHECK(ok);
+    ResourceLoader* loader = owner_->GetLoader(filter->child_id(), request_id);
+    if (!loader || !loader->client())
+      return false;
+
+    DCHECK(!filter_);
+    filter_ = filter;
+    bool handled = true;
+    IPC_BEGIN_MESSAGE_MAP(MojoHelper, message)
+      IPC_MESSAGE_HANDLER(ResourceMsg_ReceivedResponse, OnReceivedResponse)
+      IPC_MESSAGE_HANDLER(ResourceMsg_RequestComplete, OnRequestComplete)
+      IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_END_MESSAGE_MAP()
+
+    filter_ = nullptr;
+    return handled;
+  }
+
+  void AddUninitiatedURLLoader(int child_id,
+                               std::unique_ptr<mojom::URLLoader> loader) {
+    mojom::URLLoader* raw = loader.get();
+    uninitiated_url_loaders_.insert(
+        std::make_pair(raw, std::make_pair(child_id, std::move(loader))));
+  }
+
+  std::unique_ptr<mojom::URLLoader> TakeUninitiatedURLLoader(
+      mojom::URLLoader* loader) {
+    auto it = uninitiated_url_loaders_.find(loader);
+    if (it == uninitiated_url_loaders_.end())
+      return nullptr;
+    std::unique_ptr<mojom::URLLoader> result = std::move(it->second.second);
+    uninitiated_url_loaders_.erase(it);
+    return result;
+  }
+
+  void CancelUninitiatedLoaders(int child_id) {
+    auto it = uninitiated_url_loaders_.begin();
+    while (it != uninitiated_url_loaders_.end()) {
+      if (it->second.first == child_id) {
+        it = uninitiated_url_loaders_.erase(it);
+      } else {
+        ++it;
+      }
+    }
+  }
+
+ private:
+  void OnReceivedResponse(int request_id, const ResourceResponseHead& head) {
+    int child_id = filter_->child_id();
+    ResourceLoader* loader = owner_->GetLoader(child_id, request_id);
+    mojom::URLLoaderClient* client = loader->client();
+    client->OnReceiveResponse(head, loader->GetRequestInfo()->TakeBodyReader());

[mmenke, 2016/05/23 17:34:53]

Why do we need to pass the body reader all over the place?  The dependency
diagram here seems rather unfortunate.

Can we do this all at the AsyncResourceHandler layer instead?  Having the
AsyncResourceHandler both at the bottom of the ResourceHandle chain, below the
ResourceLoader (Which talked directly to the RDH), and also talk to a private
RDH inner class through this sidechannel seems very unfortunate to me.

[yhirano, 2016/05/24 06:40:04]

What dependency are you concerned about? Even without this CL,
ResourceDispatcherHostImpl calls loader->GetRequestInfo() (in
CancelRequestsForContext) and AsyncResourceHandler calls GetRequestInfo() (such
as OnRequestRedirected). I didn't think I introduced a new dependency here.
Please correct me.

[yhirano, 2016/05/24 08:03:21]

PS24 removes the response body from ResourceRequestInfoImpl and uses
ResourceMessageFilter instead.

+  }
+
+  void OnRequestComplete(int request_id,
+                         const ResourceRequestCompletionStatus& status) {
+    int child_id = filter_->child_id();
+    ResourceLoader* loader = owner_->GetLoader(child_id, request_id);
+    mojom::URLLoaderClient* client = loader->client();
+
+    client->OnComplete(status);
+  }
+
+  ResourceDispatcherHostImpl* owner_;
+  ResourceMessageFilter* filter_ = nullptr;
+  std::map<mojom::URLLoader*, std::pair<int, std::unique_ptr<mojom::URLLoader>>>
+      uninitiated_url_loaders_;
+
+  DISALLOW_COPY_AND_ASSIGN(MojoHelper);
+};
+
 ResourceDispatcherHostImpl::ResourceDispatcherHostImpl()
     : save_file_manager_(new SaveFileManager()),
       request_id_(-1),
@@ -551,7 +633,8 @@ ResourceDispatcherHostImpl::ResourceDispatcherHostImpl()
       filter_(NULL),
       delegate_(NULL),
       allow_cross_origin_auth_prompt_(false),
-      cert_store_for_testing_(nullptr) {
+      cert_store_for_testing_(nullptr),
+      mojo_helper_(new MojoHelper(this)) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!g_resource_dispatcher_host);
   g_resource_dispatcher_host = this;
@@ -584,6 +667,7 @@ ResourceDispatcherHostImpl::ResourceDispatcherHostImpl()
 ResourceDispatcherHostImpl::~ResourceDispatcherHostImpl() {
   DCHECK(outstanding_requests_stats_map_.empty());
   DCHECK(g_resource_dispatcher_host);
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   g_resource_dispatcher_host = NULL;
 }
 
@@ -1177,6 +1261,7 @@ void ResourceDispatcherHostImpl::OnShutdown() {
 bool ResourceDispatcherHostImpl::OnMessageReceived(
     const IPC::Message& message,
     ResourceMessageFilter* filter) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   filter_ = filter;
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ResourceDispatcherHostImpl, message)
@@ -1218,6 +1303,16 @@ void ResourceDispatcherHostImpl::OnRequestResource(
     int routing_id,
     int request_id,
     const ResourceRequest& request_data) {
+  OnRequestResourceInternal(routing_id, request_id, request_data, nullptr,
+                            nullptr);
+}
+
+void ResourceDispatcherHostImpl::OnRequestResourceInternal(
+    int routing_id,
+    int request_id,
+    const ResourceRequest& request_data,
+    std::unique_ptr<mojom::URLLoader> loader,

[mmenke, 2016/05/23 17:34:53]

loader is not a good variable name, given that we also have
content::ResourceLoader.

[yhirano, 2016/05/24 06:40:03]

Done.

+    mojom::URLLoaderClientPtr client) {
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/477117 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
@@ -1238,7 +1333,8 @@ void ResourceDispatcherHostImpl::OnRequestResource(
                    request_data.render_frame_id,
                    request_data.url));
   }
-  BeginRequest(request_id, request_data, NULL, routing_id);
+  BeginRequest(request_id, request_data, NULL, routing_id, std::move(loader),
+               std::move(client));
 }
 
 // Begins a resource request with the given params on behalf of the specified
@@ -1368,7 +1464,9 @@ void ResourceDispatcherHostImpl::BeginRequest(
     int request_id,
     const ResourceRequest& request_data,
     IPC::Message* sync_result,  // only valid for sync
-    int route_id) {
+    int route_id,
+    std::unique_ptr<mojom::URLLoader> url_loader,
+    mojom::URLLoaderClientPtr client) {
   int process_type = filter_->process_type();
   int child_id = filter_->child_id();
 
@@ -1627,10 +1725,11 @@ void ResourceDispatcherHostImpl::BeginRequest(
 
   std::unique_ptr<ResourceHandler> handler(CreateResourceHandler(
       new_request.get(), request_data, sync_result, route_id, process_type,
-      child_id, resource_context));
+      child_id, resource_context, client != nullptr));
 
   if (handler)
-    BeginRequestInternal(std::move(new_request), std::move(handler));
+    BeginRequestInternal(std::move(new_request), std::move(handler),
+                         std::move(url_loader), std::move(client));
 }
 
 std::unique_ptr<ResourceHandler>
@@ -1641,7 +1740,8 @@ ResourceDispatcherHostImpl::CreateResourceHandler(
     int route_id,
     int process_type,
     int child_id,
-    ResourceContext* resource_context) {
+    ResourceContext* resource_context,
+    bool using_mojo) {
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/456331 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
@@ -1649,6 +1749,7 @@ ResourceDispatcherHostImpl::CreateResourceHandler(
   // Construct the IPC resource handler.
   std::unique_ptr<ResourceHandler> handler;
   if (sync_result) {
+    DCHECK(!using_mojo);
     // download_to_file is not supported for synchronous requests.
     if (request_data.download_to_file) {
       bad_message::ReceivedBadMessage(filter_, bad_message::RDH_BAD_DOWNLOAD);
@@ -1657,7 +1758,7 @@ ResourceDispatcherHostImpl::CreateResourceHandler(
 
     handler.reset(new SyncResourceHandler(request, sync_result, this));
   } else {
-    handler.reset(new AsyncResourceHandler(request, this));
+    handler.reset(new AsyncResourceHandler(request, this, using_mojo));
 
     // The RedirectToFileResourceHandler depends on being next in the chain.
     if (request_data.download_to_file) {
@@ -2063,6 +2164,11 @@ void ResourceDispatcherHostImpl::CancelRequestsForRoute(
       CancelBlockedRequestsForRoute(route_id);
     }
   }
+
+  // Uninitiated URLLoader has no routing ID, so it should be deleted only when
+  // cancel_all_routes is specified.
+  if (cancel_all_routes)
+    mojo_helper_->CancelUninitiatedLoaders(child_id);
 }
 
 // Cancels the request and removes it from the list.
@@ -2350,6 +2456,36 @@ void ResourceDispatcherHostImpl::EnableStaleWhileRevalidateForTesting() {
     async_revalidation_manager_.reset(new AsyncRevalidationManager);
 }
 
+void ResourceDispatcherHostImpl::OnRequestResourceWithMojo(
+    int routing_id,
+    int request_id,
+    const ResourceRequest& request,
+    std::unique_ptr<mojom::URLLoader> loader,
+    mojom::URLLoaderClientPtr client,
+    ResourceMessageFilter* filter) {
+  filter_ = filter;
+  OnRequestResourceInternal(routing_id, request_id, request, std::move(loader),
+                            std::move(client));
+  filter_ = nullptr;
+}
+
+bool ResourceDispatcherHostImpl::SendWithMojoIfPossible(
+    const IPC::Message& message,
+    ResourceMessageFilter* filter) {
+  return mojo_helper_->Send(message, filter);
+}
+
+void ResourceDispatcherHostImpl::AddUninitiatedURLLoader(
+    int child_id,
+    std::unique_ptr<mojom::URLLoader> loader) {
+  mojo_helper_->AddUninitiatedURLLoader(child_id, std::move(loader));
+}
+
+std::unique_ptr<mojom::URLLoader>
+ResourceDispatcherHostImpl::TakeUninitiatedURLLoader(mojom::URLLoader* loader) {
+  return mojo_helper_->TakeUninitiatedURLLoader(loader);
+}
+
 // static
 int ResourceDispatcherHostImpl::CalculateApproximateMemoryCost(
     net::URLRequest* request) {
@@ -2368,7 +2504,9 @@ int ResourceDispatcherHostImpl::CalculateApproximateMemoryCost(
 
 void ResourceDispatcherHostImpl::BeginRequestInternal(
     std::unique_ptr<net::URLRequest> request,
-    std::unique_ptr<ResourceHandler> handler) {
+    std::unique_ptr<ResourceHandler> handler,
+    std::unique_ptr<mojom::URLLoader> url_loader,
+    mojom::URLLoaderClientPtr client) {
   DCHECK(!request->is_pending());
   ResourceRequestInfoImpl* info =
       ResourceRequestInfoImpl::ForRequest(request.get());
@@ -2404,8 +2542,9 @@ void ResourceDispatcherHostImpl::BeginRequestInternal(
     return;
   }
 
-  std::unique_ptr<ResourceLoader> loader(new ResourceLoader(
-      std::move(request), std::move(handler), GetCertStore(), this));
+  std::unique_ptr<ResourceLoader> loader(
+      new ResourceLoader(std::move(request), std::move(handler), GetCertStore(),
+                         std::move(url_loader), std::move(client), this));
 
   GlobalFrameRoutingId id(info->GetChildID(), info->GetRenderFrameID());
   BlockedLoadersMap::const_iterator iter = blocked_loaders_map_.find(id);