Unbreak unit tests. Revert r7564.

chrome/browser/download/download_file.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 <Windows.h>
 #include <objbase.h>
 
 #include "chrome/browser/download/download_file.h"
 
 #include "base/file_util.h"
@@ skipping 67 matching lines @@
   if (file_) {
     fwrite(data, 1, data_len, file_);
     bytes_so_far_ += data_len;
     return true;
   }
   return false;
 }
 
 void DownloadFile::Cancel() {
   Close();
-  file_util::Delete(full_path_, false);
+  DeleteFile(full_path_.c_str());
 }
 
 // The UI has provided us with our finalized name.
-bool DownloadFile::Rename(const FilePath& new_path) {
+bool DownloadFile::Rename(const std::wstring& new_path) {
   Close();
 
   // We cannot rename because rename will keep the same security descriptor
   // on the destination file. We want to recreate the security descriptor
   // with the security that makes sense in the new path.
-  if (!file_util::RenameFileAndResetSecurityDescriptor(
-      full_path_.value().c_str(), new_path.value().c_str())) {
+  if (!file_util::RenameFileAndResetSecurityDescriptor(full_path_.c_str(),
+                                                       new_path.c_str())) {
     return false;
   }
 
-  file_util::Delete(full_path_, false);
+  DeleteFile(full_path_.c_str());
 
   full_path_ = new_path;
   path_renamed_ = true;
 
   // We don't need to re-open the file if we're done (finished or canceled).
   if (!in_progress_)
     return true;
 
   if (!Open("a+b"))
     return false;
   return true;
 }
 
 void DownloadFile::Close() {
   if (file_) {
     file_util::CloseFile(file_);
     file_ = NULL;
   }
 }
 
 bool DownloadFile::Open(const char* open_mode) {
   DCHECK(!full_path_.empty());
   file_ = file_util::OpenFile(full_path_, open_mode);
   if (!file_) {
     return false;
   }
   // Sets the Zone to tell Windows that this file comes from the internet.
   // We ignore the return value because a failure is not fatal.
-  win_util::SetInternetZoneIdentifier(full_path_.value());
+  win_util::SetInternetZoneIdentifier(full_path_);
   return true;
 }
 
 // DownloadFileManager implementation ------------------------------------------
 
 DownloadFileManager::DownloadFileManager(MessageLoop* ui_loop,
                                          ResourceDispatcherHost* rdh)
     : next_id_(0),
       ui_loop_(ui_loop),
       resource_dispatcher_host_(rdh) {
@@ skipping 362 matching lines @@
                                            render_process_host_id,
                                            render_view_id,
                                            request_context);
 }
 
 // Actions from the UI thread and run on the download thread
 
 // Open a download, or show it in a Windows Explorer window. We run on this
 // thread to avoid blocking the UI with (potentially) slow Shell operations.
 // TODO(paulg): File 'stat' operations.
-void DownloadFileManager::OnShowDownloadInShell(const FilePath& full_path) {
+void DownloadFileManager::OnShowDownloadInShell(const std::wstring full_path) {
   DCHECK(MessageLoop::current() == file_loop_);
-  win_util::ShowItemInFolder(full_path.value());
+  win_util::ShowItemInFolder(full_path);
 }
 
 // Launches the selected download using ShellExecute 'open' verb. If there is
 // a valid parent window, the 'safer' version will be used which can
 // display a modal dialog asking for user consent on dangerous files.
-void DownloadFileManager::OnOpenDownloadInShell(const FilePath& full_path,
+void DownloadFileManager::OnOpenDownloadInShell(const std::wstring full_path,
                                                 const std::wstring& url,
                                                 HWND parent_window) {
   DCHECK(MessageLoop::current() == file_loop_);
   if (NULL != parent_window) {
-    win_util::SaferOpenItemViaShell(parent_window, L"", full_path.value(),
-                                    url, true);
+    win_util::SaferOpenItemViaShell(parent_window, L"", full_path, url, true);
   } else {
-    win_util::OpenItemViaShell(full_path.value(), true);
+    win_util::OpenItemViaShell(full_path, true);
   }
 }
 
 // The DownloadManager in the UI thread has provided a final name for the
 // download specified by 'id'. Rename the in progress download, and remove it
 // from our table if it has been completed or cancelled already.
 void DownloadFileManager::OnFinalDownloadName(int id,
-                                              const FilePath& full_path) {
+                                              const std::wstring& full_path) {
   DCHECK(MessageLoop::current() == file_loop_);
   DownloadFileMap::iterator it = downloads_.find(id);
   if (it == downloads_.end())
     return;
 
-  file_util::CreateDirectory(full_path.DirName());
+  std::wstring download_dir = file_util::GetDirectoryFromPath(full_path);
+  if (!file_util::PathExists(download_dir))
+    file_util::CreateDirectory(download_dir);
 
   DownloadFile* download = it->second;
   if (!download->Rename(full_path)) {
     // Error. Between the time the UI thread generated 'full_path' to the time
     // this code runs, something happened that prevents us from renaming.
     DownloadManagerMap::iterator dmit = managers_.find(download->id());
     if (dmit != managers_.end()) {
       DownloadManager* dlm = dmit->second;
       ui_loop_->PostTask(FROM_HERE,
           NewRunnableMethod(dlm,
@@ skipping 12 matching lines @@
   if (!download->in_progress()) {
     downloads_.erase(it);
     delete download;
   }
 
   if (downloads_.empty())
     ui_loop_->PostTask(FROM_HERE, NewRunnableMethod(
         this, &DownloadFileManager::StopUpdateTimer));
 }
 
-// static
-void DownloadFileManager::DeleteFile(const FilePath& path) {
+void DownloadFileManager::CreateDirectory(const std::wstring& directory) {
+  if (!file_util::PathExists(directory))
+    file_util::CreateDirectory(directory);
+}
+
+void DownloadFileManager::DeleteFile(const std::wstring& path) {
   // Make sure we only delete files.
-  if (!file_util::DirectoryExists(path))
+  if (file_util::PathExists(path) && !file_util::DirectoryExists(path))
     file_util::Delete(path, false);
 }