Move PathExists to base namespace.

base/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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
@@ skipping 331 matching lines @@
 
 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_b_path = dir_path.Append(FPL("file_b"));
   file_util::CreateDirectory(dir_path);
 
   FilePath normalized_file_a_path, normalized_file_b_path;
-  ASSERT_FALSE(file_util::PathExists(file_a_path));
+  ASSERT_FALSE(base::PathExists(file_a_path));
   ASSERT_FALSE(file_util::NormalizeFilePath(file_a_path,
                                             &normalized_file_a_path))
     << "NormalizeFilePath() should fail on nonexistent paths.";
 
   CreateTextFile(file_a_path, bogus_content);
-  ASSERT_TRUE(file_util::PathExists(file_a_path));
+  ASSERT_TRUE(base::PathExists(file_a_path));
   ASSERT_TRUE(file_util::NormalizeFilePath(file_a_path,
                                            &normalized_file_a_path));
 
   CreateTextFile(file_b_path, bogus_content);
-  ASSERT_TRUE(file_util::PathExists(file_b_path));
+  ASSERT_TRUE(base::PathExists(file_b_path));
   ASSERT_TRUE(file_util::NormalizeFilePath(file_b_path,
                                            &normalized_file_b_path));
 
   // Beacuse this test created |dir_path|, we know it is not a link
   // or junction.  So, the real path of the directory holding file a
   // must be the parent of the path holding file b.
   ASSERT_TRUE(normalized_file_a_path.DirName()
       .IsParent(normalized_file_b_path.DirName()));
 }
 
@@ skipping 245 matching lines @@
   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);
   ASSERT_STRNE(kLongDirName, short_test_dir.BaseName().value().c_str());
 
   FilePath temp_file;
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(short_test_dir, &temp_file));
   EXPECT_STREQ(kLongDirName, temp_file.DirName().BaseName().value().c_str());
-  EXPECT_TRUE(file_util::PathExists(temp_file));
+  EXPECT_TRUE(base::PathExists(temp_file));
 
   // Create a subdirectory of |long_test_dir| and make |long_test_dir|
   // unreadable. We should still be able to create a temp file in the
   // subdirectory, but we won't be able to determine the long path for it. This
   // mimics the environment that some users run where their user profiles reside
   // in a location where the don't have full access to the higher level
   // directories. (Note that this assumption is true for NTFS, but not for some
   // network file systems. E.g. AFS).
   FilePath access_test_dir = long_test_dir.Append(kTestSubDirName);
   ASSERT_TRUE(file_util::CreateDirectory(access_test_dir));
   file_util::PermissionRestorer long_test_dir_restorer(long_test_dir);
   ASSERT_TRUE(file_util::MakeFileUnreadable(long_test_dir));
 
   // Use the short form of the directory to create a temporary filename.
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(
       short_test_dir.Append(kTestSubDirName), &temp_file));
-  EXPECT_TRUE(file_util::PathExists(temp_file));
+  EXPECT_TRUE(base::PathExists(temp_file));
   EXPECT_TRUE(short_test_dir.IsParent(temp_file.DirName()));
 
   // Check that the long path can't be determined for |temp_file|.
   path_buffer_length = GetLongPathName(temp_file.value().c_str(),
                                        path_buffer, MAX_PATH);
   EXPECT_EQ(DWORD(0), path_buffer_length);
 }
 
 #endif  // defined(OS_WIN)
 
