Bug fix for 10876, file extension handling refactoring

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 508 matching lines @@
   // 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() && !IsExecutable(
-        FilePath::FromWStringHack(extensions[i]).value()))
+    if (!extensions[i].empty() && !IsExecutableFile(
+        FilePath::FromWStringHack(extensions[i])))
       auto_open_.insert(FilePath::FromWStringHack(extensions[i]).value());
   }
 
   return true;
 }
 
 void DownloadManager::QueryHistoryForDownloads() {
   HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
   if (hs) {
     hs->QueryDownloads(
@@ skipping 309 matching lines @@
                                                  const FilePath& full_path) {
 }
 
 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);
 
-  // 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 (IsExtensionInstall(download)) {
     OpenChromeExtension(download->full_path(), download->url(),
                         download->referrer_url());
     download->set_auto_opened(true);
   } else if (download->open_when_complete() ||
-             ShouldOpenFileExtension(extension)) {
+             ShouldOpenFileBasedOnExtension(download->full_path())) {
     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();
 }
+
 // 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;
   if (file_util::PathExists(path)) {
     new_path = path.DirName().Append(original_name);
@@ skipping 106 matching lines @@
 // 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.
-  FilePath::StringType extension = file_name.Extension();
-  // Drop the leading period.
-  if (extension.size() > 0)
-    extension = extension.substr(1);
-  return IsExecutable(extension);
+  return IsExecutableFile(file_name);
 }
 
 void DownloadManager::RenameDownload(DownloadItem* download,
                                      const FilePath& new_path) {
   download->Rename(new_path);
 
   // Update the history.
 
   // No update necessary if the download was initiated while in incognito mode.
   if (download->db_handle() <= kUninitializedHandle)
@@ skipping 126 matching lines @@
 
   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 (IsExecutable(extension) && !IsExecutableMimeType(mime_type)) {
+  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 .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 &&
-          !IsExecutable(append_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("gz"))) {
         extension += FILE_PATH_LITERAL(".");
         extension += append_extension;
       }
     }
   }
 
@@ skipping 78 matching lines @@
   // Mac OS X requires opening downloads on the UI thread.
   platform_util::OpenItem(download->full_path());
 #else
   file_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(file_manager_,
                         &DownloadFileManager::OnOpenDownloadInShell,
                         download->full_path(), download->url(), parent_window));
 #endif
 }
 
-void DownloadManager::OpenFilesOfExtension(
-    const FilePath::StringType& extension, bool open) {
-  if (open && !IsExecutable(extension))
+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))
     auto_open_.insert(extension);
   else
     auto_open_.erase(extension);
   SaveAutoOpens();
 }
 
-bool DownloadManager::ShouldOpenFileExtension(
-    const FilePath::StringType& extension) {
+bool DownloadManager::ShouldOpenFileBasedOnExtension(
+    const FilePath& path) const {
   // Special-case Chrome extensions as always-open.
-  if (!IsExecutable(extension) &&
-      (auto_open_.find(extension) != auto_open_.end() ||
-       Extension::IsExtension(FilePath(extension))))
+  FilePath::StringType extension = path.Extension();
+  if (extension.empty())
+    return false;
+  if (IsExecutableExtension(extension))
+    return false;
+  DCHECK(extension[0] == FilePath::kExtensionSeparator);
+  extension.erase(0, 1);
+  if (auto_open_.find(extension) != auto_open_.end() ||
+      Extension::IsExtension(path))
     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.
@@ skipping 16 matching lines @@
       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::IsExecutable(const FilePath::StringType& extension) {
+bool DownloadManager::IsExecutableFile(const FilePath& path) const {
+  return IsExecutableExtension(path.Extension());
+}
+
+bool DownloadManager::IsExecutableExtension(
+    const FilePath::StringType& extension) const {
+  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();
 }
 
 void DownloadManager::ResetAutoOpenFiles() {
   auto_open_.clear();
   SaveAutoOpens();
 }
 
 bool DownloadManager::HasAutoOpenFileTypesRegistered() const {
   return !auto_open_.empty();
 }
 
 void DownloadManager::SaveAutoOpens() {
   PrefService* prefs = profile_->GetPrefs();
   if (prefs) {
     FilePath::StringType extensions;
-    for (std::set<FilePath::StringType>::iterator it = auto_open_.begin();
+    for (AutoOpenSet::iterator it = auto_open_.begin();
          it != auto_open_.end(); ++it) {
       extensions += *it + FILE_PATH_LITERAL(":");
     }
     if (!extensions.empty())
       extensions.erase(extensions.size() - 1);
 
     std::wstring extensions_w;
 #if defined(OS_WIN)
     extensions_w = extensions;
 #elif defined(OS_POSIX)
@@ skipping 162 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();
 }