Add mimetypes on the "chrome-resource://" responses....

chrome/browser/dom_ui/chrome_url_data_manager.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/dom_ui/chrome_url_data_manager.h"
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
@@ skipping 34 matching lines @@
   // URLRequestJob implementation.
   virtual void Start();
   virtual void Kill();
   virtual bool ReadRawData(char* buf, int buf_size, int *bytes_read);
   virtual bool GetMimeType(std::string* mime_type);
 
   // Called by ChromeURLDataManager to notify us that the data blob is ready
   // for us.
   void DataAvailable(RefCountedBytes* bytes);
 
+  void SetMimeType(const std::string& mime_type) {
+    mime_type_ = mime_type;
+  }
+
  private:
   // Helper for Start(), to let us start asynchronously.
   // (This pattern is shared by most URLRequestJob implementations.)
   void StartAsync();
 
   // Do the actual copy from data_ (the data we're serving) into |buf|.
   // Separate from ReadRawData so we can handle async I/O.
   void CompleteRead(char* buf, int buf_size, int* bytes_read);
 
   // The actual data we're serving.  NULL until it's been fetched.
   scoped_refptr<RefCountedBytes> data_;
   // The current offset into the data that we're handing off to our
   // callers via the Read interfaces.
   int data_offset_;
 
   // For async reads, we keep around a pointer to the buffer that
   // we're reading into.
   char* pending_buf_;
   int pending_buf_size_;
+  std::string mime_type_;
 
   DISALLOW_EVIL_CONSTRUCTORS(URLRequestChromeJob);
 };
 
 // URLRequestChromeFileJob is a URLRequestJob that acts like a file:// URL
 class URLRequestChromeFileJob : public URLRequestFileJob {
  public:
   URLRequestChromeFileJob(URLRequest* request, const std::wstring& path);
   virtual ~URLRequestChromeFileJob();
 
@@ skipping 96 matching lines @@
   // Look up the data source for the request.
   DataSourceMap::iterator i = data_sources_.find(source_name);
   if (i == data_sources_.end())
     return false;
   DataSource* source = i->second;
 
   // Save this request so we know where to send the data.
   RequestID request_id = next_request_id_++;
   pending_requests_.insert(std::make_pair(request_id, job));
 
+  // TODO(eroman): would be nicer if the mimetype were set at the same time
+  // as the data blob. For now do it here, since NotifyHeadersComplete() is
+  // going to get called once we return.
+  job->SetMimeType(source->GetMimeType(path));
+
   // Forward along the request to the data source.
   source->message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(source, &DataSource::StartDataRequest,
                         path, request_id));
   return true;
 }
 
 void ChromeURLDataManager::RemoveRequest(URLRequestChromeJob* job) {
   // Remove the request from our list of pending requests.
   // If/when the source sends the data that was requested, the data will just
@@ skipping 51 matching lines @@
   // callbacks happen as they would for network requests.
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &URLRequestChromeJob::StartAsync));
 }
 
 void URLRequestChromeJob::Kill() {
   chrome_url_data_manager.RemoveRequest(this);
 }
 
 bool URLRequestChromeJob::GetMimeType(std::string* mime_type) {
-  // Rely on MIME sniffing to simplify the logic here.
-  *mime_type = "text/html";
-  return true;
+  *mime_type = mime_type_;
+  return !mime_type_.empty();
 }
 
 void URLRequestChromeJob::DataAvailable(RefCountedBytes* bytes) {
   if (bytes) {
     // The request completed, and we have all the data.
     // Clear any IO pending status.
     SetStatus(URLRequestStatus());
 
     data_ = bytes;
     int bytes_read;
@@ skipping 46 matching lines @@
 }
 
 URLRequestChromeFileJob::URLRequestChromeFileJob(URLRequest* request,
                                                  const std::wstring& path)
     : URLRequestFileJob(request) {
   this->file_path_ = path;  // set URLRequestFileJob::file_path_
 }
 
 URLRequestChromeFileJob::~URLRequestChromeFileJob() { }