//base: Make ScopedTempDir::path() a GetPath() with a DCHECK

base/files/file_util_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <fstream>
 #include <set>
@@ skipping 231 matching lines @@
   file.open(filename.value().c_str());
   EXPECT_TRUE(file.is_open());
   file.getline(contents, arraysize(contents));
   file.close();
   return std::wstring(contents);
 }
 
 TEST_F(FileUtilTest, FileAndDirectorySize) {
   // Create three files of 20, 30 and 3 chars (utf8). ComputeDirectorySize
   // should return 53 bytes.
-  FilePath file_01 = temp_dir_.path().Append(FPL("The file 01.txt"));
+  FilePath file_01 = temp_dir_.GetPath().Append(FPL("The file 01.txt"));
   CreateTextFile(file_01, L"12345678901234567890");
   int64_t size_f1 = 0;
   ASSERT_TRUE(GetFileSize(file_01, &size_f1));
   EXPECT_EQ(20ll, size_f1);
 
-  FilePath subdir_path = temp_dir_.path().Append(FPL("Level2"));
+  FilePath subdir_path = temp_dir_.GetPath().Append(FPL("Level2"));
   CreateDirectory(subdir_path);
 
   FilePath file_02 = subdir_path.Append(FPL("The file 02.txt"));
   CreateTextFile(file_02, L"123456789012345678901234567890");
   int64_t size_f2 = 0;
   ASSERT_TRUE(GetFileSize(file_02, &size_f2));
   EXPECT_EQ(30ll, size_f2);
 
   FilePath subsubdir_path = subdir_path.Append(FPL("Level3"));
   CreateDirectory(subsubdir_path);
 
   FilePath file_03 = subsubdir_path.Append(FPL("The file 03.txt"));
   CreateTextFile(file_03, L"123");
 
-  int64_t computed_size = ComputeDirectorySize(temp_dir_.path());
+  int64_t computed_size = ComputeDirectorySize(temp_dir_.GetPath());
   EXPECT_EQ(size_f1 + size_f2 + 3, computed_size);
 }
 
 TEST_F(FileUtilTest, NormalizeFilePathBasic) {
   // Create a directory under the test dir.  Because we create it,
   // we know it is not a link.
-  FilePath file_a_path = temp_dir_.path().Append(FPL("file_a"));
-  FilePath dir_path = temp_dir_.path().Append(FPL("dir"));
+  FilePath file_a_path = temp_dir_.GetPath().Append(FPL("file_a"));
+  FilePath dir_path = temp_dir_.GetPath().Append(FPL("dir"));
   FilePath file_b_path = dir_path.Append(FPL("file_b"));
   CreateDirectory(dir_path);
 
   FilePath normalized_file_a_path, normalized_file_b_path;
   ASSERT_FALSE(PathExists(file_a_path));
   ASSERT_FALSE(NormalizeFilePath(file_a_path, &normalized_file_a_path))
     << "NormalizeFilePath() should fail on nonexistent paths.";
 
   CreateTextFile(file_a_path, bogus_content);
   ASSERT_TRUE(PathExists(file_a_path));
@@ skipping 20 matching lines @@
   // |   |-> sub_a
   // |       |-> file.txt
   // |       |-> long_name___... (Very long name.)
   // |           |-> sub_long
   // |              |-> deep.txt
   // |-> base_b
   //     |-> to_sub_a (reparse point to temp_dir\base_a\sub_a)
   //     |-> to_base_b (reparse point to temp_dir\base_b)
   //     |-> to_sub_long (reparse point to temp_dir\sub_a\long_name_\sub_long)
 
-  FilePath base_a = temp_dir_.path().Append(FPL("base_a"));
+  FilePath base_a = temp_dir_.GetPath().Append(FPL("base_a"));
 #if defined(OS_WIN)
   // TEMP can have a lower case drive letter.
   string16 temp_base_a = base_a.value();
   ASSERT_FALSE(temp_base_a.empty());
   *temp_base_a.begin() = ToUpperASCII(*temp_base_a.begin());
   base_a = FilePath(temp_base_a);
 #endif
   ASSERT_TRUE(CreateDirectory(base_a));
 
   FilePath sub_a = base_a.Append(FPL("sub_a"));
@@ skipping 22 matching lines @@
 
   FilePath long_name = sub_a.Append(FilePath(long_name_str));
   FilePath deep_file = long_name.Append(sub_long_rel).Append(deep_txt);
   ASSERT_EQ(static_cast<size_t>(MAX_PATH - kCreateDirLimit),
             deep_file.value().length());
 
   FilePath sub_long = deep_file.DirName();
   ASSERT_TRUE(CreateDirectory(sub_long));
   CreateTextFile(deep_file, bogus_content);
 
-  FilePath base_b = temp_dir_.path().Append(FPL("base_b"));
+  FilePath base_b = temp_dir_.GetPath().Append(FPL("base_b"));
   ASSERT_TRUE(CreateDirectory(base_b));
 
   FilePath to_sub_a = base_b.Append(FPL("to_sub_a"));
   ASSERT_TRUE(CreateDirectory(to_sub_a));
   FilePath normalized_path;
   {
     ReparsePoint reparse_to_sub_a(to_sub_a, sub_a);
     ASSERT_TRUE(reparse_to_sub_a.IsValid());
 
     FilePath to_base_b = base_b.Append(FPL("to_base_b"));
@@ skipping 47 matching lines @@
     // to traverse them.
   }
 
   ASSERT_FALSE(NormalizeFilePath(to_sub_a.Append(FPL("file.txt")),
                                             &normalized_path));
 }
 
 TEST_F(FileUtilTest, DevicePathToDriveLetter) {
   // Get a drive letter.
   string16 real_drive_letter =
-      ToUpperASCII(temp_dir_.path().value().substr(0, 2));
+      ToUpperASCII(temp_dir_.GetPath().value().substr(0, 2));
   if (!isalpha(real_drive_letter[0]) || ':' != real_drive_letter[1]) {
     LOG(ERROR) << "Can't get a drive letter to test with.";
     return;
   }
 
   // Get the NT style path to that drive.
   wchar_t device_path[MAX_PATH] = {'\0'};
   ASSERT_TRUE(
       ::QueryDosDevice(real_drive_letter.c_str(), device_path, MAX_PATH));
   FilePath actual_device_path(device_path);
@@ skipping 53 matching lines @@
 }
 
 TEST_F(FileUtilTest, CreateTemporaryFileInDirLongPathTest) {
   // Test that CreateTemporaryFileInDir() creates a path and returns a long path
   // if it is available. This test requires that:
   // - the filesystem at |temp_dir_| supports long filenames.
   // - the account has FILE_LIST_DIRECTORY permission for all ancestor
   //   directories of |temp_dir_|.
   const FilePath::CharType kLongDirName[] = FPL("A long path");
   const FilePath::CharType kTestSubDirName[] = FPL("test");
-  FilePath long_test_dir = temp_dir_.path().Append(kLongDirName);
+  FilePath long_test_dir = temp_dir_.GetPath().Append(kLongDirName);
   ASSERT_TRUE(CreateDirectory(long_test_dir));
 
   // kLongDirName is not a 8.3 component. So GetShortName() should give us a
   // different short name.
   WCHAR path_buffer[MAX_PATH];
   DWORD path_buffer_length = GetShortPathName(long_test_dir.value().c_str(),
                                               path_buffer, MAX_PATH);
   ASSERT_LT(path_buffer_length, DWORD(MAX_PATH));
   ASSERT_NE(DWORD(0), path_buffer_length);
   FilePath short_test_dir(path_buffer);
@@ skipping 26 matching lines @@
   path_buffer_length = GetLongPathName(temp_file.value().c_str(),
                                        path_buffer, MAX_PATH);
   EXPECT_EQ(DWORD(0), path_buffer_length);
 }
 
 #endif  // defined(OS_WIN)
 
 #if defined(OS_POSIX)
 
 TEST_F(FileUtilTest, CreateAndReadSymlinks) {
-  FilePath link_from = temp_dir_.path().Append(FPL("from_file"));
-  FilePath link_to = temp_dir_.path().Append(FPL("to_file"));
+  FilePath link_from = temp_dir_.GetPath().Append(FPL("from_file"));
+  FilePath link_to = temp_dir_.GetPath().Append(FPL("to_file"));
   CreateTextFile(link_to, bogus_content);
 
   ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
     << "Failed to create file symlink.";
 
   // If we created the link properly, we should be able to read the contents
   // through it.
   std::wstring contents = ReadTextFile(link_from);
   EXPECT_EQ(bogus_content, contents);
 
   FilePath result;
   ASSERT_TRUE(ReadSymbolicLink(link_from, &result));
   EXPECT_EQ(link_to.value(), result.value());
 
   // Link to a directory.
-  link_from = temp_dir_.path().Append(FPL("from_dir"));
-  link_to = temp_dir_.path().Append(FPL("to_dir"));
+  link_from = temp_dir_.GetPath().Append(FPL("from_dir"));
+  link_to = temp_dir_.GetPath().Append(FPL("to_dir"));
   ASSERT_TRUE(CreateDirectory(link_to));
   ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
     << "Failed to create directory symlink.";
 
   // Test failures.
   EXPECT_FALSE(CreateSymbolicLink(link_to, link_to));
   EXPECT_FALSE(ReadSymbolicLink(link_to, &result));
-  FilePath missing = temp_dir_.path().Append(FPL("missing"));
+  FilePath missing = temp_dir_.GetPath().Append(FPL("missing"));
   EXPECT_FALSE(ReadSymbolicLink(missing, &result));
 }
 
 // The following test of NormalizeFilePath() require that we create a symlink.
 // This can not be done on Windows before Vista.  On Vista, creating a symlink
 // requires privilege "SeCreateSymbolicLinkPrivilege".
 // TODO(skerner): Investigate the possibility of giving base_unittests the
 // privileges required to create a symlink.
 TEST_F(FileUtilTest, NormalizeFilePathSymlinks) {
   // Link one file to another.
-  FilePath link_from = temp_dir_.path().Append(FPL("from_file"));
-  FilePath link_to = temp_dir_.path().Append(FPL("to_file"));
+  FilePath link_from = temp_dir_.GetPath().Append(FPL("from_file"));
+  FilePath link_to = temp_dir_.GetPath().Append(FPL("to_file"));
   CreateTextFile(link_to, bogus_content);
 
   ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
     << "Failed to create file symlink.";
 
   // Check that NormalizeFilePath sees the link.
   FilePath normalized_path;
   ASSERT_TRUE(NormalizeFilePath(link_from, &normalized_path));
   EXPECT_NE(link_from, link_to);
   EXPECT_EQ(link_to.BaseName().value(), normalized_path.BaseName().value());
   EXPECT_EQ(link_to.BaseName().value(), normalized_path.BaseName().value());
 
   // Link to a directory.
-  link_from = temp_dir_.path().Append(FPL("from_dir"));
-  link_to = temp_dir_.path().Append(FPL("to_dir"));
+  link_from = temp_dir_.GetPath().Append(FPL("from_dir"));
+  link_to = temp_dir_.GetPath().Append(FPL("to_dir"));
   ASSERT_TRUE(CreateDirectory(link_to));
   ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
     << "Failed to create directory symlink.";
 
   EXPECT_FALSE(NormalizeFilePath(link_from, &normalized_path))
     << "Links to directories should return false.";
 
   // Test that a loop in the links causes NormalizeFilePath() to return false.
-  link_from = temp_dir_.path().Append(FPL("link_a"));
-  link_to = temp_dir_.path().Append(FPL("link_b"));
+  link_from = temp_dir_.GetPath().Append(FPL("link_a"));
+  link_to = temp_dir_.GetPath().Append(FPL("link_b"));
   ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
     << "Failed to create loop symlink a.";
   ASSERT_TRUE(CreateSymbolicLink(link_from, link_to))
     << "Failed to create loop symlink b.";
 
   // Infinite loop!
   EXPECT_FALSE(NormalizeFilePath(link_from, &normalized_path));
 }
 #endif  // defined(OS_POSIX)
 
 TEST_F(FileUtilTest, DeleteNonExistent) {
-  FilePath non_existent = temp_dir_.path().AppendASCII("bogus_file_dne.foobar");
+  FilePath non_existent =
+      temp_dir_.GetPath().AppendASCII("bogus_file_dne.foobar");
   ASSERT_FALSE(PathExists(non_existent));
 
   EXPECT_TRUE(DeleteFile(non_existent, false));
   ASSERT_FALSE(PathExists(non_existent));
   EXPECT_TRUE(DeleteFile(non_existent, true));
   ASSERT_FALSE(PathExists(non_existent));
 }
 
 TEST_F(FileUtilTest, DeleteNonExistentWithNonExistentParent) {
-  FilePath non_existent = temp_dir_.path().AppendASCII("bogus_topdir");
+  FilePath non_existent = temp_dir_.GetPath().AppendASCII("bogus_topdir");
   non_existent = non_existent.AppendASCII("bogus_subdir");
   ASSERT_FALSE(PathExists(non_existent));
 
   EXPECT_TRUE(DeleteFile(non_existent, false));
   ASSERT_FALSE(PathExists(non_existent));
   EXPECT_TRUE(DeleteFile(non_existent, true));
   ASSERT_FALSE(PathExists(non_existent));
 }
 
 TEST_F(FileUtilTest, DeleteFile) {
   // Create a file
-  FilePath file_name = temp_dir_.path().Append(FPL("Test DeleteFile 1.txt"));
+  FilePath file_name = temp_dir_.GetPath().Append(FPL("Test DeleteFile 1.txt"));
   CreateTextFile(file_name, bogus_content);
   ASSERT_TRUE(PathExists(file_name));
 
   // Make sure it's deleted
   EXPECT_TRUE(DeleteFile(file_name, false));
   EXPECT_FALSE(PathExists(file_name));
 
   // Test recursive case, create a new file
-  file_name = temp_dir_.path().Append(FPL("Test DeleteFile 2.txt"));
+  file_name = temp_dir_.GetPath().Append(FPL("Test DeleteFile 2.txt"));
   CreateTextFile(file_name, bogus_content);
   ASSERT_TRUE(PathExists(file_name));
 
   // Make sure it's deleted
   EXPECT_TRUE(DeleteFile(file_name, true));
   EXPECT_FALSE(PathExists(file_name));
 }
 
 #if defined(OS_POSIX)
 TEST_F(FileUtilTest, DeleteSymlinkToExistentFile) {
   // Create a file.
-  FilePath file_name = temp_dir_.path().Append(FPL("Test DeleteFile 2.txt"));
+  FilePath file_name = temp_dir_.GetPath().Append(FPL("Test DeleteFile 2.txt"));
   CreateTextFile(file_name, bogus_content);
   ASSERT_TRUE(PathExists(file_name));
 
   // Create a symlink to the file.
-  FilePath file_link = temp_dir_.path().Append("file_link_2");
+  FilePath file_link = temp_dir_.GetPath().Append("file_link_2");
   ASSERT_TRUE(CreateSymbolicLink(file_name, file_link))
       << "Failed to create symlink.";
 
   // Delete the symbolic link.
   EXPECT_TRUE(DeleteFile(file_link, false));
 
   // Make sure original file is not deleted.
   EXPECT_FALSE(PathExists(file_link));
   EXPECT_TRUE(PathExists(file_name));
 }
 
 TEST_F(FileUtilTest, DeleteSymlinkToNonExistentFile) {
   // Create a non-existent file path.
-  FilePath non_existent = temp_dir_.path().Append(FPL("Test DeleteFile 3.txt"));
+  FilePath non_existent =
+      temp_dir_.GetPath().Append(FPL("Test DeleteFile 3.txt"));
   EXPECT_FALSE(PathExists(non_existent));
 
   // Create a symlink to the non-existent file.
-  FilePath file_link = temp_dir_.path().Append("file_link_3");
+  FilePath file_link = temp_dir_.GetPath().Append("file_link_3");
   ASSERT_TRUE(CreateSymbolicLink(non_existent, file_link))
       << "Failed to create symlink.";
 
   // Make sure the symbolic link is exist.
   EXPECT_TRUE(IsLink(file_link));
   EXPECT_FALSE(PathExists(file_link));
 
   // Delete the symbolic link.
   EXPECT_TRUE(DeleteFile(file_link, false));
 
   // Make sure the symbolic link is deleted.
   EXPECT_FALSE(IsLink(file_link));
 }
 
 TEST_F(FileUtilTest, ChangeFilePermissionsAndRead) {
   // Create a file path.
-  FilePath file_name = temp_dir_.path().Append(FPL("Test Readable File.txt"));
+  FilePath file_name =
+      temp_dir_.GetPath().Append(FPL("Test Readable File.txt"));
   EXPECT_FALSE(PathExists(file_name));
 
   const std::string kData("hello");
 
   int buffer_size = kData.length();
   char* buffer = new char[buffer_size];
 
   // Write file.
   EXPECT_EQ(static_cast<int>(kData.length()),
             WriteFile(file_name, kData.data(), kData.length()));
@@ skipping 21 matching lines @@
 
   // Delete the file.
   EXPECT_TRUE(DeleteFile(file_name, false));
   EXPECT_FALSE(PathExists(file_name));
 
   delete[] buffer;
 }
 
 TEST_F(FileUtilTest, ChangeFilePermissionsAndWrite) {
   // Create a file path.
-  FilePath file_name = temp_dir_.path().Append(FPL("Test Readable File.txt"));
+  FilePath file_name =
+      temp_dir_.GetPath().Append(FPL("Test Readable File.txt"));
   EXPECT_FALSE(PathExists(file_name));
 
   const std::string kData("hello");
 
   // Write file.
   EXPECT_EQ(static_cast<int>(kData.length()),
             WriteFile(file_name, kData.data(), kData.length()));
   EXPECT_TRUE(PathExists(file_name));
 
   // Make sure the file is writable.
@@ skipping 20 matching lines @@
             WriteFile(file_name, kData.data(), kData.length()));
   EXPECT_TRUE(PathIsWritable(file_name));
 
   // Delete the file.
   EXPECT_TRUE(DeleteFile(file_name, false));
   EXPECT_FALSE(PathExists(file_name));
 }
 
 TEST_F(FileUtilTest, ChangeDirectoryPermissionsAndEnumerate) {
   // Create a directory path.
-  FilePath subdir_path =
-      temp_dir_.path().Append(FPL("PermissionTest1"));
+  FilePath subdir_path = temp_dir_.GetPath().Append(FPL("PermissionTest1"));
   CreateDirectory(subdir_path);
   ASSERT_TRUE(PathExists(subdir_path));
 
   // Create a dummy file to enumerate.
   FilePath file_name = subdir_path.Append(FPL("Test Readable File.txt"));
   EXPECT_FALSE(PathExists(file_name));
   const std::string kData("hello");
   EXPECT_EQ(static_cast<int>(kData.length()),
             WriteFile(file_name, kData.data(), kData.length()));
   EXPECT_TRUE(PathExists(file_name));
@@ skipping 30 matching lines @@
   EXPECT_TRUE(DeleteFile(subdir_path, true));
   EXPECT_FALSE(PathExists(subdir_path));
 }
 
 TEST_F(FileUtilTest, ExecutableExistsInPath) {
   // Create two directories that we will put in our PATH
   const char kPath[] = "PATH";
   const FilePath::CharType kDir1[] = FPL("dir1");
   const FilePath::CharType kDir2[] = FPL("dir2");
 
-  FilePath dir1 = temp_dir_.path().Append(kDir1);
-  FilePath dir2 = temp_dir_.path().Append(kDir2);
+  FilePath dir1 = temp_dir_.GetPath().Append(kDir1);
+  FilePath dir2 = temp_dir_.GetPath().Append(kDir2);
   ASSERT_TRUE(CreateDirectory(dir1));
   ASSERT_TRUE(CreateDirectory(dir2));
 
   std::unique_ptr<Environment> env(base::Environment::Create());
 
   ASSERT_TRUE(env->SetVar(kPath, dir1.value() + ":" + dir2.value()));
 
   const FilePath::CharType kRegularFileName[] = FPL("regular_file");
   const FilePath::CharType kExeFileName[] = FPL("exe");
   const FilePath::CharType kDneFileName[] = FPL("does_not_exist");
@@ skipping 19 matching lines @@
 }
 
 #endif  // defined(OS_POSIX)
 
 #if defined(OS_WIN)
 // Tests that the Delete function works for wild cards, especially
 // with the recursion flag.  Also coincidentally tests PathExists.
 // TODO(erikkay): see if anyone's actually using this feature of the API
 TEST_F(FileUtilTest, DeleteWildCard) {
   // Create a file and a directory
-  FilePath file_name = temp_dir_.path().Append(FPL("Test DeleteWildCard.txt"));
+  FilePath file_name =
+      temp_dir_.GetPath().Append(FPL("Test DeleteWildCard.txt"));
   CreateTextFile(file_name, bogus_content);
   ASSERT_TRUE(PathExists(file_name));
 
-  FilePath subdir_path = temp_dir_.path().Append(FPL("DeleteWildCardDir"));
+  FilePath subdir_path = temp_dir_.GetPath().Append(FPL("DeleteWildCardDir"));
   CreateDirectory(subdir_path);
   ASSERT_TRUE(PathExists(subdir_path));
 
   // Create the wildcard path
-  FilePath directory_contents = temp_dir_.path();
+  FilePath directory_contents = temp_dir_.GetPath();
   directory_contents = directory_contents.Append(FPL("*"));
 
   // Delete non-recursively and check that only the file is deleted
   EXPECT_TRUE(DeleteFile(directory_contents, false));
   EXPECT_FALSE(PathExists(file_name));
   EXPECT_TRUE(PathExists(subdir_path));
 
   // Delete recursively and make sure all contents are deleted
   EXPECT_TRUE(DeleteFile(directory_contents, true));
   EXPECT_FALSE(PathExists(file_name));
   EXPECT_FALSE(PathExists(subdir_path));
 }
 
 // TODO(erikkay): see if anyone's actually using this feature of the API
 TEST_F(FileUtilTest, DeleteNonExistantWildCard) {
   // Create a file and a directory
   FilePath subdir_path =
-      temp_dir_.path().Append(FPL("DeleteNonExistantWildCard"));
+      temp_dir_.GetPath().Append(FPL("DeleteNonExistantWildCard"));
   CreateDirectory(subdir_path);
   ASSERT_TRUE(PathExists(subdir_path));
 
   // Create the wildcard path
   FilePath directory_contents = subdir_path;
   directory_contents = directory_contents.Append(FPL("*"));
 
   // Delete non-recursively and check nothing got deleted
   EXPECT_TRUE(DeleteFile(directory_contents, false));
   EXPECT_TRUE(PathExists(subdir_path));
 
   // Delete recursively and check nothing got deleted
   EXPECT_TRUE(DeleteFile(directory_contents, true));
   EXPECT_TRUE(PathExists(subdir_path));
 }
 #endif
 
 // Tests non-recursive Delete() for a directory.
 TEST_F(FileUtilTest, DeleteDirNonRecursive) {
   // Create a subdirectory and put a file and two directories inside.
-  FilePath test_subdir = temp_dir_.path().Append(FPL("DeleteDirNonRecursive"));
+  FilePath test_subdir =
+      temp_dir_.GetPath().Append(FPL("DeleteDirNonRecursive"));
   CreateDirectory(test_subdir);
   ASSERT_TRUE(PathExists(test_subdir));
 
   FilePath file_name = test_subdir.Append(FPL("Test DeleteDir.txt"));
   CreateTextFile(file_name, bogus_content);
   ASSERT_TRUE(PathExists(file_name));
 
   FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
   CreateDirectory(subdir_path1);
   ASSERT_TRUE(PathExists(subdir_path1));
 
   FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
   CreateDirectory(subdir_path2);
   ASSERT_TRUE(PathExists(subdir_path2));
 
   // Delete non-recursively and check that the empty dir got deleted
   EXPECT_TRUE(DeleteFile(subdir_path2, false));
   EXPECT_FALSE(PathExists(subdir_path2));
 
   // Delete non-recursively and check that nothing got deleted
   EXPECT_FALSE(DeleteFile(test_subdir, false));
   EXPECT_TRUE(PathExists(test_subdir));
   EXPECT_TRUE(PathExists(file_name));
   EXPECT_TRUE(PathExists(subdir_path1));
 }
 
 // Tests recursive Delete() for a directory.
 TEST_F(FileUtilTest, DeleteDirRecursive) {
   // Create a subdirectory and put a file and two directories inside.
-  FilePath test_subdir = temp_dir_.path().Append(FPL("DeleteDirRecursive"));
+  FilePath test_subdir = temp_dir_.GetPath().Append(FPL("DeleteDirRecursive"));
   CreateDirectory(test_subdir);
   ASSERT_TRUE(PathExists(test_subdir));
 
   FilePath file_name = test_subdir.Append(FPL("Test DeleteDirRecursive.txt"));
   CreateTextFile(file_name, bogus_content);
   ASSERT_TRUE(PathExists(file_name));
 
   FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
   CreateDirectory(subdir_path1);
   ASSERT_TRUE(PathExists(subdir_path1));
 
   FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
   CreateDirectory(subdir_path2);
   ASSERT_TRUE(PathExists(subdir_path2));
 
   // Delete recursively and check that the empty dir got deleted
   EXPECT_TRUE(DeleteFile(subdir_path2, true));
   EXPECT_FALSE(PathExists(subdir_path2));
 
   // Delete recursively and check that everything got deleted
   EXPECT_TRUE(DeleteFile(test_subdir, true));
   EXPECT_FALSE(PathExists(file_name));
   EXPECT_FALSE(PathExists(subdir_path1));
   EXPECT_FALSE(PathExists(test_subdir));
 }
 
 TEST_F(FileUtilTest, MoveFileNew) {
   // Create a file
   FilePath file_name_from =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // The destination.
-  FilePath file_name_to = temp_dir_.path().Append(
+  FilePath file_name_to = temp_dir_.GetPath().Append(
       FILE_PATH_LITERAL("Move_Test_File_Destination.txt"));
   ASSERT_FALSE(PathExists(file_name_to));
 
   EXPECT_TRUE(Move(file_name_from, file_name_to));
 
   // Check everything has been moved.
   EXPECT_FALSE(PathExists(file_name_from));
   EXPECT_TRUE(PathExists(file_name_to));
 }
 
 TEST_F(FileUtilTest, MoveFileExists) {
   // Create a file
   FilePath file_name_from =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // The destination name.
-  FilePath file_name_to = temp_dir_.path().Append(
+  FilePath file_name_to = temp_dir_.GetPath().Append(
       FILE_PATH_LITERAL("Move_Test_File_Destination.txt"));
   CreateTextFile(file_name_to, L"Old file content");
   ASSERT_TRUE(PathExists(file_name_to));
 
   EXPECT_TRUE(Move(file_name_from, file_name_to));
 
   // Check everything has been moved.
   EXPECT_FALSE(PathExists(file_name_from));
   EXPECT_TRUE(PathExists(file_name_to));
   EXPECT_TRUE(L"Gooooooooooooooooooooogle" == ReadTextFile(file_name_to));
 }
 
 TEST_F(FileUtilTest, MoveFileDirExists) {
   // Create a file
   FilePath file_name_from =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // The destination directory
   FilePath dir_name_to =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Destination"));
   CreateDirectory(dir_name_to);
   ASSERT_TRUE(PathExists(dir_name_to));
 
   EXPECT_FALSE(Move(file_name_from, dir_name_to));
 }
 
 
 TEST_F(FileUtilTest, MoveNew) {
   // Create a directory
   FilePath dir_name_from =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Move_From_Subdir"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory
   FilePath txt_file_name(FILE_PATH_LITERAL("Move_Test_File.txt"));
   FilePath file_name_from = dir_name_from.Append(txt_file_name);
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Move the directory.
   FilePath dir_name_to =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Move_To_Subdir"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_To_Subdir"));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
 
   ASSERT_FALSE(PathExists(dir_name_to));
 
   EXPECT_TRUE(Move(dir_name_from, dir_name_to));
 
   // Check everything has been moved.
   EXPECT_FALSE(PathExists(dir_name_from));
   EXPECT_FALSE(PathExists(file_name_from));
   EXPECT_TRUE(PathExists(dir_name_to));
   EXPECT_TRUE(PathExists(file_name_to));
 
   // Test path traversal.
   file_name_from = dir_name_to.Append(txt_file_name);
   file_name_to = dir_name_to.Append(FILE_PATH_LITERAL(".."));
   file_name_to = file_name_to.Append(txt_file_name);
   EXPECT_FALSE(Move(file_name_from, file_name_to));
   EXPECT_TRUE(PathExists(file_name_from));
   EXPECT_FALSE(PathExists(file_name_to));
   EXPECT_TRUE(internal::MoveUnsafe(file_name_from, file_name_to));
   EXPECT_FALSE(PathExists(file_name_from));
   EXPECT_TRUE(PathExists(file_name_to));
 }
 
 TEST_F(FileUtilTest, MoveExist) {
   // Create a directory
   FilePath dir_name_from =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Move_From_Subdir"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Move the directory
   FilePath dir_name_exists =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Destination"));
 
   FilePath dir_name_to =
       dir_name_exists.Append(FILE_PATH_LITERAL("Move_To_Subdir"));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
 
   // Create the destination directory.
   CreateDirectory(dir_name_exists);
   ASSERT_TRUE(PathExists(dir_name_exists));
 
   EXPECT_TRUE(Move(dir_name_from, dir_name_to));
 
   // Check everything has been moved.
   EXPECT_FALSE(PathExists(dir_name_from));
   EXPECT_FALSE(PathExists(file_name_from));
   EXPECT_TRUE(PathExists(dir_name_to));
   EXPECT_TRUE(PathExists(file_name_to));
 }
 
 TEST_F(FileUtilTest, CopyDirectoryRecursivelyNew) {
   // Create a directory.
   FilePath dir_name_from =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory.
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Create a subdirectory.
   FilePath subdir_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
   CreateDirectory(subdir_name_from);
   ASSERT_TRUE(PathExists(subdir_name_from));
 
   // Create a file under the subdirectory.
   FilePath file_name2_from =
       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name2_from));
 
   // Copy the directory recursively.
   FilePath dir_name_to =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
+      temp_dir_.GetPath().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(PathExists(dir_name_to));
 
   EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_to, true));
 
   // Check everything has been copied.
   EXPECT_TRUE(PathExists(dir_name_from));
   EXPECT_TRUE(PathExists(file_name_from));
   EXPECT_TRUE(PathExists(subdir_name_from));
   EXPECT_TRUE(PathExists(file_name2_from));
   EXPECT_TRUE(PathExists(dir_name_to));
   EXPECT_TRUE(PathExists(file_name_to));
   EXPECT_TRUE(PathExists(subdir_name_to));
   EXPECT_TRUE(PathExists(file_name2_to));
 }
 
 TEST_F(FileUtilTest, CopyDirectoryRecursivelyExists) {
   // Create a directory.
   FilePath dir_name_from =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory.
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Create a subdirectory.
   FilePath subdir_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
   CreateDirectory(subdir_name_from);
   ASSERT_TRUE(PathExists(subdir_name_from));
 
   // Create a file under the subdirectory.
   FilePath file_name2_from =
       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name2_from));
 
   // Copy the directory recursively.
   FilePath dir_name_exists =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Destination"));
 
   FilePath dir_name_to =
       dir_name_exists.Append(FILE_PATH_LITERAL("Copy_From_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"));
 
@@ skipping 10 matching lines @@
   EXPECT_TRUE(PathExists(file_name2_from));
   EXPECT_TRUE(PathExists(dir_name_to));
   EXPECT_TRUE(PathExists(file_name_to));
   EXPECT_TRUE(PathExists(subdir_name_to));
   EXPECT_TRUE(PathExists(file_name2_to));
 }
 
 TEST_F(FileUtilTest, CopyDirectoryNew) {
   // Create a directory.
   FilePath dir_name_from =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory.
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Create a subdirectory.
   FilePath subdir_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
   CreateDirectory(subdir_name_from);
   ASSERT_TRUE(PathExists(subdir_name_from));
 
   // Create a file under the subdirectory.
   FilePath file_name2_from =
       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name2_from));
 
   // Copy the directory not recursively.
   FilePath dir_name_to =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
+      temp_dir_.GetPath().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(PathExists(dir_name_to));
 
   EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_to, false));
 
   // Check everything has been copied.
   EXPECT_TRUE(PathExists(dir_name_from));
   EXPECT_TRUE(PathExists(file_name_from));
   EXPECT_TRUE(PathExists(subdir_name_from));
   EXPECT_TRUE(PathExists(file_name2_from));
   EXPECT_TRUE(PathExists(dir_name_to));
   EXPECT_TRUE(PathExists(file_name_to));
   EXPECT_FALSE(PathExists(subdir_name_to));
 }
 
 TEST_F(FileUtilTest, CopyDirectoryExists) {
   // Create a directory.
   FilePath dir_name_from =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory.
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Create a subdirectory.
   FilePath subdir_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
   CreateDirectory(subdir_name_from);
   ASSERT_TRUE(PathExists(subdir_name_from));
 
   // Create a file under the subdirectory.
   FilePath file_name2_from =
       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name2_from));
 
   // Copy the directory not recursively.
   FilePath dir_name_to =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
+      temp_dir_.GetPath().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"));
 
   // Create the destination directory.
   CreateDirectory(dir_name_to);
   ASSERT_TRUE(PathExists(dir_name_to));
 
   EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_to, false));
 
   // Check everything has been copied.
   EXPECT_TRUE(PathExists(dir_name_from));
   EXPECT_TRUE(PathExists(file_name_from));
   EXPECT_TRUE(PathExists(subdir_name_from));
   EXPECT_TRUE(PathExists(file_name2_from));
   EXPECT_TRUE(PathExists(dir_name_to));
   EXPECT_TRUE(PathExists(file_name_to));
   EXPECT_FALSE(PathExists(subdir_name_to));
 }
 
 TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToNew) {
   // Create a file
   FilePath file_name_from =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // The destination name
-  FilePath file_name_to = temp_dir_.path().Append(
+  FilePath file_name_to = temp_dir_.GetPath().Append(
       FILE_PATH_LITERAL("Copy_Test_File_Destination.txt"));
   ASSERT_FALSE(PathExists(file_name_to));
 
   EXPECT_TRUE(CopyDirectory(file_name_from, file_name_to, true));
 
   // Check the has been copied
   EXPECT_TRUE(PathExists(file_name_to));
 }
 
 TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToExisting) {
   // Create a file
   FilePath file_name_from =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // The destination name
-  FilePath file_name_to = temp_dir_.path().Append(
+  FilePath file_name_to = temp_dir_.GetPath().Append(
       FILE_PATH_LITERAL("Copy_Test_File_Destination.txt"));
   CreateTextFile(file_name_to, L"Old file content");
   ASSERT_TRUE(PathExists(file_name_to));
 
   EXPECT_TRUE(CopyDirectory(file_name_from, file_name_to, true));
 
   // Check the has been copied
   EXPECT_TRUE(PathExists(file_name_to));
   EXPECT_TRUE(L"Gooooooooooooooooooooogle" == ReadTextFile(file_name_to));
 }
 
 TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToExistingDirectory) {
   // Create a file
   FilePath file_name_from =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // The destination
   FilePath dir_name_to =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Destination"));
   CreateDirectory(dir_name_to);
   ASSERT_TRUE(PathExists(dir_name_to));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
 
   EXPECT_TRUE(CopyDirectory(file_name_from, dir_name_to, true));
 
   // Check the has been copied
   EXPECT_TRUE(PathExists(file_name_to));
 }
 
 TEST_F(FileUtilTest, CopyDirectoryWithTrailingSeparators) {
   // Create a directory.
   FilePath dir_name_from =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory.
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Copy the directory recursively.
   FilePath dir_name_to =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
 
   // Create from path with trailing separators.
 #if defined(OS_WIN)
   FilePath from_path =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir\\\\\\"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir\\\\\\"));
 #elif defined(OS_POSIX)
   FilePath from_path =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir///"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir///"));
 #endif
 
   EXPECT_TRUE(CopyDirectory(from_path, dir_name_to, true));
 
   // Check everything has been copied.
   EXPECT_TRUE(PathExists(dir_name_from));
   EXPECT_TRUE(PathExists(file_name_from));
   EXPECT_TRUE(PathExists(dir_name_to));
   EXPECT_TRUE(PathExists(file_name_to));
 }
