Support dragging a virtual file out of the browser.

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 117 matching lines @@
       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) {
+      request_id_(-1),
+      save_as_(false),
+      name_finalized_(false),
+      is_temporary_(false) {
   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 GURL& referrer_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,
                            bool save_as,
-                           bool is_extension_install)
+                           bool is_extension_install,
+                           bool is_temporary)
     : id_(download_id),
       full_path_(path),
       path_uniquifier_(path_uniquifier),
       url_(url),
       referrer_url_(referrer_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),
       auto_opened_(false),
       original_name_(original_name),
       render_process_id_(render_process_id),
       request_id_(request_id),
       save_as_(save_as),
-      is_extension_install_(is_extension_install) {
+      is_extension_install_(is_extension_install),
+      name_finalized_(false),
+      is_temporary_(is_temporary) {
   Init(true /* start progress timer */);
 }
 
 void DownloadItem::Init(bool start_timer) {
   file_name_ = full_path_.BaseName();
   if (start_timer)
     StartProgressTimer();
 }
 
 DownloadItem::~DownloadItem() {
   state_ = REMOVING;
   UpdateObservers();
 }
 
 void DownloadItem::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void DownloadItem::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void DownloadItem::UpdateObservers() {
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadUpdated(this));
 }
 
+void DownloadItem::NotifyObserversDownloadFileCompleted() {
+  FOR_EACH_OBSERVER(Observer, observers_, OnDownloadFileCompleted(this));
+}
+
 void DownloadItem::NotifyObserversDownloadOpened() {
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadOpened(this));
 }
 
 // If we've received more data than we were expecting (bad server info?), revert
 // to 'unknown size mode'.
 void DownloadItem::UpdateSize(int64 bytes_so_far) {
   received_bytes_ = bytes_so_far;
   if (received_bytes_ > total_bytes_)
     total_bytes_ = 0;
@@ skipping 246 matching lines @@
   if (hs) {
     HistoryService::Handle h =
         hs->SearchDownloads(search_text,
                             &cancelable_consumer_,
                             NewCallback(this,
                                         &DownloadManager::OnSearchComplete));
     cancelable_consumer_.SetClientData(hs, h, observer);
   }
 }
 
+void DownloadManager::GetTemporaryDownloads(Observer* observer,
+                                            const FilePath& dir_path) {
+  DCHECK(observer);
+
+  std::vector<DownloadItem*> download_copy;
+
+  for (DownloadMap::iterator it = downloads_.begin();
+       it != downloads_.end(); ++it) {
+    if (it->second->is_temporary() &&
+        it->second->full_path().DirName() == dir_path)
+      download_copy.push_back(it->second);
+  }
+
+  observer->SetDownloads(download_copy);
+}
+
 // Query the history service for information about all persisted downloads.
 bool DownloadManager::Init(Profile* profile) {
   DCHECK(profile);
   DCHECK(!shutdown_needed_)  << "DownloadManager already initialized.";
   shutdown_needed_ = true;
 
   profile_ = profile;
   request_context_getter_ = profile_->GetRequestContext();
 
   // 'incognito mode' will have access to past downloads, but we won't store
@@ skipping 17 matching lines @@
   DCHECK(prefs);
   prompt_for_download_.Init(prefs::kPromptForDownload, prefs, NULL);
 
   download_path_.Init(prefs::kDownloadDefaultDirectory, prefs, NULL);
 
   // Ensure that the download directory specified in the preferences exists.
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableFunction(&file_util::CreateDirectory, download_path()));
 
