Navigation transitions: Plumb data from the outgoing renderer to the incoming renderer

content/browser/loader/cross_site_resource_handler.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.
 
 #include "content/browser/loader/cross_site_resource_handler.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 70 matching lines @@
   } else if (leak_requests_for_testing_ && cross_site_transferring_request) {
     // Some unit tests expect requests to be leaked in this case, so they can
     // pass them along manually.
     cross_site_transferring_request->ReleaseRequest();
   }
 }
 
 void OnDeferredAfterResponseStartedHelper(
     const GlobalRequestID& global_request_id,
     int render_frame_id,
-    const scoped_refptr<net::HttpResponseHeaders>& headers,
-    const GURL& url) {
+    const TransitionLayerData& transition_data) {
   RenderFrameHostImpl* rfh =
       RenderFrameHostImpl::FromID(global_request_id.child_id, render_frame_id);
   if (rfh)
-    rfh->OnDeferredAfterResponseStarted(global_request_id, headers, url);
+    rfh->OnDeferredAfterResponseStarted(global_request_id, transition_data);
 }
 
 bool CheckNavigationPolicyOnUI(GURL url, int process_id, int render_frame_id) {
   RenderFrameHostImpl* rfh =
       RenderFrameHostImpl::FromID(process_id, render_frame_id);
   if (!rfh)
     return false;
 
   // TODO(nasko): This check is very simplistic and is used temporarily only
   // for --site-per-process. It should be updated to match the check performed
@@ skipping 39 matching lines @@
     ResourceResponse* response,
     bool* defer) {
   response_ = response;
   has_started_response_ = true;
 
   // Store this handler on the ExtraRequestInfo, so that RDH can call our
   // ResumeResponse method when we are ready to resume.
   ResourceRequestInfoImpl* info = GetRequestInfo();
   info->set_cross_site_handler(this);
 
+  TransitionLayerData transition_data;
   bool is_navigation_transition =
       TransitionRequestManager::GetInstance()->HasPendingTransitionRequest(
-          info->GetChildID(), info->GetRenderFrameID());
+          info->GetChildID(), info->GetRenderFrameID(), request()->url(),
+          &transition_data);
 
-  if (is_navigation_transition)
-    return OnNavigationTransitionResponseStarted(response, defer);
-  else
+  if (is_navigation_transition) {
+    if (response_)
+      transition_data.response_headers = response_->head.headers;
+    transition_data.request_url = request()->url();
+
+    return OnNavigationTransitionResponseStarted(response, defer,
+                                                 transition_data);
+  } else {
     return OnNormalResponseStarted(response, defer);
+  }
 }
 
 bool CrossSiteResourceHandler::OnNormalResponseStarted(
     ResourceResponse* response,
     bool* defer) {
   // At this point, we know that the response is safe to send back to the
   // renderer: it is not a download, and it has passed the SSL and safe
   // browsing checks.
   // We should not have already started the transition before now.
   DCHECK(!in_cross_site_transition_);
@@ skipping 50 matching lines @@
   StartCrossSiteTransition(response, should_transfer);
 
   // Defer loading until after the onunload event handler has run.
   *defer = true;
   OnDidDefer();
   return true;
 }
 
 bool CrossSiteResourceHandler::OnNavigationTransitionResponseStarted(
     ResourceResponse* response,
-    bool* defer) {
+    bool* defer,
+    const TransitionLayerData& transition_data) {
   ResourceRequestInfoImpl* info = GetRequestInfo();
 
-  scoped_refptr<net::HttpResponseHeaders> headers;
-  if (response_)
-    headers = response_->head.headers;
-  GURL url = request()->url();
-
   GlobalRequestID global_id(info->GetChildID(), info->GetRequestID());
   int render_frame_id = info->GetRenderFrameID();
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
           &OnDeferredAfterResponseStartedHelper,
           global_id,
           render_frame_id,
-          headers,
-          url));
+          transition_data));
 
   *defer = true;
   OnDidDefer();
   return true;
 }
 
 void CrossSiteResourceHandler::ResumeResponseDeferredAtStart(int request_id) {
   bool defer = false;
   if (!OnNormalResponseStarted(response_, &defer)) {
     controller()->Cancel();
@@ skipping 176 matching lines @@
     controller()->Resume();
   }
 }
 
 void CrossSiteResourceHandler::OnDidDefer() {
   did_defer_ = true;
   request()->LogBlockedBy("CrossSiteResourceHandler");
 }
 
 }  // namespace content