@@ skipping 33 matching lines @@
   return attrs & FILE_ATTRIBUTE_READONLY;
 #else
   int mode = 0;
   EXPECT_TRUE(GetPosixFilePermissions(path, &mode));
   return !(mode & S_IWUSR);
 #endif
 }
 
 TEST_F(FileUtilTest, CopyDirectoryACL) {
   // Create source directories.
-  FilePath src = temp_dir_.path().Append(FILE_PATH_LITERAL("src"));
+  FilePath src = temp_dir_.GetPath().Append(FILE_PATH_LITERAL("src"));
   FilePath src_subdir = src.Append(FILE_PATH_LITERAL("subdir"));
   CreateDirectory(src_subdir);
   ASSERT_TRUE(PathExists(src_subdir));
 
   // Create a file under the directory.
   FilePath src_file = src.Append(FILE_PATH_LITERAL("src.txt"));
   CreateTextFile(src_file, L"Gooooooooooooooooooooogle");
   SetReadOnly(src_file, true);
   ASSERT_TRUE(IsReadOnly(src_file));
 
   // Make directory read-only.
   SetReadOnly(src_subdir, true);
   ASSERT_TRUE(IsReadOnly(src_subdir));
 
   // Copy the directory recursively.
-  FilePath dst = temp_dir_.path().Append(FILE_PATH_LITERAL("dst"));
+  FilePath dst = temp_dir_.GetPath().Append(FILE_PATH_LITERAL("dst"));
   FilePath dst_file = dst.Append(FILE_PATH_LITERAL("src.txt"));
   EXPECT_TRUE(CopyDirectory(src, dst, true));
 
   FilePath dst_subdir = dst.Append(FILE_PATH_LITERAL("subdir"));
   ASSERT_FALSE(IsReadOnly(dst_subdir));
   ASSERT_FALSE(IsReadOnly(dst_file));
 
   // Give write permissions to allow deletion.
   SetReadOnly(src_subdir, false);
   ASSERT_FALSE(IsReadOnly(src_subdir));
 }
 
 TEST_F(FileUtilTest, CopyFile) {
   // Create a directory
   FilePath dir_name_from =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory
   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(PathExists(file_name_from));
 
@@ skipping 17 matching lines @@
   const std::wstring read_contents = ReadTextFile(dest_file);
   EXPECT_EQ(file_contents, read_contents);
   EXPECT_FALSE(PathExists(dest_file2_test));
   EXPECT_FALSE(PathExists(dest_file2));
 }
 
 TEST_F(FileUtilTest, CopyFileACL) {
   // While FileUtilTest.CopyFile asserts the content is correctly copied over,
   // this test case asserts the access control bits are meeting expectations in
   // CopyFile().
-  FilePath src = temp_dir_.path().Append(FILE_PATH_LITERAL("src.txt"));
+  FilePath src = temp_dir_.GetPath().Append(FILE_PATH_LITERAL("src.txt"));
   const std::wstring file_contents(L"Gooooooooooooooooooooogle");
   CreateTextFile(src, file_contents);
 
   // Set the source file to read-only.
   ASSERT_FALSE(IsReadOnly(src));
   SetReadOnly(src, true);
   ASSERT_TRUE(IsReadOnly(src));
 
   // Copy the file.
-  FilePath dst = temp_dir_.path().Append(FILE_PATH_LITERAL("dst.txt"));
+  FilePath dst = temp_dir_.GetPath().Append(FILE_PATH_LITERAL("dst.txt"));
   ASSERT_TRUE(CopyFile(src, dst));
   EXPECT_EQ(file_contents, ReadTextFile(dst));
 
   ASSERT_FALSE(IsReadOnly(dst));
 }
 
 // file_util winds up using autoreleased objects on the Mac, so this needs
 // to be a PlatformTest.
 typedef PlatformTest ReadOnlyFileUtilTest;
 