-  // We use this to determine possibly dangerous downloads.
-  download_util::InitializeExeTypes(&exe_types_);
-
   // We store any file extension that should be opened automatically at
   // download completion in this pref.
   std::wstring extensions_to_open =
       prefs->GetString(prefs::kDownloadExtensionsToOpen);
   std::vector<std::wstring> extensions;
   SplitString(extensions_to_open, L':', &extensions);
   for (size_t i = 0; i < extensions.size(); ++i) {
     if (!extensions[i].empty() && !IsExecutableFile(
         FilePath::FromWStringHack(extensions[i])))
       auto_open_.insert(FilePath::FromWStringHack(extensions[i]).value());
@@ skipping 33 matching lines @@
   // bounce around a bunch of threads and we don't want to worry about race
   // conditions where the user changes this pref out from under us.
   if (*prompt_for_download_) {
     // But never obey the preference for extension installation. Note that we
     // only care here about the case where an extension is installed, not when
     // one is downloaded with "save as...".
     if (!info->is_extension_install)
       info->save_as = true;
   }
 
-  // Determine the proper path for a download, by choosing either the default
-  // download directory, or prompting the user.
+  // Determine the proper path for a download, by either one of the following:
+  // 1) using the provided save file path.
+  // 2) using the default download directory.
+  // 3) prompting the user.
   FilePath generated_name;
-  GenerateFilename(info, &generated_name);
-  if (info->save_as && !last_download_path_.empty())
+  GenerateFileNameFromInfo(info, &generated_name);
+  if (!info->save_file_path.empty())
+    info->suggested_path = info->save_file_path;
+  else if (info->save_as && !last_download_path_.empty())
     info->suggested_path = last_download_path_;
   else
     info->suggested_path = download_path();
   info->suggested_path = info->suggested_path.Append(generated_name);
 
-  if (!info->save_as) {
+  if (!info->save_as && info->save_file_path.empty()) {
     // Downloads can be marked as dangerous for two reasons:
     // a) They have a dangerous-looking filename
     // b) They are an extension that is not from the gallery
     if (IsDangerous(info->suggested_path.BaseName()))
       info->is_dangerous = true;
     else if (info->is_extension_install &&
              !ExtensionsService::IsDownloadFromGallery(info->url,
                                                        info->referrer_url)) {
       info->is_dangerous = true;
     }
@@ skipping 109 matching lines @@
                                 info->url,
                                 info->referrer_url,
                                 info->mime_type,
                                 info->original_name,
                                 info->start_time,
                                 info->total_bytes,
                                 info->child_id,
                                 info->request_id,
                                 info->is_dangerous,
                                 info->save_as,
-                                info->is_extension_install);
+                                info->is_extension_install,
+                                !info->save_file_path.empty());
     download->set_manager(this);
     in_progress_[info->download_id] = download;
   } else {
     NOTREACHED();  // Should not exist!
     return;
   }
 
   // Called before DownloadFinished in order to avoid a race condition where we
   // attempt to open a completed download before it has been renamed.
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(
           file_manager_, &DownloadFileManager::OnFinalDownloadName,
           download->id(), target_path, this));
 
   // If the download already completed by the time we reached this point, then
   // notify observers that it did.
   PendingFinishedMap::iterator pending_it =
       pending_finished_downloads_.find(info->download_id);
   if (pending_it != pending_finished_downloads_.end())
     DownloadFinished(pending_it->first, pending_it->second);
 
   download->Rename(target_path);
 
   // Do not store the download in the history database for a few special cases:
   // - incognito mode (that is the point of this mode)
   // - extensions (users don't think of extension installation as 'downloading')
+  // - temporary download, like in drag-and-drop
   // We have to make sure that these handles don't collide with normal db
   // handles, so we use a negative value. Eventually, they could overlap, but
   // you'd have to do enough downloading that your ISP would likely stab you in
   // the neck first. YMMV.
