Clean up download code:

chrome/browser/download/download_manager.cc

 // Copyright (c) 2010 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 "app/resource_bundle.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/task.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/download/download_file_manager.h"
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/download/download_item.h"
 #include "chrome/browser/download/download_util.h"
-#include "chrome/browser/extensions/crx_installer.h"
-#include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/history/download_types.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/infobar_delegate.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_util.h"
@@ skipping 13 matching lines @@
 #include "base/win_util.h"
 #endif
 
 namespace {
 
 // Used to sort download items based on descending start time.
 bool CompareStartTime(DownloadItem* first, DownloadItem* second) {
   return first->start_time() > second->start_time();
 }
 
-void DeleteDownloadedFile(const FilePath& path) {
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
-
-  // Make sure we only delete files.
-  if (!file_util::DirectoryExists(path))
-    file_util::Delete(path, false);
-}
-
 }  // namespace
 
 // static
 void DownloadManager::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kPromptForDownload, false);
   prefs->RegisterStringPref(prefs::kDownloadExtensionsToOpen, "");
   prefs->RegisterBooleanPref(prefs::kDownloadDirUpgraded, false);
 
   // The default download path is userprofile\download.
   const FilePath& default_download_path =
@@ skipping 210 matching lines @@
   // Check whether this download is for an extension install or not.
   // Allow extensions to be explicitly saved.
   if (!info->prompt_user_for_save_location) {
     if (UserScript::HasUserScriptFileExtension(info->url) ||
         info->mime_type == Extension::kMimeType)
       info->is_extension_install = true;
   }
 
   if (info->save_info.file_path.empty()) {
     FilePath generated_name;
-    GenerateFileNameFromInfo(info, &generated_name);
+    download_util::GenerateFileNameFromInfo(info, &generated_name);
 
     // Freeze the user's preference for showing a Save As dialog.  We're going
     // to 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 ignore the user's preference for the following scenarios:
       // 1) Extension installation. Note that we only care here about the case
       //    where an extension is installed, not when one is downloaded with
       //    "save as...".
       // 2) Filetypes marked "always open." If the user just wants this file
@@ skipping 14 matching lines @@
     info->suggested_path = info->suggested_path.Append(generated_name);
   } else {
     info->suggested_path = info->save_info.file_path;
   }
 
   if (!info->prompt_user_for_save_location &&
       info->save_info.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()))
+    if (IsExecutableFile(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;
     }
   }
 
   // We need to move over to the download thread because we don't want to stat
   // the suggested path on the UI thread.
@@ skipping 245 matching lines @@
 
 void DownloadManager::ContinueDownloadFinished(DownloadItem* download) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
   // 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.
   dangerous_finished_.erase(download->id());
 
   // Handle chrome extensions explicitly and skip the shell execute.
   if (download->is_extension_install()) {
-    OpenChromeExtension(download->full_path(),
-                        download->url(),
-                        download->referrer_url(),
-                        download->original_mime_type());
+    download_util::OpenChromeExtension(profile_, this, *download);
     download->set_auto_opened(true);
   } else if (download->open_when_complete() ||
              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);
@@ skipping 95 matching lines @@
                           request_id));
 
   // Tell the file manager to cancel the download.
   file_manager_->RemoveDownload(download_id, this);  // On the UI thread
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(
           file_manager_, &DownloadFileManager::CancelDownload, download_id));
 }
 
