Add ResourceRequestInfo.

content/browser/renderer_host/resource_dispatcher_host.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <set>
 #include <vector>
@@ skipping 20 matching lines @@
 #include "content/browser/download/save_file_manager.h"
 #include "content/browser/download/save_file_resource_handler.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/plugin_service_impl.h"
 #include "content/browser/renderer_host/async_resource_handler.h"
 #include "content/browser/renderer_host/buffered_resource_handler.h"
 #include "content/browser/renderer_host/cross_site_resource_handler.h"
 #include "content/browser/renderer_host/doomed_resource_handler.h"
 #include "content/browser/renderer_host/redirect_to_file_resource_handler.h"
 #include "content/browser/renderer_host/render_view_host.h"
-#include "content/browser/renderer_host/resource_dispatcher_host_request_info.h"
+#include "content/browser/renderer_host/resource_request_info_impl.h"
 #include "content/browser/renderer_host/resource_message_filter.h"
 #include "content/browser/renderer_host/resource_request_details.h"
 #include "content/browser/renderer_host/sync_resource_handler.h"
 #include "content/browser/renderer_host/throttling_resource_handler.h"
 #include "content/browser/ssl/ssl_client_auth_handler.h"
 #include "content/browser/ssl/ssl_manager.h"
 #include "content/browser/worker_host/worker_service_impl.h"
 #include "content/common/resource_messages.h"
 #include "content/common/ssl_status_serialization.h"
 #include "content/common/view_messages.h"
@@ skipping 31 matching lines @@
 #include "webkit/appcache/appcache_interfaces.h"
 #include "webkit/blob/blob_storage_controller.h"
 #include "webkit/blob/shareable_file_reference.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 using content::BrowserThread;
 using content::GlobalRequestID;
 using content::ResourceContext;
+using content::ResourceRequestInfo;
+using content::ResourceRequestInfoImpl;
 using content::ResourceResponse;
 using content::ResourceThrottle;
 using content::ThrottlingResourceHandler;
 using content::WebContents;
 using content::WorkerServiceImpl;
 using webkit_blob::ShareableFileReference;
 
 // ----------------------------------------------------------------------------
 
 namespace {
@@ skipping 270 matching lines @@
     delegate_->DownloadStarting(request, context, child_id, route_id,
                                 request_id, !request->is_pending(), &throttles);
     if (!throttles.empty()) {
       handler = new ThrottlingResourceHandler(this, handler, child_id,
                                               request_id, throttles.Pass());
     }
   }
   return handler;
 }
 
+// static
+void ResourceDispatcherHost::ClearLoginDelegate(net::URLRequest* request) {
+  ResourceRequestInfoImpl* info =
+      ResourceDispatcherHost::InfoForRequest(request);
+  if (!info)
+    return;
+
+  info->set_login_delegate(NULL);
+}
+
 void ResourceDispatcherHost::SetRequestInfo(
     net::URLRequest* request,
-    ResourceDispatcherHostRequestInfo* info) {
+    ResourceRequestInfoImpl* info) {
   request->SetUserData(NULL, info);
 }
 
 void ResourceDispatcherHost::OnShutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   is_shutdown_ = true;
   for (PendingRequestList::const_iterator i = pending_requests_.begin();
        i != pending_requests_.end(); ++i) {
     transferred_navigations_.erase(i->first);
   }
@@ skipping 277 matching lines @@
                                 route_id,
                                 is_continuation_of_transferred_request,
                                 &throttles);
     if (!throttles.empty()) {
       handler = new ThrottlingResourceHandler(this, handler, child_id,
                                               request_id, throttles.Pass());
     }
   }
 
   // Make extra info and read footer (contains request ID).
