Merge 21612 - Implement mimetype sniffing for extensions....

chrome/browser/download/download_manager.cc

 // Copyright (c) 2006-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/download/download_manager.h"
 
 #include "app/l10n_util.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 99 matching lines @@
   return (download_path == desktop_dir);
 }
 
 // DownloadItem implementation -------------------------------------------------
 
 // Constructor for reading from the history service.
 DownloadItem::DownloadItem(const DownloadCreateInfo& info)
     : id_(-1),
       full_path_(info.path),
       url_(info.url),
+      referrer_url_(info.referrer_url),
+      mime_type_(info.mime_type),
       total_bytes_(info.total_bytes),
       received_bytes_(info.received_bytes),
       start_tick_(base::TimeTicks()),
       state_(static_cast<DownloadState>(info.state)),
       start_time_(info.start_time),
       db_handle_(info.db_handle),
       manager_(NULL),
       is_paused_(false),
       open_when_complete_(false),
       safety_state_(SAFE),
       auto_opened_(false),
       original_name_(info.original_name),
       render_process_id_(-1),
       request_id_(-1) {
   if (state_ == IN_PROGRESS)
     state_ = CANCELLED;
   Init(false /* don't start progress timer */);
 }
 
 // Constructor for DownloadItem created via user action in the main thread.
 DownloadItem::DownloadItem(int32 download_id,
                            const FilePath& path,
                            int path_uniquifier,
                            const GURL& url,
+                           const std::string& mime_type,
                            const FilePath& original_name,
                            const base::Time start_time,
                            int64 download_size,
                            int render_process_id,
                            int request_id,
                            bool is_dangerous)
     : id_(download_id),
       full_path_(path),
       path_uniquifier_(path_uniquifier),
       url_(url),
+      mime_type_(mime_type),
       total_bytes_(download_size),
       received_bytes_(0),
       start_tick_(base::TimeTicks::Now()),
       state_(IN_PROGRESS),
       start_time_(start_time),
       db_handle_(kUninitializedHandle),
       manager_(NULL),
       is_paused_(false),
       open_when_complete_(false),
       safety_state_(is_dangerous ? DANGEROUS : SAFE),
@@ skipping 503 matching lines @@
   scoped_ptr<DownloadCreateInfo> infop(info);
   info->path = target_path;
 
   DownloadItem* download = NULL;
   DownloadMap::iterator it = in_progress_.find(info->download_id);
   if (it == in_progress_.end()) {
     download = new DownloadItem(info->download_id,
                                 info->path,
                                 info->path_uniquifier,
                                 info->url,
+                                info->mime_type,
                                 info->original_name,
                                 info->start_time,
                                 info->total_bytes,
                                 info->render_process_id,
                                 info->request_id,
                                 info->is_dangerous);
     download->set_manager(this);
     in_progress_[info->download_id] = download;
   } else {
     NOTREACHED();  // Should not exist!
@@ skipping 144 matching lines @@
   if (it != dangerous_finished_.end())
     dangerous_finished_.erase(it);
 
   // Open the download if the user or user prefs indicate it should be.
   FilePath::StringType extension = download->full_path().Extension();
   // Drop the leading period. (The auto-open list is period-less.)
   if (extension.size() > 0)
     extension = extension.substr(1);
 
   // Handle chrome extensions explicitly and skip the shell execute.
-  if (Extension::IsExtension(download->full_path())) {
+  if (download->mime_type() == Extension::kMimeType) {
     OpenChromeExtension(download->full_path());
     download->set_auto_opened(true);
   } else if (download->open_when_complete() ||
              ShouldOpenFileExtension(extension)) {
     OpenDownloadInShell(download, NULL);
     download->set_auto_opened(true);
   }
 
   // Notify our observers that we are complete (the call to Finished() set the
   // state to complete but did not notify).
@@ skipping 348 matching lines @@
   file_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(file_manager_,
                         &DownloadFileManager::OnShowDownloadInShell,
                         FilePath(download->full_path())));
 }
 
 void DownloadManager::OpenDownload(const DownloadItem* download,
                                    gfx::NativeView parent_window) {
   // Open Chrome extensions with ExtensionsService. For everything else do shell
   // execute.
-  if (Extension::IsExtension(download->full_path())) {
+  if (download->mime_type() == Extension::kMimeType) {
     OpenChromeExtension(download->full_path());
   } else {
     OpenDownloadInShell(download, parent_window);
   }
 }
 
 void DownloadManager::OpenChromeExtension(const FilePath& full_path) {
   profile_->GetOriginalProfile()->GetExtensionsService()->
       InstallExtension(full_path);
 }
@@ skipping 259 matching lines @@
 
   if (contents)
     contents->OnStartDownload(download);
 }
 
 // Clears the last download path, used to initialize "save as" dialogs.
 void DownloadManager::ClearLastDownloadPath() {
   last_download_path_ = FilePath();
 }