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 1101 matching lines @@
     }
   }
   return false;
 }
 
 void ResourceDispatcherHostImpl::UpdateRequestForTransfer(
     int child_id,
     int route_id,
     int request_id,
     const ResourceRequest& request_data,
-    LoaderMap::iterator iter) {
+    LoaderMap::iterator iter,
+    mojom::URLLoaderAssociatedRequest mojo_request,
+    mojom::URLLoaderClientAssociatedPtr url_loader_client) {
   ResourceRequestInfoImpl* info = iter->second->GetRequestInfo();
   GlobalFrameRoutingId old_routing_id(request_data.transferred_request_child_id,
                                       info->GetRenderFrameID());
   GlobalRequestID old_request_id(request_data.transferred_request_child_id,
                                  request_data.transferred_request_request_id);
   GlobalFrameRoutingId new_routing_id(child_id, request_data.render_frame_id);
   GlobalRequestID new_request_id(child_id, request_id);
 
   // Clear out data that depends on |info| before updating it.
   // We always need to move the memory stats to the new process.  In contrast,
   // stats.num_requests is only tracked for some requests (those that require
   // file descriptors for their shared memory buffer).
   IncrementOutstandingRequestsMemory(-1, *info);
   bool should_update_count = info->counted_as_in_flight_request();
   if (should_update_count)
     IncrementOutstandingRequestsCount(-1, info);
 
   DCHECK(pending_loaders_.find(old_request_id) == iter);
   std::unique_ptr<ResourceLoader> loader = std::move(iter->second);
   ResourceLoader* loader_ptr = loader.get();
   pending_loaders_.erase(iter);
 
   // ResourceHandlers should always get state related to the request from the
   // ResourceRequestInfo rather than caching it locally.  This lets us update
   // the info object when a transfer occurs.
   info->UpdateForTransfer(child_id, route_id, request_data.render_frame_id,
                           request_data.origin_pid, request_id,
-                          filter_->GetWeakPtr());
+                          filter_->GetWeakPtr(), std::move(mojo_request),
+                          std::move(url_loader_client));
 
   // Update maps that used the old IDs, if necessary.  Some transfers in tests
   // do not actually use a different ID, so not all maps need to be updated.
   pending_loaders_[new_request_id] = std::move(loader);
   IncrementOutstandingRequestsMemory(1, *info);
   if (should_update_count)
     IncrementOutstandingRequestsCount(1, info);
   if (old_routing_id != new_routing_id) {
     if (blocked_loaders_map_.find(old_routing_id) !=
             blocked_loaders_map_.end()) {
@@ skipping 29 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 23 matching lines @@
     // transferring loader on the browser side.
     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);
+                           request_data, it, std::move(mojo_request),
+                           std::move(url_loader_client));
   pending_loader->CompleteTransfer();
 }
 
 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) {
@@ skipping 29 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 1484 matching lines @@
                                  &throttles);
     if (!throttles.empty()) {
       handler.reset(new ThrottlingResourceHandler(std::move(handler), request,
                                                   std::move(throttles)));
     }
   }
   return handler;
 }
 
 }  // namespace content