@@ skipping 69 matching lines @@
   ASSERT_TRUE(file_util::CreateSymbolicLink(link_from, link_to))
     << "Failed to create loop symlink b.";
 
   // Infinite loop!
   EXPECT_FALSE(file_util::NormalizeFilePath(link_from, &normalized_path));
 }
 #endif  // defined(OS_POSIX)
 
 TEST_F(FileUtilTest, DeleteNonExistent) {
   FilePath non_existent = temp_dir_.path().AppendASCII("bogus_file_dne.foobar");
-  ASSERT_FALSE(file_util::PathExists(non_existent));
+  ASSERT_FALSE(base::PathExists(non_existent));
 
   EXPECT_TRUE(base::Delete(non_existent, false));
-  ASSERT_FALSE(file_util::PathExists(non_existent));
+  ASSERT_FALSE(base::PathExists(non_existent));
   EXPECT_TRUE(base::Delete(non_existent, true));
-  ASSERT_FALSE(file_util::PathExists(non_existent));
+  ASSERT_FALSE(base::PathExists(non_existent));
 }
 
 TEST_F(FileUtilTest, DeleteFile) {
   // Create a file
   FilePath file_name = temp_dir_.path().Append(FPL("Test DeleteFile 1.txt"));
   CreateTextFile(file_name, bogus_content);
-  ASSERT_TRUE(file_util::PathExists(file_name));
+  ASSERT_TRUE(base::PathExists(file_name));
 
   // Make sure it's deleted
   EXPECT_TRUE(base::Delete(file_name, false));
-  EXPECT_FALSE(file_util::PathExists(file_name));
+  EXPECT_FALSE(base::PathExists(file_name));
 
   // Test recursive case, create a new file
   file_name = temp_dir_.path().Append(FPL("Test DeleteFile 2.txt"));
   CreateTextFile(file_name, bogus_content);
-  ASSERT_TRUE(file_util::PathExists(file_name));
+  ASSERT_TRUE(base::PathExists(file_name));
 
   // Make sure it's deleted
   EXPECT_TRUE(base::Delete(file_name, true));
-  EXPECT_FALSE(file_util::PathExists(file_name));
+  EXPECT_FALSE(base::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"));
   CreateTextFile(file_name, bogus_content);
-  ASSERT_TRUE(file_util::PathExists(file_name));
+  ASSERT_TRUE(base::PathExists(file_name));
 
   // Create a symlink to the file.
   FilePath file_link = temp_dir_.path().Append("file_link_2");
   ASSERT_TRUE(file_util::CreateSymbolicLink(file_name, file_link))
       << "Failed to create symlink.";
 
   // Delete the symbolic link.
   EXPECT_TRUE(base::Delete(file_link, false));
 
   // Make sure original file is not deleted.
-  EXPECT_FALSE(file_util::PathExists(file_link));
-  EXPECT_TRUE(file_util::PathExists(file_name));
+  EXPECT_FALSE(base::PathExists(file_link));
+  EXPECT_TRUE(base::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"));
-  EXPECT_FALSE(file_util::PathExists(non_existent));
+  EXPECT_FALSE(base::PathExists(non_existent));
 
   // Create a symlink to the non-existent file.
   FilePath file_link = temp_dir_.path().Append("file_link_3");
   ASSERT_TRUE(file_util::CreateSymbolicLink(non_existent, file_link))
       << "Failed to create symlink.";
 
   // Make sure the symbolic link is exist.
   EXPECT_TRUE(file_util::IsLink(file_link));
-  EXPECT_FALSE(file_util::PathExists(file_link));
+  EXPECT_FALSE(base::PathExists(file_link));
 
   // Delete the symbolic link.
   EXPECT_TRUE(base::Delete(file_link, false));
 
   // Make sure the symbolic link is deleted.
   EXPECT_FALSE(file_util::IsLink(file_link));
 }
 
 TEST_F(FileUtilTest, ChangeFilePermissionsAndRead) {
   // Create a file path.
   FilePath file_name = temp_dir_.path().Append(FPL("Test Readable File.txt"));
-  EXPECT_FALSE(file_util::PathExists(file_name));
+  EXPECT_FALSE(base::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()),
             file_util::WriteFile(file_name, kData.data(), kData.length()));
-  EXPECT_TRUE(file_util::PathExists(file_name));
+  EXPECT_TRUE(base::PathExists(file_name));
 
   // Make sure the file is readable.
   int32 mode = 0;
   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
   EXPECT_TRUE(mode & file_util::FILE_PERMISSION_READ_BY_USER);
 
   // Get rid of the read permission.
   EXPECT_TRUE(file_util::SetPosixFilePermissions(file_name, 0u));
   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
   EXPECT_FALSE(mode & file_util::FILE_PERMISSION_READ_BY_USER);
   // Make sure the file can't be read.
   EXPECT_EQ(-1, file_util::ReadFile(file_name, buffer, buffer_size));
 
   // Give the read permission.
   EXPECT_TRUE(file_util::SetPosixFilePermissions(
       file_name,
       file_util::FILE_PERMISSION_READ_BY_USER));
   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
   EXPECT_TRUE(mode & file_util::FILE_PERMISSION_READ_BY_USER);
   // Make sure the file can be read.
   EXPECT_EQ(static_cast<int>(kData.length()),
             file_util::ReadFile(file_name, buffer, buffer_size));
 
   // Delete the file.
   EXPECT_TRUE(base::Delete(file_name, false));
-  EXPECT_FALSE(file_util::PathExists(file_name));
+  EXPECT_FALSE(base::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"));
-  EXPECT_FALSE(file_util::PathExists(file_name));
+  EXPECT_FALSE(base::PathExists(file_name));
 
   const std::string kData("hello");
 
   // Write file.
   EXPECT_EQ(static_cast<int>(kData.length()),
             file_util::WriteFile(file_name, kData.data(), kData.length()));
-  EXPECT_TRUE(file_util::PathExists(file_name));
+  EXPECT_TRUE(base::PathExists(file_name));
 
   // Make sure the file is writable.
   int mode = 0;
   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
   EXPECT_TRUE(mode & file_util::FILE_PERMISSION_WRITE_BY_USER);
   EXPECT_TRUE(file_util::PathIsWritable(file_name));
 
   // Get rid of the write permission.
   EXPECT_TRUE(file_util::SetPosixFilePermissions(file_name, 0u));
   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
   EXPECT_FALSE(mode & file_util::FILE_PERMISSION_WRITE_BY_USER);
   // Make sure the file can't be write.
   EXPECT_EQ(-1,
             file_util::WriteFile(file_name, kData.data(), kData.length()));
   EXPECT_FALSE(file_util::PathIsWritable(file_name));
 
   // Give read permission.
   EXPECT_TRUE(file_util::SetPosixFilePermissions(
       file_name,
       file_util::FILE_PERMISSION_WRITE_BY_USER));
   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
   EXPECT_TRUE(mode & file_util::FILE_PERMISSION_WRITE_BY_USER);
   // Make sure the file can be write.
   EXPECT_EQ(static_cast<int>(kData.length()),
             file_util::WriteFile(file_name, kData.data(), kData.length()));
   EXPECT_TRUE(file_util::PathIsWritable(file_name));
 
   // Delete the file.
   EXPECT_TRUE(base::Delete(file_name, false));
-  EXPECT_FALSE(file_util::PathExists(file_name));
+  EXPECT_FALSE(base::PathExists(file_name));
 }
 
 TEST_F(FileUtilTest, ChangeDirectoryPermissionsAndEnumerate) {
   // Create a directory path.
   FilePath subdir_path =
       temp_dir_.path().Append(FPL("PermissionTest1"));
   file_util::CreateDirectory(subdir_path);
-  ASSERT_TRUE(file_util::PathExists(subdir_path));
+  ASSERT_TRUE(base::PathExists(subdir_path));
 
   // Create a dummy file to enumerate.
   FilePath file_name = subdir_path.Append(FPL("Test Readable File.txt"));
-  EXPECT_FALSE(file_util::PathExists(file_name));
+  EXPECT_FALSE(base::PathExists(file_name));
   const std::string kData("hello");
   EXPECT_EQ(static_cast<int>(kData.length()),
             file_util::WriteFile(file_name, kData.data(), kData.length()));
-  EXPECT_TRUE(file_util::PathExists(file_name));
+  EXPECT_TRUE(base::PathExists(file_name));
 
   // Make sure the directory has the all permissions.
   int mode = 0;
   EXPECT_TRUE(file_util::GetPosixFilePermissions(subdir_path, &mode));
   EXPECT_EQ(file_util::FILE_PERMISSION_USER_MASK,
             mode & file_util::FILE_PERMISSION_USER_MASK);
 
   // Get rid of the permissions from the directory.
   EXPECT_TRUE(file_util::SetPosixFilePermissions(subdir_path, 0u));
   EXPECT_TRUE(file_util::GetPosixFilePermissions(subdir_path, &mode));
   EXPECT_FALSE(mode & file_util::FILE_PERMISSION_USER_MASK);
 
   // Make sure the file in the directory can't be enumerated.
   FileEnumerator f1(subdir_path, true, FileEnumerator::FILES);
-  EXPECT_TRUE(file_util::PathExists(subdir_path));
+  EXPECT_TRUE(base::PathExists(subdir_path));
   FindResultCollector c1(f1);
   EXPECT_EQ(c1.size(), 0);
   EXPECT_FALSE(file_util::GetPosixFilePermissions(file_name, &mode));
 
   // Give the permissions to the directory.
   EXPECT_TRUE(file_util::SetPosixFilePermissions(
       subdir_path,
       file_util::FILE_PERMISSION_USER_MASK));
   EXPECT_TRUE(file_util::GetPosixFilePermissions(subdir_path, &mode));
   EXPECT_EQ(file_util::FILE_PERMISSION_USER_MASK,
             mode & file_util::FILE_PERMISSION_USER_MASK);
 
   // Make sure the file in the directory can be enumerated.
   FileEnumerator f2(subdir_path, true, FileEnumerator::FILES);
   FindResultCollector c2(f2);
   EXPECT_TRUE(c2.HasFile(file_name));
   EXPECT_EQ(c2.size(), 1);
 
   // Delete the file.
   EXPECT_TRUE(base::Delete(subdir_path, true));
-  EXPECT_FALSE(file_util::PathExists(subdir_path));
+  EXPECT_FALSE(base::PathExists(subdir_path));
 }
 
 #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"));
   CreateTextFile(file_name, bogus_content);
-  ASSERT_TRUE(file_util::PathExists(file_name));
+  ASSERT_TRUE(base::PathExists(file_name));
 
   FilePath subdir_path = temp_dir_.path().Append(FPL("DeleteWildCardDir"));
   file_util::CreateDirectory(subdir_path);
-  ASSERT_TRUE(file_util::PathExists(subdir_path));
+  ASSERT_TRUE(base::PathExists(subdir_path));
 
   // Create the wildcard path
   FilePath directory_contents = temp_dir_.path();
   directory_contents = directory_contents.Append(FPL("*"));
 
   // Delete non-recursively and check that only the file is deleted
   EXPECT_TRUE(base::Delete(directory_contents, false));
-  EXPECT_FALSE(file_util::PathExists(file_name));
-  EXPECT_TRUE(file_util::PathExists(subdir_path));
+  EXPECT_FALSE(base::PathExists(file_name));
+  EXPECT_TRUE(base::PathExists(subdir_path));
 
   // Delete recursively and make sure all contents are deleted
   EXPECT_TRUE(base::Delete(directory_contents, true));
-  EXPECT_FALSE(file_util::PathExists(file_name));
-  EXPECT_FALSE(file_util::PathExists(subdir_path));
+  EXPECT_FALSE(base::PathExists(file_name));
+  EXPECT_FALSE(base::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"));
   file_util::CreateDirectory(subdir_path);
-  ASSERT_TRUE(file_util::PathExists(subdir_path));
+  ASSERT_TRUE(base::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(base::Delete(directory_contents, false));
-  EXPECT_TRUE(file_util::PathExists(subdir_path));
+  EXPECT_TRUE(base::PathExists(subdir_path));
 
   // Delete recursively and check nothing got deleted
   EXPECT_TRUE(base::Delete(directory_contents, true));
-  EXPECT_TRUE(file_util::PathExists(subdir_path));
+  EXPECT_TRUE(base::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"));
   file_util::CreateDirectory(test_subdir);
-  ASSERT_TRUE(file_util::PathExists(test_subdir));
+  ASSERT_TRUE(base::PathExists(test_subdir));
 
   FilePath file_name = test_subdir.Append(FPL("Test DeleteDir.txt"));
   CreateTextFile(file_name, bogus_content);
-  ASSERT_TRUE(file_util::PathExists(file_name));
+  ASSERT_TRUE(base::PathExists(file_name));
 
   FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
   file_util::CreateDirectory(subdir_path1);
-  ASSERT_TRUE(file_util::PathExists(subdir_path1));
+  ASSERT_TRUE(base::PathExists(subdir_path1));
 
   FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
   file_util::CreateDirectory(subdir_path2);
-  ASSERT_TRUE(file_util::PathExists(subdir_path2));
+  ASSERT_TRUE(base::PathExists(subdir_path2));
 
   // Delete non-recursively and check that the empty dir got deleted
   EXPECT_TRUE(base::Delete(subdir_path2, false));
-  EXPECT_FALSE(file_util::PathExists(subdir_path2));
+  EXPECT_FALSE(base::PathExists(subdir_path2));
 
   // Delete non-recursively and check that nothing got deleted
   EXPECT_FALSE(base::Delete(test_subdir, false));
-  EXPECT_TRUE(file_util::PathExists(test_subdir));
-  EXPECT_TRUE(file_util::PathExists(file_name));
-  EXPECT_TRUE(file_util::PathExists(subdir_path1));
+  EXPECT_TRUE(base::PathExists(test_subdir));
+  EXPECT_TRUE(base::PathExists(file_name));
+  EXPECT_TRUE(base::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"));
   file_util::CreateDirectory(test_subdir);
-  ASSERT_TRUE(file_util::PathExists(test_subdir));
+  ASSERT_TRUE(base::PathExists(test_subdir));
 
   FilePath file_name = test_subdir.Append(FPL("Test DeleteDirRecursive.txt"));
   CreateTextFile(file_name, bogus_content);
-  ASSERT_TRUE(file_util::PathExists(file_name));
+  ASSERT_TRUE(base::PathExists(file_name));
 
   FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
   file_util::CreateDirectory(subdir_path1);
-  ASSERT_TRUE(file_util::PathExists(subdir_path1));
+  ASSERT_TRUE(base::PathExists(subdir_path1));
 
   FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
   file_util::CreateDirectory(subdir_path2);
-  ASSERT_TRUE(file_util::PathExists(subdir_path2));
+  ASSERT_TRUE(base::PathExists(subdir_path2));
 
   // Delete recursively and check that the empty dir got deleted
   EXPECT_TRUE(base::Delete(subdir_path2, true));
-  EXPECT_FALSE(file_util::PathExists(subdir_path2));
+  EXPECT_FALSE(base::PathExists(subdir_path2));
 
   // Delete recursively and check that everything got deleted
   EXPECT_TRUE(base::Delete(test_subdir, true));
-  EXPECT_FALSE(file_util::PathExists(file_name));
-  EXPECT_FALSE(file_util::PathExists(subdir_path1));
-  EXPECT_FALSE(file_util::PathExists(test_subdir));
+  EXPECT_FALSE(base::PathExists(file_name));
+  EXPECT_FALSE(base::PathExists(subdir_path1));
+  EXPECT_FALSE(base::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"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
-  ASSERT_TRUE(file_util::PathExists(file_name_from));
+  ASSERT_TRUE(base::PathExists(file_name_from));
 
   // The destination.
   FilePath file_name_to = temp_dir_.path().Append(
       FILE_PATH_LITERAL("Move_Test_File_Destination.txt"));
-  ASSERT_FALSE(file_util::PathExists(file_name_to));
+  ASSERT_FALSE(base::PathExists(file_name_to));
 
   EXPECT_TRUE(base::Move(file_name_from, file_name_to));
 
   // Check everything has been moved.
-  EXPECT_FALSE(file_util::PathExists(file_name_from));
-  EXPECT_TRUE(file_util::PathExists(file_name_to));
+  EXPECT_FALSE(base::PathExists(file_name_from));
+  EXPECT_TRUE(base::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"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
-  ASSERT_TRUE(file_util::PathExists(file_name_from));
+  ASSERT_TRUE(base::PathExists(file_name_from));
 
   // The destination name.
   FilePath file_name_to = temp_dir_.path().Append(
       FILE_PATH_LITERAL("Move_Test_File_Destination.txt"));
   CreateTextFile(file_name_to, L"Old file content");
-  ASSERT_TRUE(file_util::PathExists(file_name_to));
+  ASSERT_TRUE(base::PathExists(file_name_to));
 
   EXPECT_TRUE(base::Move(file_name_from, file_name_to));
 
   // Check everything has been moved.
-  EXPECT_FALSE(file_util::PathExists(file_name_from));
-  EXPECT_TRUE(file_util::PathExists(file_name_to));
+  EXPECT_FALSE(base::PathExists(file_name_from));
+  EXPECT_TRUE(base::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"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
-  ASSERT_TRUE(file_util::PathExists(file_name_from));
+  ASSERT_TRUE(base::PathExists(file_name_from));
 
   // The destination directory
   FilePath dir_name_to =
       temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
   file_util::CreateDirectory(dir_name_to);
-  ASSERT_TRUE(file_util::PathExists(dir_name_to));
+  ASSERT_TRUE(base::PathExists(dir_name_to));
 
   EXPECT_FALSE(base::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"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(file_util::PathExists(dir_name_from));
+  ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+  ASSERT_TRUE(base::PathExists(file_name_from));
 
   // Move the directory.
   FilePath dir_name_to =
       temp_dir_.path().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));
+  ASSERT_FALSE(base::PathExists(dir_name_to));
 
   EXPECT_TRUE(base::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));
+  EXPECT_FALSE(base::PathExists(dir_name_from));
+  EXPECT_FALSE(base::PathExists(file_name_from));
+  EXPECT_TRUE(base::PathExists(dir_name_to));
+  EXPECT_TRUE(base::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(base::Move(file_name_from, file_name_to));
-  EXPECT_TRUE(file_util::PathExists(file_name_from));
-  EXPECT_FALSE(file_util::PathExists(file_name_to));
+  EXPECT_TRUE(base::PathExists(file_name_from));
+  EXPECT_FALSE(base::PathExists(file_name_to));
   EXPECT_TRUE(base::internal::MoveUnsafe(file_name_from, file_name_to));
-  EXPECT_FALSE(file_util::PathExists(file_name_from));
-  EXPECT_TRUE(file_util::PathExists(file_name_to));
+  EXPECT_FALSE(base::PathExists(file_name_from));
+  EXPECT_TRUE(base::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"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(file_util::PathExists(dir_name_from));
+  ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+  ASSERT_TRUE(base::PathExists(file_name_from));
 
   // Move the directory
   FilePath dir_name_exists =
       temp_dir_.path().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.
   file_util::CreateDirectory(dir_name_exists);
-  ASSERT_TRUE(file_util::PathExists(dir_name_exists));
+  ASSERT_TRUE(base::PathExists(dir_name_exists));
 
   EXPECT_TRUE(base::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));
+  EXPECT_FALSE(base::PathExists(dir_name_from));
+  EXPECT_FALSE(base::PathExists(file_name_from));
+  EXPECT_TRUE(base::PathExists(dir_name_to));
+  EXPECT_TRUE(base::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"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(file_util::PathExists(dir_name_from));
+  ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+  ASSERT_TRUE(base::PathExists(file_name_from));
 
   // Create a subdirectory.
   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));
+  ASSERT_TRUE(base::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(file_util::PathExists(file_name2_from));
+  ASSERT_TRUE(base::PathExists(file_name2_from));
 
   // Copy the directory recursively.
   FilePath dir_name_to =
       temp_dir_.path().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));
+  ASSERT_FALSE(base::PathExists(dir_name_to));
 
   EXPECT_TRUE(base::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));
+  EXPECT_TRUE(base::PathExists(dir_name_from));
+  EXPECT_TRUE(base::PathExists(file_name_from));
+  EXPECT_TRUE(base::PathExists(subdir_name_from));
+  EXPECT_TRUE(base::PathExists(file_name2_from));
+  EXPECT_TRUE(base::PathExists(dir_name_to));
+  EXPECT_TRUE(base::PathExists(file_name_to));
+  EXPECT_TRUE(base::PathExists(subdir_name_to));
+  EXPECT_TRUE(base::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"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(file_util::PathExists(dir_name_from));
+  ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+  ASSERT_TRUE(base::PathExists(file_name_from));
 
   // Create a subdirectory.
   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));
+  ASSERT_TRUE(base::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(file_util::PathExists(file_name2_from));
+  ASSERT_TRUE(base::PathExists(file_name2_from));
 
   // Copy the directory recursively.
   FilePath dir_name_exists =
       temp_dir_.path().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"));
 
   // Create the destination directory.
   file_util::CreateDirectory(dir_name_exists);
-  ASSERT_TRUE(file_util::PathExists(dir_name_exists));
+  ASSERT_TRUE(base::PathExists(dir_name_exists));
 
   EXPECT_TRUE(base::CopyDirectory(dir_name_from, dir_name_exists, 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));
+  EXPECT_TRUE(base::PathExists(dir_name_from));
+  EXPECT_TRUE(base::PathExists(file_name_from));
+  EXPECT_TRUE(base::PathExists(subdir_name_from));
+  EXPECT_TRUE(base::PathExists(file_name2_from));
+  EXPECT_TRUE(base::PathExists(dir_name_to));
+  EXPECT_TRUE(base::PathExists(file_name_to));
+  EXPECT_TRUE(base::PathExists(subdir_name_to));
+  EXPECT_TRUE(base::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"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(file_util::PathExists(dir_name_from));
+  ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+  ASSERT_TRUE(base::PathExists(file_name_from));
 
   // Create a subdirectory.
   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));
+  ASSERT_TRUE(base::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(file_util::PathExists(file_name2_from));
+  ASSERT_TRUE(base::PathExists(file_name2_from));
 
   // Copy the directory not recursively.
   FilePath dir_name_to =
       temp_dir_.path().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));
+  ASSERT_FALSE(base::PathExists(dir_name_to));
 
   EXPECT_TRUE(base::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));
+  EXPECT_TRUE(base::PathExists(dir_name_from));
+  EXPECT_TRUE(base::PathExists(file_name_from));
+  EXPECT_TRUE(base::PathExists(subdir_name_from));
+  EXPECT_TRUE(base::PathExists(file_name2_from));
+  EXPECT_TRUE(base::PathExists(dir_name_to));
+  EXPECT_TRUE(base::PathExists(file_name_to));
+  EXPECT_FALSE(base::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"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(file_util::PathExists(dir_name_from));
+  ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+  ASSERT_TRUE(base::PathExists(file_name_from));
 
   // Create a subdirectory.
   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));
+  ASSERT_TRUE(base::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(file_util::PathExists(file_name2_from));
+  ASSERT_TRUE(base::PathExists(file_name2_from));
 
   // Copy the directory not recursively.
   FilePath dir_name_to =
       temp_dir_.path().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.
   file_util::CreateDirectory(dir_name_to);
-  ASSERT_TRUE(file_util::PathExists(dir_name_to));
+  ASSERT_TRUE(base::PathExists(dir_name_to));
 
   EXPECT_TRUE(base::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));
+  EXPECT_TRUE(base::PathExists(dir_name_from));
+  EXPECT_TRUE(base::PathExists(file_name_from));
+  EXPECT_TRUE(base::PathExists(subdir_name_from));
+  EXPECT_TRUE(base::PathExists(file_name2_from));
+  EXPECT_TRUE(base::PathExists(dir_name_to));
+  EXPECT_TRUE(base::PathExists(file_name_to));
+  EXPECT_FALSE(base::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"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
-  ASSERT_TRUE(file_util::PathExists(file_name_from));
+  ASSERT_TRUE(base::PathExists(file_name_from));
 
   // The destination name
   FilePath file_name_to = temp_dir_.path().Append(
       FILE_PATH_LITERAL("Copy_Test_File_Destination.txt"));
-  ASSERT_FALSE(file_util::PathExists(file_name_to));
+  ASSERT_FALSE(base::PathExists(file_name_to));
 
   EXPECT_TRUE(base::CopyDirectory(file_name_from, file_name_to, true));
 
   // Check the has been copied
-  EXPECT_TRUE(file_util::PathExists(file_name_to));
+  EXPECT_TRUE(base::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"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
-  ASSERT_TRUE(file_util::PathExists(file_name_from));
+  ASSERT_TRUE(base::PathExists(file_name_from));
 
   // The destination name
   FilePath file_name_to = temp_dir_.path().Append(
       FILE_PATH_LITERAL("Copy_Test_File_Destination.txt"));
   CreateTextFile(file_name_to, L"Old file content");
-  ASSERT_TRUE(file_util::PathExists(file_name_to));
+  ASSERT_TRUE(base::PathExists(file_name_to));
 
   EXPECT_TRUE(base::CopyDirectory(file_name_from, file_name_to, true));
 
   // Check the has been copied
-  EXPECT_TRUE(file_util::PathExists(file_name_to));
+  EXPECT_TRUE(base::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"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
-  ASSERT_TRUE(file_util::PathExists(file_name_from));
+  ASSERT_TRUE(base::PathExists(file_name_from));
 
   // The destination
   FilePath dir_name_to =
       temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
   file_util::CreateDirectory(dir_name_to);
-  ASSERT_TRUE(file_util::PathExists(dir_name_to));
+  ASSERT_TRUE(base::PathExists(dir_name_to));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
 
   EXPECT_TRUE(base::CopyDirectory(file_name_from, dir_name_to, true));
 
   // Check the has been copied
-  EXPECT_TRUE(file_util::PathExists(file_name_to));
+  EXPECT_TRUE(base::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"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(file_util::PathExists(dir_name_from));
+  ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+  ASSERT_TRUE(base::PathExists(file_name_from));
 
   // Copy the directory recursively.
   FilePath dir_name_to =
       temp_dir_.path().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\\\\\\"));
 #elif defined (OS_POSIX)
   FilePath from_path =
       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir///"));
 #endif
 
   EXPECT_TRUE(base::CopyDirectory(from_path, 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(dir_name_to));
-  EXPECT_TRUE(file_util::PathExists(file_name_to));
+  EXPECT_TRUE(base::PathExists(dir_name_from));
+  EXPECT_TRUE(base::PathExists(file_name_from));
+  EXPECT_TRUE(base::PathExists(dir_name_to));
+  EXPECT_TRUE(base::PathExists(file_name_to));
 }
 
 TEST_F(FileUtilTest, CopyFile) {
   // Create a directory
   FilePath dir_name_from =
       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(file_util::PathExists(dir_name_from));
+  ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+  ASSERT_TRUE(base::PathExists(file_name_from));
 
   // Copy the file.
   FilePath dest_file = dir_name_from.Append(FILE_PATH_LITERAL("DestFile.txt"));
   ASSERT_TRUE(base::CopyFile(file_name_from, dest_file));
 
   // Copy the file to another location using '..' in the path.
   FilePath dest_file2(dir_name_from);
   dest_file2 = dest_file2.AppendASCII("..");
   dest_file2 = dest_file2.AppendASCII("DestFile.txt");
   ASSERT_FALSE(base::CopyFile(file_name_from, dest_file2));
   ASSERT_TRUE(base::internal::CopyFileUnsafe(file_name_from, dest_file2));
 
   FilePath dest_file2_test(dir_name_from);
   dest_file2_test = dest_file2_test.DirName();
   dest_file2_test = dest_file2_test.AppendASCII("DestFile.txt");
 
   // Check everything has been copied.
-  EXPECT_TRUE(file_util::PathExists(file_name_from));
-  EXPECT_TRUE(file_util::PathExists(dest_file));
+  EXPECT_TRUE(base::PathExists(file_name_from));
+  EXPECT_TRUE(base::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(base::PathExists(dest_file2_test));
+  EXPECT_TRUE(base::PathExists(dest_file2));
 }
 
 // file_util winds up using autoreleased objects on the Mac, so this needs
 // to be a PlatformTest.
 typedef PlatformTest ReadOnlyFileUtilTest;
 
 TEST_F(ReadOnlyFileUtilTest, ContentsEqual) {
   FilePath data_dir;
   ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &data_dir));
   data_dir = data_dir.AppendASCII("file_util");
-  ASSERT_TRUE(file_util::PathExists(data_dir));
+  ASSERT_TRUE(base::PathExists(data_dir));
 
   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 =
@@ skipping 26 matching lines @@
   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));
 }
 
 TEST_F(ReadOnlyFileUtilTest, TextContentsEqual) {
   FilePath data_dir;
   ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &data_dir));
   data_dir = data_dir.AppendASCII("file_util");
-  ASSERT_TRUE(file_util::PathExists(data_dir));
+  ASSERT_TRUE(base::PathExists(data_dir));
 
   FilePath original_file =
       data_dir.Append(FILE_PATH_LITERAL("original.txt"));
   FilePath same_file =
       data_dir.Append(FILE_PATH_LITERAL("same.txt"));
   FilePath crlf_file =
       data_dir.Append(FILE_PATH_LITERAL("crlf.txt"));
   FilePath shortened_file =
       data_dir.Append(FILE_PATH_LITERAL("shortened.txt"));
   FilePath different_file =
@@ skipping 30 matching lines @@
                                            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"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(file_util::PathExists(dir_name_from));
+  ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+  ASSERT_TRUE(base::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 file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("CopyAndDelete_Test_File.txt"));
 
-  ASSERT_FALSE(file_util::PathExists(dir_name_to));
+  ASSERT_FALSE(base::PathExists(dir_name_to));
 
   EXPECT_TRUE(base::internal::CopyAndDeleteDirectory(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));
+  EXPECT_FALSE(base::PathExists(dir_name_from));
+  EXPECT_FALSE(base::PathExists(file_name_from));
+  EXPECT_TRUE(base::PathExists(dir_name_to));
+  EXPECT_TRUE(base::PathExists(file_name_to));
 }
 
 TEST_F(FileUtilTest, GetTempDirTest) {
   static const TCHAR* kTmpKey = _T("TMP");
   static const TCHAR* kTmpValues[] = {
     _T(""), _T("C:"), _T("C:\\"), _T("C:\\tmp"), _T("C:\\tmp\\")
   };
   // Save the original $TMP.
   size_t original_tmp_size;
   TCHAR* original_tmp;
@@ skipping 15 matching lines @@
   } else {
     ::_tputenv_s(kTmpKey, _T(""));
   }
 }
 #endif  // OS_WIN
 
 TEST_F(FileUtilTest, CreateTemporaryFileTest) {
   FilePath temp_files[3];
   for (int i = 0; i < 3; i++) {
     ASSERT_TRUE(file_util::CreateTemporaryFile(&(temp_files[i])));
-    EXPECT_TRUE(file_util::PathExists(temp_files[i]));
+    EXPECT_TRUE(base::PathExists(temp_files[i]));
     EXPECT_FALSE(file_util::DirectoryExists(temp_files[i]));
   }
   for (int i = 0; i < 3; i++)
     EXPECT_FALSE(temp_files[i] == temp_files[(i+1)%3]);
   for (int i = 0; i < 3; i++)
     EXPECT_TRUE(base::Delete(temp_files[i], false));
 }
 
 TEST_F(FileUtilTest, CreateAndOpenTemporaryFileTest) {
   FilePath names[3];
   FILE* fps[3];
   int i;
 
   // Create; make sure they are open and exist.
   for (i = 0; i < 3; ++i) {
     fps[i] = file_util::CreateAndOpenTemporaryFile(&(names[i]));
     ASSERT_TRUE(fps[i]);
-    EXPECT_TRUE(file_util::PathExists(names[i]));
+    EXPECT_TRUE(base::PathExists(names[i]));
   }
 
   // Make sure all names are unique.
   for (i = 0; i < 3; ++i) {
     EXPECT_FALSE(names[i] == names[(i+1)%3]);
   }
 
   // Close and delete.
   for (i = 0; i < 3; ++i) {
     EXPECT_TRUE(file_util::CloseFile(fps[i]));
     EXPECT_TRUE(base::Delete(names[i], false));
   }
 }
 
 TEST_F(FileUtilTest, CreateNewTempDirectoryTest) {
   FilePath temp_dir;
   ASSERT_TRUE(file_util::CreateNewTempDirectory(FilePath::StringType(),
                                                 &temp_dir));
-  EXPECT_TRUE(file_util::PathExists(temp_dir));
+  EXPECT_TRUE(base::PathExists(temp_dir));
   EXPECT_TRUE(base::Delete(temp_dir, false));
 }
 
 TEST_F(FileUtilTest, CreateNewTemporaryDirInDirTest) {
   FilePath new_dir;
   ASSERT_TRUE(file_util::CreateTemporaryDirInDir(
                   temp_dir_.path(),
                   FILE_PATH_LITERAL("CreateNewTemporaryDirInDirTest"),
                   &new_dir));
-  EXPECT_TRUE(file_util::PathExists(new_dir));
+  EXPECT_TRUE(base::PathExists(new_dir));
   EXPECT_TRUE(temp_dir_.path().IsParent(new_dir));
   EXPECT_TRUE(base::Delete(new_dir, false));
 }
 
 TEST_F(FileUtilTest, GetShmemTempDirTest) {
   FilePath dir;
   EXPECT_TRUE(file_util::GetShmemTempDir(&dir, false));
   EXPECT_TRUE(file_util::DirectoryExists(dir));
 }
 
 TEST_F(FileUtilTest, CreateDirectoryTest) {
   FilePath test_root =
       temp_dir_.path().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(file_util::PathExists(test_path));
+  EXPECT_FALSE(base::PathExists(test_path));
   EXPECT_TRUE(file_util::CreateDirectory(test_path));
-  EXPECT_TRUE(file_util::PathExists(test_path));
+  EXPECT_TRUE(base::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
   test_path = test_path.Append(FILE_PATH_LITERAL("foobar.txt"));
-  EXPECT_FALSE(file_util::PathExists(test_path));
+  EXPECT_FALSE(base::PathExists(test_path));
   CreateTextFile(test_path, L"test file");
-  EXPECT_TRUE(file_util::PathExists(test_path));
+  EXPECT_TRUE(base::PathExists(test_path));
   EXPECT_FALSE(file_util::CreateDirectory(test_path));
 
   EXPECT_TRUE(base::Delete(test_root, true));
-  EXPECT_FALSE(file_util::PathExists(test_root));
-  EXPECT_FALSE(file_util::PathExists(test_path));
+  EXPECT_FALSE(base::PathExists(test_root));
+  EXPECT_FALSE(base::PathExists(test_path));
 
   // Verify assumptions made by the Windows implementation:
   // 1. The current directory always exists.
   // 2. The root directory always exists.
   ASSERT_TRUE(file_util::DirectoryExists(
       FilePath(FilePath::kCurrentDirectory)));
   FilePath top_level = test_root;
   while (top_level != top_level.DirName()) {
     top_level = top_level.DirName();
   }
   ASSERT_TRUE(file_util::DirectoryExists(top_level));
 
   // Given these assumptions hold, it should be safe to
   // test that "creating" these directories succeeds.
   EXPECT_TRUE(file_util::CreateDirectory(
       FilePath(FilePath::kCurrentDirectory)));
   EXPECT_TRUE(file_util::CreateDirectory(top_level));
 
 #if defined(OS_WIN)
   FilePath invalid_drive(FILE_PATH_LITERAL("o:\\"));
   FilePath invalid_path =
       invalid_drive.Append(FILE_PATH_LITERAL("some\\inaccessible\\dir"));
-  if (!file_util::PathExists(invalid_drive)) {
+  if (!base::PathExists(invalid_drive)) {
     EXPECT_FALSE(file_util::CreateDirectory(invalid_path));
   }
 #endif
 }
 
 TEST_F(FileUtilTest, DetectDirectoryTest) {
   // Check a directory
   FilePath test_root =
       temp_dir_.path().Append(FILE_PATH_LITERAL("detect_directory_test"));
-  EXPECT_FALSE(file_util::PathExists(test_root));
+  EXPECT_FALSE(base::PathExists(test_root));
   EXPECT_TRUE(file_util::CreateDirectory(test_root));
-  EXPECT_TRUE(file_util::PathExists(test_root));
+  EXPECT_TRUE(base::PathExists(test_root));
   EXPECT_TRUE(file_util::DirectoryExists(test_root));
   // Check a file
   FilePath test_path =
       test_root.Append(FILE_PATH_LITERAL("foobar.txt"));
-  EXPECT_FALSE(file_util::PathExists(test_path));
+  EXPECT_FALSE(base::PathExists(test_path));
   CreateTextFile(test_path, L"test file");
-  EXPECT_TRUE(file_util::PathExists(test_path));
+  EXPECT_TRUE(base::PathExists(test_path));
   EXPECT_FALSE(file_util::DirectoryExists(test_path));
   EXPECT_TRUE(base::Delete(test_path, false));
 
   EXPECT_TRUE(base::Delete(test_root, true));
 }
 
 TEST_F(FileUtilTest, FileEnumeratorTest) {
   // Test an empty directory.
   FileEnumerator f0(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
   EXPECT_EQ(f0.Next().value(), FILE_PATH_LITERAL(""));
@@ skipping 100 matching lines @@
   FileEnumerator f6(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
   EXPECT_FALSE(f6.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"));
 
   // Create a fresh, empty copy of this directory.
-  if (file_util::PathExists(data_dir)) {
+  if (base::PathExists(data_dir)) {
     ASSERT_TRUE(base::Delete(data_dir, true));
   }
   ASSERT_TRUE(file_util::CreateDirectory(data_dir));
 
   // Create a fresh, empty copy of this directory.
-  if (file_util::PathExists(data_dir)) {
+  if (base::PathExists(data_dir)) {
     ASSERT_TRUE(base::Delete(data_dir, true));
   }
   ASSERT_TRUE(file_util::CreateDirectory(data_dir));
   FilePath foobar(data_dir.Append(FILE_PATH_LITERAL("foobar.txt")));
 
   std::string data("hello");
   EXPECT_EQ(-1, file_util::AppendToFile(foobar, data.c_str(), data.length()));
   EXPECT_EQ(static_cast<int>(data.length()),
             file_util::WriteFile(foobar, data.c_str(), data.length()));
   EXPECT_EQ(static_cast<int>(data.length()),
             file_util::AppendToFile(foobar, data.c_str(), data.length()));
 
   const std::wstring read_content = ReadTextFile(foobar);
   EXPECT_EQ(L"hellohello", read_content);
 }
 
 TEST_F(FileUtilTest, TouchFile) {
   FilePath data_dir =
       temp_dir_.path().Append(FILE_PATH_LITERAL("FilePathTest"));
 
   // Create a fresh, empty copy of this directory.
-  if (file_util::PathExists(data_dir)) {
+  if (base::PathExists(data_dir)) {
     ASSERT_TRUE(base::Delete(data_dir, true));
   }
   ASSERT_TRUE(file_util::CreateDirectory(data_dir));
 
   FilePath foobar(data_dir.Append(FILE_PATH_LITERAL("foobar.txt")));
   std::string data("hello");
   ASSERT_TRUE(file_util::WriteFile(foobar, data.c_str(), data.length()));
 
   base::Time access_time;
   // This timestamp is divisible by one day (in local timezone),
@@ skipping 12 matching lines @@
   ASSERT_TRUE(file_util::GetFileInfo(foobar, &file_info));
   EXPECT_EQ(file_info.last_accessed.ToInternalValue(),
             access_time.ToInternalValue());
   EXPECT_EQ(file_info.last_modified.ToInternalValue(),
             modification_time.ToInternalValue());
 }
 
 TEST_F(FileUtilTest, IsDirectoryEmpty) {
   FilePath empty_dir = temp_dir_.path().Append(FILE_PATH_LITERAL("EmptyDir"));
 
-  ASSERT_FALSE(file_util::PathExists(empty_dir));
+  ASSERT_FALSE(base::PathExists(empty_dir));
 
   ASSERT_TRUE(file_util::CreateDirectory(empty_dir));
 
   EXPECT_TRUE(file_util::IsDirectoryEmpty(empty_dir));
 
   FilePath foo(empty_dir.Append(FILE_PATH_LITERAL("foo.txt")));
   std::string bar("baz");
   ASSERT_TRUE(file_util::WriteFile(foo, bar.c_str(), bar.length()));
 
   EXPECT_FALSE(file_util::IsDirectoryEmpty(empty_dir));
@@ skipping 107 matching lines @@
   EXPECT_FALSE(
       file_util::VerifyPathControlledByUser(
           file_link, file_link, uid_, ok_gids_));
 
   // Symlink from one directory to another within the path.
   FilePath link_to_sub_dir =  base_dir_.AppendASCII("link_to_sub_dir");
   ASSERT_TRUE(file_util::CreateSymbolicLink(sub_dir_, link_to_sub_dir))
     << "Failed to create symlink.";
 
   FilePath file_path_with_link = link_to_sub_dir.AppendASCII("file.txt");
-  ASSERT_TRUE(file_util::PathExists(file_path_with_link));
+  ASSERT_TRUE(base::PathExists(file_path_with_link));
 
   EXPECT_FALSE(
       file_util::VerifyPathControlledByUser(
           base_dir_, file_path_with_link, uid_, ok_gids_));
 
   EXPECT_FALSE(
       file_util::VerifyPathControlledByUser(
           link_to_sub_dir, file_path_with_link, uid_, ok_gids_));
 
   // Symlinks in parents of base path are allowed.
@@ skipping 237 matching lines @@
       file_util::VerifyPathControlledByUser(
           base_dir_, text_file_, uid_, ok_gids_));
   EXPECT_TRUE(
       file_util::VerifyPathControlledByUser(
           sub_dir_, text_file_, uid_, ok_gids_));
 }
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace