RefCounted types should not have public destructors

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"
@@ skipping 146 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_->headers && response_->headers->response_code() == 304;
+      (response_->head.headers &&
+       response_->head.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_->mime_type.assign(mime_type);
+    response_->head.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_->mime_type.assign(new_type);
+    response_->head.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* defer) {
   ResourceRequestInfoImpl* info =
       ResourceRequestInfoImpl::ForRequest(request_);
   std::string mime_type;
   request_->GetMimeType(&mime_type);
 
   if (mime_type == "application/x-x509-user-cert") {
     // Let X.509 certs be handled by the X509UserCertResourceHandler.
 
     // This is entirely similar to how DownloadResourceHandler 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) {
+    if (response_->head.headers &&  // Can be NULL if FTP.
+        response_->head.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_->CancelWithError(net::ERR_FILE_NOT_FOUND);
       return false;
     }
 
     scoped_ptr<ResourceHandler> handler(
         new X509UserCertResourceHandler(request_,
                                         info->GetChildID(),
                                         info->GetRouteID()));
 
     return UseAlternateResourceHandler(request_id, handler.Pass(), defer);
   }
 
   if (info->allow_download() && ShouldDownload(NULL)) {
     // Forward the data to the download thread.
-
-    if (response_->headers &&  // Can be NULL if FTP.
-        response_->headers->response_code() / 100 != 2) {
+    if (response_->head.headers &&  // Can be NULL if FTP.
+        response_->head.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_->CancelWithError(net::ERR_FILE_NOT_FOUND);
       return false;
     }
 
     info->set_is_download(true);
@@ skipping 23 matching lines @@
   PluginServiceImpl::GetInstance()->GetPlugins(
       base::Bind(&BufferedResourceHandler::OnPluginsLoaded, AsWeakPtr()));
   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_->mime_type);
+  std::string type = StringToLowerASCII(response_->head.mime_type);
 
   // First, examine Content-Disposition.
   std::string disposition;
   request_->GetResponseHeaderByName("content-disposition", &disposition);
   if (!disposition.empty()) {
     net::HttpContentDisposition parsed_disposition(disposition, std::string());
     if (parsed_disposition.is_attachment())
       return true;
   }
 
@@ skipping 98 matching lines @@
 
   bool defer = false;
   if (!CompleteResponseStarted(request_id, &defer)) {
     controller()->Cancel();
   } else if (!defer && needs_resume) {
     controller()->Resume();
   }
 }
 
 }  // namespace content