@@ skipping 85 matching lines @@
   EXPECT_FALSE(TextContentsEqual(first1_file, first2_file));
   EXPECT_TRUE(TextContentsEqual(empty1_file, empty2_file));
   EXPECT_FALSE(TextContentsEqual(original_file, empty1_file));
   EXPECT_TRUE(TextContentsEqual(blank_line_file, blank_line_crlf_file));
 }
 
 // We don't need equivalent functionality outside of Windows.
 #if defined(OS_WIN)
 TEST_F(FileUtilTest, CopyAndDeleteDirectoryTest) {
   // Create a directory
-  FilePath dir_name_from =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("CopyAndDelete_From_Subdir"));
+  FilePath dir_name_from = temp_dir_.GetPath().Append(
+      FILE_PATH_LITERAL("CopyAndDelete_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("CopyAndDelete_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Move the directory by using CopyAndDeleteDirectory
-  FilePath dir_name_to = temp_dir_.path().Append(
-      FILE_PATH_LITERAL("CopyAndDelete_To_Subdir"));
+  FilePath dir_name_to =
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("CopyAndDelete_To_Subdir"));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("CopyAndDelete_Test_File.txt"));
 
   ASSERT_FALSE(PathExists(dir_name_to));
 
   EXPECT_TRUE(internal::CopyAndDeleteDirectory(dir_name_from,
                                                      dir_name_to));
 
   // Check everything has been moved.
   EXPECT_FALSE(PathExists(dir_name_from));