+// DownloadManager is owned by RDH, no need for reference counting.
+DISABLE_RUNNABLE_METHOD_REFCOUNT(ResourceDispatcherHost);
+
 void DownloadManager::PauseDownload(int32 download_id, bool pause) {
   DownloadMap::iterator it = in_progress_.find(download_id);
   if (it == in_progress_.end())
     return;
 
   DownloadItem* download = it->second;
   if (pause == download->is_paused())
     return;
 
   // Inform the ResourceDispatcherHost of the new pause state.
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
-      NewRunnableFunction(&DownloadManager::OnPauseDownloadRequest,
-                          g_browser_process->resource_dispatcher_host(),
-                          download->render_process_id(),
-                          download->request_id(),
-                          pause));
-}
-
-// static
-void DownloadManager::OnPauseDownloadRequest(ResourceDispatcherHost* rdh,
-                                             int render_process_id,
-                                             int request_id,
-                                             bool pause) {
-  rdh->PauseRequest(render_process_id, request_id, pause);
-}
-
-bool DownloadManager::IsDangerous(const FilePath& file_name) {
-  // TODO(jcampan): Improve me.
-  return IsExecutableFile(file_name);
+      NewRunnableMethod(g_browser_process->resource_dispatcher_host(),
+                        &ResourceDispatcherHost::PauseRequest,
+                        download->render_process_id(),
+                        download->request_id(),
+                        pause));
 }
 
 void DownloadManager::UpdateAppIcon() {
   int64 total_bytes = 0;
   int64 received_bytes = 0;
   int download_count = 0;
   bool progress_known = true;
 
   for (DownloadMap::iterator i = in_progress_.begin();
        i != in_progress_.end();
        ++i) {
     ++download_count;
     const DownloadItem* item = i->second;
     if (item->total_bytes() > 0) {
       total_bytes += item->total_bytes();
       received_bytes += item->received_bytes();
     } else {
       // This download didn't specify a Content-Length, so the combined progress
       // bar neeeds to be indeterminate.
       progress_known = false;
     }
   }
 
   float progress = 0;
   if (progress_known && download_count)
-    progress = (float)received_bytes / total_bytes;
+    progress = static_cast<float>(received_bytes) / total_bytes;
 
   download_util::UpdateAppIconDownloadProgress(download_count,
                                                progress_known,
                                                progress);
 }
 
 void DownloadManager::RenameDownload(DownloadItem* download,
                                      const FilePath& new_path) {
   download->Rename(new_path);
   download_history_->UpdateDownloadPath(download, new_path);
@@ skipping 98 matching lines @@
                           url,
                           referrer,
                           referrer_charset,
                           save_info,
                           g_browser_process->resource_dispatcher_host(),
                           tab_contents->GetRenderProcessHost()->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:
-  //
-  // 1) Security.  Many sites let users upload content, such as buddy icons, to
-  //    their web sites.  We want to mitigate the case where an attacker
-  //    supplies a malicious executable with an executable file extension but an
-  //    honest site serves the content with a benign content type, such as
-  //    image/jpeg.
-  //
-  // 2) Usability.  If the site fails to provide a file extension, we want to
-  //    guess a reasonable file extension based on the content type.
-  //
-  // 3) Shell integration.  Some file extensions automatically integrate with
-  //    the shell.  We block these extensions to prevent a malicious web site
-  //    from integrating with the user's shell.
-
-  static const FilePath::CharType default_extension[] =
-      FILE_PATH_LITERAL("download");
-
-  // See if our file name already contains an extension.
-  FilePath::StringType extension = file_name.Extension();
-  if (!extension.empty())
-    extension.erase(extension.begin());  // Erase preceding '.'.
-
-#if defined(OS_WIN)
-  // Rename shell-integrated extensions.
-  if (win_util::IsShellIntegratedExtension(extension))
-    extension.assign(default_extension);
-#endif
-
-  std::string mime_type_from_extension;
-  net::GetMimeTypeFromFile(file_name,
-                           &mime_type_from_extension);
-  if (mime_type == mime_type_from_extension) {
-    // The hinted extension matches the mime type.  It looks like a winner.
-    generated_extension->swap(extension);
-    return;
-  }
-
-  if (IsExecutableExtension(extension) && !IsExecutableMimeType(mime_type)) {
-    // We want to be careful about executable extensions.  The worry here is
-    // that a trusted web site could be tricked into dropping an executable file
-    // on the user's filesystem.
-    if (!net::GetPreferredExtensionForMimeType(mime_type, &extension)) {
-      // We couldn't find a good extension for this content type.  Use a dummy
-      // extension instead.
-      extension.assign(default_extension);
-    }
-  }
-
-  if (extension.empty()) {
-    net::GetPreferredExtensionForMimeType(mime_type, &extension);
-  } else {
-    // Append extension generated from the mime type if:
-    // 1. New extension is not ".txt"
-    // 2. New extension is not the same as the already existing extension.
-    // 3. New extension is not executable. This action mitigates the case when
-    //    an executable is hidden in a benign file extension;
-    //    E.g. my-cat.jpg becomes my-cat.jpg.js if content type is
-    //         application/x-javascript.
-    // 4. New extension is not ".tar" for .tar.gz files. For misconfigured web
-    //    servers, i.e. bug 5772.
-    // 5. The original extension is not ".tgz" & the new extension is not "gz".
-    FilePath::StringType append_extension;
-    if (net::GetPreferredExtensionForMimeType(mime_type, &append_extension)) {
-      if (append_extension != FILE_PATH_LITERAL("txt") &&
-          append_extension != extension &&
-          !IsExecutableExtension(append_extension) &&
-          !(append_extension == FILE_PATH_LITERAL("gz") &&
-            extension == FILE_PATH_LITERAL("tgz")) &&
-          (append_extension != FILE_PATH_LITERAL("tar") ||
-           extension != FILE_PATH_LITERAL("tar.gz"))) {
-        extension += FILE_PATH_LITERAL(".");
-        extension += append_extension;
-      }
-    }
-  }
-
-  generated_extension->swap(extension);
-}
-
-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(url),
-                                              content_disposition,
-                                              referrer_charset,
-                                              default_file_path);
-
-  DCHECK(!generated_name->empty());
-
-  GenerateSafeFileName(mime_type, generated_name);
-}
-
 void DownloadManager::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
   observer->ModelChanged();
 }
 
 void DownloadManager::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 // Post Windows Shell operations to the Download thread, to avoid blocking the
