Balance defers with Resume.

content/browser/renderer_host/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 <string>
 
 #include "content/browser/renderer_host/cross_site_resource_handler.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
-#include "content/browser/renderer_host/resource_dispatcher_host_impl.h"
 #include "content/browser/renderer_host/resource_request_info_impl.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/global_request_id.h"
+#include "content/public/browser/resource_controller.h"
 #include "content/public/common/resource_response.h"
-#include "net/base/io_buffer.h"
 #include "net/http/http_response_headers.h"
 
 namespace content {
 
 namespace {
 
 void OnCrossSiteResponseHelper(int render_process_id,
                                int render_view_id,
                                int request_id) {
   RenderViewHostImpl* rvh = RenderViewHostImpl::FromID(render_process_id,
                                                        render_view_id);
   if (rvh && rvh->GetDelegate()->GetRendererManagementDelegate()) {
     rvh->GetDelegate()->GetRendererManagementDelegate()->OnCrossSiteResponse(
         render_process_id, request_id);
   }
 }
 
 }  // namespace
 
 CrossSiteResourceHandler::CrossSiteResourceHandler(
     scoped_ptr<ResourceHandler> next_handler,
     int render_process_host_id,
     int render_view_id,
-    ResourceDispatcherHostImpl* rdh)
+    net::URLRequest* request)
     : LayeredResourceHandler(next_handler.Pass()),
       render_process_host_id_(render_process_host_id),
       render_view_id_(render_view_id),
+      request_(request),
       has_started_response_(false),
       in_cross_site_transition_(false),
       request_id_(-1),
       completed_during_transition_(false),
       did_defer_(false),
       completed_status_(),
-      response_(NULL),
-      rdh_(rdh) {
+      response_(NULL) {
 }
 
 CrossSiteResourceHandler::~CrossSiteResourceHandler() {
 }
 
 bool CrossSiteResourceHandler::OnRequestRedirected(
     int request_id,
     const GURL& new_url,
     ResourceResponse* response,
     bool* defer) {
   // We should not have started the transition before being redirected.
   DCHECK(!in_cross_site_transition_);
   return next_handler_->OnRequestRedirected(
       request_id, new_url, response, defer);
 }
 
 bool CrossSiteResourceHandler::OnResponseStarted(
     int request_id,
     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_);
   has_started_response_ = true;
 
-  // Look up the request and associated info.
-  GlobalRequestID global_id(render_process_host_id_, request_id);
-  net::URLRequest* request = rdh_->GetURLRequest(global_id);
-  if (!request) {
-    DLOG(WARNING) << "Request wasn't found";
-    return false;
-  }
-  ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
+  ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request_);
 
   // If this is a download, just pass the response through without doing a
   // cross-site check.  The renderer will see it is a download and abort the
   // request.
   //
   // Similarly, HTTP 204 (No Content) responses leave us showing the previous
   // page.  We should allow the navigation to finish without running the unload
   // handler or swapping in the pending RenderViewHost.
   //
   // In both cases, the pending RenderViewHost will stick around until the next
   // cross-site navigation, since we are unable to tell when to destroy it.
   // See RenderViewHostManager::RendererAbortedProvisionalLoad.
   if (info->is_download() ||
       (response->headers && response->headers->response_code() == 204)) {
     return next_handler_->OnResponseStarted(request_id, response, defer);
   }
 
   // Tell the renderer to run the onunload event handler, and wait for the
   // reply.
