Use mojo for Chrome Loading, Part 1

content/browser/loader/resource_dispatcher_host_impl.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 
 #include <stddef.h>
 
@@ skipping 520 matching lines @@
       static_cast<RenderFrameHostImpl*>(render_frame_host)
           ->GetGlobalFrameRoutingId(),
       base::Bind(&ResourceDispatcherHostImpl::OnRenderFrameDeleted));
 }
 
 // static
 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),
       is_shutdown_(false),
       num_in_flight_requests_(0),
       max_num_in_flight_requests_(base::SharedMemory::GetHandleLimit()),
       max_num_in_flight_requests_per_process_(static_cast<int>(
           max_num_in_flight_requests_ * kMaxRequestsPerProcessRatio)),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
       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;
 
   GetContentClient()->browser()->ResourceDispatcherHostCreated();
 
   ANNOTATE_BENIGN_RACE(
       &last_user_gesture_time_,
       "We don't care about the precise value, see http://crbug.com/92889");
 
@@ skipping 12 matching lines @@
   // navigation becomes the default. crbug.com/561610
   if (!IsBrowserSideNavigationEnabled() &&
       base::FeatureList::IsEnabled(features::kStaleWhileRevalidate)) {
     async_revalidation_manager_.reset(new AsyncRevalidationManager);
   }
 }
 
 ResourceDispatcherHostImpl::~ResourceDispatcherHostImpl() {
   DCHECK(outstanding_requests_stats_map_.empty());
   DCHECK(g_resource_dispatcher_host);
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   g_resource_dispatcher_host = NULL;
 }
 
 // static
 ResourceDispatcherHostImpl* ResourceDispatcherHostImpl::Get() {
   return g_resource_dispatcher_host;
 }
 
 // static
 void ResourceDispatcherHostImpl::ResumeBlockedRequestsForRouteFromUI(
@@ skipping 573 matching lines @@
   for (const auto& routing_id : ids) {
     CancelBlockedRequestsForRoute(routing_id);
   }
 
   scheduler_.reset();
 }
 
 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)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_RequestResource, OnRequestResource)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ResourceHostMsg_SyncLoad, OnSyncLoad)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_ReleaseDownloadedFile,
                         OnReleaseDownloadedFile)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_DataDownloaded_ACK, OnDataDownloadedACK)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_CancelRequest, OnCancelRequest)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_DidChangePriority, OnDidChangePriority)
@@ skipping 21 matching lines @@
   }
 
   filter_ = NULL;
   return handled;
 }
 
 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(
           "477117 ResourceDispatcherHostImpl::OnRequestResource"));
   // When logging time-to-network only care about main frame and non-transfer
   // navigations.
   // PlzNavigate: this log happens from NavigationRequest::OnRequestStarted
   // instead.
   if (request_data.resource_type == RESOURCE_TYPE_MAIN_FRAME &&
       request_data.transferred_request_request_id == -1 &&
       !IsBrowserSideNavigationEnabled()) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&LogResourceRequestTimeOnUI,
                    TimeTicks::Now(),
                    filter_->child_id(),
                    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
 // child process.  Responses will be dispatched through the given receiver. The
 // process ID is used to lookup WebContentsImpl from routing_id's in the case of
 // a request from a renderer.  request_context is the cookie/cache context to be
 // used for this request.
 //
 // If sync_result is non-null, then a SyncLoad reply will be generated, else
 // a normal asynchronous set of response messages will be generated.
@@ skipping 109 matching lines @@
   }
 
   // We should have a CrossSiteResourceHandler to finish the transfer.
   DCHECK(info->cross_site_handler());
 }
 
 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();
 
   // Reject request id that's currently in use.
   if (IsRequestIDInUse(GlobalRequestID(child_id, request_id))) {
     bad_message::ReceivedBadMessage(filter_,
                                     bad_message::RDH_INVALID_REQUEST_ID);
     return;
   }
 
@@ skipping 238 matching lines @@
   }
 
   // Have the appcache associate its extra info with the request.
   AppCacheInterceptor::SetExtraRequestInfo(
       new_request.get(), filter_->appcache_service(), child_id,
       request_data.appcache_host_id, request_data.resource_type,
       request_data.should_reset_appcache);
 
   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>
 ResourceDispatcherHostImpl::CreateResourceHandler(
     net::URLRequest* request,
     const ResourceRequest& request_data,
     IPC::Message* sync_result,
     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(
           "456331 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);
       return std::unique_ptr<ResourceHandler>();
     }
 
     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) {
       handler.reset(
           new RedirectToFileResourceHandler(std::move(handler), request));
     }
   }
 
   // Prefetches and <a ping> requests outlive their child process.
   if (!sync_result && IsDetachableResourceType(request_data.resource_type)) {
@@ skipping 385 matching lines @@
     // blocked_loaders_map_, as blocking requests modifies the map.
     std::set<GlobalFrameRoutingId> routing_ids;
     for (const auto& blocked_loaders : blocked_loaders_map_) {
       if (blocked_loaders.first.child_id == child_id)
         routing_ids.insert(blocked_loaders.first);
     }
     for (const GlobalFrameRoutingId& route_id : routing_ids) {
       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.
 void ResourceDispatcherHostImpl::RemovePendingRequest(int child_id,
                                                       int request_id) {
   LoaderMap::iterator i = pending_loaders_.find(
       GlobalRequestID(child_id, request_id));
   if (i == pending_loaders_.end()) {
     NOTREACHED() << "Trying to remove a request that's not here";
     return;
@@ skipping 267 matching lines @@
                           std::move(handler));
 
   BeginRequestInternal(std::move(new_request), std::move(handler));
 }
 
 void ResourceDispatcherHostImpl::EnableStaleWhileRevalidateForTesting() {
   if (!async_revalidation_manager_)
     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) {
   // The following fields should be a minor size contribution (experimentally
   // on the order of 100). However since they are variable length, it could
   // in theory be a sizeable contribution.
   int strings_cost = request->extra_request_headers().ToString().size() +
                      request->original_url().spec().size() +
                      request->referrer().size() +
                      request->method().size();
 
   // Note that this expression will typically be dominated by:
   // |kAvgBytesPerOutstandingRequest|.
   return kAvgBytesPerOutstandingRequest + strings_cost;
 }
 
 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());
 
   if ((TimeTicks::Now() - last_user_gesture_time_) <
       TimeDelta::FromMilliseconds(kUserGestureWindowMs)) {
     request->SetLoadFlags(
         request->load_flags() | net::LOAD_MAYBE_USER_GESTURE);
   }
 
@@ skipping 15 matching lines @@
       NOTREACHED();
     }
 
     IncrementOutstandingRequestsMemory(-1, *info);
 
     // A ResourceHandler must not outlive its associated URLRequest.
     handler.reset();
     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);
   if (iter != blocked_loaders_map_.end()) {
     // The request should be blocked.
     iter->second->push_back(std::move(loader));
     return;
   }
 
   StartLoading(info, std::move(loader));
@@ skipping 270 matching lines @@
   ssl.cert_id = GetCertStore()->StoreCert(ssl_info.cert.get(), child_id);
   response->head.security_info = SerializeSecurityInfo(ssl);
 }
 
 CertStore* ResourceDispatcherHostImpl::GetCertStore() {
   return cert_store_for_testing_ ? cert_store_for_testing_
                                  : CertStore::GetInstance();
 }
 
 }  // namespace content