Begin the first small step towards using FilePath everywhere:

base/file_util.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 <stdio.h>
 
 #include <fstream>
 
+#include "base/file_path.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "unicode/uniset.h"
 
 namespace file_util {
 
 const wchar_t kExtensionSeparator = L'.';
 
 void PathComponents(const std::wstring& path,
                     std::vector<std::wstring>* components) {
@@ skipping 201 matching lines @@
     // replace it, just append the supplied extension. For example
     // 'c:\tmp.bar\foo'.
     AppendExtension(extension, file_name);
     return;
   }
   std::wstring result = file_name->substr(0, last_dot);
   AppendExtension(extension, &result);
   file_name->swap(result);
 }
 
-bool ContentsEqual(const std::wstring& filename1,
-                   const std::wstring& filename2) {
+bool ContentsEqual(const FilePath& filename1, const FilePath& filename2) {
   // We open the file in binary format even if they are text files because
   // we are just comparing that bytes are exactly same in both files and not
   // doing anything smart with text formatting.
-#if defined(OS_WIN)
-  std::ifstream file1(filename1.c_str(), std::ios::in | std::ios::binary);
-  std::ifstream file2(filename2.c_str(), std::ios::in | std::ios::binary);
-#elif defined(OS_POSIX)
-  std::ifstream file1(WideToUTF8(filename1).c_str(),
+  std::ifstream file1(filename1.value().c_str(),
                       std::ios::in | std::ios::binary);
-  std::ifstream file2(WideToUTF8(filename2).c_str(),
+  std::ifstream file2(filename2.value().c_str(),
                       std::ios::in | std::ios::binary);
-#endif
   
   // Even if both files aren't openable (and thus, in some sense, "equal"),
   // any unusable file yields a result of "false".
   if (!file1.is_open() || !file2.is_open())
     return false;
 
   const int BUFFER_SIZE = 2056;
   char buffer1[BUFFER_SIZE], buffer2[BUFFER_SIZE];
   do {
     file1.read(buffer1, BUFFER_SIZE);
@@ skipping 37 matching lines @@
   *file_size = info.size;
   return true;
 }
 
 bool CloseFile(FILE* file) {
   if (file == NULL)
     return true;
   return fclose(file) == 0;
 }
 
+// Deprecated functions ----------------------------------------------------
+
+bool AbsolutePath(std::wstring* path_str) {
+  FilePath path;
+  if (!AbsolutePath(&path))
+    return false;
+  *path_str = path.ToWStringHack();
+  return true;
+}
+bool Delete(const std::wstring& path, bool recursive) {
+  return Delete(FilePath::FromWStringHack(path), recursive);
+}
+bool Move(const std::wstring& from_path, const std::wstring& to_path) {
+  return Move(FilePath::FromWStringHack(from_path),
+              FilePath::FromWStringHack(to_path));
+}
+bool CopyFile(const std::wstring& from_path, const std::wstring& to_path) {
+  return CopyFile(FilePath::FromWStringHack(from_path),
+                  FilePath::FromWStringHack(to_path));
+}
+bool CopyDirectory(const std::wstring& from_path, const std::wstring& to_path,
+                   bool recursive) {
+  return CopyDirectory(FilePath::FromWStringHack(from_path),
+                       FilePath::FromWStringHack(to_path),
+                       recursive);
+}
+bool PathExists(const std::wstring& path) {
+  return PathExists(FilePath::FromWStringHack(path));
+}
+bool DirectoryExists(const std::wstring& path) {
+  return DirectoryExists(FilePath::FromWStringHack(path));
+}
+bool ContentsEqual(const std::wstring& filename1,
+                   const std::wstring& filename2) {
+  return ContentsEqual(FilePath::FromWStringHack(filename1),
+                       FilePath::FromWStringHack(filename2));
+}
+bool CreateDirectory(const std::wstring& full_path) {
+  return CreateDirectory(FilePath::FromWStringHack(full_path));
+}
+bool GetCurrentDirectory(std::wstring* path_str) {
+  FilePath path;
+  if (!GetCurrentDirectory(&path))
+    return false;
+  *path_str = path.ToWStringHack();
+  return true;
+}
+bool GetTempDir(std::wstring* path_str) {
+  FilePath path;
+  if (!GetTempDir(&path))
+    return false;
+  *path_str = path.ToWStringHack();
+  return true;
+}
+
 }  // namespace