Unbreak unit tests. Revert r7564.

chrome/browser/download/download_manager.cc

 // Copyright (c) 2006-2008 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 <time.h>
 
 #include "chrome/browser/download/download_manager.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 47 matching lines @@
 static const int kUpdateTimeMs = 1000;
 
 // Our download table ID starts at 1, so we use 0 to represent a download that
 // has started, but has not yet had its data persisted in the table. We use fake
 // database handles in incognito mode starting at -1 and progressively getting
 // more negative.
 static const int kUninitializedHandle = 0;
 
 // Appends the passed the number between parenthesis the path before the
 // extension.
-static void AppendNumberToPath(FilePath* path, int number) {
-  file_util::InsertBeforeExtension(path,
-      StringPrintf(FILE_PATH_LITERAL(" (%d)"), number));
+static void AppendNumberToPath(std::wstring* path, int number) {
+  file_util::InsertBeforeExtension(path, StringPrintf(L" (%d)", number));
 }
 
 // Attempts to find a number that can be appended to that path to make it
 // unique. If |path| does not exist, 0 is returned.  If it fails to find such
 // a number, -1 is returned.
-static int GetUniquePathNumber(const FilePath& path) {
+static int GetUniquePathNumber(const std::wstring& path) {
   const int kMaxAttempts = 100;
 
   if (!file_util::PathExists(path))
     return 0;
 
-  FilePath new_path;
+  std::wstring new_path;
   for (int count = 1; count <= kMaxAttempts; ++count) {
-    new_path = FilePath(path);
+    new_path.assign(path);
     AppendNumberToPath(&new_path, count);
 
     if (!file_util::PathExists(new_path))
       return count;
   }
 
   return -1;
 }
 
-static bool DownloadPathIsDangerous(const FilePath& download_path) {
-  FilePath desktop_dir;
+static bool DownloadPathIsDangerous(const std::wstring& download_path) {
+  std::wstring desktop_dir;
   if (!PathService::Get(chrome::DIR_USER_DESKTOP, &desktop_dir)) {
     NOTREACHED();
     return false;
   }
   return (download_path == desktop_dir);
 }
 
 // DownloadItem implementation -------------------------------------------------
 
 // Constructor for reading from the history service.
@@ skipping 14 matching lines @@
       open_when_complete_(false),
       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,
+                           const std::wstring& path,
                            int path_uniquifier,
                            const std::wstring& url,
-                           const FilePath& original_name,
+                           const std::wstring& original_name,
                            const 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),
       original_name_(original_name),
       total_bytes_(download_size),
       received_bytes_(0),
       start_tick_(GetTickCount()),
       state_(IN_PROGRESS),
       start_time_(start_time),
       db_handle_(kUninitializedHandle),
       manager_(NULL),
       safety_state_(is_dangerous ? DANGEROUS : SAFE),
       is_paused_(false),
       open_when_complete_(false),
       render_process_id_(render_process_id),
       request_id_(request_id) {
   Init(true /* start progress timer */);
 }
 
 void DownloadItem::Init(bool start_timer) {
-  file_name_ = full_path_.BaseName();
+  file_name_ = file_util::GetFilenameFromPath(full_path_);
   if (start_timer)
     StartProgressTimer();
 }
 
 DownloadItem::~DownloadItem() {
   state_ = REMOVING;
   UpdateObservers();
 }
 
 void DownloadItem::AddObserver(Observer* observer) {
@@ skipping 84 matching lines @@
   return diff == 0 ? 0 : received_bytes_ * 1000 / diff;
 }
 
 int DownloadItem::PercentComplete() const {
   int percent = -1;
   if (total_bytes_ > 0)
     percent = static_cast<int>(received_bytes_ * 100.0 / total_bytes_);
   return percent;
 }
 
-void DownloadItem::Rename(const FilePath& full_path) {
+void DownloadItem::Rename(const std::wstring& full_path) {
   DCHECK(!full_path.empty());
   full_path_ = full_path;
-  file_name_ = full_path_.BaseName();
+  file_name_ = file_util::GetFilenameFromPath(full_path_);
 }
 
 void DownloadItem::TogglePause() {
   DCHECK(state_ == IN_PROGRESS);
   manager_->PauseDownload(id_, !is_paused_);
   is_paused_ = !is_paused_;
   UpdateObservers();
 }
 
-FilePath DownloadItem::GetFileName() const {
+std::wstring DownloadItem::GetFileName() const {
   if (safety_state_ == DownloadItem::SAFE)
     return file_name_;
   if (path_uniquifier_ > 0) {
-    FilePath name(original_name_);
+    std::wstring name(original_name_);
     AppendNumberToPath(&name, path_uniquifier_);
     return name;
   }
   return original_name_;
 }
 
 // DownloadManager implementation ----------------------------------------------
 
 // static
 void DownloadManager::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kPromptForDownload, false);
   prefs->RegisterStringPref(prefs::kDownloadExtensionsToOpen, L"");
   prefs->RegisterBooleanPref(prefs::kDownloadDirUpgraded, false);
 
   // The default download path is userprofile\download.
-  FilePath default_download_path;
+  std::wstring default_download_path;
   if (!PathService::Get(chrome::DIR_DEFAULT_DOWNLOADS,
                         &default_download_path)) {
     NOTREACHED();
   }
   prefs->RegisterStringPref(prefs::kDownloadDefaultDirectory,
-                            default_download_path.ToWStringHack());
+                            default_download_path);
 
   // If the download path is dangerous we forcefully reset it. But if we do
   // so we set a flag to make sure we only do it once, to avoid fighting
   // the user if he really wants it on an unsafe place such as the desktop.
 
   if (!prefs->GetBoolean(prefs::kDownloadDirUpgraded)) {
-    FilePath current_download_dir = FilePath::FromWStringHack(
-        prefs->GetString(prefs::kDownloadDefaultDirectory));
+    std::wstring current_download_dir =
+        prefs->GetString(prefs::kDownloadDefaultDirectory);
     if (DownloadPathIsDangerous(current_download_dir)) {
       prefs->SetString(prefs::kDownloadDefaultDirectory,
-                       default_download_path.ToWStringHack());
+                       default_download_path);
     }
     prefs->SetBoolean(prefs::kDownloadDirUpgraded, true);
   }
 }
 
 DownloadManager::DownloadManager()
     : shutdown_needed_(false),
       profile_(NULL),
       file_manager_(NULL),
       ui_loop_(MessageLoop::current()),
