Begin the first small step towards using FilePath everywhere:

base/file_util_win.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 "base/file_util.h"
 
 #include <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
 #include <time.h>
 #include <string>
 
+#include "base/file_path.h"
 #include "base/logging.h"
 #include "base/scoped_handle.h"
 #include "base/string_util.h"
 #include "base/win_util.h"
 
 namespace file_util {
 
 const wchar_t kPathSeparator = L'\\';
 
 std::wstring GetDirectoryFromPath(const std::wstring& path) {
   wchar_t path_buffer[MAX_PATH];
   wchar_t* file_ptr = NULL;
   if (GetFullPathName(path.c_str(), MAX_PATH, path_buffer, &file_ptr) == 0)
     return L"";
 
   std::wstring::size_type length =
       file_ptr ? file_ptr - path_buffer : path.length();
   std::wstring directory(path, 0, length);
   TrimTrailingSeparator(&directory);
   return directory;
 }
 
-bool AbsolutePath(std::wstring* path) {
+bool AbsolutePath(FilePath* path) {
   wchar_t file_path_buf[MAX_PATH];
-  if (!_wfullpath(file_path_buf, path->c_str(), MAX_PATH))
+  if (!_wfullpath(file_path_buf, path->value().c_str(), MAX_PATH))
     return false;
-  *path = file_path_buf;
+  *path = FilePath(file_path_buf);
   return true;
 }
   
 int CountFilesCreatedAfter(const std::wstring& path,
                            const FILETIME& comparison_time) {
   int file_count = 0;
 
   WIN32_FIND_DATA find_file_data;
   std::wstring filename_spec = path + L"\\*";  // All files in given dir
   HANDLE find_handle = FindFirstFile(filename_spec.c_str(), &find_file_data);
   if (find_handle != INVALID_HANDLE_VALUE) {
     do {
       // Don't count current or parent directories.
       if ((wcscmp(find_file_data.cFileName, L"..") == 0) ||
           (wcscmp(find_file_data.cFileName, L".") == 0))
         continue;
 
       long result = CompareFileTime(&find_file_data.ftCreationTime,
                                     &comparison_time);
       // File was created after or on comparison time
       if ((result == 1) || (result == 0))
         ++file_count;
     } while (FindNextFile(find_handle,  &find_file_data));
     FindClose(find_handle);
   }
 
   return file_count;
 }
 
-bool Delete(const std::wstring& path, bool recursive) {
-  if (path.length() >= MAX_PATH)
+bool Delete(const FilePath& path, bool recursive) {
+  if (path.value().length() >= MAX_PATH)
     return false;
 
   // If we're not recursing use DeleteFile; it should be faster. DeleteFile
   // fails if passed a directory though, which is why we fall through on
   // failure to the SHFileOperation.
-  if (!recursive && DeleteFile(path.c_str()) != 0)
+  if (!recursive && DeleteFile(path.value().c_str()) != 0)
     return true;
 
   // SHFILEOPSTRUCT wants the path to be terminated with two NULLs,
   // so we have to use wcscpy because wcscpy_s writes non-NULLs
   // into the rest of the buffer.
   wchar_t double_terminated_path[MAX_PATH + 1] = {0};
 #pragma warning(suppress:4996)  // don't complain about wcscpy deprecation
-  wcscpy(double_terminated_path, path.c_str());
+  wcscpy(double_terminated_path, path.value().c_str());
 
   SHFILEOPSTRUCT file_operation = {0};
   file_operation.wFunc = FO_DELETE;
   file_operation.pFrom = double_terminated_path;
   file_operation.fFlags = FOF_NOERRORUI | FOF_SILENT | FOF_NOCONFIRMATION;
   if (!recursive)
     file_operation.fFlags |= FOF_NORECURSION | FOF_FILESONLY;
   return (SHFileOperation(&file_operation) == 0);
 }
 
-bool Move(const std::wstring& from_path, const std::wstring& to_path) {
+bool Move(const FilePath& from_path, const FilePath& to_path) {
   // NOTE: I suspect we could support longer paths, but that would involve
   // analyzing all our usage of files.
-  if (from_path.length() >= MAX_PATH || to_path.length() >= MAX_PATH)
+  if (from_path.value().length() >= MAX_PATH ||
+      to_path.value().length() >= MAX_PATH) {
     return false;
-  return (MoveFileEx(from_path.c_str(), to_path.c_str(),
+  }
+  return (MoveFileEx(from_path.value().c_str(), to_path.value().c_str(),
                      MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING) != 0);
 }
 
-bool CopyFile(const std::wstring& from_path, const std::wstring& to_path) {
+bool CopyFile(const FilePath& from_path, const FilePath& to_path) {
   // NOTE: I suspect we could support longer paths, but that would involve
   // analyzing all our usage of files.
-  if (from_path.length() >= MAX_PATH || to_path.length() >= MAX_PATH)
+  if (from_path.value().length() >= MAX_PATH ||
+      to_path.value().length() >= MAX_PATH) {
     return false;
-  return (::CopyFile(from_path.c_str(), to_path.c_str(), false) != 0);
+  }
+  return (::CopyFile(from_path.value().c_str(), to_path.value().c_str(),
+                     false) != 0);
 }
 
-bool ShellCopy(const std::wstring& from_path, const std::wstring& to_path,
+bool ShellCopy(const FilePath& from_path, const FilePath& to_path,
                bool recursive) {
   // NOTE: I suspect we could support longer paths, but that would involve
   // analyzing all our usage of files.
-  if (from_path.length() >= MAX_PATH || to_path.length() >= MAX_PATH)
+  if (from_path.value().length() >= MAX_PATH ||
+      to_path.value().length() >= MAX_PATH) {
     return false;
+  }
 
   // SHFILEOPSTRUCT wants the path to be terminated with two NULLs,
   // so we have to use wcscpy because wcscpy_s writes non-NULLs
   // into the rest of the buffer.
   wchar_t double_terminated_path_from[MAX_PATH + 1] = {0};
   wchar_t double_terminated_path_to[MAX_PATH + 1] = {0};
 #pragma warning(suppress:4996)  // don't complain about wcscpy deprecation
-  wcscpy(double_terminated_path_from, from_path.c_str());
+  wcscpy(double_terminated_path_from, from_path.value().c_str());
 #pragma warning(suppress:4996)  // don't complain about wcscpy deprecation
-  wcscpy(double_terminated_path_to, to_path.c_str());
+  wcscpy(double_terminated_path_to, to_path.value().c_str());
 
   SHFILEOPSTRUCT file_operation = {0};
   file_operation.wFunc = FO_COPY;
   file_operation.pFrom = double_terminated_path_from;
   file_operation.pTo = double_terminated_path_to;
   file_operation.fFlags = FOF_NOERRORUI | FOF_SILENT | FOF_NOCONFIRMATION |
                           FOF_NOCONFIRMMKDIR;
   if (!recursive)
     file_operation.fFlags |= FOF_NORECURSION | FOF_FILESONLY;
 
   return (SHFileOperation(&file_operation) == 0);
 }
 
-bool CopyDirectory(const std::wstring& from_path, const std::wstring& to_path,
+bool CopyDirectory(const FilePath& from_path, const FilePath& to_path,
                    bool recursive) {
   if (recursive)
     return ShellCopy(from_path, to_path, true);
 
   // Instead of creating a new directory, we copy the old one to include the
   // security information of the folder as part of the copy.
   if (!PathExists(to_path)) {
     // Except that Vista fails to do that, and instead do a recursive copy if
     // the target directory doesn't exist.
     if (win_util::GetWinVersion() >= win_util::WINVERSION_VISTA)
       CreateDirectory(to_path);
     else
       ShellCopy(from_path, to_path, false);
   }
 
-  std::wstring directory(from_path);
-  AppendToPath(&directory, L"*.*");
+  FilePath directory = from_path.Append(L"*.*");
   return ShellCopy(directory, to_path, false);
 }
 
-bool PathExists(const std::wstring& path) {
-  return (GetFileAttributes(path.c_str()) != INVALID_FILE_ATTRIBUTES);
+bool PathExists(const FilePath& path) {
+  return (GetFileAttributes(path.value().c_str()) != INVALID_FILE_ATTRIBUTES);
 }
 
 bool PathIsWritable(const std::wstring& path) {
   HANDLE dir =
       CreateFile(path.c_str(), FILE_ADD_FILE,
                  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                  NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
 
   if (dir == INVALID_HANDLE_VALUE)
     return false;
 
   CloseHandle(dir);
   return true;
 }
 
-bool DirectoryExists(const std::wstring& path) {
-  DWORD fileattr = GetFileAttributes(path.c_str());
+bool DirectoryExists(const FilePath& path) {
+  DWORD fileattr = GetFileAttributes(path.value().c_str());
   if (fileattr != INVALID_FILE_ATTRIBUTES)
     return (fileattr & FILE_ATTRIBUTE_DIRECTORY) != 0;
   return false;
 }
 
 bool GetFileCreationLocalTimeFromHandle(HANDLE file_handle,
                                         LPSYSTEMTIME creation_time) {
   if (!file_handle)
     return false;
 
@@ skipping 174 matching lines @@
   return SUCCEEDED(result);
 }
 
 bool IsDirectoryEmpty(const std::wstring& dir_path) {
   FileEnumerator files(dir_path, false, FileEnumerator::FILES_AND_DIRECTORIES);
   if (files.Next().empty())
     return true;
   return false;
 }
 
-bool GetTempDir(std::wstring* path) {
+bool GetTempDir(FilePath* path) {
   wchar_t temp_path[MAX_PATH + 1];
   DWORD path_len = ::GetTempPath(MAX_PATH, temp_path);
   if (path_len >= MAX_PATH || path_len <= 0)
     return false;
-  path->assign(temp_path);
-  TrimTrailingSeparator(path);
+  // TODO(evanm): the old behavior of this function was to always strip the
+  // trailing slash.  We duplicate this here, but it shouldn't be necessary
+  // when everyone is using the appropriate FilePath APIs.
+  std::wstring path_str(temp_path);
+  TrimTrailingSeparator(&path_str);
+  *path = FilePath(path_str);
   return true;
 }
 
 bool CreateTemporaryFileName(std::wstring* temp_file) {
   std::wstring temp_path;
 
   if (!GetTempDir(&temp_path))
     return false;
 
   return CreateTemporaryFileNameInDir(temp_path, temp_file);
@@ skipping 39 matching lines @@
   }
 
   if (count == 50) {
     return false;
   }
 
   new_temp_path->assign(path_to_create);
   return true;
 }
 
-bool CreateDirectory(const std::wstring& full_path) {
+bool CreateDirectory(const FilePath& full_path) {
   if (DirectoryExists(full_path))
     return true;
-  int err = SHCreateDirectoryEx(NULL, full_path.c_str(), NULL);
+  int err = SHCreateDirectoryEx(NULL, full_path.value().c_str(), NULL);
   return err == ERROR_SUCCESS;
 }
 
 bool GetFileInfo(const std::wstring& file_path, FileInfo* results) {
   WIN32_FILE_ATTRIBUTE_DATA attr;
   if (!GetFileAttributesEx(file_path.c_str(), GetFileExInfoStandard, &attr))
     return false;
 
   ULARGE_INTEGER size;
   size.HighPart = attr.nFileSizeHigh;
   size.LowPart = attr.nFileSizeLow;
   results->size = size.QuadPart;
 
   results->is_directory =
       (attr.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
   return true;
 }
 
+FILE* OpenFile(const FilePath& filename, const char* mode) {
+  std::wstring w_mode = ASCIIToWide(std::string(mode));
+  FILE* file;
+  if (_wfopen_s(&file, filename.value().c_str(), w_mode.c_str()) != 0) {
+    return NULL;
+  }
+  return file;
+}
+
 FILE* OpenFile(const std::string& filename, const char* mode) {
   FILE* file;
   if (fopen_s(&file, filename.c_str(), mode) != 0) {
     return NULL;
   }
   return file;
 }
 
 FILE* OpenFile(const std::wstring& filename, const char* mode) {
-  std::wstring w_mode = ASCIIToWide(std::string(mode));
-  FILE* file;
-  if (_wfopen_s(&file, filename.c_str(), w_mode.c_str()) != 0) {
-    return NULL;
-  }
-  return file;
+  return OpenFile(FilePath(filename), mode);
 }
 
 int ReadFile(const std::wstring& filename, char* data, int size) {
   ScopedHandle file(CreateFile(filename.c_str(),
                                GENERIC_READ,
                                FILE_SHARE_READ | FILE_SHARE_WRITE,
                                NULL,
                                OPEN_EXISTING,
                                FILE_FLAG_SEQUENTIAL_SCAN,
                                NULL));
@@ skipping 61 matching lines @@
   move_info.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI |
                      FOF_NOCONFIRMMKDIR | FOF_NOCOPYSECURITYATTRIBS;
 
   if (0 != SHFileOperation(&move_info))
    return false;
   
   return true;
 }
 
 // Gets the current working directory for the process.
-bool GetCurrentDirectory(std::wstring* dir) {
+bool GetCurrentDirectory(FilePath* dir) {
   wchar_t system_buffer[MAX_PATH];
   system_buffer[0] = 0;
   DWORD len = ::GetCurrentDirectory(MAX_PATH, system_buffer);
   if (len == 0 || len > MAX_PATH)
     return false;
-  *dir = system_buffer;
-  file_util::TrimTrailingSeparator(dir);
+  // TODO(evanm): the old behavior of this function was to always strip the
+  // trailing slash.  We duplicate this here, but it shouldn't be necessary
+  // when everyone is using the appropriate FilePath APIs.
+  std::wstring dir_str(system_buffer);
+  file_util::TrimTrailingSeparator(&dir_str);
+  *dir = FilePath(dir_str);
   return true;
 }
 
 // Sets the current working directory for the process.
 bool SetCurrentDirectory(const std::wstring& current_directory) {
   BOOL ret = ::SetCurrentDirectory(current_directory.c_str());
   return (ret ? true : false);
 }
 
 ///////////////////////////////////////////////
@@ skipping 83 matching lines @@
       // it to pending_paths_ so we scan it after we finish scanning this
       // directory.
       pending_paths_.push(cur_file);
     }
     return (file_type_ & FileEnumerator::DIRECTORIES) ? cur_file : Next();
   }
   return (file_type_ & FileEnumerator::FILES) ? cur_file : Next();
 }
 
 }  // namespace file_util