Move ResourceResponse struct into the Content API, since it's used in Chrome. While at it, I also...

content/browser/renderer_host/buffered_resource_handler.cc

 // Copyright (c) 2011 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_id_factory.h"
 #include "content/browser/download/download_resource_handler.h"
 #include "content/browser/download/download_types.h"
 #include "content/browser/plugin_service.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/x509_user_cert_resource_handler.h"
 #include "content/browser/resource_context.h"
-#include "content/common/resource_response.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.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"
 #include "net/http/http_response_headers.h"
 #include "webkit/plugins/webplugininfo.h"
 
 namespace {
 
 void RecordSnifferMetrics(bool sniffing_blocked,
@@ skipping 36 matching lines @@
       buffering_(false),
       finished_(false) {
 }
 
 bool BufferedResourceHandler::OnUploadProgress(int request_id,
                                                uint64 position,
                                                uint64 size) {
   return real_handler_->OnUploadProgress(request_id, position, size);
 }
 
-bool BufferedResourceHandler::OnRequestRedirected(int request_id,
-                                                  const GURL& new_url,
-                                                  ResourceResponse* response,
-                                                  bool* defer) {
+bool BufferedResourceHandler::OnRequestRedirected(
+    int request_id,
+    const GURL& new_url,
+    content::ResourceResponse* response,
+    bool* defer) {
   return real_handler_->OnRequestRedirected(
       request_id, new_url, response, defer);
 }
 
-bool BufferedResourceHandler::OnResponseStarted(int request_id,
-                                                ResourceResponse* response) {
+bool BufferedResourceHandler::OnResponseStarted(
+    int request_id,
+    content::ResourceResponse* response) {
   response_ = response;
   if (!DelayResponse())
     return CompleteResponseStarted(request_id, false);
   return true;
 }
 
 bool BufferedResourceHandler::OnResponseCompleted(
     int request_id,
     const net::URLRequestStatus& status,
     const std::string& security_info) {
@@ skipping 67 matching lines @@
   std::string mime_type;
   request_->GetMimeType(&mime_type);
 
   std::string content_type_options;
   request_->GetResponseHeaderByName("x-content-type-options",
                                     &content_type_options);
 
   const bool sniffing_blocked =
       LowerCaseEqualsASCII(content_type_options, "nosniff");
   const bool not_modified_status =
-      response_->response_head.headers &&
-      response_->response_head.headers->response_code() == 304;
+      response_->headers && response_->headers->response_code() == 304;
   const bool we_would_like_to_sniff = not_modified_status ?
       false : net::ShouldSniffMimeType(request_->url(), mime_type);
 
   RecordSnifferMetrics(sniffing_blocked, we_would_like_to_sniff, mime_type);
 
   if (!sniffing_blocked && we_would_like_to_sniff) {
     // We're going to look at the data before deciding what the content type
     // is.  That means we need to delay sending the ResponseStarted message
     // over the IPC channel.
     sniff_content_ = true;
     VLOG(1) << "To buffer: " << request_->url().spec();
     return true;
   }
 
   if (sniffing_blocked && mime_type.empty() && !not_modified_status) {
     // Ugg.  The server told us not to sniff the content but didn't give us a
     // mime type.  What's a browser to do?  Turns out, we're supposed to treat
     // the response as "text/plain".  This is the most secure option.
     mime_type.assign("text/plain");
-    response_->response_head.mime_type.assign(mime_type);
+    response_->mime_type.assign(mime_type);
   }
 
   if (mime_type == "application/rss+xml" ||
       mime_type == "application/atom+xml") {
     // Sad face.  The server told us that they wanted us to treat the response
     // as RSS or Atom.  Unfortunately, we don't have a built-in feed previewer
     // like other browsers.  We can't just render the content as XML because
     // web sites let third parties inject arbitrary script into their RSS
     // feeds.  That leaves us with little choice but to practically ignore the
     // response.  In the future, when we have an RSS feed previewer, we can
     // remove this logic.
     mime_type.assign("text/plain");
-    response_->response_head.mime_type.assign(mime_type);
+    response_->mime_type.assign(mime_type);
   }
 
   if (!not_modified_status && ShouldWaitForPlugins()) {
     wait_for_plugins_ = true;
     return true;
   }
 
   return false;
 }
 
@@ skipping 26 matching lines @@
       // SniffMimeType() returns false if there is not enough data to determine
       // the mime type. However, even if it returns false, it returns a new type
       // that is probably better than the current one.
       DCHECK_LT(bytes_read_, net::kMaxBytesToSniff);
       if (!finished_) {
         buffering_ = true;
         return true;
       }
     }
     sniff_content_ = false;
-    response_->response_head.mime_type.assign(new_type);
+    response_->mime_type.assign(new_type);
 
     // We just sniffed the mime type, maybe there is a doctype to process.
     if (ShouldWaitForPlugins())
       wait_for_plugins_ = true;
   }
 
   buffering_ = false;
 
   if (wait_for_plugins_)
     return true;
 
   return false;
 }
 
 bool BufferedResourceHandler::CompleteResponseStarted(int request_id,
                                                       bool in_complete) {
   ResourceDispatcherHostRequestInfo* 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 DownloadThrottlingResourceHandler
     // works except we are doing it for an X.509 client certificates.
 
-    if (response_->response_head.headers &&  // Can be NULL if FTP.
-        response_->response_head.headers->response_code() / 100 != 2) {
+    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());
     UseAlternateResourceHandler(request_id, x509_cert_handler);
   }
 
   // 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_->response_head.headers &&  // Can be NULL if FTP.
-        response_->response_head.headers->response_code() / 100 != 2) {
+    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);
@@ skipping 38 matching lines @@
   PluginService::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) {
   if (need_plugin_list)
     *need_plugin_list = false;
-  std::string type = StringToLowerASCII(response_->response_head.mime_type);
+  std::string type = StringToLowerASCII(response_->mime_type);
   std::string disposition;
   request_->GetResponseHeaderByName("content-disposition", &disposition);
   disposition = StringToLowerASCII(disposition);
 
   // First, examine content-disposition.
   if (!disposition.empty()) {
     bool should_download = true;
 
     // Some broken sites just send ...
     //    Content-Disposition: ; filename="file"
@@ skipping 88 matching lines @@
   wait_for_plugins_ = false;
   if (!request_)
     return;
 
   ResourceDispatcherHostRequestInfo* info =
       ResourceDispatcherHost::InfoForRequest(request_);
   host_->PauseRequest(info->child_id(), info->request_id(), false);
   if (!CompleteResponseStarted(info->request_id(), false))
     host_->CancelRequest(info->child_id(), info->request_id(), false);
 }