@@ skipping 121 matching lines @@
     EXPECT_TRUE(CloseFile(fps[i]));
     EXPECT_TRUE(DeleteFile(names[i], false));
   }
 }
 
 TEST_F(FileUtilTest, FileToFILE) {
   File file;
   FILE* stream = FileToFILE(std::move(file), "w");
   EXPECT_FALSE(stream);
 
-  FilePath file_name = temp_dir_.path().Append(FPL("The file.txt"));
+  FilePath file_name = temp_dir_.GetPath().Append(FPL("The file.txt"));
   file = File(file_name, File::FLAG_CREATE | File::FLAG_WRITE);
   EXPECT_TRUE(file.IsValid());
 
   stream = FileToFILE(std::move(file), "w");
   EXPECT_TRUE(stream);
   EXPECT_FALSE(file.IsValid());
   EXPECT_TRUE(CloseFile(stream));
 }
 
 TEST_F(FileUtilTest, CreateNewTempDirectoryTest) {
   FilePath temp_dir;
   ASSERT_TRUE(CreateNewTempDirectory(FilePath::StringType(), &temp_dir));
   EXPECT_TRUE(PathExists(temp_dir));
   EXPECT_TRUE(DeleteFile(temp_dir, false));
 }
 
 TEST_F(FileUtilTest, CreateNewTemporaryDirInDirTest) {
   FilePath new_dir;
   ASSERT_TRUE(CreateTemporaryDirInDir(
-                  temp_dir_.path(),
-                  FILE_PATH_LITERAL("CreateNewTemporaryDirInDirTest"),
-                  &new_dir));
+      temp_dir_.GetPath(), FILE_PATH_LITERAL("CreateNewTemporaryDirInDirTest"),
+      &new_dir));
   EXPECT_TRUE(PathExists(new_dir));
