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 566 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) {
+  std::unique_ptr<mojom::URLLoader> loader =
+      std::move(mojo_loader_for_next_load_request_);
+  mojom::URLLoaderClientPtr client =
+      std::move(mojo_loader_client_for_next_load_request_);
+
   // 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 100 matching lines @@
   ResourceLoader* loader = GetLoader(filter_->child_id(), request_id);
   // The request may go away before processing this message, so |loader| can
   // legitimately be null.
   if (!loader)
     return;
 
   scheduler_->ReprioritizeRequest(loader->request(), new_priority,
                                   intra_priority_value);
 }
 
+void ResourceDispatcherHostImpl::OnReceivedResponseForMojo(
+    int request_id,
+    const ResourceResponseHead& head) {
+  int child_id = filter_->child_id();
+  ResourceLoader* loader = GetLoader(child_id, request_id);
+  mojom::URLLoaderClient* client = loader->client();
+  client->OnReceiveResponse(head, loader->GetRequestInfo()->TakeBodyReader());
+}
+
+void ResourceDispatcherHostImpl::OnRequestCompleteForMojo(
+    int request_id,
+    const ResourceRequestCompletionStatus& status) {
+  int child_id = filter_->child_id();
+  ResourceLoader* loader = GetLoader(child_id, request_id);
+  DCHECK(loader);
+  mojom::URLLoaderClient* client = loader->client();
+  DCHECK(client);
+
+  client->OnComplete(status);
+}
+
 void ResourceDispatcherHostImpl::OnDataDownloadedACK(int request_id) {
   // TODO(michaeln): maybe throttle DataDownloaded messages
 }
 
 void ResourceDispatcherHostImpl::RegisterDownloadedTempFile(
     int child_id, int request_id, const base::FilePath& file_path) {
   scoped_refptr<ShareableFileReference> reference =
       ShareableFileReference::Get(file_path);
   DCHECK(reference.get());
 
@@ skipping 265 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) {
+    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;
+      }
+    }
+  }
 }
 
 // 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);
 }
 
+bool ResourceDispatcherHostImpl::SendWithMojoIfPossible(
+    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 = GetLoader(filter->child_id(), request_id);
+  if (!loader || !loader->client())
+    return false;
+
+  DCHECK(!filter_);
+  filter_ = filter;
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(ResourceDispatcherHostImpl, message)
+    IPC_MESSAGE_HANDLER(ResourceMsg_ReceivedResponse, OnReceivedResponseForMojo)
+    IPC_MESSAGE_HANDLER(ResourceMsg_RequestComplete, OnRequestCompleteForMojo)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+
+  filter_ = nullptr;
+  return handled;
+}
+
+void ResourceDispatcherHostImpl::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>
+ResourceDispatcherHostImpl::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 ResourceDispatcherHostImpl::SetMojoLoaderAndClientrForNextLoadRequest(
+    std::unique_ptr<mojom::URLLoader> loader,
+    mojom::URLLoaderClientPtr client) {
+  mojo_loader_for_next_load_request_ = std::move(loader);
+  mojo_loader_client_for_next_load_request_ = std::move(client);
+}
+
 // 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