-  ResourceDispatcherHostRequestInfo* extra_info =
-      new ResourceDispatcherHostRequestInfo(
+  ResourceRequestInfoImpl* extra_info =
+      new ResourceRequestInfoImpl(
           handler,
           process_type,
           child_id,
           route_id,
           request_data.origin_pid,
           request_id,
           request_data.is_main_frame,
           request_data.frame_id,
           request_data.parent_is_main_frame,
           request_data.parent_frame_id,
@@ skipping 18 matching lines @@
 
   // Have the appcache associate its extra info with the request.
   appcache::AppCacheInterceptor::SetExtraRequestInfo(
       request, ResourceContext::GetAppCacheService(resource_context), child_id,
       request_data.appcache_host_id, request_data.resource_type);
 
   if (deferred_request) {
     // This is a request that has been transferred from another process, so
     // resume it rather than continuing the regular procedure for starting a
     // request. Currently this is only done for redirects.
-    GlobalRequestID global_id(extra_info->child_id(), extra_info->request_id());
+    GlobalRequestID global_id(extra_info->GetChildID(),
+                              extra_info->GetRequestID());
     pending_requests_[global_id] = request;
     request->FollowDeferredRedirect();
   } else {
     BeginRequestInternal(request);
   }
 }
 
 void ResourceDispatcherHost::OnReleaseDownloadedFile(int request_id) {
   DCHECK(pending_requests_.end() ==
          pending_requests_.find(
              GlobalRequestID(filter_->child_id(), request_id)));
   UnregisterDownloadedTempFile(filter_->child_id(), request_id);
 }
 
 void ResourceDispatcherHost::OnDataReceivedACK(int request_id) {
   DataReceivedACK(filter_->child_id(), request_id);
 }
 
 void ResourceDispatcherHost::DataReceivedACK(int child_id,
                                              int request_id) {
   PendingRequestList::iterator i = pending_requests_.find(
       GlobalRequestID(child_id, request_id));
   if (i == pending_requests_.end())
     return;
 
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
+  ResourceRequestInfoImpl* info = InfoForRequest(i->second);
 
   // Decrement the number of pending data messages.
   info->DecrementPendingDataCount();
 
   // If the pending data count was higher than the max, resume the request.
   if (info->pending_data_count() == kMaxPendingDataMessages) {
     // Decrement the pending data count one more time because we also
     // incremented it before pausing the request.
     info->DecrementPendingDataCount();
 
@@ skipping 43 matching lines @@
   return false;
 }
 
 void ResourceDispatcherHost::OnUploadProgressACK(int request_id) {
   int child_id = filter_->child_id();
   PendingRequestList::iterator i = pending_requests_.find(
       GlobalRequestID(child_id, request_id));
   if (i == pending_requests_.end())
     return;
 
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
+  ResourceRequestInfoImpl* info = InfoForRequest(i->second);
   info->set_waiting_for_upload_progress_ack(false);
 }
 
 void ResourceDispatcherHost::OnCancelRequest(int request_id) {
   CancelRequest(filter_->child_id(), request_id, true);
 }
 
 // Assigns the pending request a new routing_id because it was transferred
 // to a new page.
 void ResourceDispatcherHost::OnTransferRequestToNewPage(int new_routing_id,
                                                         int request_id) {
   PendingRequestList::iterator i = pending_requests_.find(
       GlobalRequestID(filter_->child_id(), request_id));
   if (i == pending_requests_.end()) {
     // We probably want to remove this warning eventually, but I wanted to be
     // able to notice when this happens during initial development since it
     // should be rare and may indicate a bug.
     DVLOG(1) << "Updating a request that wasn't found";
     return;
   }
   net::URLRequest* request = i->second;
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  ResourceRequestInfoImpl* info = InfoForRequest(request);
   info->set_route_id(new_routing_id);
 }
 
 void ResourceDispatcherHost::OnFollowRedirect(
     int request_id,
     bool has_new_first_party_for_cookies,
     const GURL& new_first_party_for_cookies) {
   FollowDeferredRedirect(filter_->child_id(), request_id,
                          has_new_first_party_for_cookies,
                          new_first_party_for_cookies);
 }
 
-ResourceDispatcherHostRequestInfo* ResourceDispatcherHost::CreateRequestInfo(
+ResourceRequestInfoImpl* ResourceDispatcherHost::CreateRequestInfo(
     ResourceHandler* handler,
     int child_id,
     int route_id,
     bool download,
     content::ResourceContext* context) {
-  return new ResourceDispatcherHostRequestInfo(
+  return new ResourceRequestInfoImpl(
       handler,
       content::PROCESS_TYPE_RENDERER,
       child_id,
       route_id,
       0,
       request_id_,
       false,     // is_main_frame
       -1,        // frame_id
       false,     // parent_is_main_frame
       -1,        // parent_frame_id
       ResourceType::SUB_RESOURCE,
       content::PAGE_TRANSITION_LINK,
       0,         // upload_size
       download,  // is_download
       download,  // allow_download
       false,     // has_user_gesture
       WebKit::WebReferrerPolicyDefault,
       context);
 }
 
 void ResourceDispatcherHost::OnSwapOutACK(
     const ViewMsg_SwapOut_Params& params) {
   // Closes for cross-site transitions are handled such that the cross-site
   // transition continues.
   GlobalRequestID global_id(params.new_render_process_host_id,
                             params.new_request_id);
   PendingRequestList::iterator i = pending_requests_.find(global_id);
   if (i != pending_requests_.end()) {
     // The response we were meant to resume could have already been canceled.
-    ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
+    ResourceRequestInfoImpl* info = InfoForRequest(i->second);
     if (info->cross_site_handler())
       info->cross_site_handler()->ResumeResponse();
   }
   // Update the RenderViewHost's internal state after the ACK.
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&OnSwapOutACKHelper,
                  params.closing_process_id,
                  params.closing_route_id));
@@ skipping 55 matching lines @@
       CreateResourceHandlerForDownload(request.get(), context, child_id,
                                        route_id, request_id_, save_info,
                                        started_cb));
 
   if (!request_context->job_factory()->IsHandledURL(url)) {
     VLOG(1) << "Download request for unsupported protocol: "
             << url.possibly_invalid_spec();
     return net::ERR_ACCESS_DENIED;
   }
 
-  ResourceDispatcherHostRequestInfo* extra_info =
+  ResourceRequestInfoImpl* extra_info =
       CreateRequestInfo(handler, child_id, route_id, true, context);
   SetRequestInfo(request.get(), extra_info);  // Request takes ownership.
 
   BeginRequestInternal(request.release());
 
   return net::OK;
 }
 
 // This function is only used for saving feature.
 void ResourceDispatcherHost::BeginSaveFile(
@@ skipping 25 matching lines @@
 
   net::URLRequest* request = new net::URLRequest(url, this);
   request->set_method("GET");
   request->set_referrer(MaybeStripReferrer(referrer).spec());
   // So far, for saving page, we need fetch content from cache, in the
   // future, maybe we can use a configuration to configure this behavior.
   request->set_load_flags(net::LOAD_PREFERRING_CACHE);
   request->set_context(context->GetRequestContext());
 
   // Since we're just saving some resources we need, disallow downloading.
-  ResourceDispatcherHostRequestInfo* extra_info =
+  ResourceRequestInfoImpl* extra_info =
       CreateRequestInfo(handler, child_id, route_id, false, context);
   SetRequestInfo(request, extra_info);  // Request takes ownership.
 
   BeginRequestInternal(request);
 }
 
 void ResourceDispatcherHost::FollowDeferredRedirect(
     int child_id,
     int request_id,
     bool has_new_first_party_for_cookies,
@@ skipping 29 matching lines @@
 
 bool ResourceDispatcherHost::WillSendData(int child_id,
                                           int request_id) {
   PendingRequestList::iterator i = pending_requests_.find(
       GlobalRequestID(child_id, request_id));
   if (i == pending_requests_.end()) {
     NOTREACHED() << "WillSendData for invalid request";
     return false;
   }
 
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
+  ResourceRequestInfoImpl* info = InfoForRequest(i->second);
 
   info->IncrementPendingDataCount();
   if (info->pending_data_count() > kMaxPendingDataMessages) {
     // We reached the max number of data messages that can be sent to
     // the renderer for a given request. Pause the request and wait for
     // the renderer to start processing them before resuming it.
     PauseRequest(child_id, request_id, true);
     return false;
   }
 
   return true;
 }
 
 void ResourceDispatcherHost::PauseRequest(int child_id,
                                           int request_id,
                                           bool pause) {
   GlobalRequestID global_id(child_id, request_id);
   PendingRequestList::iterator i = pending_requests_.find(global_id);
   if (i == pending_requests_.end()) {
     DVLOG(1) << "Pausing a request that wasn't found";
     return;
   }
 
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
+  ResourceRequestInfoImpl* info = InfoForRequest(i->second);
   int pause_count = info->pause_count() + (pause ? 1 : -1);
   if (pause_count < 0) {
     NOTREACHED();  // Unbalanced call to pause.
     return;
   }
   info->set_pause_count(pause_count);
 
   VLOG(1) << "To pause (" << pause << "): " << i->second->url().spec();
 
   // If we're resuming, kick the request to start reading again. Run the read
@@ skipping 27 matching lines @@
   // Since pending_requests_ is a map, we first build up a list of all of the
   // matching requests to be cancelled, and then we cancel them.  Since there
   // may be more than one request to cancel, we cannot simply hold onto the map
   // iterators found in the first loop.
 
   // Find the global ID of all matching elements.
   std::vector<GlobalRequestID> matching_requests;
   for (PendingRequestList::const_iterator i = pending_requests_.begin();
        i != pending_requests_.end(); ++i) {
     if (i->first.child_id == child_id) {
-      ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
+      ResourceRequestInfoImpl* info = InfoForRequest(i->second);
       GlobalRequestID id(child_id, i->first.request_id);
       DCHECK(id == i->first);
       // Don't cancel navigations that are transferring to another process,
       // since they belong to another process now.
       if (!info->is_download() &&
           (transferred_navigations_.find(id) ==
                transferred_navigations_.end()) &&
-          (route_id == -1 || route_id == info->route_id())) {
+          (route_id == -1 || route_id == info->GetRouteID())) {
         matching_requests.push_back(
             GlobalRequestID(child_id, i->first.request_id));
       }
     }
   }
 
   // Remove matches.
   for (size_t i = 0; i < matching_requests.size(); ++i) {
     PendingRequestList::iterator iter =
         pending_requests_.find(matching_requests[i]);
@@ skipping 39 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(context);
 
   // Note that request cancellation has side effects. Therefore, we gather all
   // the requests to cancel first, and then we start cancelling. We assert at
   // the end that there are no more to cancel since the context is about to go
   // away.
   std::vector<net::URLRequest*> requests_to_cancel;
   for (PendingRequestList::iterator i = pending_requests_.begin();
        i != pending_requests_.end();) {
-    ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
-    if (info->context() == context) {
+    ResourceRequestInfoImpl* info = InfoForRequest(i->second);
+    if (info->GetContext() == context) {
       requests_to_cancel.push_back(i->second);
       pending_requests_.erase(i++);
     } else {
       ++i;
     }
   }
 
   for (BlockedRequestMap::iterator i = blocked_requests_map_.begin();
        i != blocked_requests_map_.end();) {
     BlockedRequestsList* requests = i->second;
     if (requests->empty()) {
       // This can happen if BlockRequestsForRoute() has been called for a route,
       // but we haven't blocked any matching requests yet.
       ++i;
       continue;
     }
-    ResourceDispatcherHostRequestInfo* info =
+    ResourceRequestInfoImpl* info =
         InfoForRequest(requests->front());
-    if (info->context() == context) {
+    if (info->GetContext() == context) {
       blocked_requests_map_.erase(i++);
       for (BlockedRequestsList::const_iterator it = requests->begin();
            it != requests->end(); ++it) {
         net::URLRequest* request = *it;
         info = InfoForRequest(request);
         // We make the assumption that all requests on the list have the same
         // ResourceContext.
-        DCHECK_EQ(context, info->context());
+        DCHECK_EQ(context, info->GetContext());
         IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost(),
-                                               info->child_id());
+                                               info->GetChildID());
         requests_to_cancel.push_back(request);
       }
       delete requests;
     } else {
       ++i;
     }
   }
 
   for (std::vector<net::URLRequest*>::iterator i = requests_to_cancel.begin();
        i != requests_to_cancel.end(); ++i) {
     net::URLRequest* request = *i;
-    ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+    ResourceRequestInfoImpl* info = InfoForRequest(request);
     // There is no strict requirement that this be the case, but currently
     // downloads and transferred requests are the only requests that aren't
     // cancelled when the associated processes go away. It may be OK for this
     // invariant to change in the future, but if this assertion fires without
     // the invariant changing, then it's indicative of a leak.
-    GlobalRequestID request_id(info->child_id(), info->request_id());
+    GlobalRequestID request_id(info->GetChildID(), info->GetRequestID());
     bool is_transferred = IsTransferredNavigation(request_id);
     DCHECK(info->is_download() || is_transferred);
     if (is_transferred)
       transferred_navigations_.erase(request_id);
     delete request;
   }
 
   // Validate that no more requests for this context were added.
   for (PendingRequestList::const_iterator i = pending_requests_.begin();
        i != pending_requests_.end(); ++i) {
-    ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
-    DCHECK_NE(info->context(), context);
+    ResourceRequestInfoImpl* info = InfoForRequest(i->second);
+    DCHECK_NE(info->GetContext(), context);
   }
 
   for (BlockedRequestMap::const_iterator i = blocked_requests_map_.begin();
        i != blocked_requests_map_.end(); ++i) {
     BlockedRequestsList* requests = i->second;
     if (!requests->empty()) {
-      ResourceDispatcherHostRequestInfo* info =
+      ResourceRequestInfoImpl* info =
           InfoForRequest(requests->front());
-      DCHECK_NE(info->context(), context);
+      DCHECK_NE(info->GetContext(), context);
     }
   }
 }
 
 // Cancels the request and removes it from the list.
 void ResourceDispatcherHost::RemovePendingRequest(int child_id,
                                                   int request_id) {
   PendingRequestList::iterator i = pending_requests_.find(
       GlobalRequestID(child_id, request_id));
   if (i == pending_requests_.end()) {
     NOTREACHED() << "Trying to remove a request that's not here";
     return;
   }
   RemovePendingRequest(i);
 }
 
 void ResourceDispatcherHost::RemovePendingRequest(
     const PendingRequestList::iterator& iter) {
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(iter->second);
+  ResourceRequestInfoImpl* info = InfoForRequest(iter->second);
 
   // Remove the memory credit that we added when pushing the request onto
   // the pending list.
   IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost(),
-                                         info->child_id());
+                                         info->GetChildID());
 
   // Notify interested parties that the request object is going away.
   if (info->login_delegate())
     info->login_delegate()->OnRequestCancelled();
   if (info->ssl_client_auth_handler())
     info->ssl_client_auth_handler()->OnRequestCancelled();
   transferred_navigations_.erase(
-      GlobalRequestID(info->child_id(), info->request_id()));
+      GlobalRequestID(info->GetChildID(), info->GetRequestID()));
 
   delete iter->second;
   pending_requests_.erase(iter);
 
   // If we have no more pending requests, then stop the load state monitor
   if (pending_requests_.empty())
     update_load_states_timer_.Stop();
 }
 
 // net::URLRequest::Delegate ---------------------------------------------------
 
 void ResourceDispatcherHost::OnReceivedRedirect(net::URLRequest* request,
                                                 const GURL& new_url,
                                                 bool* defer_redirect) {
   VLOG(1) << "OnReceivedRedirect: " << request->url().spec();
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  ResourceRequestInfoImpl* info = InfoForRequest(request);
 
   DCHECK(request->status().is_success());
 
   if (info->process_type() != content::PROCESS_TYPE_PLUGIN &&
       !ChildProcessSecurityPolicyImpl::GetInstance()->
-          CanRequestURL(info->child_id(), new_url)) {
+          CanRequestURL(info->GetChildID(), new_url)) {
     VLOG(1) << "Denied unauthorized request for "
             << new_url.possibly_invalid_spec();
 
     // Tell the renderer that this request was disallowed.
     CancelRequestInternal(request, false);
     return;
   }
 
-  NotifyReceivedRedirect(request, info->child_id(), new_url);
+  NotifyReceivedRedirect(request, info->GetChildID(), new_url);
 
-  if (HandleExternalProtocol(info->request_id(), info->child_id(),
-                             info->route_id(), new_url,
-                             info->resource_type(),
+  if (HandleExternalProtocol(info->GetRequestID(), info->GetChildID(),
+                             info->GetRouteID(), new_url,
+                             info->GetResourceType(),
                              *request->context()->job_factory(),
                              info->resource_handler())) {
     // The request is complete so we can remove it.
-    RemovePendingRequest(info->child_id(), info->request_id());
+    RemovePendingRequest(info->GetChildID(), info->GetRequestID());
     return;
   }
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   PopulateResourceResponse(request, response);
-  if (!info->resource_handler()->OnRequestRedirected(info->request_id(),
+  if (!info->resource_handler()->OnRequestRedirected(info->GetRequestID(),
                                                      new_url,
                                                      response, defer_redirect))
     CancelRequestInternal(request, false);
 }
 
 void ResourceDispatcherHost::OnAuthRequired(
     net::URLRequest* request,
     net::AuthChallengeInfo* auth_info) {
   if (request->load_flags() & net::LOAD_DO_NOT_PROMPT_FOR_LOGIN) {
     request->CancelAuth();
@@ skipping 20 matching lines @@
     }
   }
 
 
   // Create a login dialog on the UI thread to get authentication data,
   // or pull from cache and continue on the IO thread.
   // TODO(mpcomplete): We should block the parent tab while waiting for
   // authentication.
   // That would also solve the problem of the net::URLRequest being cancelled
   // before we receive authentication.
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  ResourceRequestInfoImpl* info = InfoForRequest(request);
   DCHECK(!info->login_delegate()) <<
       "OnAuthRequired called with login_delegate pending";
   if (delegate_) {
     info->set_login_delegate(delegate_->CreateLoginDelegate(
         auth_info, request));
   }
   if (!info->login_delegate())
     request->CancelAuth();
 }
 
 void ResourceDispatcherHost::OnCertificateRequested(
     net::URLRequest* request,
     net::SSLCertRequestInfo* cert_request_info) {
   DCHECK(request);
   if (delegate_ && !delegate_->AcceptSSLClientCertificateRequest(
           request, cert_request_info)) {
     request->Cancel();
     return;
   }
 
   if (cert_request_info->client_certs.empty()) {
     // No need to query the user if there are no certs to choose from.
     request->ContinueWithCertificate(NULL);
     return;
   }
 
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  ResourceRequestInfoImpl* info = InfoForRequest(request);
   DCHECK(!info->ssl_client_auth_handler()) <<
       "OnCertificateRequested called with ssl_client_auth_handler pending";
   info->set_ssl_client_auth_handler(
       new SSLClientAuthHandler(request, cert_request_info));
   info->ssl_client_auth_handler()->SelectCertificate();
 }
 
 void ResourceDispatcherHost::OnSSLCertificateError(
     net::URLRequest* request,
     const net::SSLInfo& ssl_info,
     bool is_hsts_host) {
   DCHECK(request);
   SSLManager::OnSSLCertificateError(this, request, ssl_info, is_hsts_host);
 }
 
 bool ResourceDispatcherHost::CanGetCookies(
     const net::URLRequest* request,
     const net::CookieList& cookie_list) const {
   VLOG(1) << "OnGetCookies: " << request->url().spec();
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
     return false;
 
-  const ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  const ResourceRequestInfoImpl* info = InfoForRequest(request);
 
   return content::GetContentClient()->browser()->AllowGetCookie(
       request->url(), request->first_party_for_cookies(), cookie_list,
-      info->context(), render_process_id, render_view_id);
+      info->GetContext(), render_process_id, render_view_id);
 }
 
 bool ResourceDispatcherHost::CanSetCookie(const net::URLRequest* request,
                                           const std::string& cookie_line,
                                           net::CookieOptions* options) const {
   VLOG(1) << "OnSetCookie: " << request->url().spec();
 
   int render_process_id, render_view_id;
   if (!RenderViewForRequest(request, &render_process_id, &render_view_id))
     return false;
 
-  const ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  const ResourceRequestInfoImpl* info = InfoForRequest(request);
   return content::GetContentClient()->browser()->AllowSetCookie(
       request->url(), request->first_party_for_cookies(), cookie_line,
-      info->context(), render_process_id, render_view_id, options);
+      info->GetContext(), render_process_id, render_view_id, options);
 }
 
 void ResourceDispatcherHost::OnResponseStarted(net::URLRequest* request) {
   VLOG(1) << "OnResponseStarted: " << request->url().spec();
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  ResourceRequestInfoImpl* info = InfoForRequest(request);
 
   if (request->status().is_success()) {
     if (PauseRequestIfNeeded(info)) {
       VLOG(1) << "OnResponseStarted pausing: " << request->url().spec();
       return;
     }
 
     // We want to send a final upload progress message prior to sending
     // the response complete message even if we're waiting for an ack to
     // to a previous upload progress message.
@@ skipping 10 matching lines @@
       }
 
       StartReading(request);
     }
   } else {
     ResponseCompleted(request);
   }
 }
 
 bool ResourceDispatcherHost::CompleteResponseStarted(net::URLRequest* request) {
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  ResourceRequestInfoImpl* info = InfoForRequest(request);
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   PopulateResourceResponse(request, response);
 
   if (request->ssl_info().cert) {
     int cert_id =
         CertStore::GetInstance()->StoreCert(request->ssl_info().cert,
-                                            info->child_id());
+                                            info->GetChildID());
     response->security_info = content::SerializeSecurityInfo(
         cert_id, request->ssl_info().cert_status,
         request->ssl_info().security_bits,
         request->ssl_info().connection_status);
   } else {
     // We should not have any SSL state.
     DCHECK(!request->ssl_info().cert_status &&
            request->ssl_info().security_bits == -1 &&
            !request->ssl_info().connection_status);
   }
 
