Implement transfer navigation with mojo

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 1182 matching lines @@
     } else {
       handler->CompleteCrossSiteTransfer(
           child_id, request_data.service_worker_provider_id);
     }
   }
 }
 
 void ResourceDispatcherHostImpl::CompleteTransfer(
     int request_id,
     const ResourceRequest& request_data,
-    int route_id) {
+    int route_id,
+    mojom::URLLoaderAssociatedRequest mojo_request,
+    mojom::URLLoaderClientAssociatedPtr url_loader_client) {
   // Caller should ensure that |request_data| is associated with a transfer.
   DCHECK(request_data.transferred_request_child_id != -1 ||
          request_data.transferred_request_request_id != -1);
 
   bool is_navigational_request =
       request_data.resource_type == RESOURCE_TYPE_MAIN_FRAME ||
       request_data.resource_type == RESOURCE_TYPE_SUB_FRAME;
   if (!is_navigational_request) {
     // Transfers apply only to navigational requests - the renderer seems to
     // have sent bogus IPC data.
@@ skipping 24 matching lines @@
     base::debug::Alias(pending_loader);
     bad_message::ReceivedBadMessage(filter_,
                                     bad_message::RDH_REQUEST_NOT_TRANSFERRING);
     return;
   }
 
   // If the request is transferring to a new process, we can update our
   // state and let it resume with its existing ResourceHandlers.
   UpdateRequestForTransfer(filter_->child_id(), route_id, request_id,
                            request_data, it);
-  pending_loader->CompleteTransfer();
+  pending_loader->CompleteTransfer(std::move(mojo_request),
+                                   std::move(url_loader_client));
 }
 
 void ResourceDispatcherHostImpl::BeginRequest(
     int request_id,
     const ResourceRequest& request_data,
     const SyncLoadResultCallback& sync_result_handler,  // only valid for sync
     int route_id,
     mojom::URLLoaderAssociatedRequest mojo_request,
     mojom::URLLoaderClientAssociatedPtr url_loader_client) {
   int process_type = filter_->process_type();
@@ skipping 28 matching lines @@
   // If we crash here, figure out what URL the renderer was requesting.
   // http://crbug.com/91398
   char url_buf[128];
   base::strlcpy(url_buf, request_data.url.spec().c_str(), arraysize(url_buf));
   base::debug::Alias(url_buf);
 
   // If the request that's coming in is being transferred from another process,
   // we want to reuse and resume the old loader rather than start a new one.
   if (request_data.transferred_request_child_id != -1 ||
       request_data.transferred_request_request_id != -1) {
-    // TODO(yhirano): Make mojo work for this case.
-    DCHECK(!url_loader_client);
-
-    CompleteTransfer(request_id, request_data, route_id);
+    CompleteTransfer(request_id, request_data, route_id,
+                     std::move(mojo_request), std::move(url_loader_client));
     return;
   }
 
   ResourceContext* resource_context = NULL;
   net::URLRequestContext* request_context = NULL;
   filter_->GetContexts(request_data.resource_type, &resource_context,
                        &request_context);
 
   // Parse the headers before calling ShouldServiceRequest, so that they are
   // available to be validated.
@@ skipping 280 matching lines @@
 ResourceDispatcherHostImpl::CreateResourceHandler(
     net::URLRequest* request,
     const ResourceRequest& request_data,
     const SyncLoadResultCallback& sync_result_handler,
     int route_id,
     int process_type,
     int child_id,
     ResourceContext* resource_context,
     mojom::URLLoaderAssociatedRequest mojo_request,
     mojom::URLLoaderClientAssociatedPtr url_loader_client) {
+  TransferCallback transfer_callback;
   // 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_handler) {
     // 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>();
     }
 
     DCHECK(!mojo_request.is_pending());
     DCHECK(!url_loader_client);
     handler.reset(new SyncResourceHandler(request, sync_result_handler, this));
   } else {
     if (mojo_request.is_pending()) {
-      handler.reset(new MojoAsyncResourceHandler(request, this,
-                                                 std::move(mojo_request),
-                                                 std::move(url_loader_client)));
+      auto mojo_handler = base::MakeUnique<MojoAsyncResourceHandler>(
+          request, this, std::move(mojo_request), std::move(url_loader_client));
+      transfer_callback = mojo_handler->GetTransferCallback();
+      handler = std::move(mojo_handler);
     } else {
       handler.reset(new AsyncResourceHandler(request, this));
     }
 
     // The RedirectToFileResourceHandler depends on being next in the chain.
     if (request_data.download_to_file) {
       handler.reset(
           new RedirectToFileResourceHandler(std::move(handler), request));
     }
   }
