Begin the first small step towards using FilePath everywhere:

base/file_util_unittest.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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
 #endif
 
 #include <fstream>
 #include <iostream>
 #include <set>
 
 #include "base/base_paths.h"
+#include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/platform_test.h"
 #include "base/string_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // file_util winds up using autoreleased objects on the Mac, so this needs
 // to be a PlatformTest
 class FileUtilTest : public PlatformTest {
  protected:
   virtual void SetUp() {
     PlatformTest::SetUp();
     // Name a subdirectory of the temp directory.
     ASSERT_TRUE(PathService::Get(base::DIR_TEMP, &test_dir_));
-    file_util::AppendToPath(&test_dir_, L"FileUtilTest");
+    test_dir_ = test_dir_.Append(FILE_PATH_LITERAL("FileUtilTest"));
 
     // Create a fresh, empty copy of this directory.
     file_util::Delete(test_dir_, true);
-    file_util::CreateDirectory(test_dir_.c_str());
+    file_util::CreateDirectory(test_dir_);
   }
   virtual void TearDown() {
     PlatformTest::TearDown();
     // Clean up test directory
     ASSERT_TRUE(file_util::Delete(test_dir_, true));
     ASSERT_FALSE(file_util::PathExists(test_dir_));
   }
 
   // the path to temporary directory used to contain the test operations
-  std::wstring test_dir_;
+  FilePath test_dir_;
 };
 
 // Collects all the results from the given file enumerator, and provides an
 // interface to query whether a given file is present.
 class FindResultCollector {
  public:
   FindResultCollector(file_util::FileEnumerator& enumerator) {
     std::wstring cur_file;
     while (!(cur_file = enumerator.Next()).empty()) {
+      FilePath::StringType path = FilePath::FromWStringHack(cur_file).value();
       // The file should not be returned twice.
-      EXPECT_TRUE(files_.end() == files_.find(cur_file))
+      EXPECT_TRUE(files_.end() == files_.find(path))
           << "Same file returned twice";
 
       // Save for later.
-      files_.insert(cur_file);
+      files_.insert(path);
     }
   }
 
   // Returns true if the enumerator found the file.
-  bool HasFile(const std::wstring& file) const {
-    return files_.find(file) != files_.end();
+  bool HasFile(const FilePath& file) const {
+    return files_.find(file.value()) != files_.end();
   }
-  
+
   int size() {
     return static_cast<int>(files_.size());
   }
 
  private:
-  std::set<std::wstring> files_;
+  std::set<FilePath::StringType> files_;
 };
 
 // Simple function to dump some text into a new file.
-void CreateTextFile(const std::wstring& filename,
+void CreateTextFile(const FilePath& filename,
                     const std::wstring& contents) {
   std::ofstream file;
-  file.open(WideToUTF8(filename).c_str());
+  file.open(WideToUTF8(filename.ToWStringHack()).c_str());
   ASSERT_TRUE(file.is_open());
   file << contents;
   file.close();
 }
 
 // Simple function to take out some text from a file.
-std::wstring ReadTextFile(const std::wstring& filename) {
+std::wstring ReadTextFile(const FilePath& filename) {
   wchar_t contents[64];
   std::wifstream file;
-  file.open(WideToUTF8(filename).c_str());
+  file.open(WideToUTF8(filename.ToWStringHack()).c_str());
   EXPECT_TRUE(file.is_open());
   file.getline(contents, 64);
   file.close();
   return std::wstring(contents);
 }
 
 #if defined(OS_WIN)
 uint64 FileTimeAsUint64(const FILETIME& ft) {
   ULARGE_INTEGER u;
   u.LowPart = ft.dwLowDateTime;
@@ skipping 197 matching lines @@
     const std::wstring parent =
         file_util::GetDirectoryFromPath(dir.full_path);
     EXPECT_EQ(dir.directory, parent);
   }
 }
 
 // TODO(erikkay): implement
 #if defined OS_WIN
 TEST_F(FileUtilTest, CountFilesCreatedAfter) {
   // Create old file (that we don't want to count)
-  std::wstring old_file_name = test_dir_;
-  file_util::AppendToPath(&old_file_name, L"Old File.txt");
+  FilePath old_file_name = test_dir_.Append(L"Old File.txt");
   CreateTextFile(old_file_name, L"Just call me Mr. Creakybits");
 
   // Age to perfection
   Sleep(100);
 
   // Establish our cutoff time
   FILETIME test_start_time;
   GetSystemTimeAsFileTime(&test_start_time);
-  EXPECT_EQ(0, file_util::CountFilesCreatedAfter(test_dir_, test_start_time));
+  EXPECT_EQ(0, file_util::CountFilesCreatedAfter(test_dir_.value(),
+                                                 test_start_time));
 
   // Create a new file (that we do want to count)
-  std::wstring new_file_name = test_dir_;
-  file_util::AppendToPath(&new_file_name, L"New File.txt");
+  FilePath new_file_name = test_dir_.Append(L"New File.txt");
   CreateTextFile(new_file_name, L"Waaaaaaaaaaaaaah.");
 
   // We should see only the new file.
-  EXPECT_EQ(1, file_util::CountFilesCreatedAfter(test_dir_, test_start_time));
+  EXPECT_EQ(1, file_util::CountFilesCreatedAfter(test_dir_.value(),
+                                                 test_start_time));
 
   // Delete new file, we should see no files after cutoff now
   EXPECT_TRUE(file_util::Delete(new_file_name, false));
-  EXPECT_EQ(0, file_util::CountFilesCreatedAfter(test_dir_, test_start_time));
+  EXPECT_EQ(0, file_util::CountFilesCreatedAfter(test_dir_.value(),
+                                                 test_start_time));
 }
 #endif
 
 // Tests that the Delete function works as expected, especially
 // the recursion flag.  Also coincidentally tests PathExists.
 TEST_F(FileUtilTest, Delete) {
   // Create a file
-  std::wstring file_name = test_dir_;
-  file_util::AppendToPath(&file_name, L"Test File.txt");
+  FilePath file_name = test_dir_.Append(FILE_PATH_LITERAL("Test File.txt"));
   CreateTextFile(file_name, L"I'm cannon fodder.");
 
   ASSERT_TRUE(file_util::PathExists(file_name));
 
-  std::wstring subdir_path = test_dir_;
-  file_util::AppendToPath(&subdir_path, L"Subdirectory");
-  file_util::CreateDirectory(subdir_path.c_str());
+  FilePath subdir_path = test_dir_.Append(FILE_PATH_LITERAL("Subdirectory"));
+  file_util::CreateDirectory(subdir_path);
 
   ASSERT_TRUE(file_util::PathExists(subdir_path));
 
-  std::wstring directory_contents = test_dir_;
+  FilePath directory_contents = test_dir_;
 #if defined(OS_WIN)
   // TODO(erikkay): see if anyone's actually using this feature of the API
-  file_util::AppendToPath(&directory_contents, L"*");
-
+  directory_contents = directory_contents.Append(FILE_PATH_LITERAL("*"));
   // Delete non-recursively and check that only the file is deleted
   ASSERT_TRUE(file_util::Delete(directory_contents, false));
   EXPECT_FALSE(file_util::PathExists(file_name));
   EXPECT_TRUE(file_util::PathExists(subdir_path));
 #endif
 
   // Delete recursively and make sure all contents are deleted
   ASSERT_TRUE(file_util::Delete(directory_contents, true));
   EXPECT_FALSE(file_util::PathExists(file_name));
   EXPECT_FALSE(file_util::PathExists(subdir_path));
 }
 
 TEST_F(FileUtilTest, Move) {
   // Create a directory
-  std::wstring dir_name_from(test_dir_);
-  file_util::AppendToPath(&dir_name_from, L"Move_From_Subdir");
-  file_util::CreateDirectory(dir_name_from.c_str());
+  FilePath dir_name_from =
+      test_dir_.Append(FILE_PATH_LITERAL("Move_From_Subdir"));
+  file_util::CreateDirectory(dir_name_from);
   ASSERT_TRUE(file_util::PathExists(dir_name_from));
 
   // Create a file under the directory
-  std::wstring file_name_from(dir_name_from);
-  file_util::AppendToPath(&file_name_from, L"Move_Test_File.txt");
+  FilePath file_name_from =
+      dir_name_from.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(file_util::PathExists(file_name_from));
 
   // Move the directory
-  std::wstring dir_name_to(test_dir_);
-  file_util::AppendToPath(&dir_name_to, L"Move_To_Subdir");
-  std::wstring file_name_to(dir_name_to);
-  file_util::AppendToPath(&file_name_to, L"Move_Test_File.txt");
+  FilePath dir_name_to = test_dir_.Append(FILE_PATH_LITERAL("Move_To_Subdir"));
+  FilePath file_name_to =
+      dir_name_to.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
 
   ASSERT_FALSE(file_util::PathExists(dir_name_to));
 
   EXPECT_TRUE(file_util::Move(dir_name_from, dir_name_to));
 
   // Check everything has been moved.
   EXPECT_FALSE(file_util::PathExists(dir_name_from));
   EXPECT_FALSE(file_util::PathExists(file_name_from));
   EXPECT_TRUE(file_util::PathExists(dir_name_to));
   EXPECT_TRUE(file_util::PathExists(file_name_to));
 }
 
 TEST_F(FileUtilTest, CopyDirectoryRecursively) {
   // Create a directory.
-  std::wstring dir_name_from(test_dir_);
-  file_util::AppendToPath(&dir_name_from, L"Copy_From_Subdir");
-  file_util::CreateDirectory(dir_name_from.c_str());
+  FilePath dir_name_from =
+      test_dir_.Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
+  file_util::CreateDirectory(dir_name_from);
   ASSERT_TRUE(file_util::PathExists(dir_name_from));
 
   // Create a file under the directory.
-  std::wstring file_name_from(dir_name_from);
-  file_util::AppendToPath(&file_name_from, L"Copy_Test_File.txt");
+  FilePath file_name_from =
+      dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(file_util::PathExists(file_name_from));
 
   // Create a subdirectory.
-  std::wstring subdir_name_from(dir_name_from);
-  file_util::AppendToPath(&subdir_name_from, L"Subdir");
-  file_util::CreateDirectory(subdir_name_from.c_str());
+  FilePath subdir_name_from =
+      dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
+  file_util::CreateDirectory(subdir_name_from);
   ASSERT_TRUE(file_util::PathExists(subdir_name_from));
 
   // Create a file under the subdirectory.
-  std::wstring file_name2_from(subdir_name_from);
-  file_util::AppendToPath(&file_name2_from, L"Copy_Test_File.txt");
+  FilePath file_name2_from =
+      subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(file_util::PathExists(file_name2_from));
 
   // Copy the directory recursively.
-  std::wstring dir_name_to(test_dir_);
-  file_util::AppendToPath(&dir_name_to, L"Copy_To_Subdir");
-  std::wstring file_name_to(dir_name_to);
-  file_util::AppendToPath(&file_name_to, L"Copy_Test_File.txt");
-  std::wstring subdir_name_to(dir_name_to);
-  file_util::AppendToPath(&subdir_name_to, L"Subdir");
-  std::wstring file_name2_to(subdir_name_to);
-  file_util::AppendToPath(&file_name2_to, L"Copy_Test_File.txt");
+  FilePath dir_name_to =
+      test_dir_.Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
+  FilePath file_name_to =
+      dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
+  FilePath subdir_name_to =
+      dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
+  FilePath file_name2_to =
+      subdir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
 
   ASSERT_FALSE(file_util::PathExists(dir_name_to));
 
   EXPECT_TRUE(file_util::CopyDirectory(dir_name_from, dir_name_to, true));
 
   // Check everything has been copied.
   EXPECT_TRUE(file_util::PathExists(dir_name_from));
   EXPECT_TRUE(file_util::PathExists(file_name_from));
   EXPECT_TRUE(file_util::PathExists(subdir_name_from));
   EXPECT_TRUE(file_util::PathExists(file_name2_from));
   EXPECT_TRUE(file_util::PathExists(dir_name_to));
   EXPECT_TRUE(file_util::PathExists(file_name_to));
   EXPECT_TRUE(file_util::PathExists(subdir_name_to));
   EXPECT_TRUE(file_util::PathExists(file_name2_to));
 }
 
 TEST_F(FileUtilTest, CopyDirectory) {
   // Create a directory.
-  std::wstring dir_name_from(test_dir_);
-  file_util::AppendToPath(&dir_name_from, L"Copy_From_Subdir");
-  file_util::CreateDirectory(dir_name_from.c_str());
+  FilePath dir_name_from =
+      test_dir_.Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
+  file_util::CreateDirectory(dir_name_from);
   ASSERT_TRUE(file_util::PathExists(dir_name_from));
 
   // Create a file under the directory.
-  std::wstring file_name_from(dir_name_from);
-  file_util::AppendToPath(&file_name_from, L"Copy_Test_File.txt");
+  FilePath file_name_from =
+      dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(file_util::PathExists(file_name_from));
 
   // Create a subdirectory.
-  std::wstring subdir_name_from(dir_name_from);
-  file_util::AppendToPath(&subdir_name_from, L"Subdir");
-  file_util::CreateDirectory(subdir_name_from.c_str());
+  FilePath subdir_name_from =
+      dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
+  file_util::CreateDirectory(subdir_name_from);
   ASSERT_TRUE(file_util::PathExists(subdir_name_from));
 
   // Create a file under the subdirectory.
-  std::wstring file_name2_from(subdir_name_from);
-  file_util::AppendToPath(&file_name2_from, L"Copy_Test_File.txt");
+  FilePath file_name2_from =
+      subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(file_util::PathExists(file_name2_from));
 
   // Copy the directory not recursively.
-  std::wstring dir_name_to(test_dir_);
-  file_util::AppendToPath(&dir_name_to, L"Copy_To_Subdir");
-  std::wstring file_name_to(dir_name_to);
-  file_util::AppendToPath(&file_name_to, L"Copy_Test_File.txt");
-  std::wstring subdir_name_to(dir_name_to);
-  file_util::AppendToPath(&subdir_name_to, L"Subdir");
+  FilePath dir_name_to =
+      test_dir_.Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
+  FilePath file_name_to =
+      dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
+  FilePath subdir_name_to =
+      dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
 
   ASSERT_FALSE(file_util::PathExists(dir_name_to));
 
   EXPECT_TRUE(file_util::CopyDirectory(dir_name_from, dir_name_to, false));
 
   // Check everything has been copied.
   EXPECT_TRUE(file_util::PathExists(dir_name_from));
   EXPECT_TRUE(file_util::PathExists(file_name_from));
   EXPECT_TRUE(file_util::PathExists(subdir_name_from));
   EXPECT_TRUE(file_util::PathExists(file_name2_from));
   EXPECT_TRUE(file_util::PathExists(dir_name_to));
   EXPECT_TRUE(file_util::PathExists(file_name_to));
   EXPECT_FALSE(file_util::PathExists(subdir_name_to));
 }
 
 TEST_F(FileUtilTest, CopyFile) {
   // Create a directory
-  std::wstring dir_name_from(test_dir_);
-  file_util::AppendToPath(&dir_name_from, L"Copy_From_Subdir");
-  file_util::CreateDirectory(dir_name_from.c_str());
+  FilePath dir_name_from =
+      test_dir_.Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
+  file_util::CreateDirectory(dir_name_from);
   ASSERT_TRUE(file_util::PathExists(dir_name_from));
 
   // Create a file under the directory
-  std::wstring file_name_from(dir_name_from);
-  file_util::AppendToPath(&file_name_from, L"Copy_Test_File.txt");
+  FilePath file_name_from =
+      dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   const std::wstring file_contents(L"Gooooooooooooooooooooogle");
   CreateTextFile(file_name_from, file_contents);
   ASSERT_TRUE(file_util::PathExists(file_name_from));
 
   // Copy the file.
-  std::wstring dest_file(dir_name_from);
-  file_util::AppendToPath(&dest_file, L"DestFile.txt");
+  FilePath dest_file = dir_name_from.Append(FILE_PATH_LITERAL("DestFile.txt"));
   ASSERT_TRUE(file_util::CopyFile(file_name_from, dest_file));
 
   // Copy the file to another location using '..' in the path.
-  std::wstring dest_file2(dir_name_from);
+  std::wstring dest_file2(dir_name_from.ToWStringHack());
   file_util::AppendToPath(&dest_file2, L"..");
   file_util::AppendToPath(&dest_file2, L"DestFile.txt");
-  ASSERT_TRUE(file_util::CopyFile(file_name_from, dest_file2));
-  std::wstring dest_file2_test(dir_name_from);
+  ASSERT_TRUE(file_util::CopyFile(file_name_from,
+                                  FilePath::FromWStringHack(dest_file2)));
+  std::wstring dest_file2_test(dir_name_from.ToWStringHack());
   file_util::UpOneDirectory(&dest_file2_test);
   file_util::AppendToPath(&dest_file2_test, L"DestFile.txt");
 
   // Check everything has been copied.
   EXPECT_TRUE(file_util::PathExists(file_name_from));
   EXPECT_TRUE(file_util::PathExists(dest_file));
   const std::wstring read_contents = ReadTextFile(dest_file);
   EXPECT_EQ(file_contents, read_contents);
-  EXPECT_TRUE(file_util::PathExists(dest_file2_test));
-  EXPECT_TRUE(file_util::PathExists(dest_file2));
+  EXPECT_TRUE(file_util::PathExists(
+      FilePath::FromWStringHack(dest_file2_test)));
+  EXPECT_TRUE(file_util::PathExists(FilePath::FromWStringHack(dest_file2)));
 }
 
 // TODO(erikkay): implement
 #if defined(OS_WIN)
 TEST_F(FileUtilTest, GetFileCreationLocalTime) {
-  std::wstring file_name = test_dir_;
-  file_util::AppendToPath(&file_name, L"Test File.txt");
+  FilePath file_name = test_dir_.Append(L"Test File.txt");
 
   SYSTEMTIME start_time;
   GetLocalTime(&start_time);
   Sleep(100);
   CreateTextFile(file_name, L"New file!");
   Sleep(100);
   SYSTEMTIME end_time;
   GetLocalTime(&end_time);
 
   SYSTEMTIME file_creation_time;
-  file_util::GetFileCreationLocalTime(file_name, &file_creation_time);
+  file_util::GetFileCreationLocalTime(file_name.value(), &file_creation_time);
 
   FILETIME start_filetime;
   SystemTimeToFileTime(&start_time, &start_filetime);
   FILETIME end_filetime;
   SystemTimeToFileTime(&end_time, &end_filetime);
   FILETIME file_creation_filetime;
   SystemTimeToFileTime(&file_creation_time, &file_creation_filetime);
 
   EXPECT_EQ(-1, CompareFileTime(&start_filetime, &file_creation_filetime)) <<
     "start time: " << FileTimeAsUint64(start_filetime) << ", " <<
     "creation time: " << FileTimeAsUint64(file_creation_filetime);
 
   EXPECT_EQ(-1, CompareFileTime(&file_creation_filetime, &end_filetime)) <<
     "creation time: " << FileTimeAsUint64(file_creation_filetime) << ", " <<
     "end time: " << FileTimeAsUint64(end_filetime);
 
-  ASSERT_TRUE(DeleteFile(file_name.c_str()));
+  ASSERT_TRUE(DeleteFile(file_name.value().c_str()));
 }
 #endif
 
 // file_util winds up using autoreleased objects on the Mac, so this needs
-// to be a PlatformTest
+// to be a PlatformTest.
 typedef PlatformTest ReadOnlyFileUtilTest;
 
 TEST_F(ReadOnlyFileUtilTest, ContentsEqual) {
-  std::wstring data_dir;
+  FilePath data_dir;
   ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &data_dir));
-  file_util::AppendToPath(&data_dir, L"base");
-  file_util::AppendToPath(&data_dir, L"data");
-  file_util::AppendToPath(&data_dir, L"file_util_unittest");
+  data_dir = data_dir.Append(FILE_PATH_LITERAL("base"))
+                     .Append(FILE_PATH_LITERAL("data"))
+                     .Append(FILE_PATH_LITERAL("file_util_unittest"));
   ASSERT_TRUE(file_util::PathExists(data_dir));
 
-  std::wstring original_file = data_dir;
-  file_util::AppendToPath(&original_file, L"original.txt");
-  std::wstring same_file = data_dir;
-  file_util::AppendToPath(&same_file, L"same.txt");
-  std::wstring same_length_file = data_dir;
-  file_util::AppendToPath(&same_length_file, L"same_length.txt");
-  std::wstring different_file = data_dir;
-  file_util::AppendToPath(&different_file, L"different.txt");
-  std::wstring different_first_file = data_dir;
-  file_util::AppendToPath(&different_first_file, L"different_first.txt");
-  std::wstring different_last_file = data_dir;
-  file_util::AppendToPath(&different_last_file, L"different_last.txt");
-  std::wstring empty1_file = data_dir;
-  file_util::AppendToPath(&empty1_file, L"empty1.txt");
-  std::wstring empty2_file = data_dir;
-  file_util::AppendToPath(&empty2_file, L"empty2.txt");
-  std::wstring shortened_file = data_dir;
-  file_util::AppendToPath(&shortened_file, L"shortened.txt");
-  std::wstring binary_file = data_dir;
-  file_util::AppendToPath(&binary_file, L"binary_file.bin");
-  std::wstring binary_file_same = data_dir;
-  file_util::AppendToPath(&binary_file_same, L"binary_file_same.bin");
-  std::wstring binary_file_diff = data_dir;
-  file_util::AppendToPath(&binary_file_diff, L"binary_file_diff.bin");
+  FilePath original_file =
+      data_dir.Append(FILE_PATH_LITERAL("original.txt"));
+  FilePath same_file =
+      data_dir.Append(FILE_PATH_LITERAL("same.txt"));
+  FilePath same_length_file =
+      data_dir.Append(FILE_PATH_LITERAL("same_length.txt"));
+  FilePath different_file =
+      data_dir.Append(FILE_PATH_LITERAL("different.txt"));
+  FilePath different_first_file =
+      data_dir.Append(FILE_PATH_LITERAL("different_first.txt"));
+  FilePath different_last_file =
+      data_dir.Append(FILE_PATH_LITERAL("different_last.txt"));
+  FilePath empty1_file =
+      data_dir.Append(FILE_PATH_LITERAL("empty1.txt"));
+  FilePath empty2_file =
+      data_dir.Append(FILE_PATH_LITERAL("empty2.txt"));
+  FilePath shortened_file =
+      data_dir.Append(FILE_PATH_LITERAL("shortened.txt"));
+  FilePath binary_file =
+      data_dir.Append(FILE_PATH_LITERAL("binary_file.bin"));
+  FilePath binary_file_same =
+      data_dir.Append(FILE_PATH_LITERAL("binary_file_same.bin"));
+  FilePath binary_file_diff =
+      data_dir.Append(FILE_PATH_LITERAL("binary_file_diff.bin"));
 
   EXPECT_TRUE(file_util::ContentsEqual(original_file, original_file));
   EXPECT_TRUE(file_util::ContentsEqual(original_file, same_file));
   EXPECT_FALSE(file_util::ContentsEqual(original_file, same_length_file));
   EXPECT_FALSE(file_util::ContentsEqual(original_file, different_file));
   EXPECT_FALSE(file_util::ContentsEqual(L"bogusname", L"bogusname"));
   EXPECT_FALSE(file_util::ContentsEqual(original_file, different_first_file));
   EXPECT_FALSE(file_util::ContentsEqual(original_file, different_last_file));
   EXPECT_TRUE(file_util::ContentsEqual(empty1_file, empty2_file));
   EXPECT_FALSE(file_util::ContentsEqual(original_file, shortened_file));
   EXPECT_FALSE(file_util::ContentsEqual(shortened_file, original_file));
   EXPECT_TRUE(file_util::ContentsEqual(binary_file, binary_file_same));
   EXPECT_FALSE(file_util::ContentsEqual(binary_file, binary_file_diff));
 }
 
 // We don't need equivalent functionality outside of Windows.
 #if defined(OS_WIN)
 TEST_F(FileUtilTest, ResolveShortcutTest) {
-  std::wstring target_file = test_dir_;
-  file_util::AppendToPath(&target_file, L"Target.txt");
+  FilePath target_file = test_dir_.Append(L"Target.txt");
   CreateTextFile(target_file, L"This is the target.");
 
-  std::wstring link_file = test_dir_;
-  file_util::AppendToPath(&link_file, L"Link.lnk");
+  FilePath link_file = test_dir_.Append(L"Link.lnk");
 
   HRESULT result;
   IShellLink *shell = NULL;
   IPersistFile *persist = NULL;
 
   CoInitialize(NULL);
   // Temporarily create a shortcut for test
   result = CoCreateInstance(CLSID_ShellLink, NULL,
                           CLSCTX_INPROC_SERVER, IID_IShellLink,
                           reinterpret_cast<LPVOID*>(&shell));
   EXPECT_TRUE(SUCCEEDED(result));
   result = shell->QueryInterface(IID_IPersistFile,
                              reinterpret_cast<LPVOID*>(&persist));
   EXPECT_TRUE(SUCCEEDED(result));
-  result = shell->SetPath(target_file.c_str());
+  result = shell->SetPath(target_file.value().c_str());
   EXPECT_TRUE(SUCCEEDED(result));
   result = shell->SetDescription(L"ResolveShortcutTest");
   EXPECT_TRUE(SUCCEEDED(result));
-  result = persist->Save(link_file.c_str(), TRUE);
+  result = persist->Save(link_file.value().c_str(), TRUE);
   EXPECT_TRUE(SUCCEEDED(result));
   if (persist)
     persist->Release();
   if (shell)
     shell->Release();
 
   bool is_solved;
-  is_solved = file_util::ResolveShortcut(&link_file);
+  std::wstring link_file_str = link_file.value();
+  is_solved = file_util::ResolveShortcut(&link_file_str);
   EXPECT_TRUE(is_solved);
   std::wstring contents;
-  contents = ReadTextFile(link_file);
+  contents = ReadTextFile(FilePath(link_file_str));
   EXPECT_EQ(L"This is the target.", contents);
 
   // Cleaning
-  DeleteFile(target_file.c_str());
-  DeleteFile(link_file.c_str());
+  DeleteFile(target_file.value().c_str());
+  DeleteFile(link_file_str.c_str());
   CoUninitialize();
 }
 
 TEST_F(FileUtilTest, CreateShortcutTest) {
   const wchar_t file_contents[] = L"This is another target.";
-  std::wstring target_file = test_dir_;
-  file_util::AppendToPath(&target_file, L"Target1.txt");
+  FilePath target_file = test_dir_.Append(L"Target1.txt");
   CreateTextFile(target_file, file_contents);
 
-  std::wstring link_file = test_dir_;
-  file_util::AppendToPath(&link_file, L"Link1.lnk");
+  FilePath link_file = test_dir_.Append(L"Link1.lnk");
 
   CoInitialize(NULL);
-  EXPECT_TRUE(file_util::CreateShortcutLink(target_file.c_str(),
-                                            link_file.c_str(),
+  EXPECT_TRUE(file_util::CreateShortcutLink(target_file.value().c_str(),
+                                            link_file.value().c_str(),
                                             NULL, NULL, NULL, NULL, 0));
-  std::wstring resolved_name = link_file;
+  std::wstring resolved_name = link_file.value();
   EXPECT_TRUE(file_util::ResolveShortcut(&resolved_name));
-  std::wstring read_contents = ReadTextFile(resolved_name);
+  std::wstring read_contents = ReadTextFile(FilePath(resolved_name));
   EXPECT_EQ(file_contents, read_contents);
 
-  DeleteFile(target_file.c_str());
-  DeleteFile(link_file.c_str());
+  DeleteFile(target_file.value().c_str());
+  DeleteFile(link_file.value().c_str());
   CoUninitialize();
 }
 #endif
 
 TEST_F(FileUtilTest, CreateTemporaryFileNameTest) {
   std::wstring temp_file;
   file_util::CreateTemporaryFileName(&temp_file);
   EXPECT_TRUE(file_util::PathExists(temp_file));
   EXPECT_TRUE(file_util::Delete(temp_file, false));
 }
 
 TEST_F(FileUtilTest, CreateNewTempDirectoryTest) {
   std::wstring temp_dir;
   file_util::CreateNewTempDirectory(std::wstring(), &temp_dir);
   EXPECT_TRUE(file_util::PathExists(temp_dir));
   EXPECT_TRUE(file_util::Delete(temp_dir, false));
 }
 
 TEST_F(FileUtilTest, CreateDirectoryTest) {
-  std::wstring test_root = test_dir_;
-  file_util::AppendToPath(&test_root, L"create_directory_test");
-  std::wstring test_path(test_root);
+  FilePath test_root =
+      test_dir_.Append(FILE_PATH_LITERAL("create_directory_test"));
 #if defined(OS_WIN)
-  file_util::AppendToPath(&test_path, L"dir\\tree\\likely\\doesnt\\exist\\");
+  FilePath test_path =
+      test_root.Append(FILE_PATH_LITERAL("dir\\tree\\likely\\doesnt\\exist\\"));
 #elif defined(OS_POSIX)
-  file_util::AppendToPath(&test_path, L"dir/tree/likely/doesnt/exist/");
+  FilePath test_path =
+      test_root.Append(FILE_PATH_LITERAL("dir/tree/likely/doesnt/exist/"));
 #endif
 
   EXPECT_FALSE(file_util::PathExists(test_path));
   EXPECT_TRUE(file_util::CreateDirectory(test_path));
   EXPECT_TRUE(file_util::PathExists(test_path));
   // CreateDirectory returns true if the DirectoryExists returns true.
   EXPECT_TRUE(file_util::CreateDirectory(test_path));
 
   // Doesn't work to create it on top of a non-dir
-  file_util::AppendToPath(&test_path, L"foobar.txt");
+  test_path = test_path.Append(FILE_PATH_LITERAL("foobar.txt"));
   EXPECT_FALSE(file_util::PathExists(test_path));
   CreateTextFile(test_path, L"test file");
   EXPECT_TRUE(file_util::PathExists(test_path));
   EXPECT_FALSE(file_util::CreateDirectory(test_path));
 
   EXPECT_TRUE(file_util::Delete(test_root, true));
   EXPECT_FALSE(file_util::PathExists(test_root));
   EXPECT_FALSE(file_util::PathExists(test_path));
 }
 
 TEST_F(FileUtilTest, DetectDirectoryTest) {
   // Check a directory
-  std::wstring test_root = test_dir_;
-  file_util::AppendToPath(&test_root, L"detect_directory_test");
+  FilePath test_root =
+      test_dir_.Append(FILE_PATH_LITERAL("detect_directory_test"));
   EXPECT_FALSE(file_util::PathExists(test_root));
   EXPECT_TRUE(file_util::CreateDirectory(test_root));
   EXPECT_TRUE(file_util::PathExists(test_root));
   EXPECT_TRUE(file_util::DirectoryExists(test_root));
 
   // Check a file
-  std::wstring test_path(test_root);
-  file_util::AppendToPath(&test_path, L"foobar.txt");
+  FilePath test_path =
+      test_root.Append(FILE_PATH_LITERAL("foobar.txt"));
   EXPECT_FALSE(file_util::PathExists(test_path));
   CreateTextFile(test_path, L"test file");
   EXPECT_TRUE(file_util::PathExists(test_path));
   EXPECT_FALSE(file_util::DirectoryExists(test_path));
   EXPECT_TRUE(file_util::Delete(test_path, false));
 
   EXPECT_TRUE(file_util::Delete(test_root, true));
 }
 
 static const struct goodbad_pair {
@@ skipping 68 matching lines @@
   file_util::AppendToPath(&path, L"foo.bar");
   file_util::AppendToPath(&path, L"foo");
   // '/foo.bar/foo' with extension '.baz'
   std::wstring result_path = path;
   file_util::ReplaceExtension(&result_path, L".baz");
   EXPECT_EQ(path + L".baz", result_path);
 }
 
 TEST_F(FileUtilTest, FileEnumeratorTest) {
   // Test an empty directory.
-  file_util::FileEnumerator f0(test_dir_, true,
+  file_util::FileEnumerator f0(test_dir_.ToWStringHack(), true,
       file_util::FileEnumerator::FILES_AND_DIRECTORIES);
   EXPECT_EQ(f0.Next(), L"");
   EXPECT_EQ(f0.Next(), L"");
 
   // create the directories
-  std::wstring dir1 = test_dir_;
-  file_util::AppendToPath(&dir1, L"dir1");
+  FilePath dir1 = test_dir_.Append(FILE_PATH_LITERAL("dir1"));
   EXPECT_TRUE(file_util::CreateDirectory(dir1));
-  std::wstring dir2 = test_dir_;
-  file_util::AppendToPath(&dir2, L"dir2");
+  FilePath dir2 = test_dir_.Append(FILE_PATH_LITERAL("dir2"));
   EXPECT_TRUE(file_util::CreateDirectory(dir2));
-  std::wstring dir2inner = dir2;
-  file_util::AppendToPath(&dir2inner, L"inner");
+  FilePath dir2inner = dir2.Append(FILE_PATH_LITERAL("inner"));
   EXPECT_TRUE(file_util::CreateDirectory(dir2inner));
-  
+
   // create the files
-  std::wstring dir2file = dir2;
-  file_util::AppendToPath(&dir2file, L"dir2file.txt");
+  FilePath dir2file = dir2.Append(FILE_PATH_LITERAL("dir2file.txt"));
   CreateTextFile(dir2file, L"");
-  std::wstring dir2innerfile = dir2inner;
-  file_util::AppendToPath(&dir2innerfile, L"innerfile.txt");
+  FilePath dir2innerfile = dir2inner.Append(FILE_PATH_LITERAL("innerfile.txt"));
   CreateTextFile(dir2innerfile, L"");
-  std::wstring file1 = test_dir_;
-  file_util::AppendToPath(&file1, L"file1.txt");
+  FilePath file1 = test_dir_.Append(FILE_PATH_LITERAL("file1.txt"));
   CreateTextFile(file1, L"");
-  std::wstring file2_rel = dir2;
-  file_util::AppendToPath(&file2_rel, L"..");
-  file_util::AppendToPath(&file2_rel, L"file2.txt");
+  FilePath file2_rel =
+      dir2.Append(FilePath::kParentDirectory)
+          .Append(FILE_PATH_LITERAL("file2.txt"));
   CreateTextFile(file2_rel, L"");
-  std::wstring file2_abs = test_dir_;
-  file_util::AppendToPath(&file2_abs, L"file2.txt");
+  FilePath file2_abs = test_dir_.Append(FILE_PATH_LITERAL("file2.txt"));
 
   // Only enumerate files.
-  file_util::FileEnumerator f1(test_dir_, true,
+  file_util::FileEnumerator f1(test_dir_.ToWStringHack(), true,
                                file_util::FileEnumerator::FILES);
   FindResultCollector c1(f1);
   EXPECT_TRUE(c1.HasFile(file1));
   EXPECT_TRUE(c1.HasFile(file2_abs));
   EXPECT_TRUE(c1.HasFile(dir2file));
   EXPECT_TRUE(c1.HasFile(dir2innerfile));
   EXPECT_EQ(c1.size(), 4);
 
   // Only enumerate directories.
-  file_util::FileEnumerator f2(test_dir_, true,
+  file_util::FileEnumerator f2(test_dir_.ToWStringHack(), true,
                                file_util::FileEnumerator::DIRECTORIES);
   FindResultCollector c2(f2);
   EXPECT_TRUE(c2.HasFile(dir1));
   EXPECT_TRUE(c2.HasFile(dir2));
   EXPECT_TRUE(c2.HasFile(dir2inner));
   EXPECT_EQ(c2.size(), 3);
 
   // Only enumerate directories non-recursively.
   file_util::FileEnumerator f2_non_recursive(
-      test_dir_, false, file_util::FileEnumerator::DIRECTORIES);
+      test_dir_.ToWStringHack(), false, file_util::FileEnumerator::DIRECTORIES);
   FindResultCollector c2_non_recursive(f2_non_recursive);
   EXPECT_TRUE(c2_non_recursive.HasFile(dir1));
   EXPECT_TRUE(c2_non_recursive.HasFile(dir2));
   EXPECT_EQ(c2_non_recursive.size(), 2);
 
   // Enumerate files and directories.
-  file_util::FileEnumerator f3(test_dir_, true,
+  file_util::FileEnumerator f3(test_dir_.ToWStringHack(), true,
       file_util::FileEnumerator::FILES_AND_DIRECTORIES);
   FindResultCollector c3(f3);
   EXPECT_TRUE(c3.HasFile(dir1));
   EXPECT_TRUE(c3.HasFile(dir2));
   EXPECT_TRUE(c3.HasFile(file1));
   EXPECT_TRUE(c3.HasFile(file2_abs));
   EXPECT_TRUE(c3.HasFile(dir2file));
   EXPECT_TRUE(c3.HasFile(dir2inner));
   EXPECT_TRUE(c3.HasFile(dir2innerfile));
   EXPECT_EQ(c3.size(), 7);
 
   // Non-recursive operation.
-  file_util::FileEnumerator f4(test_dir_, false,
+  file_util::FileEnumerator f4(test_dir_.ToWStringHack(), false,
       file_util::FileEnumerator::FILES_AND_DIRECTORIES);
   FindResultCollector c4(f4);
   EXPECT_TRUE(c4.HasFile(dir2));
   EXPECT_TRUE(c4.HasFile(dir2));
   EXPECT_TRUE(c4.HasFile(file1));
   EXPECT_TRUE(c4.HasFile(file2_abs));
   EXPECT_EQ(c4.size(), 4);
 
   // Enumerate with a pattern.
-  file_util::FileEnumerator f5(test_dir_, true,
+  file_util::FileEnumerator f5(test_dir_.ToWStringHack(), true,
       file_util::FileEnumerator::FILES_AND_DIRECTORIES, L"dir*");
   FindResultCollector c5(f5);
   EXPECT_TRUE(c5.HasFile(dir1));
   EXPECT_TRUE(c5.HasFile(dir2));
   EXPECT_TRUE(c5.HasFile(dir2file));
   EXPECT_TRUE(c5.HasFile(dir2inner));
   EXPECT_TRUE(c5.HasFile(dir2innerfile));
   EXPECT_EQ(c5.size(), 5);
 
   // Make sure the destructor closes the find handle while in the middle of a
   // query to allow TearDown to delete the directory.
-  file_util::FileEnumerator f6(test_dir_, true,
+  file_util::FileEnumerator f6(test_dir_.ToWStringHack(), true,
       file_util::FileEnumerator::FILES_AND_DIRECTORIES);
   EXPECT_FALSE(f6.Next().empty());  // Should have found something
                                     // (we don't care what).
 }
 
 }  // namespace