@@ skipping 147 matching lines @@
     return false;
   }
 
   // Get our user preference state.
   PrefService* prefs = profile_->GetPrefs();
   DCHECK(prefs);
   prompt_for_download_.Init(prefs::kPromptForDownload, prefs, NULL);
 
   download_path_.Init(prefs::kDownloadDefaultDirectory, prefs, NULL);
 
-  // This variable is needed to resolve which CreateDirectory we want to point
-  // to. Without it, the NewRunnableFunction cannot resolve the ambiguity.
-  // TODO(estade): when file_util::CreateDirectory(wstring) is removed,
-  // get rid of |CreateDirectoryPtr|.
-  bool (*CreateDirectoryPtr)(const FilePath&) = &file_util::CreateDirectory;
   // Ensure that the download directory specified in the preferences exists.
-  file_loop_->PostTask(FROM_HERE, NewRunnableFunction(
-      CreateDirectoryPtr, download_path()));
+  file_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+      file_manager_, &DownloadFileManager::CreateDirectory, *download_path_));
 
   // We store any file extension that should be opened automatically at
   // download completion in this pref.
   download_util::InitializeExeTypes(&exe_types_);
 
   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) {
@@ skipping 25 matching lines @@
   DCHECK(info);
 
   // 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_)
     info->save_as = true;
 
   // Determine the proper path for a download, by choosing either the default
   // download directory, or prompting the user.
-  FilePath generated_name;
+  std::wstring generated_name;
   GenerateFilename(info, &generated_name);
   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);
