Sniff 204 responses as text/plain to avoid creating unwanted downloads....

chrome/browser/renderer_host/buffered_resource_handler.cc

 // Copyright (c) 2009 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 "chrome/browser/renderer_host/buffered_resource_handler.h"
 
 #include <vector>
 
 #include "base/histogram.h"
 #include "base/logging.h"
@@ skipping 136 matching lines @@
 bool BufferedResourceHandler::DelayResponse() {
   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 no_data =
-      response_->response_head.headers &&  // Can be NULL if FTP.
-      (response_->response_head.headers->response_code() == 304 ||
-       response_->response_head.headers->response_code() == 204);
-  const bool we_would_like_to_sniff =
-      no_data ? false : net::ShouldSniffMimeType(request_->url(), mime_type);
+  const bool not_modified_status =
+      response_->response_head.headers &&
+      response_->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;
     LOG(INFO) << "To buffer: " << request_->url().spec();
     return true;
   }
 
-  if (sniffing_blocked && mime_type.empty() && !no_data) {
+  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);
   }
 
   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);
   }
 
   if (ShouldBuffer(request_->url(), mime_type)) {
     // This is a temporary fix for the fact that webkit expects to have
     // enough data to decode the doctype in order to select the rendering
     // mode.
     should_buffer_ = true;
     LOG(INFO) << "To buffer: " << request_->url().spec();
     return true;
   }
 
-  if (!no_data && ShouldWaitForPlugins()) {
+  if (!not_modified_status && ShouldWaitForPlugins()) {
     wait_for_plugins_ = true;
     return true;
   }
 
   return false;
 }
 
 bool BufferedResourceHandler::ShouldBuffer(const GURL& url,
                                            const std::string& mime_type) {
   // We are willing to buffer for HTTP and HTTPS.
@@ skipping 232 matching lines @@
   wait_for_plugins_ = false;
   if (request_) {
     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);
   }
   Release();
 }