Clean up ResourceHandler API.

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/logging.h"
@@ skipping 31 matching lines @@
 
   delegate->GetRendererManagementDelegate()->OnCrossSiteResponse(
       rvh, global_request_id, is_transfer, transfer_url, referrer, frame_id);
 }
 
 }  // namespace
 
 CrossSiteResourceHandler::CrossSiteResourceHandler(
     scoped_ptr<ResourceHandler> next_handler,
     net::URLRequest* request)
-    : LayeredResourceHandler(next_handler.Pass()),
-      request_(request),
+    : LayeredResourceHandler(request, next_handler.Pass()),
       has_started_response_(false),
       in_cross_site_transition_(false),
       completed_during_transition_(false),
       did_defer_(false),
       completed_status_(),
       response_(NULL) {
 }
 
 CrossSiteResourceHandler::~CrossSiteResourceHandler() {
   // Cleanup back-pointer stored on the request info.
-  ResourceRequestInfoImpl::ForRequest(request_)->set_cross_site_handler(NULL);
+  GetRequestInfo()->set_cross_site_handler(NULL);
 }
 
 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;
 
-  ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request_);
+  ResourceRequestInfoImpl* info = GetRequestInfo();
 
   // We will need to swap processes if either (1) a redirect that requires a
   // transfer occurred before we got here, or (2) a pending cross-site request
   // was already in progress.  Note that a swap may no longer be needed if we
   // transferred back into the original process due to a redirect.
   bool should_transfer =
       GetContentClient()->browser()->ShouldSwapProcessesForRedirect(
-          info->GetContext(), request_->original_url(), request_->url());
+          info->GetContext(), request()->original_url(), request()->url());
   bool swap_needed = should_transfer ||
       CrossSiteRequestManager::GetInstance()->
           HasPendingCrossSiteRequest(info->GetChildID(), info->GetRouteID());
 
   // 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
@@ skipping 24 matching lines @@
                                                bool* defer) {
   CHECK(!in_cross_site_transition_);
   return next_handler_->OnReadCompleted(request_id, bytes_read, defer);
 }
 
 bool CrossSiteResourceHandler::OnResponseCompleted(
     int request_id,
     const net::URLRequestStatus& status,
     const std::string& security_info) {
   if (!in_cross_site_transition_) {
-    ResourceRequestInfoImpl* info =
-        ResourceRequestInfoImpl::ForRequest(request_);
+    ResourceRequestInfoImpl* info = GetRequestInfo();
     // If we've already completed the transition, or we're canceling the
     // request, or an error occurred with no cross-process navigation in
     // progress, then we should just pass this through.
     if (has_started_response_ ||
         status.status() != net::URLRequestStatus::FAILED ||
         !CrossSiteRequestManager::GetInstance()->HasPendingCrossSiteRequest(
             info->GetChildID(), info->GetRouteID())) {
       return next_handler_->OnResponseCompleted(request_id, status,
                                                 security_info);
     }
@@ skipping 12 matching lines @@
 
   // Return false to tell RDH not to notify the world or clean up the
   // pending request.  We will do so in ResumeResponse.
   did_defer_ = true;
   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_);
+  DCHECK(request());
   DCHECK(in_cross_site_transition_);
   in_cross_site_transition_ = false;
-  ResourceRequestInfoImpl* info =
-      ResourceRequestInfoImpl::ForRequest(request_);
+  ResourceRequestInfoImpl* info = GetRequestInfo();
 
   if (has_started_response_) {
     // Send OnResponseStarted to the new renderer.
     DCHECK(response_);
     bool defer = false;
     if (!next_handler_->OnResponseStarted(info->GetRequestID(), response_,
                                           &defer)) {
       controller()->Cancel();
     } else if (!defer) {
       // Unpause the request to resume reading.  Any further reads will be
@@ skipping 20 matching lines @@
 // telling the old RenderViewHost to run its onunload handler.
 void CrossSiteResourceHandler::StartCrossSiteTransition(
     int request_id,
     ResourceResponse* response,
     bool should_transfer) {
   in_cross_site_transition_ = true;
   response_ = response;
 
   // Store this handler on the ExtraRequestInfo, so that RDH can call our
   // ResumeResponse method when we are ready to resume.
-  ResourceRequestInfoImpl* info =
-      ResourceRequestInfoImpl::ForRequest(request_);
+  ResourceRequestInfoImpl* info = GetRequestInfo();
   info->set_cross_site_handler(this);
 
   DCHECK_EQ(request_id, info->GetRequestID());
   GlobalRequestID global_id(info->GetChildID(), info->GetRequestID());
 
   // 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 until the unload is finished and (if a transfer
   // is needed) for the new renderer's request to arrive.
   GURL transfer_url;
   Referrer referrer;
   int frame_id = -1;
   if (should_transfer) {
-    transfer_url = request_->url();
-    referrer = Referrer(GURL(request_->referrer()), info->GetReferrerPolicy());
+    transfer_url = request()->url();
+    referrer = Referrer(GURL(request()->referrer()), info->GetReferrerPolicy());
     frame_id = info->GetFrameID();
 
     ResourceDispatcherHostImpl::Get()->MarkAsTransferredNavigation(
         global_id, transfer_url);
   }
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
           &OnCrossSiteResponseHelper,
           info->GetChildID(),
           info->GetRouteID(),
           global_id,
           should_transfer,
           transfer_url,
           referrer,
           frame_id));
 }
 
 void CrossSiteResourceHandler::ResumeIfDeferred() {
   if (did_defer_) {
     did_defer_ = false;
     controller()->Resume();
   }
 }
 
 }  // namespace content