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;
 }
 
+// This is a helper class consisting of mojo-related functionalities used in
+// ResourceDispatcherHostImpl.

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

This is confusing...Why is the filter calling into this method to pass messages
from AsyncResourceHandler?  Why isn't AsyncResourceHandler sending those
directly, via its mojo-thing, like it does for everything else?

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

Done.

+class ResourceDispatcherHostImpl::MojoHelper final {
+ public:
+  explicit MojoHelper(ResourceDispatcherHostImpl* owner) : owner_(owner) {}
+
+  // Sends |message| via mojo. Returns true if it sends the message.
+  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;
+  }
+
+  // Adds |loader| as an uninitiated loader.
+  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))));
+  }
+
+  // Takes and returns the uninitiated loader whose address equals to |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;
+  }
+
+  // Cancels all uninitiated loaders for |child_id|.
+  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);
+    loader->client()->OnReceiveResponse(head);
+  }
+
+  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 574 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> url_loader,
+    mojom::URLLoaderClientPtr url_loader_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(url_loader), std::move(url_loader_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 url_loader_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, url_loader_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(url_loader_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));

[mmenke, 2016/05/24 20:06:07]

Why doesn't the AsyncResourceHandler take ownership of the mojo stuff?  It's the
only class here that actually talks to mojo, and it should be the only class
sending mojo data.

(Eventually the sync one may need to as well, of course)

[mmenke, 2016/05/25 04:39:03]

Actually, can we just make a MojoResourceHandler, to replace the
AsyncResourceHandler, rather than have the AsyncResourceHandler have two paths? 
Then we'll work towards getting rid of the AsyncResourceHandler entirely.

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

Done.

 
     // 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> url_loader,
+    mojom::URLLoaderClientPtr url_loader_client,
+    ResourceMessageFilter* filter) {
+  filter_ = filter;
+  OnRequestResourceInternal(routing_id, request_id, request,
+                            std::move(url_loader),
+                            std::move(url_loader_client));
+  filter_ = nullptr;
+}
+
+bool ResourceDispatcherHostImpl::SendWithMojoIfPossible(
+    const IPC::Message& message,
+    ResourceMessageFilter* filter) {
+  return mojo_helper_->Send(message, filter);
+}
+
+void ResourceDispatcherHostImpl::OnStartLoadingResponseBodyWithMojo(
+    const GlobalRequestID& id,
+    mojo::ScopedDataPipeConsumerHandle response_body) {
+  ResourceLoader* loader = GetLoader(id);
+  if (!loader)
+    return;
+
+  loader->client()->OnStartLoadingResponseBody(std::move(response_body));
+}
+
+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 url_loader_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 16 matching lines @@
     }
 
     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::move(request), std::move(handler), GetCertStore(),
+      std::move(url_loader), std::move(url_loader_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