Implement ResourceQueue, an object that makes it easy to delay starting

chrome/browser/renderer_host/cross_site_resource_handler.cc

 // Copyright (c) 2009 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 "chrome/browser/renderer_host/cross_site_resource_handler.h"
 
 #include "base/logging.h"
 #include "chrome/browser/chrome_thread.h"
+#include "chrome/browser/renderer_host/global_request_id.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_view_host_delegate.h"
+#include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host_request_info.h"
 #include "net/base/io_buffer.h"
 
 namespace {
 
 // Task to notify the TabContents that a cross-site response has begun, so that
 // TabContents can tell the old page to run its onunload handler.
 class CrossSiteNotifyTask : public Task {
  public:
   CrossSiteNotifyTask(int render_process_host_id,
@@ skipping 75 matching lines @@
 bool CrossSiteResourceHandler::OnResponseStarted(int request_id,
                                                  ResourceResponse* response) {
   // 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.
-  ResourceDispatcherHost::GlobalRequestID global_id(render_process_host_id_,
-                                                    request_id);
+  GlobalRequestID global_id(render_process_host_id_, request_id);
   URLRequest* request = rdh_->GetURLRequest(global_id);
   if (!request) {
     DLOG(WARNING) << "Request wasn't found";
     return false;
   }
   ResourceDispatcherHostRequestInfo* info =
       ResourceDispatcherHost::InfoForRequest(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
@@ skipping 45 matching lines @@
             ChromeThread::UI, FROM_HERE,
             new CancelPendingRenderViewTask(
                 render_process_host_id_, render_view_id_));
         return next_handler_->OnResponseCompleted(request_id, status,
                                                   security_info);
       } else {
         // 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.
-        ResourceDispatcherHost::GlobalRequestID global_id(
-            render_process_host_id_, request_id);
+        GlobalRequestID global_id(render_process_host_id_, request_id);
         StartCrossSiteTransition(request_id, NULL, global_id);
       }
     }
   }
 
   // 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
 // TabContents 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.
-  ResourceDispatcherHost::GlobalRequestID global_id(render_process_host_id_,
-                                                    request_id_);
+  GlobalRequestID global_id(render_process_host_id_, request_id_);
   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_);
     next_handler_->OnResponseStarted(request_id_, response_);
@@ skipping 19 matching lines @@
     rdh_->NotifyResponseCompleted(request, render_process_host_id_);
     rdh_->RemovePendingRequest(render_process_host_id_, request_id_);
   }
 }
 
 // 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,
-    ResourceDispatcherHost::GlobalRequestID global_id) {
+    const GlobalRequestID& global_id) {
   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.
   URLRequest* request = rdh_->GetURLRequest(global_id);
   if (!request) {
     DLOG(WARNING) << "Cross site response for a request that wasn't found";
     return;
@@ skipping 12 matching lines @@
   // there will be no reads.
 
   // Tell the tab 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.
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       new CrossSiteNotifyTask(
           render_process_host_id_, render_view_id_, request_id));
 }