@@ skipping 11 matching lines @@
           file_manager_, &DownloadFileManager::OnShowDownloadInShell,
           FilePath(download->full_path())));
 #endif
 }
 
 void DownloadManager::OpenDownload(const DownloadItem* download,
                                    gfx::NativeView parent_window) {
   // Open Chrome extensions with ExtensionsService. For everything else do shell
   // execute.
   if (download->is_extension_install()) {
-    OpenChromeExtension(download->full_path(),
-                        download->url(),
-                        download->referrer_url(),
-                        download->original_mime_type());
+    download_util::OpenChromeExtension(profile_, this, *download);
   } else {
     OpenDownloadInShell(download, parent_window);
   }
 }
 
-void DownloadManager::OpenChromeExtension(
-    const FilePath& full_path,
-    const GURL& download_url,
-    const GURL& referrer_url,
-    const std::string& original_mime_type) {
-  // We don't support extensions in OTR mode.
-  ExtensionsService* service = profile_->GetExtensionsService();
-  if (service) {
-    NotificationService* nservice = NotificationService::current();
-    GURL nonconst_download_url = download_url;
-    nservice->Notify(NotificationType::EXTENSION_READY_FOR_INSTALL,
-                     Source<DownloadManager>(this),
-                     Details<GURL>(&nonconst_download_url));
-
-    scoped_refptr<CrxInstaller> installer(
-        new CrxInstaller(service->install_directory(),
-                         service,
-                         new ExtensionInstallUI(profile_)));
-    installer->set_delete_source(true);
-
-    if (UserScript::HasUserScriptFileExtension(download_url)) {
-      installer->InstallUserScript(full_path, download_url);
-    } else {
-      bool is_gallery_download =
-          ExtensionsService::IsDownloadFromGallery(download_url, referrer_url);
-      installer->set_original_mime_type(original_mime_type);
-      installer->set_apps_require_extension_mime_type(true);
-      installer->set_allow_privilege_increase(true);
-      installer->set_original_url(download_url);
-      installer->set_limit_web_extent_to_download_host(!is_gallery_download);
-      installer->InstallCrx(full_path);
-    }
-  } else {
-    TabContents* contents = NULL;
-    // Get last active normal browser of profile.
-    Browser* last_active = BrowserList::FindBrowserWithType(profile_,
-        Browser::TYPE_NORMAL, true);
-    if (last_active)
-      contents = last_active->GetSelectedTabContents();
-    if (contents) {
-      contents->AddInfoBar(
-          new SimpleAlertInfoBarDelegate(contents,
-              l10n_util::GetString(
-                  IDS_EXTENSION_INCOGNITO_INSTALL_INFOBAR_LABEL),
-              ResourceBundle::GetSharedInstance().GetBitmapNamed(
-                  IDR_INFOBAR_PLUGIN_INSTALL),
-              true));
-    }
-  }
-}
-
 void DownloadManager::OpenDownloadInShell(const DownloadItem* download,
                                           gfx::NativeView parent_window) {
   DCHECK(file_manager_);
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 #if defined(OS_MACOSX)
   // Mac OS X requires opening downloads on the UI thread.
   platform_util::OpenItem(download->full_path());
 #else
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(
           file_manager_, &DownloadFileManager::OnOpenDownloadInShell,
           download->full_path(), download->url(), parent_window));
 #endif
 }
 
 void DownloadManager::OpenFilesBasedOnExtension(
     const FilePath& path, bool open) {
   FilePath::StringType extension = path.Extension();
   if (extension.empty())
     return;
   DCHECK(extension[0] == FilePath::kExtensionSeparator);
   extension.erase(0, 1);
-  if (open && !IsExecutableExtension(extension))
+  if (open && !download_util::IsExecutableExtension(extension))
     auto_open_.insert(extension);
   else
     auto_open_.erase(extension);
   SaveAutoOpens();
 }
 
 bool DownloadManager::ShouldOpenFileBasedOnExtension(
     const FilePath& path) const {
   FilePath::StringType extension = path.Extension();
   if (extension.empty())
     return false;
-  if (IsExecutableExtension(extension))
+  if (download_util::IsExecutableExtension(extension))
     return false;
   if (Extension::IsExtension(path))
     return false;
   DCHECK(extension[0] == FilePath::kExtensionSeparator);
   extension.erase(0, 1);
   if (auto_open_.find(extension) != auto_open_.end())
     return true;
   return false;
 }
 
