MHTML loading fix

chrome/browser/ui/webui/chromeos/gdata_source.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 "chrome/browser/ui/webui/chromeos/gdata_source.h"
 
 #include <string>
 #include <vector>
 
+#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/gdata/gdata_file_system.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 
 using content::BrowserThread;
 
 namespace {
 
 const int kBufferSize = 8*1024;
 const char kMimeTypeOctetStream[] = "application/octet-stream";
 const net::UnescapeRule::Type kUrlPathUnescapeMask =
     net::UnescapeRule::SPACES |
     net::UnescapeRule::URL_SPECIAL_CHARS |
     net::UnescapeRule::CONTROL_CHARS;
 
+const struct MimeTypeReplacement {
+  const char* original_type;
+  const char* new_type;
+} kMimeTypeReplacements[] = {
+    {"message/rfc822", "multipart/related"}
+};
+
 // Helper function that reads file size.
 void GetFileSizeOnIOThreadPool(const FilePath& file_path,
                                int64* file_size) {
   if (!file_util::GetFileSize(file_path, file_size))
     *file_size = 0;
 }
 
+std::string FixupMimeType(const std::string& type) {
+  for (size_t i = 0; i < arraysize(kMimeTypeReplacements); i++) {
+    if (type == kMimeTypeReplacements[i].original_type)
+      return kMimeTypeReplacements[i].new_type;
+  }
+  return type;
+}
+
 bool ParseGDataUrlPath(const std::string& path,
                        std::string* resource_id,
                        std::string* file_name) {
   std::vector<std::string> components;
   FilePath url_path= FilePath::FromUTF8Unsafe(path);
   url_path.GetComponents(&components);
   if (components.size() != 2) {
     LOG(WARNING) << "Invalid path: " << url_path.value();
     return false;
   }
@@ skipping 98 matching lines @@
   if (!system_service_)
     return kMimeTypeOctetStream;
 
   std::string resource_id;
   std::string unused_file_name;
   if (!ParseGDataUrlPath(path, &resource_id, &unused_file_name))
     return kMimeTypeOctetStream;
 
   GetFileMimeTypeDelegate delegate;
   system_service_->file_system()->FindFileByResourceIdSync(resource_id,
-                                                          &delegate);
+                                                           &delegate);
   if (delegate.mime_type().empty())
     return kMimeTypeOctetStream;
 
-  return delegate.mime_type();
+  return FixupMimeType(delegate.mime_type());
 }
 
 
 void GDataSource::OnGetFileForResourceId(
     int request_id,
     base::PlatformFileError error,
     const FilePath& file_path,
     const std::string& mime_type,
     GDataFileType file_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 105 matching lines @@
   if (read_value != net::ERR_IO_PENDING) {
     LOG(WARNING) << "Failed to read file for request "
                  << context->file_path.value();
     SendResponse(context->request_id,
                  reinterpret_cast<RefCountedMemory*>(NULL));
     return;
   }
 }
 
 }  // namespace gdata