+    info->suggested_path = *download_path_;
+  file_util::AppendToPath(&info->suggested_path, generated_name);
 
   if (!info->save_as) {
     // Let's check if this download is dangerous, based on its name.
-    info->is_dangerous = IsDangerous(info->suggested_path.BaseName());
+    const std::wstring filename =
+        file_util::GetFilenameFromPath(info->suggested_path);
+    info->is_dangerous = IsDangerous(filename);
   }
 
   // We need to move over to the download thread because we don't want to stat
   // the suggested path on the UI thread.
   file_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this,
                         &DownloadManager::CheckIfSuggestedPathExists,
                         info));
 }
 
 void DownloadManager::CheckIfSuggestedPathExists(DownloadCreateInfo* info) {
   DCHECK(info);
 
   // Check writability of the suggested path. If we can't write to it, default
   // to the user's "My Documents" directory. We'll prompt them in this case.
-  FilePath dir = info->suggested_path.DirName();
-  FilePath filename = info->suggested_path.BaseName();
+  std::wstring dir = file_util::GetDirectoryFromPath(info->suggested_path);
+  const std::wstring filename =
+      file_util::GetFilenameFromPath(info->suggested_path);
   if (!file_util::PathIsWritable(dir)) {
     info->save_as = true;
     PathService::Get(chrome::DIR_USER_DOCUMENTS, &info->suggested_path);
-    info->suggested_path = info->suggested_path.Append(filename);
+    file_util::AppendToPath(&info->suggested_path, filename);
   }
 
   info->path_uniquifier = GetUniquePathNumber(info->suggested_path);
 
   // If the download is deemed dangerous, we'll use a temporary name for it.
   if (info->is_dangerous) {
-    info->original_name = FilePath(info->suggested_path).BaseName();
+    info->original_name = file_util::GetFilenameFromPath(info->suggested_path);
     // Create a temporary file to hold the file until the user approves its
     // download.
-    FilePath::StringType file_name;
-    FilePath path;
+    std::wstring file_name;
+    std::wstring path;
     while (path.empty()) {
-      SStringPrintf(&file_name, FILE_PATH_LITERAL("unconfirmed %d.download"),
+      SStringPrintf(&file_name, L"unconfirmed %d.download",
                     base::RandInt(0, 100000));
-      path = dir.Append(file_name);
+      path = dir;
+      file_util::AppendToPath(&path, file_name);
       if (file_util::PathExists(path))
-        path = FilePath();
+        path.clear();
     }
     info->suggested_path = path;
   } else {
     // We know the final path, build it if necessary.
     if (info->path_uniquifier > 0) {
       AppendNumberToPath(&(info->suggested_path), info->path_uniquifier);
       // Setting path_uniquifier to 0 to make sure we don't try to unique it
       // later on.
       info->path_uniquifier = 0;
     } else if (info->path_uniquifier == -1) {
       // We failed to find a unique path.  We have to prompt the user.
       info->save_as = true;
     }
   }
 
   if (!info->save_as) {
     // Create an empty file at the suggested path so that we don't allocate the
     // same "non-existant" path to multiple downloads.
     // See: http://code.google.com/p/chromium/issues/detail?id=3662
-    file_util::WriteFile(info->suggested_path.ToWStringHack(), "", 0);
+    file_util::WriteFile(info->suggested_path, "", 0);
   }
 
   // Now we return to the UI thread.
   ui_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this,
                         &DownloadManager::OnPathExistenceAvailable,
                         info));
 }
 
 void DownloadManager::OnPathExistenceAvailable(DownloadCreateInfo* info) {
   DCHECK(MessageLoop::current() == ui_loop_);
   DCHECK(info);
 
   if (info->save_as) {
     // We must ask the user for the place to put the download.
     if (!select_file_dialog_.get())
       select_file_dialog_ = SelectFileDialog::Create(this);
 
     WebContents* contents = tab_util::GetWebContentsByID(
         info->render_process_id, info->render_view_id);
-    std::wstring filter =
-        win_util::GetFileFilterFromPath(info->suggested_path.value());
+    std::wstring filter = win_util::GetFileFilterFromPath(info->suggested_path);
     HWND owning_hwnd =
         contents ? GetAncestor(contents->GetContainerHWND(), GA_ROOT) : NULL;
     select_file_dialog_->SelectFile(SelectFileDialog::SELECT_SAVEAS_FILE,
-                                    std::wstring(),
-                                    info->suggested_path.ToWStringHack(),
+                                    std::wstring(), info->suggested_path,
                                     filter, std::wstring(),
                                     owning_hwnd, info);
   } else {
     // No prompting for download, just continue with the suggested name.
     ContinueStartDownload(info, info->suggested_path);
   }
 }
 
 void DownloadManager::ContinueStartDownload(DownloadCreateInfo* info,
-                                            const FilePath& target_path) {
+                                            const std::wstring& target_path) {
   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,
@@ skipping 154 matching lines @@
   // Open the download if the user or user prefs indicate it should be.
   const std::wstring extension =
       file_util::GetFileExtensionFromPath(download->full_path());
   if (download->open_when_complete() || ShouldOpenFileExtension(extension))
     OpenDownloadInShell(download, NULL);
 }
 
 // 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) {