-static const char* kExecutableWhiteList[] = {
-  // JavaScript is just as powerful as EXE.
-  "text/javascript",
-  "text/javascript;version=*",
-  // Registry files can cause critical changes to the MS OS behavior.
-  // Addition of this mimetype also addresses bug 7337.
-  "text/x-registry",
-  // Some sites use binary/octet-stream to mean application/octet-stream.
-  // See http://code.google.com/p/chromium/issues/detail?id=1573
-  "binary/octet-stream"
-};
-
-static const char* kExecutableBlackList[] = {
-  // These application types are not executable.
-  "application/*+xml",
-  "application/xml"
-};
-
-// static
-bool DownloadManager::IsExecutableMimeType(const std::string& mime_type) {
-  for (size_t i = 0; i < arraysize(kExecutableWhiteList); ++i) {
-    if (net::MatchesMimeType(kExecutableWhiteList[i], mime_type))
-      return true;
-  }
-  for (size_t i = 0; i < arraysize(kExecutableBlackList); ++i) {
-    if (net::MatchesMimeType(kExecutableBlackList[i], mime_type))
-      return false;
-  }
-  // 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) {
-  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
-
-  // Strip out leading dot if it's still there
-  if (ascii_extension[0] == FilePath::kExtensionSeparator)
-    ascii_extension.erase(0, 1);
-
-  return download_util::IsExecutableExtension(ascii_extension);
+  return download_util::IsExecutableExtension(path.Extension());
 }
 
 void DownloadManager::ResetAutoOpenFiles() {
   auto_open_.clear();
   SaveAutoOpens();
 }
 
 bool DownloadManager::HasAutoOpenFileTypesRegistered() const {
   return !auto_open_.empty();
 }
@@ skipping 38 matching lines @@
 
 void DownloadManager::FileSelectionCanceled(void* params) {
   // The user didn't pick a place to save the file, so need to cancel the
   // download that's already in progress to the temporary location.
   DownloadCreateInfo* info = reinterpret_cast<DownloadCreateInfo*>(params);
   DownloadCancelledInternal(info->download_id,
                             info->child_id,
                             info->request_id);
 }
 
-void DownloadManager::DeleteDownload(const FilePath& path) {
-  ChromeThread::PostTask(
-      ChromeThread::FILE, FROM_HERE,
-      NewRunnableFunction(&DeleteDownloadedFile, path));
-}
-
 void DownloadManager::DangerousDownloadValidated(DownloadItem* download) {
   DCHECK_EQ(DownloadItem::DANGEROUS, download->safety_state());
   download->set_safety_state(DownloadItem::DANGEROUS_BUT_VALIDATED);
   download->UpdateObservers();
 
   // If the download is not complete, nothing to do.  The required
   // post-processing will be performed when it does complete.
   if (download->state() != DownloadItem::COMPLETE)
     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,
-                                           FilePath* file_name) {
-  // Make sure we get the right file extension
-  FilePath::StringType extension;
-  GenerateExtension(*file_name, mime_type, &extension);
-  *file_name = file_name->ReplaceExtension(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());
-  if (win_util::IsReservedName(leaf_name)) {
-    leaf_name = FilePath::StringType(FILE_PATH_LITERAL("_")) + leaf_name;
-    *file_name = file_name->DirName();
-    if (file_name->value() == FilePath::kCurrentDirectory) {
-      *file_name = FilePath(leaf_name);
-    } else {
-      *file_name = file_name->Append(leaf_name);
-    }
-  }
-#endif
-}
-
 // Operations posted to us from the history service ----------------------------
 
 // The history service has retrieved all download entries. 'entries' contains
 // 'DownloadCreateInfo's in sorted order (by ascending start_time).
 void DownloadManager::OnQueryDownloadEntriesComplete(
     std::vector<DownloadCreateInfo>* entries) {
   for (size_t i = 0; i < entries->size(); ++i) {
     DownloadItem* download = new DownloadItem(this, entries->at(i));
     DCHECK(!ContainsKey(downloads_, download->db_handle()));
     downloads_[download->db_handle()] = download;
@@ skipping 106 matching lines @@
     observed_download_manager_->RemoveObserver(this);
 }
 
 void DownloadManager::OtherDownloadManagerObserver::ModelChanged() {
   observing_download_manager_->NotifyModelChanged();
 }
 
 void DownloadManager::OtherDownloadManagerObserver::ManagerGoingDown() {
   observed_download_manager_ = NULL;
 }