Refactor the guts of ResourceDispatcherHostImpl into a new class named

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"
@@ skipping 29 matching lines @@
     int render_process_host_id,
     int render_view_id,
     ResourceDispatcherHostImpl* rdh)
     : LayeredResourceHandler(next_handler.Pass()),
       render_process_host_id_(render_process_host_id),
       render_view_id_(render_view_id),
       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) {
 }
 
 CrossSiteResourceHandler::~CrossSiteResourceHandler() {
 }
 
 bool CrossSiteResourceHandler::OnRequestRedirected(
     int request_id,
@@ skipping 103 matching lines @@
   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)) {
-      rdh_->CancelRequest(render_process_host_id_, request_id_, false);
+      controller()->Cancel();
     } else if (!defer) {
       // Unpause the request to resume reading.  Any further reads will be
       // directed toward the new renderer.
-      rdh_->ResumeDeferredRequest(render_process_host_id_, request_id_);
+      ResumeIfDeferred();
     }
   }
 
   // Remove ourselves from the ExtraRequestInfo.
   ResourceRequestInfoImpl* info =
       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_) {
-    next_handler_->OnResponseCompleted(request_id_, completed_status_,
-                                       completed_security_info_);
-    // TODO(darin): OnResponseCompleted can return false to defer
-    // RemovePendingRequest.
-    rdh_->RemovePendingRequest(render_process_host_id_, request_id_);
+    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);
   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.
-    *defer = true;
+    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.
 
   // Tell the contents responsible for this request that a cross-site response
   // is starting, so that it can tell its old renderer to run its onunload
   // handler now.  We will wait to hear the corresponding ClosePage_ACK.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
           &OnCrossSiteResponseHelper,
           render_process_host_id_,
           render_view_id_,
           request_id));
 
   // TODO(creis): If the above call should fail, then we need to notify the IO
   // thread to proceed anyway, using ResourceDispatcherHost::OnClosePageACK.
 }
 
+void CrossSiteResourceHandler::ResumeIfDeferred() {
+  if (did_defer_) {
+    did_defer_ = false;
+    controller()->Resume();
+  }
+}
+
 }  // namespace content