-  if (profile_->IsOffTheRecord() || download->is_extension_install()) {
+  if (profile_->IsOffTheRecord() || download->is_extension_install() ||
+      download->is_temporary()) {
     static int64 fake_db_handle = kUninitializedHandle - 1;
     OnCreateDownloadEntryComplete(*info, fake_db_handle--);
   } else {
     // Update the history system with the new download.
     // FIXME(paulg) see bug 958058. EXPLICIT_ACCESS below is wrong.
     HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
     if (hs) {
       hs->CreateDownload(
           *info, &cancelable_consumer_,
           NewCallback(this, &DownloadManager::OnCreateDownloadEntryComplete));
@@ skipping 92 matching lines @@
             this, &DownloadManager::ProceedWithFinishedDangerousDownload,
             download->db_handle(),
             download->full_path(), download->original_name()));
     return;
   }
   ContinueDownloadFinished(download);
 }
 
 void DownloadManager::DownloadRenamedToFinalName(int download_id,
                                                  const FilePath& full_path) {
+  DownloadMap::iterator it = downloads_.begin();
+  while (it != downloads_.end()) {
+    DownloadItem* download = it->second;
+    if (download->id() == download_id) {
+      // The download file is meant to be completed if both the filename is
+      // finalized and the file data is downloaded. The ordering of these two
+      // actions is indeterministic. Thus, if we are still in downloading the
+      // file, delay the notification.
+      download->set_name_finalized(true);
+      if (download->state() == DownloadItem::COMPLETE)
+        download->NotifyObserversDownloadFileCompleted();
+      return;
+    }
+    it++;
+  }
 }
 
 void DownloadManager::ContinueDownloadFinished(DownloadItem* download) {
   // If this was a dangerous download, it has now been approved and must be
   // removed from dangerous_finished_ so it does not get deleted on shutdown.
   DownloadMap::iterator it = dangerous_finished_.find(download->id());
   if (it != dangerous_finished_.end())
     dangerous_finished_.erase(it);
 
   // Handle chrome extensions explicitly and skip the shell execute.
   if (download->is_extension_install()) {
     OpenChromeExtension(download->full_path(), download->url(),
                         download->referrer_url());
     download->set_auto_opened(true);
   } else if (download->open_when_complete() ||
-             ShouldOpenFileBasedOnExtension(download->full_path())) {
-    OpenDownloadInShell(download, NULL);
+             ShouldOpenFileBasedOnExtension(download->full_path()) ||
+             download->is_temporary()) {
+    // If the download is temporary, like in drag-and-drop, do not open it but
+    // we still need to set it auto-opened so that it can be removed from the
+    // download shelf.
+    if (!download->is_temporary())
+      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).
   download->UpdateObservers();
+
+  // The download file is meant to be completed if both the filename is
+  // finalized and the file data is downloaded. The ordering of these two
+  // actions is indeterministic. Thus, if the filename is not finalized yet,
+  // delay the notification.
+  if (download->name_finalized())
+    download->NotifyObserversDownloadFileCompleted();
 }
 
 // Called on the file thread.  Renames the downloaded file to its original name.
 void DownloadManager::ProceedWithFinishedDangerousDownload(
     int64 download_handle,
     const FilePath& path,
     const FilePath& original_name) {
   bool success = false;
   FilePath new_path;
   int uniquifier = 0;
@@ skipping 206 matching lines @@
   return RemoveDownloadsBetween(base::Time(), base::Time());
 }
 
 // Initiate a download of a specific URL. We send the request to the
 // ResourceDispatcherHost, and let it send us responses like a regular
 // download.
 void DownloadManager::DownloadUrl(const GURL& url,
                                   const GURL& referrer,
                                   const std::string& referrer_charset,
                                   TabContents* tab_contents) {
+  file_manager_->DownloadUrl(url,
+                             referrer,
+                             referrer_charset,
+                             FilePath(),
+                             tab_contents->process()->id(),
+                             tab_contents->render_view_host()->routing_id(),
+                             request_context_getter_);
+}
+
+void DownloadManager::DownloadUrlToFile(const GURL& url,
+                                        const GURL& referrer,
+                                        const std::string& referrer_charset,
+                                        const FilePath& save_file_path,
+                                        TabContents* tab_contents) {
   DCHECK(tab_contents);
   file_manager_->DownloadUrl(url,
                              referrer,
                              referrer_charset,
+                             save_file_path,
                              tab_contents->process()->id(),
                              tab_contents->render_view_host()->routing_id(),
                              request_context_getter_);
 }
 
 void DownloadManager::GenerateExtension(
     const FilePath& file_name,
     const std::string& mime_type,
     FilePath::StringType* generated_extension) {
   // We're worried about three things here:
@@ skipping 68 matching lines @@
            extension != FILE_PATH_LITERAL("gz"))) {
         extension += FILE_PATH_LITERAL(".");
         extension += append_extension;
       }
     }
   }
 
   generated_extension->swap(extension);
 }
 
