Add the ability to specify a default MIME type when loading a resource. We'l...

chrome/browser/renderer_host/buffered_resource_handler.cc

 // Copyright (c) 2006-2008 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 "base/histogram.h"
 #include "base/string_util.h"
 #include "net/base/mime_sniffer.h"
 #include "chrome/browser/renderer_host/download_throttling_resource_handler.h"
@@ skipping 162 matching lines @@
     return false;
 
   // Today, the only reason to buffer the request is to fix the doctype decoding
   // performed by webkit: if there is not enough data it will go to quirks mode.
   // We only expect the doctype check to apply to html documents.
   return mime_type == "text/html";
 }
 
 bool BufferedResourceHandler::KeepBuffering(int bytes_read) {
   DCHECK(read_buffer_);
+
+  ResourceDispatcherHost::ExtraRequestInfo* info =
+      ResourceDispatcherHost::ExtraInfoForRequest(request_);
+  DCHECK(info);
+
   if (my_buffer_) {
     // We are using our own buffer to read, update the main buffer.
     CHECK(bytes_read + bytes_read_ < read_buffer_size_);
     memcpy(read_buffer_->data() + bytes_read_, my_buffer_->data(), bytes_read);
     my_buffer_ = NULL;
   }
   bytes_read_ += bytes_read;
   finished_ = (bytes_read == 0);
 
   if (sniff_content_) {
     std::string type_hint, new_type;
     request_->GetMimeType(&type_hint);
 
+    if (type_hint.empty())
+      type_hint = info->default_mime_type;
+
     if (!net::SniffMimeType(read_buffer_->data(), bytes_read_,
                             request_->url(), type_hint, &new_type)) {
       // 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(bytes_read_ < kMaxBytesToSniff);
       if (!finished_) {
         buffering_ = true;
         return true;
       }
@@ skipping 74 matching lines @@
     real_handler_ = download_handler;
   }
   return real_handler_->OnResponseStarted(request_id, response_);
 }
 
 bool BufferedResourceHandler::DidBufferEnough(int bytes_read) {
   const int kRequiredLength = 256;
 
   return bytes_read >= kRequiredLength;
 }