@@ skipping 10 matching lines @@
             base::TimeDelta::FromMilliseconds(kDefaultDetachableCancelDelayMs),
             std::move(handler));
     if (start_detached)
       detachable_handler->Detach();
     handler = std::move(detachable_handler);
   }
 
   return AddStandardHandlers(
       request, request_data.resource_type, resource_context,
       request_data.fetch_request_context_type, filter_->appcache_service(),
-      child_id, route_id, std::move(handler));
+      child_id, route_id, std::move(handler), transfer_callback);
 }
 
 std::unique_ptr<ResourceHandler>
 ResourceDispatcherHostImpl::AddStandardHandlers(
     net::URLRequest* request,
     ResourceType resource_type,
     ResourceContext* resource_context,
     RequestContextType fetch_request_context_type,
     AppCacheService* appcache_service,
     int child_id,
     int route_id,
-    std::unique_ptr<ResourceHandler> handler) {
+    std::unique_ptr<ResourceHandler> handler,
+    TransferCallback transfer_callback) {
   // PlzNavigate: do not add ResourceThrottles for main resource requests from
   // the renderer.  Decisions about the navigation should have been done in the
   // initial request.
   bool is_renderer =
       filter_ ? (filter_->process_type() == PROCESS_TYPE_RENDERER) : false;
   if (is_renderer && IsBrowserSideNavigationEnabled() &&
       IsResourceTypeFrame(resource_type)) {
     DCHECK(request->url().SchemeIs(url::kBlobScheme));
     return handler;
   }
 
   // The InterceptingResourceHandler will replace its next handler with an
   // appropriate one based on the MIME type of the response if needed. It
   // should be placed at the end of the chain, just before |handler|.
   handler.reset(new InterceptingResourceHandler(std::move(handler), request));
   InterceptingResourceHandler* intercepting_handler =
       static_cast<InterceptingResourceHandler*>(handler.get());
 
   ScopedVector<ResourceThrottle> throttles;
 
   // Add a NavigationResourceThrottle for navigations.
   // PlzNavigate: the throttle is unnecessary as communication with the UI
   // thread is handled by the NavigationURLloader.
   if (!IsBrowserSideNavigationEnabled() && IsResourceTypeFrame(resource_type)) {
     throttles.push_back(new NavigationResourceThrottle(
-        request, delegate_, fetch_request_context_type));
+        request, delegate_, fetch_request_context_type, transfer_callback));
   }
 
   if (delegate_) {
     delegate_->RequestBeginning(request,
                                 resource_context,
                                 appcache_service,
                                 resource_type,
                                 &throttles);
   }
 
@@ skipping 155 matching lines @@
 }
 
 void ResourceDispatcherHostImpl::OnRenderViewHostSetIsLoading(int child_id,
                                                               int route_id,
                                                               bool is_loading) {
   scheduler_->OnLoadingStateChanged(child_id, route_id, !is_loading);
 }
 
 void ResourceDispatcherHostImpl::MarkAsTransferredNavigation(
     const GlobalRequestID& id,
-    const base::Closure& on_transfer_complete_callback) {
+    const TransferCallback& on_transfer_complete_callback) {
   GetLoader(id)->MarkAsTransferring(on_transfer_complete_callback);
 }
 
 void ResourceDispatcherHostImpl::CancelTransferringNavigation(
     const GlobalRequestID& id) {
   // Request should still exist and be in the middle of a transfer.
   DCHECK(IsTransferredNavigation(id));
   RemovePendingRequest(id.child_id, id.request_id);
 }
 
 void ResourceDispatcherHostImpl::ResumeDeferredNavigation(
     const GlobalRequestID& id) {
   ResourceLoader* loader = GetLoader(id);
   // The response we were meant to resume could have already been canceled.
   if (loader)
-    loader->CompleteTransfer();
+    loader->CompleteTransfer(nullptr, nullptr);
 }
 
 // The object died, so cancel and detach all requests associated with it except
 // for downloads and detachable resources, which belong to the browser process
 // even if initiated via a renderer.
 void ResourceDispatcherHostImpl::CancelRequestsForProcess(int child_id) {
   CancelRequestsForRoute(
       GlobalFrameRoutingId(child_id, MSG_ROUTING_NONE /* cancel all */));
   registered_temp_files_.erase(child_id);
 }
@@ skipping 363 matching lines @@
 
   // TODO(davidben): Pass in the appropriate appcache_service. Also fix the
   // dependency on child_id/route_id. Those are used by the ResourceScheduler;
   // currently it's a no-op.
   handler =
       AddStandardHandlers(new_request.get(), resource_type, resource_context,
                           info.begin_params.request_context_type,
                           nullptr,  // appcache_service
                           -1,       // child_id
                           -1,       // route_id
-                          std::move(handler));
+                          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::SetLoaderDelegate(
@@ skipping 522 matching lines @@
                                  &throttles);
     if (!throttles.empty()) {
       handler.reset(new ThrottlingResourceHandler(std::move(handler), request,
                                                   std::move(throttles)));
     }
   }
   return handler;
 }
 
 }  // namespace content