-  EXPECT_TRUE(temp_dir_.path().IsParent(new_dir));
+  EXPECT_TRUE(temp_dir_.GetPath().IsParent(new_dir));
   EXPECT_TRUE(DeleteFile(new_dir, false));
 }
 
 #if defined(OS_POSIX)
 TEST_F(FileUtilTest, GetShmemTempDirTest) {
   FilePath dir;
   EXPECT_TRUE(GetShmemTempDir(false, &dir));
   EXPECT_TRUE(DirectoryExists(dir));
 }
 #endif
 
 TEST_F(FileUtilTest, GetHomeDirTest) {
 #if !defined(OS_ANDROID)  // Not implemented on Android.
   // We don't actually know what the home directory is supposed to be without
   // calling some OS functions which would just duplicate the implementation.
   // So here we just test that it returns something "reasonable".
   FilePath home = GetHomeDir();
   ASSERT_FALSE(home.empty());
   ASSERT_TRUE(home.IsAbsolute());
 #endif
 }
 
 TEST_F(FileUtilTest, CreateDirectoryTest) {
   FilePath test_root =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("create_directory_test"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("create_directory_test"));
 #if defined(OS_WIN)
   FilePath test_path =
       test_root.Append(FILE_PATH_LITERAL("dir\\tree\\likely\\doesnt\\exist\\"));
 #elif defined(OS_POSIX)
   FilePath test_path =
       test_root.Append(FILE_PATH_LITERAL("dir/tree/likely/doesnt/exist/"));
 #endif
 
   EXPECT_FALSE(PathExists(test_path));
   EXPECT_TRUE(CreateDirectory(test_path));
@@ skipping 34 matching lines @@
       invalid_drive.Append(FILE_PATH_LITERAL("some\\inaccessible\\dir"));
   if (!PathExists(invalid_drive)) {
     EXPECT_FALSE(CreateDirectory(invalid_path));
   }
 #endif
 }
 
 TEST_F(FileUtilTest, DetectDirectoryTest) {
   // Check a directory
   FilePath test_root =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("detect_directory_test"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("detect_directory_test"));
   EXPECT_FALSE(PathExists(test_root));
   EXPECT_TRUE(CreateDirectory(test_root));
   EXPECT_TRUE(PathExists(test_root));
   EXPECT_TRUE(DirectoryExists(test_root));
   // Check a file
   FilePath test_path =
       test_root.Append(FILE_PATH_LITERAL("foobar.txt"));
   EXPECT_FALSE(PathExists(test_path));
   CreateTextFile(test_path, L"test file");
   EXPECT_TRUE(PathExists(test_path));
   EXPECT_FALSE(DirectoryExists(test_path));
   EXPECT_TRUE(DeleteFile(test_path, false));
 
   EXPECT_TRUE(DeleteFile(test_root, true));
 }
 
 TEST_F(FileUtilTest, FileEnumeratorTest) {
   // Test an empty directory.
-  FileEnumerator f0(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
+  FileEnumerator f0(temp_dir_.GetPath(), true, FILES_AND_DIRECTORIES);
   EXPECT_EQ(FPL(""), f0.Next().value());
   EXPECT_EQ(FPL(""), f0.Next().value());
 
   // Test an empty directory, non-recursively, including "..".
-  FileEnumerator f0_dotdot(temp_dir_.path(), false,
+  FileEnumerator f0_dotdot(
+      temp_dir_.GetPath(), false,
       FILES_AND_DIRECTORIES | FileEnumerator::INCLUDE_DOT_DOT);
-  EXPECT_EQ(temp_dir_.path().Append(FPL("..")).value(),
+  EXPECT_EQ(temp_dir_.GetPath().Append(FPL("..")).value(),
             f0_dotdot.Next().value());
   EXPECT_EQ(FPL(""), f0_dotdot.Next().value());
 
   // create the directories
-  FilePath dir1 = temp_dir_.path().Append(FPL("dir1"));
+  FilePath dir1 = temp_dir_.GetPath().Append(FPL("dir1"));
   EXPECT_TRUE(CreateDirectory(dir1));
-  FilePath dir2 = temp_dir_.path().Append(FPL("dir2"));
+  FilePath dir2 = temp_dir_.GetPath().Append(FPL("dir2"));
   EXPECT_TRUE(CreateDirectory(dir2));
   FilePath dir2inner = dir2.Append(FPL("inner"));
   EXPECT_TRUE(CreateDirectory(dir2inner));
 
   // create the files
   FilePath dir2file = dir2.Append(FPL("dir2file.txt"));
   CreateTextFile(dir2file, std::wstring());
   FilePath dir2innerfile = dir2inner.Append(FPL("innerfile.txt"));
   CreateTextFile(dir2innerfile, std::wstring());
-  FilePath file1 = temp_dir_.path().Append(FPL("file1.txt"));
+  FilePath file1 = temp_dir_.GetPath().Append(FPL("file1.txt"));
   CreateTextFile(file1, std::wstring());
   FilePath file2_rel = dir2.Append(FilePath::kParentDirectory)
       .Append(FPL("file2.txt"));
   CreateTextFile(file2_rel, std::wstring());
-  FilePath file2_abs = temp_dir_.path().Append(FPL("file2.txt"));
+  FilePath file2_abs = temp_dir_.GetPath().Append(FPL("file2.txt"));
 
   // Only enumerate files.
-  FileEnumerator f1(temp_dir_.path(), true, FileEnumerator::FILES);
+  FileEnumerator f1(temp_dir_.GetPath(), true, 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(4, c1.size());
 
   // Only enumerate directories.
-  FileEnumerator f2(temp_dir_.path(), true, FileEnumerator::DIRECTORIES);
+  FileEnumerator f2(temp_dir_.GetPath(), true, FileEnumerator::DIRECTORIES);
   FindResultCollector c2(&f2);
   EXPECT_TRUE(c2.HasFile(dir1));
   EXPECT_TRUE(c2.HasFile(dir2));
   EXPECT_TRUE(c2.HasFile(dir2inner));
   EXPECT_EQ(3, c2.size());
 
   // Only enumerate directories non-recursively.
-  FileEnumerator f2_non_recursive(
-      temp_dir_.path(), false, FileEnumerator::DIRECTORIES);
+  FileEnumerator f2_non_recursive(temp_dir_.GetPath(), false,
+                                  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(2, c2_non_recursive.size());
 
   // Only enumerate directories, non-recursively, including "..".
-  FileEnumerator f2_dotdot(temp_dir_.path(), false,
-                           FileEnumerator::DIRECTORIES |
-                           FileEnumerator::INCLUDE_DOT_DOT);
+  FileEnumerator f2_dotdot(
+      temp_dir_.GetPath(), false,
+      FileEnumerator::DIRECTORIES | FileEnumerator::INCLUDE_DOT_DOT);
   FindResultCollector c2_dotdot(&f2_dotdot);
   EXPECT_TRUE(c2_dotdot.HasFile(dir1));
   EXPECT_TRUE(c2_dotdot.HasFile(dir2));
-  EXPECT_TRUE(c2_dotdot.HasFile(temp_dir_.path().Append(FPL(".."))));
+  EXPECT_TRUE(c2_dotdot.HasFile(temp_dir_.GetPath().Append(FPL(".."))));
   EXPECT_EQ(3, c2_dotdot.size());
 
   // Enumerate files and directories.
-  FileEnumerator f3(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
+  FileEnumerator f3(temp_dir_.GetPath(), true, 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(7, c3.size());
 
   // Non-recursive operation.
-  FileEnumerator f4(temp_dir_.path(), false, FILES_AND_DIRECTORIES);
+  FileEnumerator f4(temp_dir_.GetPath(), false, 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(4, c4.size());
 
   // Enumerate with a pattern.
-  FileEnumerator f5(temp_dir_.path(), true, FILES_AND_DIRECTORIES, FPL("dir*"));
+  FileEnumerator f5(temp_dir_.GetPath(), true, FILES_AND_DIRECTORIES,
+                    FPL("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(5, c5.size());
 
 #if defined(OS_WIN)
   {
     // Make dir1 point to dir2.
     ReparsePoint reparse_point(dir1, dir2);
     EXPECT_TRUE(reparse_point.IsValid());
 
     if ((win::GetVersion() >= win::VERSION_VISTA)) {
       // There can be a delay for the enumeration code to see the change on
       // the file system so skip this test for XP.
       // Enumerate the reparse point.
       FileEnumerator f6(dir1, true, FILES_AND_DIRECTORIES);
       FindResultCollector c6(&f6);
       FilePath inner2 = dir1.Append(FPL("inner"));
       EXPECT_TRUE(c6.HasFile(inner2));
       EXPECT_TRUE(c6.HasFile(inner2.Append(FPL("innerfile.txt"))));
       EXPECT_TRUE(c6.HasFile(dir1.Append(FPL("dir2file.txt"))));
       EXPECT_EQ(3, c6.size());
     }
 
     // No changes for non recursive operation.
-    FileEnumerator f7(temp_dir_.path(), false, FILES_AND_DIRECTORIES);
+    FileEnumerator f7(temp_dir_.GetPath(), false, FILES_AND_DIRECTORIES);
     FindResultCollector c7(&f7);
     EXPECT_TRUE(c7.HasFile(dir2));
     EXPECT_TRUE(c7.HasFile(dir2));
     EXPECT_TRUE(c7.HasFile(file1));
     EXPECT_TRUE(c7.HasFile(file2_abs));
     EXPECT_EQ(4, c7.size());
 
     // Should not enumerate inside dir1 when using recursion.
-    FileEnumerator f8(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
+    FileEnumerator f8(temp_dir_.GetPath(), true, FILES_AND_DIRECTORIES);
     FindResultCollector c8(&f8);
     EXPECT_TRUE(c8.HasFile(dir1));
     EXPECT_TRUE(c8.HasFile(dir2));
     EXPECT_TRUE(c8.HasFile(file1));
     EXPECT_TRUE(c8.HasFile(file2_abs));
     EXPECT_TRUE(c8.HasFile(dir2file));
     EXPECT_TRUE(c8.HasFile(dir2inner));
     EXPECT_TRUE(c8.HasFile(dir2innerfile));
     EXPECT_EQ(7, c8.size());
   }
 #endif
 
   // Make sure the destructor closes the find handle while in the middle of a
   // query to allow TearDown to delete the directory.
-  FileEnumerator f9(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
+  FileEnumerator f9(temp_dir_.GetPath(), true, FILES_AND_DIRECTORIES);
   EXPECT_FALSE(f9.Next().value().empty());  // Should have found something
                                             // (we don't care what).
 }
 
 TEST_F(FileUtilTest, AppendToFile) {
   FilePath data_dir =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("FilePathTest"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("FilePathTest"));
 
   // Create a fresh, empty copy of this directory.
   if (PathExists(data_dir)) {
     ASSERT_TRUE(DeleteFile(data_dir, true));
   }
   ASSERT_TRUE(CreateDirectory(data_dir));
 
   // Create a fresh, empty copy of this directory.
   if (PathExists(data_dir)) {
     ASSERT_TRUE(DeleteFile(data_dir, true));
   }
   ASSERT_TRUE(CreateDirectory(data_dir));
   FilePath foobar(data_dir.Append(FILE_PATH_LITERAL("foobar.txt")));
 
   std::string data("hello");
   EXPECT_FALSE(AppendToFile(foobar, data.c_str(), data.size()));
   EXPECT_EQ(static_cast<int>(data.length()),
             WriteFile(foobar, data.c_str(), data.length()));
   EXPECT_TRUE(AppendToFile(foobar, data.c_str(), data.size()));
 
   const std::wstring read_content = ReadTextFile(foobar);
   EXPECT_EQ(L"hellohello", read_content);
 }
 
 TEST_F(FileUtilTest, ReadFile) {
   // Create a test file to be read.
   const std::string kTestData("The quick brown fox jumps over the lazy dog.");
   FilePath file_path =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("ReadFileTest"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("ReadFileTest"));
 
   ASSERT_EQ(static_cast<int>(kTestData.size()),
             WriteFile(file_path, kTestData.data(), kTestData.size()));
 
   // Make buffers with various size.
   std::vector<char> small_buffer(kTestData.size() / 2);
   std::vector<char> exact_buffer(kTestData.size());
   std::vector<char> large_buffer(kTestData.size() * 2);
 
   // Read the file with smaller buffer.
@@ skipping 12 matching lines @@
 
   // Read the file with larger buffer.
   int bytes_read_large = ReadFile(
       file_path, &large_buffer[0], static_cast<int>(large_buffer.size()));
   EXPECT_EQ(static_cast<int>(kTestData.size()), bytes_read_large);
   EXPECT_EQ(kTestData, std::string(large_buffer.begin(),
                                    large_buffer.begin() + kTestData.size()));
 
   // Make sure the return value is -1 if the file doesn't exist.
   FilePath file_path_not_exist =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("ReadFileNotExistTest"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("ReadFileNotExistTest"));
   EXPECT_EQ(-1,
             ReadFile(file_path_not_exist,
                      &exact_buffer[0],
                      static_cast<int>(exact_buffer.size())));
 }
 
 TEST_F(FileUtilTest, ReadFileToString) {
   const char kTestData[] = "0123";
   std::string data;
 
   FilePath file_path =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("ReadFileToStringTest"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("ReadFileToStringTest"));
   FilePath file_path_dangerous =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("..")).
-      Append(temp_dir_.path().BaseName()).
-      Append(FILE_PATH_LITERAL("ReadFileToStringTest"));
+      temp_dir_.GetPath()
+          .Append(FILE_PATH_LITERAL(".."))
+          .Append(temp_dir_.GetPath().BaseName())
+          .Append(FILE_PATH_LITERAL("ReadFileToStringTest"));
 
   // Create test file.
   ASSERT_EQ(4, WriteFile(file_path, kTestData, 4));
 
   EXPECT_TRUE(ReadFileToString(file_path, &data));
   EXPECT_EQ(kTestData, data);
 
   data = "temp";
   EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, &data, 0));
   EXPECT_EQ(0u, data.length());
@@ skipping 29 matching lines @@
   EXPECT_FALSE(ReadFileToString(file_path, &data));
   EXPECT_EQ(0u, data.length());
 
   data = "temp";
   EXPECT_FALSE(ReadFileToStringWithMaxSize(file_path, &data, 6));
   EXPECT_EQ(0u, data.length());
 }
 
 TEST_F(FileUtilTest, TouchFile) {
   FilePath data_dir =
-      temp_dir_.path().Append(FILE_PATH_LITERAL("FilePathTest"));
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("FilePathTest"));
 
   // Create a fresh, empty copy of this directory.
   if (PathExists(data_dir)) {
     ASSERT_TRUE(DeleteFile(data_dir, true));
   }
   ASSERT_TRUE(CreateDirectory(data_dir));
 
   FilePath foobar(data_dir.Append(FILE_PATH_LITERAL("foobar.txt")));
   std::string data("hello");
   ASSERT_TRUE(WriteFile(foobar, data.c_str(), data.length()));
@@ skipping 13 matching lines @@
   ASSERT_TRUE(TouchFile(foobar, access_time, modification_time));
   File::Info file_info;
   ASSERT_TRUE(GetFileInfo(foobar, &file_info));
   EXPECT_EQ(access_time.ToInternalValue(),
             file_info.last_accessed.ToInternalValue());
   EXPECT_EQ(modification_time.ToInternalValue(),
             file_info.last_modified.ToInternalValue());
 }
 
 TEST_F(FileUtilTest, IsDirectoryEmpty) {
-  FilePath empty_dir = temp_dir_.path().Append(FILE_PATH_LITERAL("EmptyDir"));
+  FilePath empty_dir =
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("EmptyDir"));
 
   ASSERT_FALSE(PathExists(empty_dir));
 
   ASSERT_TRUE(CreateDirectory(empty_dir));
 
   EXPECT_TRUE(IsDirectoryEmpty(empty_dir));
 
   FilePath foo(empty_dir.Append(FILE_PATH_LITERAL("foo.txt")));
   std::string bar("baz");
   ASSERT_TRUE(WriteFile(foo, bar.c_str(), bar.length()));
@@ skipping 14 matching lines @@
 class VerifyPathControlledByUserTest : public FileUtilTest {
  protected:
   void SetUp() override {
     FileUtilTest::SetUp();
 
     // Create a basic structure used by each test.
     // base_dir_
     //  |-> sub_dir_
     //       |-> text_file_
 
-    base_dir_ = temp_dir_.path().AppendASCII("base_dir");
+    base_dir_ = temp_dir_.GetPath().AppendASCII("base_dir");
     ASSERT_TRUE(CreateDirectory(base_dir_));
 
     sub_dir_ = base_dir_.AppendASCII("sub_dir");
     ASSERT_TRUE(CreateDirectory(sub_dir_));
 
     text_file_ = sub_dir_.AppendASCII("file.txt");
     CreateTextFile(text_file_, L"This text file has some text in it.");
 
     // Get the user and group files are created with from |base_dir_|.
     struct stat stat_buf;
@@ skipping 330 matching lines @@
   // Trying to close it should crash. This is important for security.
   EXPECT_DEATH(CloseWithScopedFD(fds[1]), "");
 #endif
 }
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace
 
 }  // namespace base