-void DownloadManager::GenerateFilename(DownloadCreateInfo* info,
+void DownloadManager::GenerateFileNameFromInfo(DownloadCreateInfo* info,
+                                               FilePath* generated_name) {
+  GenerateFileName(GURL(info->url),
+                   info->content_disposition,
+                   info->referrer_charset,
+                   info->mime_type,
+                   generated_name);
+}
+
+void DownloadManager::GenerateFileName(const GURL& url,
+                                       const std::string& content_disposition,
+                                       const std::string& referrer_charset,
+                                       const std::string& mime_type,
                                        FilePath* generated_name) {
   std::wstring default_name =
       l10n_util::GetString(IDS_DEFAULT_DOWNLOAD_FILENAME);
 #if defined(OS_WIN)
   FilePath default_file_path(default_name);
 #elif defined(OS_POSIX)
   FilePath default_file_path(base::SysWideToNativeMB(default_name));
 #endif
 
-  *generated_name = net::GetSuggestedFilename(GURL(info->url),
-                                              info->content_disposition,
-                                              info->referrer_charset,
+  *generated_name = net::GetSuggestedFilename(GURL(url),
+                                              content_disposition,
+                                              referrer_charset,
                                               default_file_path);
 
   DCHECK(!generated_name->empty());
 
-  GenerateSafeFilename(info->mime_type, generated_name);
+  GenerateSafeFileName(mime_type, generated_name);
 }
 
 void DownloadManager::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
   observer->ModelChanged();
 }
 
 void DownloadManager::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
@@ skipping 136 matching lines @@
   }
   // We consider only other application types to be executable.
   return net::MatchesMimeType("application/*", mime_type);
 }
 
 bool DownloadManager::IsExecutableFile(const FilePath& path) const {
   return IsExecutableExtension(path.Extension());
 }
 
 bool DownloadManager::IsExecutableExtension(
-    const FilePath::StringType& extension) const {
+    const FilePath::StringType& extension) {
   if (extension.empty())
     return false;
   if (!IsStringASCII(extension))
     return false;
 #if defined(OS_WIN)
   std::string ascii_extension = WideToASCII(extension);
 #elif defined(OS_POSIX)
   std::string ascii_extension = extension;
 #endif
-  StringToLowerASCII(&ascii_extension);
 
   // Strip out leading dot if it's still there
   if (ascii_extension[0] == FilePath::kExtensionSeparator)
     ascii_extension.erase(0, 1);
 
-  return exe_types_.find(ascii_extension) != exe_types_.end();
+  return download_util::IsExecutableExtension(ascii_extension);
 }
 
 void DownloadManager::ResetAutoOpenFiles() {
   auto_open_.clear();
   SaveAutoOpens();
 }
 
 bool DownloadManager::HasAutoOpenFileTypesRegistered() const {
   return !auto_open_.empty();
 }
@@ skipping 55 matching lines @@
     return;
 
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(
           this, &DownloadManager::ProceedWithFinishedDangerousDownload,
           download->db_handle(), download->full_path(),
           download->original_name()));
 }
 
-void DownloadManager::GenerateSafeFilename(const std::string& mime_type,
+void DownloadManager::GenerateSafeFileName(const std::string& mime_type,
                                            FilePath* file_name) {
   // Make sure we get the right file extension
   FilePath::StringType extension;
   GenerateExtension(*file_name, mime_type, &extension);
   file_util::ReplaceExtension(file_name, extension);
 
 #if defined(OS_WIN)
   // Prepend "_" to the file name if it's a reserved name
   FilePath::StringType leaf_name = file_name->BaseName().value();
   DCHECK(!leaf_name.empty());
@@ skipping 96 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();
 }