+    const std::wstring& path,
+    const std::wstring& original_name) {
   bool success = false;
-  FilePath new_path;
+  std::wstring new_path = path;
   int uniquifier = 0;
   if (file_util::PathExists(path)) {
-    new_path = new_path.DirName().Append(original_name);
+    new_path = file_util::GetDirectoryFromPath(new_path);
+    file_util::AppendToPath(&new_path, original_name);
     // Make our name unique at this point, as if a dangerous file is downloading
     // and a 2nd download is started for a file with the same name, they would
     // have the same path.  This is because we uniquify the name on download
     // start, and at that time the first file does not exists yet, so the second
     // file gets the same name.
     uniquifier = GetUniquePathNumber(new_path);
     if (uniquifier > 0)
       AppendNumberToPath(&new_path, uniquifier);
     success = file_util::Move(path, new_path);
   } else {
     NOTREACHED();
   }
 
   ui_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &DownloadManager::DangerousDownloadRenamed,
                         download_handle, success, new_path, uniquifier));
 }
 
 // Call from the file thread when the finished dangerous download was renamed.
 void DownloadManager::DangerousDownloadRenamed(int64 download_handle,
                                                bool success,
-                                               const FilePath& new_path,
+                                               const std::wstring& new_path,
                                                int new_path_uniquifier) {
   DownloadMap::iterator it = downloads_.find(download_handle);
   if (it == downloads_.end()) {
     NOTREACHED();
     return;
   }
 
   DownloadItem* download = it->second;
   // If we failed to rename the file, we'll just keep the name as is.
   if (success) {
@@ skipping 78 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) {
+bool DownloadManager::IsDangerous(const std::wstring& file_name) {
   // TODO(jcampan): Improve me.
   return IsExecutable(file_util::GetFileExtensionFromPath(file_name));
 }
 
 void DownloadManager::RenameDownload(DownloadItem* download,
-                                     const FilePath& new_path) {
+                                     const std::wstring& 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)
     return;
 
   // FIXME(paulg) see bug 958058. EXPLICIT_ACCESS below is wrong.
   HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
   if (hs)
-    hs->UpdateDownloadPath(new_path.ToWStringHack(), download->db_handle());
+    hs->UpdateDownloadPath(new_path, download->db_handle());
 }
 
 void DownloadManager::RemoveDownload(int64 download_handle) {
   DownloadMap::iterator it = downloads_.find(download_handle);
   if (it == downloads_.end())
     return;
 
   // Make history update.
   DownloadItem* download = it->second;
   RemoveDownloadFromHistory(download);
@@ skipping 70 matching lines @@
       Notify(NOTIFY_DOWNLOAD_START, NotificationService::AllSources(),
              NotificationService::NoDetails());
 }
 
 void DownloadManager::NotifyAboutDownloadStop() {
   NotificationService::current()->
       Notify(NOTIFY_DOWNLOAD_STOP, NotificationService::AllSources(),
              NotificationService::NoDetails());
 }
 
-void DownloadManager::GenerateExtension(const FilePath& file_name,
-    const std::string& mime_type, FilePath::StringType* generated_extension) {
+void DownloadManager::GenerateExtension(const std::wstring& file_name,
+                                        const std::string& mime_type,
+                                        std::wstring* 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");
+  static const wchar_t default_extension[] = L"download";
 
   // See if our file name already contains an extension.
-  FilePath::StringType extension(
-      file_util::GetFileExtensionFromPath(file_name));
+  std::wstring extension(file_util::GetFileExtensionFromPath(file_name));
 
   // Rename shell-integrated extensions.
   if (win_util::IsShellIntegratedExtension(extension))
     extension.assign(default_extension);
 
   std::string mime_type_from_extension;
-  net::GetMimeTypeFromFile(file_name.ToWStringHack(),
-                           &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)) {
     // 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;
+    //    an execuatable is hidden in a benign file extension;
     //    E.g. my-cat.jpg becomes my-cat.jpg.js if content type is
     //         application/x-javascript.
-    FilePath::StringType append_extension;
+    std::wstring append_extension;
     if (net::GetPreferredExtensionForMimeType(mime_type, &append_extension)) {
-      if (append_extension != FILE_PATH_LITERAL(".txt") &&
-          append_extension != extension &&
+      if (append_extension != L".txt" && append_extension != extension &&
           !IsExecutable(append_extension))
         extension += append_extension;
     }
   }
 
   generated_extension->swap(extension);
 }
 
 void DownloadManager::GenerateFilename(DownloadCreateInfo* info,
-                                       FilePath* generated_name) {
-  FilePath file_name = FilePath::FromWStringHack(
+                                       std::wstring* generated_name) {
+  std::wstring file_name =
       net::GetSuggestedFilename(GURL(info->url),
                                 info->content_disposition,
-                                L"download"));
+                                L"download");
   DCHECK(!file_name.empty());
 
   // Make sure we get the right file extension.
-  FilePath::StringType extension;
+  std::wstring extension;
   GenerateExtension(file_name, info->mime_type, &extension);
   file_util::ReplaceExtension(&file_name, extension);
 
   // Prepend "_" to the file name if it's a reserved name
-  if (win_util::IsReservedName(file_name.ToWStringHack()))
-    file_name = FilePath(L"_").Append(file_name);
+  if (win_util::IsReservedName(file_name))
+    file_name = std::wstring(L"_") + file_name;
 
-  *generated_name = FilePath(file_name);
+  generated_name->assign(file_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
 // user interface.
 void DownloadManager::ShowDownloadInShell(const DownloadItem* download) {
   DCHECK(file_manager_);
   file_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(file_manager_,
                         &DownloadFileManager::OnShowDownloadInShell,
-                        FilePath(download->full_path())));
+                        download->full_path()));
 }
 
 void DownloadManager::OpenDownloadInShell(const DownloadItem* download,
                                           HWND parent_window) {
   DCHECK(file_manager_);
   file_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(file_manager_,
                         &DownloadFileManager::OnOpenDownloadInShell,
                         download->full_path(), download->url(), parent_window));
 }
 