-  NotifyResponseStarted(request, info->child_id());
+  NotifyResponseStarted(request, info->GetChildID());
   info->set_called_on_response_started(true);
-  return info->resource_handler()->OnResponseStarted(info->request_id(),
+  return info->resource_handler()->OnResponseStarted(info->GetRequestID(),
                                                      response.get());
 }
 
 void ResourceDispatcherHost::CancelRequest(int child_id,
                                            int request_id,
                                            bool from_renderer) {
   GlobalRequestID id(child_id, request_id);
   if (from_renderer) {
     // When the old renderer dies, it sends a message to us to cancel its
     // requests.
@@ skipping 25 matching lines @@
                    request_id));
   }
 }
 
 bool ResourceDispatcherHost::CancelRequestInternal(net::URLRequest* request,
                                                    bool from_renderer) {
   VLOG(1) << "CancelRequest: " << request->url().spec();
 
   // WebKit will send us a cancel for downloads since it no longer handles them.
   // In this case, ignore the cancel since we handle downloads in the browser.
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  ResourceRequestInfoImpl* info = InfoForRequest(request);
   if (!from_renderer || !info->is_download()) {
     if (info->login_delegate()) {
       info->login_delegate()->OnRequestCancelled();
       info->set_login_delegate(NULL);
     }
     if (info->ssl_client_auth_handler()) {
       info->ssl_client_auth_handler()->OnRequestCancelled();
       info->set_ssl_client_auth_handler(NULL);
     }
     request->Cancel();
@@ skipping 40 matching lines @@
                      request->referrer().size() +
                      request->method().size();
 
   // Note that this expression will typically be dominated by:
   // |kAvgBytesPerOutstandingRequest|.
   return kAvgBytesPerOutstandingRequest + strings_cost;
 }
 
 void ResourceDispatcherHost::BeginRequestInternal(net::URLRequest* request) {
   DCHECK(!request->is_pending());
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  ResourceRequestInfoImpl* info = InfoForRequest(request);
 
   if ((TimeTicks::Now() - last_user_gesture_time_) <
       TimeDelta::FromMilliseconds(kUserGestureWindowMs)) {
     request->set_load_flags(
         request->load_flags() | net::LOAD_MAYBE_USER_GESTURE);
   }
 
   // Add the memory estimate that starting this request will consume.
   info->set_memory_cost(CalculateApproximateMemoryCost(request));
   int memory_cost = IncrementOutstandingRequestsMemoryCost(info->memory_cost(),
-                                                           info->child_id());
+                                                           info->GetChildID());
 
   // If enqueing/starting this request will exceed our per-process memory
   // bound, abort it right away.
   if (memory_cost > max_outstanding_requests_cost_per_process_) {
     // We call "SimulateError()" as a way of setting the net::URLRequest's
     // status -- it has no effect beyond this, since the request hasn't started.
     request->SimulateError(net::ERR_INSUFFICIENT_RESOURCES);
 
     // TODO(eroman): this is kinda funky -- we insert the unstarted request into
     // |pending_requests_| simply to please ResponseCompleted().
-    GlobalRequestID global_id(info->child_id(), info->request_id());
+    GlobalRequestID global_id(info->GetChildID(), info->GetRequestID());
     pending_requests_[global_id] = request;
     ResponseCompleted(request);
     return;
   }
 
-  std::pair<int, int> pair_id(info->child_id(), info->route_id());
+  std::pair<int, int> pair_id(info->GetChildID(), info->GetRouteID());
   BlockedRequestMap::const_iterator iter = blocked_requests_map_.find(pair_id);
   if (iter != blocked_requests_map_.end()) {
     // The request should be blocked.
     iter->second->push_back(request);
     return;
   }
 
-  GlobalRequestID global_id(info->child_id(), info->request_id());
+  GlobalRequestID global_id(info->GetChildID(), info->GetRequestID());
   pending_requests_[global_id] = request;
 
   // Give the resource handlers an opportunity to delay the net::URLRequest from
   // being started.
   //
   // There are three cases:
   //
   //   (1) if OnWillStart() returns false, the request is cancelled (regardless
   //       of whether |defer_start| was set).
   //   (2) If |defer_start| was set to true, then the request is not added
   //       into the resource queue, and will only be started in response to
   //       calling StartDeferredRequest().
   //   (3) If |defer_start| is not set, then the request is inserted into
   //       the resource_queue_ (which may pause it further, or start it).
   bool defer_start = false;
   if (!info->resource_handler()->OnWillStart(
-          info->request_id(), request->url(),
+          info->GetRequestID(), request->url(),
           &defer_start)) {
     CancelRequestInternal(request, false);
     return;
   }
 
   if (!defer_start)
     StartRequest(request);
 }
 
 void ResourceDispatcherHost::StartRequest(net::URLRequest* request) {
   request->Start();
 
   // Make sure we have the load state monitor running
   if (!update_load_states_timer_.IsRunning()) {
     update_load_states_timer_.Start(FROM_HERE,
         TimeDelta::FromMilliseconds(kUpdateLoadStatesIntervalMsec),
         this, &ResourceDispatcherHost::UpdateLoadStates);
   }
 }
 
 bool ResourceDispatcherHost::PauseRequestIfNeeded(
-    ResourceDispatcherHostRequestInfo* info) {
+    ResourceRequestInfoImpl* info) {
   if (info->pause_count() > 0)
     info->set_is_paused(true);
   return info->is_paused();
 }
 
 void ResourceDispatcherHost::ResumeRequest(const GlobalRequestID& request_id) {
   PendingRequestList::iterator i = pending_requests_.find(request_id);
   if (i == pending_requests_.end())  // The request may have been destroyed
     return;
 
   net::URLRequest* request = i->second;
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  ResourceRequestInfoImpl* info = InfoForRequest(request);
 
   // We may already be unpaused, or the pause count may have increased since we
   // posted the task to call ResumeRequest.
   if (!info->is_paused())
     return;
   info->set_is_paused(false);
   if (PauseRequestIfNeeded(info))
     return;
 
   VLOG(1) << "Resuming: \"" << i->second->url().spec() << "\""
@@ skipping 18 matching lines @@
   if (Read(request, &bytes_read)) {
     OnReadCompleted(request, bytes_read);
   } else if (!request->status().is_io_pending()) {
     DCHECK(!InfoForRequest(request)->is_paused());
     // If the error is not an IO pending, then we're done reading.
     ResponseCompleted(request);
   }
 }
 
 bool ResourceDispatcherHost::Read(net::URLRequest* request, int* bytes_read) {
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  ResourceRequestInfoImpl* info = InfoForRequest(request);
   DCHECK(!info->is_paused());
 
   net::IOBuffer* buf;
   int buf_size;
-  if (!info->resource_handler()->OnWillRead(info->request_id(),
+  if (!info->resource_handler()->OnWillRead(info->GetRequestID(),
                                             &buf, &buf_size, -1)) {
     return false;
   }
 
   DCHECK(buf);
   DCHECK(buf_size > 0);
 
   info->set_has_started_reading(true);
   return request->Read(buf, buf_size, bytes_read);
 }
 
 void ResourceDispatcherHost::OnReadCompleted(net::URLRequest* request,
                                              int bytes_read) {
   DCHECK(request);
   VLOG(1) << "OnReadCompleted: \"" << request->url().spec() << "\""
           << " bytes_read = " << bytes_read;
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  ResourceRequestInfoImpl* info = InfoForRequest(request);
 
   // bytes_read == -1 always implies an error, so we want to skip the pause
   // checks and just call ResponseCompleted.
   if (bytes_read == -1) {
     DCHECK(!request->status().is_success());
 
     ResponseCompleted(request);
     return;
   }
 
@@ skipping 18 matching lines @@
         CompleteRead(request, &bytes_read);
       } else {
         // Force the next CompleteRead / Read pair to run as a separate task.
         // This avoids a fast, large network request from monopolizing the IO
         // thread and starving other IO operations from running.
         VLOG(1) << "OnReadCompleted postponing: \""
                 << request->url().spec() << "\""
                 << " bytes_read = " << bytes_read;
         info->set_paused_read_bytes(bytes_read);
         info->set_is_paused(true);
-        GlobalRequestID id(info->child_id(), info->request_id());
+        GlobalRequestID id(info->GetChildID(), info->GetRequestID());
         MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(
                 &ResourceDispatcherHost::ResumeRequest,
                 weak_factory_.GetWeakPtr(), id));
         return;
       }
     }
   }
 