-  StartCrossSiteTransition(request_id, response, global_id, defer);
+  StartCrossSiteTransition(request_id, response, defer);
   return true;
 }
 
 bool CrossSiteResourceHandler::OnReadCompleted(int request_id,
                                                int* bytes_read,
                                                bool* defer) {
   if (!in_cross_site_transition_) {
     return next_handler_->OnReadCompleted(request_id, bytes_read, defer);
   }
   return true;
 }
 
 bool CrossSiteResourceHandler::OnResponseCompleted(
     int request_id,
     const net::URLRequestStatus& status,
     const std::string& security_info) {
   if (!in_cross_site_transition_) {
     if (has_started_response_ ||
         status.status() != net::URLRequestStatus::FAILED) {
       // We've already completed the transition or we're canceling the request,
       // so just pass it through.
       return next_handler_->OnResponseCompleted(request_id, status,
                                                 security_info);
     }
 
     // An error occured, we should wait now for the cross-site transition,
     // so that the error message (e.g., 404) can be displayed to the user.
     // Also continue with the logic below to remember that we completed
     // during the cross-site transition.
-    GlobalRequestID global_id(render_process_host_id_, request_id);
     bool defer = false;
-    StartCrossSiteTransition(request_id, NULL, global_id, &defer);
+    StartCrossSiteTransition(request_id, NULL, &defer);
     DCHECK(!defer);  // Since !has_started_response_.
   }
 
   // We have to buffer the call until after the transition completes.
   completed_during_transition_ = true;
   completed_status_ = status;
   completed_security_info_ = security_info;
 
   // Return false to tell RDH not to notify the world or clean up the
   // pending request.  We will do so in ResumeResponse.
   return false;
 }
 
 // We can now send the response to the new renderer, which will cause
 // WebContentsImpl to swap in the new renderer and destroy the old one.
 void CrossSiteResourceHandler::ResumeResponse() {
   DCHECK(request_id_ != -1);
   DCHECK(in_cross_site_transition_);
   in_cross_site_transition_ = false;
 
-  // Find the request for this response.
-  GlobalRequestID global_id(render_process_host_id_, request_id_);
-  net::URLRequest* request = rdh_->GetURLRequest(global_id);
-  if (!request) {
-    DLOG(WARNING) << "Resuming a request that wasn't found";
-    return;
-  }
-
   if (has_started_response_) {
     // Send OnResponseStarted to the new renderer.
     DCHECK(response_);
     bool defer = false;
     if (!next_handler_->OnResponseStarted(request_id_, response_, &defer)) {
       controller()->Cancel();
     } else if (!defer) {
       // Unpause the request to resume reading.  Any further reads will be
       // directed toward the new renderer.
       ResumeIfDeferred();
     }
   }
 
   // Remove ourselves from the ExtraRequestInfo.
   ResourceRequestInfoImpl* info =
-      ResourceRequestInfoImpl::ForRequest(request);
+      ResourceRequestInfoImpl::ForRequest(request_);
   info->set_cross_site_handler(NULL);
 
   // If the response completed during the transition, notify the next
   // event handler.
   if (completed_during_transition_) {
     if (next_handler_->OnResponseCompleted(request_id_, completed_status_,
                                            completed_security_info_)) {
       ResumeIfDeferred();
     }
   }
 }
 
 // Prepare to render the cross-site response in a new RenderViewHost, by
 // telling the old RenderViewHost to run its onunload handler.
 void CrossSiteResourceHandler::StartCrossSiteTransition(
     int request_id,
     ResourceResponse* response,
-    const GlobalRequestID& global_id,
     bool* defer) {
   in_cross_site_transition_ = true;
   request_id_ = request_id;
   response_ = response;
 
   // Store this handler on the ExtraRequestInfo, so that RDH can call our
   // ResumeResponse method when the close ACK is received.
-  net::URLRequest* request = rdh_->GetURLRequest(global_id);
-  if (!request) {
-    DLOG(WARNING) << "Cross site response for a request that wasn't found";
-    return;
-  }
   ResourceRequestInfoImpl* info =
-      ResourceRequestInfoImpl::ForRequest(request);
+      ResourceRequestInfoImpl::ForRequest(request_);
   info->set_cross_site_handler(this);
 
   if (has_started_response_) {
     // Defer the request until the old renderer is finished and the new
     // renderer is ready.
     did_defer_ = *defer = true;
   }
   // If our OnResponseStarted wasn't called, then we're being called by
   // OnResponseCompleted after a failure.  We don't need to pause, because
   // there will be no reads.
@@ skipping 15 matching lines @@
 }
 
 void CrossSiteResourceHandler::ResumeIfDeferred() {
   if (did_defer_) {
     did_defer_ = false;
     controller()->Resume();
   }
 }
 
 }  // namespace content