-void DownloadManager::OpenFilesOfExtension(
-    const FilePath::StringType& extension, bool open) {
+void DownloadManager::OpenFilesOfExtension(const std::wstring& extension,
+                                           bool open) {
   if (open && !IsExecutable(extension))
     auto_open_.insert(extension);
   else
     auto_open_.erase(extension);
   SaveAutoOpens();
 }
 
-bool DownloadManager::ShouldOpenFileExtension(
-    const FilePath::StringType& extension) {
+bool DownloadManager::ShouldOpenFileExtension(const std::wstring& extension) {
   if (!IsExecutable(extension) &&
       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=*",
@@ skipping 15 matching lines @@
       return true;
   }
   for (int 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::IsExecutable(const std::wstring& extension) {
   return exe_types_.find(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();
+    std::wstring extensions;
+    for (std::set<std::wstring>::iterator it = auto_open_.begin();
          it != auto_open_.end(); ++it) {
-      extensions += *it + FILE_PATH_LITERAL(":");
+      extensions += *it + L":";
     }
     if (!extensions.empty())
       extensions.erase(extensions.size() - 1);
     prefs->SetString(prefs::kDownloadExtensionsToOpen, extensions);
   }
 }
 
-void DownloadManager::FileSelected(const std::wstring& path_string,
-                                   void* params) {
-  FilePath path = FilePath::FromWStringHack(path_string);
+void DownloadManager::FileSelected(const std::wstring& path, void* params) {
   DownloadCreateInfo* info = reinterpret_cast<DownloadCreateInfo*>(params);
   if (info->save_as)
-    last_download_path_ = path.DirName();
+    last_download_path_ = file_util::GetDirectoryFromPath(path);
   ContinueStartDownload(info, path);
 }
 
 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);
   file_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(file_manager_, &DownloadFileManager::CancelDownload,
                         info->download_id));
 }
 
-void DownloadManager::DeleteDownload(const FilePath& path) {
-  file_loop_->PostTask(FROM_HERE, NewRunnableFunction(
-      &DownloadFileManager::DeleteFile, FilePath(path)));
+void DownloadManager::DeleteDownload(const std::wstring& path) {
+  file_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+      file_manager_, &DownloadFileManager::DeleteFile, 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.
@@ skipping 90 matching lines @@
     DownloadMap::iterator dit = downloads_.find(*it);
     if (dit != downloads_.end())
       searched_downloads.push_back(dit->second);
   }
 
   requestor->SetDownloads(searched_downloads);
 }
 
 // Clears the last download path, used to initialize "save as" dialogs.
 void DownloadManager::ClearLastDownloadPath() {
-  last_download_path_ = FilePath();
+  last_download_path_.clear();
 }