@@ skipping 11 matching lines @@
     ResponseCompleted(request);
 }
 
 bool ResourceDispatcherHost::CompleteRead(net::URLRequest* request,
                                           int* bytes_read) {
   if (!request || !request->status().is_success()) {
     NOTREACHED();
     return false;
   }
 
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
-  if (!info->resource_handler()->OnReadCompleted(info->request_id(),
+  ResourceRequestInfoImpl* info = InfoForRequest(request);
+  if (!info->resource_handler()->OnReadCompleted(info->GetRequestID(),
                                                  bytes_read)) {
     CancelRequestInternal(request, false);
     return false;
   }
 
   return *bytes_read != 0;
 }
 
 void ResourceDispatcherHost::ResponseCompleted(net::URLRequest* request) {
   VLOG(1) << "ResponseCompleted: " << request->url().spec();
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  ResourceRequestInfoImpl* info = InfoForRequest(request);
 
   // If the load for a main frame has failed, track it in a histogram,
   // since it will probably cause the user to see an error page.
   if (!request->status().is_success() &&
-      info->resource_type() == ResourceType::MAIN_FRAME &&
+      info->GetResourceType() == ResourceType::MAIN_FRAME &&
       request->status().error() != net::ERR_ABORTED) {
     // This enumeration has "2" appended to its name to distinguish it from
     // its original version. We changed the buckets at one point (added
     // guard buckets by using CustomHistogram::ArrayToCustomRanges).
     UMA_HISTOGRAM_CUSTOM_ENUMERATION(
         "Net.ErrorCodesForMainFrame2",
         -request->status().error(),
         base::CustomHistogram::ArrayToCustomRanges(
             kAllNetErrorCodes, arraysize(kAllNetErrorCodes)));
 
     if (request->url().SchemeIsSecure() &&
         request->url().host() == "www.google.com") {
       UMA_HISTOGRAM_CUSTOM_ENUMERATION(
           "Net.ErrorCodesForHTTPSGoogleMainFrame",
           -request->status().error(),
           base::CustomHistogram::ArrayToCustomRanges(
               kAllNetErrorCodes, arraysize(kAllNetErrorCodes)));
     }
   }
 
   std::string security_info;
   const net::SSLInfo& ssl_info = request->ssl_info();
   if (ssl_info.cert != NULL) {
     int cert_id = CertStore::GetInstance()->StoreCert(ssl_info.cert,
-                                                      info->child_id());
+                                                      info->GetChildID());
     security_info = content::SerializeSecurityInfo(
         cert_id, ssl_info.cert_status, ssl_info.security_bits,
         ssl_info.connection_status);
   }
 
-  if (info->resource_handler()->OnResponseCompleted(info->request_id(),
+  if (info->resource_handler()->OnResponseCompleted(info->GetRequestID(),
                                                     request->status(),
                                                     security_info)) {
 
     // The request is complete so we can remove it.
-    RemovePendingRequest(info->child_id(), info->request_id());
+    RemovePendingRequest(info->GetChildID(), info->GetRequestID());
   }
   // If the handler's OnResponseCompleted returns false, we are deferring the
   // call until later.  We will notify the world and clean up when we resume.
 }
 
 void ResourceDispatcherHost::CallResponseCompleted(int child_id,
                                                    int request_id) {
   PendingRequestList::iterator i = pending_requests_.find(
       GlobalRequestID(child_id, request_id));
   if (i != pending_requests_.end())
     ResponseCompleted(i->second);
 }
 
 void ResourceDispatcherHost::OnUserGesture(TabContents* tab) {
   last_user_gesture_time_ = TimeTicks::Now();
 }
 
 // static
-ResourceDispatcherHostRequestInfo* ResourceDispatcherHost::InfoForRequest(
+ResourceRequestInfoImpl* ResourceDispatcherHost::InfoForRequest(
     net::URLRequest* request) {
   // Avoid writing this function twice by casting the const version.
   const net::URLRequest* const_request = request;
-  return const_cast<ResourceDispatcherHostRequestInfo*>(
+  return const_cast<ResourceRequestInfoImpl*>(
       InfoForRequest(const_request));
 }
 
 // static
-const ResourceDispatcherHostRequestInfo* ResourceDispatcherHost::InfoForRequest(
+const ResourceRequestInfoImpl* ResourceDispatcherHost::InfoForRequest(
     const net::URLRequest* request) {
-  const ResourceDispatcherHostRequestInfo* info =
-      static_cast<const ResourceDispatcherHostRequestInfo*>(
-          request->GetUserData(NULL));
-  return info;
+  return static_cast<const ResourceRequestInfoImpl*>(
+      ResourceRequestInfo::ForRequest(request));
 }
 
 // static
 bool ResourceDispatcherHost::RenderViewForRequest(
     const net::URLRequest* request,
-    int* render_process_host_id,
-    int* render_view_host_id) {
-  const ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+    int* render_process_id,
+    int* render_view_id) {
+  const ResourceRequestInfoImpl* info = InfoForRequest(request);
   if (!info) {
-    *render_process_host_id = -1;
-    *render_view_host_id = -1;
+    *render_process_id = -1;
+    *render_view_id = -1;
     return false;
   }
 
-  // If the request is from the worker process, find a tab that owns the worker.
-  if (info->process_type() == content::PROCESS_TYPE_WORKER) {
-    // Need to display some related UI for this network request - pick an
-    // arbitrary parent to do so.
-    if (!WorkerServiceImpl::GetInstance()->GetRendererForWorker(
-            info->child_id(), render_process_host_id, render_view_host_id)) {
-      *render_process_host_id = -1;
-      *render_view_host_id = -1;
-      return false;
-    }
-  } else {
-    *render_process_host_id = info->child_id();
-    *render_view_host_id = info->route_id();
-  }
-  return true;
+  return info->GetAssociatedRenderView(render_process_id, render_view_id);
 }
 
 net::URLRequest* ResourceDispatcherHost::GetURLRequest(
     const GlobalRequestID& request_id) const {
   // This should be running in the IO loop.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   PendingRequestList::const_iterator i = pending_requests_.find(request_id);
   if (i == pending_requests_.end())
     return NULL;
@@ skipping 117 matching lines @@
   // thread where they can be passed along to the respective RVHs.
   LoadInfoMap info_map;
 
   PendingRequestList::const_iterator i;
 
   // Determine the largest upload size of all requests
   // in each View (good chance it's zero).
   std::map<std::pair<int, int>, uint64> largest_upload_size;
   for (i = pending_requests_.begin(); i != pending_requests_.end(); ++i) {
     net::URLRequest* request = i->second;
-    ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
-    uint64 upload_size = info->upload_size();
+    ResourceRequestInfoImpl* info = InfoForRequest(request);
+    uint64 upload_size = info->GetUploadSize();
     if (request->GetLoadState().state != net::LOAD_STATE_SENDING_REQUEST)
       upload_size = 0;
-    std::pair<int, int> key(info->child_id(), info->route_id());
+    std::pair<int, int> key(info->GetChildID(), info->GetRouteID());
     if (upload_size && largest_upload_size[key] < upload_size)
       largest_upload_size[key] = upload_size;
   }
 
   for (i = pending_requests_.begin(); i != pending_requests_.end(); ++i) {
     net::URLRequest* request = i->second;
     net::LoadStateWithParam load_state = request->GetLoadState();
-    ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
-    std::pair<int, int> key(info->child_id(), info->route_id());
+    ResourceRequestInfoImpl* info = InfoForRequest(request);
+    std::pair<int, int> key(info->GetChildID(), info->GetRouteID());
 
     // We also poll for upload progress on this timer and send upload
     // progress ipc messages to the plugin process.
     MaybeUpdateUploadProgress(info, request);
 
     // If a request is uploading data, ignore all other requests so that the
     // upload progress takes priority for being shown in the status bar.
     if (largest_upload_size.find(key) != largest_upload_size.end() &&
-        info->upload_size() < largest_upload_size[key])
+        info->GetUploadSize() < largest_upload_size[key])
       continue;
 
     net::LoadStateWithParam to_insert = load_state;
     LoadInfoMap::iterator existing = info_map.find(key);
     if (existing != info_map.end()) {
       to_insert =
           MoreInterestingLoadState(existing->second.load_state, load_state);
       if (to_insert.state == existing->second.load_state.state)
         continue;
     }
     LoadInfo& load_info = info_map[key];
     load_info.url = request->url();
     load_info.load_state = to_insert;
-    load_info.upload_size = info->upload_size();
+    load_info.upload_size = info->GetUploadSize();
     load_info.upload_position = request->GetUploadProgress();
   }
 
   if (info_map.empty())
     return;
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&LoadInfoUpdateCallback, info_map));
 }
 
 // Calls the ResourceHandler to send upload progress messages to the renderer.
 void ResourceDispatcherHost::MaybeUpdateUploadProgress(
-    ResourceDispatcherHostRequestInfo *info,
+    ResourceRequestInfoImpl *info,
     net::URLRequest *request) {
 
-  if (!info->upload_size() || info->waiting_for_upload_progress_ack())
+  if (!info->GetUploadSize() || info->waiting_for_upload_progress_ack())
     return;
 
-  uint64 size = info->upload_size();
+  uint64 size = info->GetUploadSize();
   uint64 position = request->GetUploadProgress();
   if (position == info->last_upload_position())
     return;  // no progress made since last time
 
   const uint64 kHalfPercentIncrements = 200;
   const TimeDelta kOneSecond = TimeDelta::FromMilliseconds(1000);
 
   uint64 amt_since_last = position - info->last_upload_position();
   TimeDelta time_since_last = TimeTicks::Now() - info->last_upload_ticks();
 
   bool is_finished = (size == position);
   bool enough_new_progress = (amt_since_last > (size / kHalfPercentIncrements));
   bool too_much_time_passed = time_since_last > kOneSecond;
 
   if (is_finished || enough_new_progress || too_much_time_passed) {
     if (request->load_flags() & net::LOAD_ENABLE_UPLOAD_PROGRESS) {
-      info->resource_handler()->OnUploadProgress(info->request_id(),
+      info->resource_handler()->OnUploadProgress(info->GetRequestID(),
                                                  position, size);
       info->set_waiting_for_upload_progress_ack(true);
     }
     info->set_last_upload_ticks(TimeTicks::Now());
     info->set_last_upload_position(position);
   }
 }
 
 void ResourceDispatcherHost::BlockRequestsForRoute(int child_id, int route_id) {
   std::pair<int, int> key(child_id, route_id);
@@ skipping 27 matching lines @@
   BlockedRequestsList* requests = iter->second;
 
   // Removing the vector from the map unblocks any subsequent requests.
   blocked_requests_map_.erase(iter);
 
   for (BlockedRequestsList::iterator req_iter = requests->begin();
        req_iter != requests->end(); ++req_iter) {
     // Remove the memory credit that we added when pushing the request onto
     // the blocked list.
     net::URLRequest* request = *req_iter;
-    ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+    ResourceRequestInfoImpl* info = InfoForRequest(request);
     IncrementOutstandingRequestsMemoryCost(-1 * info->memory_cost(),
-                                           info->child_id());
+                                           info->GetChildID());
     if (cancel_requests)
       delete request;
     else
       BeginRequestInternal(request);
   }
 
   delete requests;
 }
 
 bool ResourceDispatcherHost::IsValidRequest(net::URLRequest* request) {
   if (!request)
     return false;
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(request);
+  ResourceRequestInfoImpl* info = InfoForRequest(request);
   return pending_requests_.find(
-      GlobalRequestID(info->child_id(), info->request_id())) !=
+      GlobalRequestID(info->GetChildID(), info->GetRequestID())) !=
       pending_requests_.end();
 }
 
 // static
 bool ResourceDispatcherHost::is_prefetch_enabled() {
   return is_prefetch_enabled_;
 }
 
 // static
 void ResourceDispatcherHost::set_is_prefetch_enabled(bool value) {
@@ skipping 33 matching lines @@
     net::URLRequest* transferred_request) {
   transferred_navigations_[transferred_request_id] = transferred_request;
 
   // If a URLRequest is transferred to a new RenderViewHost, its
   // ResourceHandlers should not receive any notifications because they may
   // depend on the state of the old RVH. We set a ResourceHandler that only
   // allows canceling requests, because on shutdown of the RDH all pending
   // requests are canceled. The RVH of requests that are being transferred may
   // be gone by that time. If the request is resumed, the ResoureHandlers are
   // substituted again.
-  ResourceDispatcherHostRequestInfo* info = InfoForRequest(transferred_request);
+  ResourceRequestInfoImpl* info = InfoForRequest(transferred_request);
   scoped_refptr<ResourceHandler> transferred_resource_handler(
       new DoomedResourceHandler(info->resource_handler()));
   info->set_resource_handler(transferred_resource_handler.get());
 }
 
 bool ResourceDispatcherHost::IsTransferredNavigation(
     const content::GlobalRequestID& transferred_request_id) const {
   return transferred_navigations_.find(transferred_request_id) !=
       transferred_navigations_.end();
 }