Add ResourceRequestInfo.

content/browser/renderer_host/buffered_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/renderer_host/buffered_resource_handler.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "content/browser/download/download_resource_handler.h"
 #include "content/browser/download/download_stats.h"
 #include "content/browser/download/download_types.h"
 #include "content/browser/plugin_service_impl.h"
 #include "content/browser/renderer_host/resource_dispatcher_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/x509_user_cert_resource_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/common/resource_response.h"
 #include "net/base/io_buffer.h"
 #include "net/base/mime_sniffer.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
@@ skipping 81 matching lines @@
     return false;
   }
   read_buffer_ = *buf;
   read_buffer_size_ = *buf_size;
   DCHECK_GE(read_buffer_size_, net::kMaxBytesToSniff * 2);
   bytes_read_ = 0;
   return true;
 }
 
 bool BufferedResourceHandler::OnReadCompleted(int request_id, int* bytes_read) {
-  ResourceDispatcherHostRequestInfo* info =
+  ResourceRequestInfoImpl* info =
       ResourceDispatcherHost::InfoForRequest(request_);
 
   if (sniff_content_) {
     if (KeepBuffering(*bytes_read))
       return true;
 
     *bytes_read = bytes_read_;
 
     // Done buffering, send the pending ResponseStarted event.
     if (!CompleteResponseStarted(request_id))
@@ skipping 118 matching lines @@
 
   buffering_ = false;
 
   if (wait_for_plugins_)
     return true;
 
   return false;
 }
 
 bool BufferedResourceHandler::CompleteResponseStarted(int request_id) {
-  ResourceDispatcherHostRequestInfo* info =
+  ResourceRequestInfoImpl* info =
       ResourceDispatcherHost::InfoForRequest(request_);
   std::string mime_type;
   request_->GetMimeType(&mime_type);
 
   // Check if this is an X.509 certificate, if yes, let it be handled
   // by X509UserCertResourceHandler.
   if (mime_type == "application/x-x509-user-cert") {
     // This is entirely similar to how DownloadResourceThrottle works except we
     // are doing it for an X.509 client certificates.
     // TODO(darin): This does not belong here!
 
     if (response_->headers &&  // Can be NULL if FTP.
         response_->headers->response_code() / 100 != 2) {
       // The response code indicates that this is an error page, but we are
       // expecting an X.509 user certificate. We follow Firefox here and show
       // our own error page instead of handling the error page as a
       // certificate.
       // TODO(abarth): We should abstract the response_code test, but this kind
       //               of check is scattered throughout our codebase.
       request_->SimulateError(net::ERR_FILE_NOT_FOUND);
       return false;
     }
 
     X509UserCertResourceHandler* x509_cert_handler =
         new X509UserCertResourceHandler(host_, request_,
-                                        info->child_id(), info->route_id());
+                                        info->GetChildID(), info->GetRouteID());
     if (!UseAlternateResourceHandler(request_id, x509_cert_handler))
       return false;
   }
 
   // Check to see if we should forward the data from this request to the
   // download thread.
   // TODO(paulg): Only download if the context from the renderer allows it.
   if (info->allow_download() && ShouldDownload(NULL)) {
     if (response_->headers &&  // Can be NULL if FTP.
         response_->headers->response_code() / 100 != 2) {
       // The response code indicates that this is an error page, but we don't
       // know how to display the content.  We follow Firefox here and show our
       // own error page instead of triggering a download.
       // TODO(abarth): We should abstract the response_code test, but this kind
       //               of check is scattered throughout our codebase.
       request_->SimulateError(net::ERR_FILE_NOT_FOUND);
       return false;
     }
 
     info->set_is_download(true);
 
     scoped_refptr<ResourceHandler> handler(
         host_->CreateResourceHandlerForDownload(
             request_,
-            info->context(),
-            info->child_id(),
-            info->route_id(),
-            info->request_id(),
+            info->GetContext(),
+            info->GetChildID(),
+            info->GetRouteID(),
+            info->GetRequestID(),
             DownloadSaveInfo(),
             DownloadResourceHandler::OnStartedCallback()));
 
     if (!UseAlternateResourceHandler(request_id, handler))
       return false;
   }
 
   if (info->pause_count())
     return true;
 
   return next_handler_->OnResponseStarted(request_id, response_);
 }
 
 bool BufferedResourceHandler::ShouldWaitForPlugins() {
   bool need_plugin_list;
   if (!ShouldDownload(&need_plugin_list) || !need_plugin_list)
     return false;
 
   // We don't want to keep buffering as our buffer will fill up.
-  ResourceDispatcherHostRequestInfo* info =
+  ResourceRequestInfoImpl* info =
       ResourceDispatcherHost::InfoForRequest(request_);
-  host_->PauseRequest(info->child_id(), info->request_id(), true);
+  host_->PauseRequest(info->GetChildID(), info->GetRequestID(), true);
 
   // Get the plugins asynchronously.
   PluginServiceImpl::GetInstance()->GetPlugins(
       base::Bind(&BufferedResourceHandler::OnPluginsLoaded, this));
   return true;
 }
 
 // This test mirrors the decision that WebKit makes in
 // WebFrameLoaderClient::dispatchDecidePolicyForMIMEType.
 bool BufferedResourceHandler::ShouldDownload(bool* need_plugin_list) {
@@ skipping 13 matching lines @@
   if (host_->delegate() &&
       host_->delegate()->ShouldForceDownloadResource(request_->url(), type))
     return true;
 
   // MIME type checking.
   if (net::IsSupportedMimeType(type))
     return false;
 
   // Finally, check the plugin list.
   bool allow_wildcard = false;
-  ResourceDispatcherHostRequestInfo* info =
+  ResourceRequestInfoImpl* info =
       ResourceDispatcherHost::InfoForRequest(request_);
   bool stale = false;
   webkit::WebPluginInfo plugin;
   bool found = PluginServiceImpl::GetInstance()->GetPluginInfo(
-      info->child_id(), info->route_id(), info->context(),
+      info->GetChildID(), info->GetRouteID(), info->GetContext(),
       request_->url(), GURL(), type, allow_wildcard,
       &stale, &plugin, NULL);
 
   if (need_plugin_list) {
     if (stale) {
       *need_plugin_list = true;
       return true;
     }
   } else {
     DCHECK(!stale);
   }
 
   return !found;
 }
 
 bool BufferedResourceHandler::UseAlternateResourceHandler(
     int request_id,
     ResourceHandler* handler) {
   // Inform the original ResourceHandler that this will be handled entirely by
   // the new ResourceHandler.
   // TODO(darin): We should probably check the return values of these.
   next_handler_->OnResponseStarted(request_id, response_);
   net::URLRequestStatus status(net::URLRequestStatus::HANDLED_EXTERNALLY, 0);
   next_handler_->OnResponseCompleted(request_id, status, std::string());
 
   // Remove the non-owning pointer to the CrossSiteResourceHandler, if any,
   // from the extra request info because the CrossSiteResourceHandler (part of
   // the original ResourceHandler chain) will be deleted by the next statement.
-  ResourceDispatcherHostRequestInfo* info =
+  ResourceRequestInfoImpl* info =
       ResourceDispatcherHost::InfoForRequest(request_);
   info->set_cross_site_handler(NULL);
 
   // This is handled entirely within the new ResourceHandler, so just reset the
   // original ResourceHandler.
   next_handler_ = handler;
 
   next_handler_needs_response_started_ = true;
   next_handler_needs_will_read_ = true;
 
   return ForwardPendingEventsToNextHandler(request_id);
 }
 
 bool BufferedResourceHandler::ForwardPendingEventsToNextHandler(
     int request_id) {
-  ResourceDispatcherHostRequestInfo* info =
+  ResourceRequestInfoImpl* info =
       ResourceDispatcherHost::InfoForRequest(request_);
   if (info->pause_count())
     return true;
 
   if (next_handler_needs_response_started_) {
     if (!next_handler_->OnResponseStarted(request_id, response_))
       return false;
     // If the request was paused during OnResponseStarted, we need to avoid
     // calling OnResponseStarted again.
     next_handler_needs_response_started_ = false;
@@ skipping 23 matching lines @@
     memcpy(buf->data(), read_buffer_->data(), bytes_read_);
   }
 }
 
 void BufferedResourceHandler::OnPluginsLoaded(
     const std::vector<webkit::WebPluginInfo>& plugins) {
   wait_for_plugins_ = false;
   if (!request_)
     return;
 
-  ResourceDispatcherHostRequestInfo* info =
+  ResourceRequestInfoImpl* info =
       ResourceDispatcherHost::InfoForRequest(request_);
-  host_->PauseRequest(info->child_id(), info->request_id(), false);
-  if (!CompleteResponseStarted(info->request_id()))
-    host_->CancelRequest(info->child_id(), info->request_id(), false);
+  int child_id = info->GetChildID();
+  int request_id = info->GetRequestID();
+
+  host_->PauseRequest(child_id, request_id, false);
+  if (!CompleteResponseStarted(request_id))
+    host_->CancelRequest(child_id, request_id, false);
 }
 
 }  // namespace content