Move Posix file utils to the 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 22 matching lines @@
 #include "base/win/windows_version.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "base/android/content_uri_utils.h"
 #endif
 
 // This macro helps avoid wrapped lines in the test structs.
 #define FPL(x) FILE_PATH_LITERAL(x)
 
-using base::DirectoryExists;
-using base::FileEnumerator;
-using base::FilePath;
-using base::PathIsWritable;
-using base::TextContentsEqual;
+namespace base {
 
 namespace {
 
 // To test that file_util::Normalize FilePath() deals with NTFS reparse points
 // correctly, we need functions to create and delete reparse points.
 #if defined(OS_WIN)
 typedef struct _REPARSE_DATA_BUFFER {
   ULONG  ReparseTag;
   USHORT  ReparseDataLength;
   USHORT  Reserved;
@@ skipping 81 matching lines @@
   }
 
   ~ReparsePoint() {
     if (created_)
       DeleteReparsePoint(dir_);
   }
 
   bool IsValid() { return created_; }
 
  private:
-  base::win::ScopedHandle dir_;
+  win::ScopedHandle dir_;
   bool created_;
   DISALLOW_COPY_AND_ASSIGN(ReparsePoint);
 };
 
 #endif
 
 #if defined(OS_POSIX)
 // Provide a simple way to change the permissions bits on |path| in tests.
 // ASSERT failures will return, but not stop the test.  Caller should wrap
 // calls to this function in ASSERT_NO_FATAL_FAILURE().
 void ChangePosixFilePermissions(const FilePath& path,
                                 int mode_bits_to_set,
                                 int mode_bits_to_clear) {
   ASSERT_FALSE(mode_bits_to_set & mode_bits_to_clear)
       << "Can't set and clear the same bits.";
 
   int mode = 0;
-  ASSERT_TRUE(file_util::GetPosixFilePermissions(path, &mode));
+  ASSERT_TRUE(GetPosixFilePermissions(path, &mode));
   mode |= mode_bits_to_set;
   mode &= ~mode_bits_to_clear;
-  ASSERT_TRUE(file_util::SetPosixFilePermissions(path, mode));
+  ASSERT_TRUE(SetPosixFilePermissions(path, mode));
 }
 #endif  // defined(OS_POSIX)
 
 const wchar_t bogus_content[] = L"I'm cannon fodder.";
 
 const int FILES_AND_DIRECTORIES =
     FileEnumerator::FILES | FileEnumerator::DIRECTORIES;
 
 // file_util winds up using autoreleased objects on the Mac, so this needs
 // to be a PlatformTest
 class FileUtilTest : public PlatformTest {
  protected:
   virtual void SetUp() OVERRIDE {
     PlatformTest::SetUp();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
-  base::ScopedTempDir temp_dir_;
+  ScopedTempDir temp_dir_;
 };
 
 // Collects all the results from the given file enumerator, and provides an
 // interface to query whether a given file is present.
 class FindResultCollector {
  public:
   explicit FindResultCollector(FileEnumerator& enumerator) {
     FilePath cur_file;
     while (!(cur_file = enumerator.Next()).value().empty()) {
       FilePath::StringType path = cur_file.value();
@@ skipping 66 matching lines @@
   int64 size_f2 = 0;
   ASSERT_TRUE(file_util::GetFileSize(file_02, &size_f2));
   EXPECT_EQ(30ll, size_f2);
 
   FilePath subsubdir_path = subdir_path.Append(FPL("Level3"));
   file_util::CreateDirectory(subsubdir_path);
 
   FilePath file_03 = subsubdir_path.Append(FPL("The file 03.txt"));
   CreateTextFile(file_03, L"123");
 
-  int64 computed_size = base::ComputeDirectorySize(temp_dir_.path());
+  int64 computed_size = ComputeDirectorySize(temp_dir_.path());
   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_b_path = dir_path.Append(FPL("file_b"));
   file_util::CreateDirectory(dir_path);
 
   FilePath normalized_file_a_path, normalized_file_b_path;
-  ASSERT_FALSE(base::PathExists(file_a_path));
+  ASSERT_FALSE(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(base::PathExists(file_a_path));
+  ASSERT_TRUE(PathExists(file_a_path));
   ASSERT_TRUE(file_util::NormalizeFilePath(file_a_path,
                                            &normalized_file_a_path));
 
   CreateTextFile(file_b_path, bogus_content);
-  ASSERT_TRUE(base::PathExists(file_b_path));
+  ASSERT_TRUE(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 180 matching lines @@
       &win32_path));
 
   ASSERT_FALSE(file_util::DevicePathToDriveLetterPath(
       real_device_path_plus_numbers.Append(kRelativePath),
       &win32_path));
 }
 
 TEST_F(FileUtilTest, GetPlatformFileInfoForDirectory) {
   FilePath empty_dir = temp_dir_.path().Append(FPL("gpfi_test"));
   ASSERT_TRUE(file_util::CreateDirectory(empty_dir));
-  base::win::ScopedHandle dir(
+  win::ScopedHandle dir(
       ::CreateFile(empty_dir.value().c_str(),
                    FILE_ALL_ACCESS,
                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                    NULL,
                    OPEN_EXISTING,
                    FILE_FLAG_BACKUP_SEMANTICS,  // Needed to open a directory.
                    NULL));
   ASSERT_TRUE(dir.IsValid());
-  base::PlatformFileInfo info;
-  EXPECT_TRUE(base::GetPlatformFileInfo(dir.Get(), &info));
+  PlatformFileInfo info;
+  EXPECT_TRUE(GetPlatformFileInfo(dir.Get(), &info));
   EXPECT_TRUE(info.is_directory);
   EXPECT_FALSE(info.is_symbolic_link);
   EXPECT_EQ(0, info.size);
 }
 
 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);
   ASSERT_TRUE(file_util::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);
   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(base::PathExists(temp_file));
+  EXPECT_TRUE(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(base::PathExists(temp_file));
+  EXPECT_TRUE(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)
 
 #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"));
   CreateTextFile(link_to, bogus_content);
 
-  ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
+  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(file_util::ReadSymbolicLink(link_from, &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"));
   ASSERT_TRUE(file_util::CreateDirectory(link_to));
-  ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
+  ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
     << "Failed to create directory symlink.";
 
   // Test failures.
-  EXPECT_FALSE(file_util::CreateSymbolicLink(link_to, link_to));
-  EXPECT_FALSE(file_util::ReadSymbolicLink(link_to, &result));
+  EXPECT_FALSE(CreateSymbolicLink(link_to, link_to));
+  EXPECT_FALSE(ReadSymbolicLink(link_to, &result));
   FilePath missing = temp_dir_.path().Append(FPL("missing"));
-  EXPECT_FALSE(file_util::ReadSymbolicLink(missing, &result));
+  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"));
   CreateTextFile(link_to, bogus_content);
 
-  ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
+  ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
     << "Failed to create file symlink.";
 
   // Check that NormalizeFilePath sees the link.
   FilePath normalized_path;
   ASSERT_TRUE(file_util::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"));
   ASSERT_TRUE(file_util::CreateDirectory(link_to));
-  ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
+  ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
     << "Failed to create directory symlink.";
 
   EXPECT_FALSE(file_util::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"));
-  ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
+  ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
     << "Failed to create loop symlink a.";
-  ASSERT_TRUE(file_util::CreateSymbolicLink(link_from, link_to))
+  ASSERT_TRUE(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(base::PathExists(non_existent));
+  ASSERT_FALSE(PathExists(non_existent));
 
-  EXPECT_TRUE(base::DeleteFile(non_existent, false));
-  ASSERT_FALSE(base::PathExists(non_existent));
-  EXPECT_TRUE(base::DeleteFile(non_existent, true));
-  ASSERT_FALSE(base::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"));
   CreateTextFile(file_name, bogus_content);
-  ASSERT_TRUE(base::PathExists(file_name));
+  ASSERT_TRUE(PathExists(file_name));
 
   // Make sure it's deleted
-  EXPECT_TRUE(base::DeleteFile(file_name, false));
-  EXPECT_FALSE(base::PathExists(file_name));
+  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"));
   CreateTextFile(file_name, bogus_content);
-  ASSERT_TRUE(base::PathExists(file_name));
+  ASSERT_TRUE(PathExists(file_name));
 
   // Make sure it's deleted
-  EXPECT_TRUE(base::DeleteFile(file_name, true));
-  EXPECT_FALSE(base::PathExists(file_name));
+  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"));
   CreateTextFile(file_name, bogus_content);
-  ASSERT_TRUE(base::PathExists(file_name));
+  ASSERT_TRUE(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))
+  ASSERT_TRUE(CreateSymbolicLink(file_name, file_link))
       << "Failed to create symlink.";
 
   // Delete the symbolic link.
-  EXPECT_TRUE(base::DeleteFile(file_link, false));
+  EXPECT_TRUE(DeleteFile(file_link, false));
 
   // Make sure original file is not deleted.
-  EXPECT_FALSE(base::PathExists(file_link));
-  EXPECT_TRUE(base::PathExists(file_name));
+  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"));
-  EXPECT_FALSE(base::PathExists(non_existent));
+  EXPECT_FALSE(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))
+  ASSERT_TRUE(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(base::PathExists(file_link));
+  EXPECT_FALSE(PathExists(file_link));
 
   // Delete the symbolic link.
-  EXPECT_TRUE(base::DeleteFile(file_link, false));
+  EXPECT_TRUE(DeleteFile(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(base::PathExists(file_name));
+  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()),
             file_util::WriteFile(file_name, kData.data(), kData.length()));
-  EXPECT_TRUE(base::PathExists(file_name));
+  EXPECT_TRUE(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);
+  EXPECT_TRUE(GetPosixFilePermissions(file_name, &mode));
+  EXPECT_TRUE(mode & 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);
+  EXPECT_TRUE(SetPosixFilePermissions(file_name, 0u));
+  EXPECT_TRUE(GetPosixFilePermissions(file_name, &mode));
+  EXPECT_FALSE(mode & 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);
+  EXPECT_TRUE(SetPosixFilePermissions(file_name, FILE_PERMISSION_READ_BY_USER));
+  EXPECT_TRUE(GetPosixFilePermissions(file_name, &mode));
+  EXPECT_TRUE(mode & 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::DeleteFile(file_name, false));
-  EXPECT_FALSE(base::PathExists(file_name));
+  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"));
-  EXPECT_FALSE(base::PathExists(file_name));
+  EXPECT_FALSE(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(base::PathExists(file_name));
+  EXPECT_TRUE(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(GetPosixFilePermissions(file_name, &mode));
+  EXPECT_TRUE(mode & FILE_PERMISSION_WRITE_BY_USER);
   EXPECT_TRUE(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);
+  EXPECT_TRUE(SetPosixFilePermissions(file_name, 0u));
+  EXPECT_TRUE(GetPosixFilePermissions(file_name, &mode));
+  EXPECT_FALSE(mode & 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(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);
+  EXPECT_TRUE(SetPosixFilePermissions(file_name,
+                                      FILE_PERMISSION_WRITE_BY_USER));
+  EXPECT_TRUE(GetPosixFilePermissions(file_name, &mode));
+  EXPECT_TRUE(mode & 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(PathIsWritable(file_name));
 
   // Delete the file.
-  EXPECT_TRUE(base::DeleteFile(file_name, false));
-  EXPECT_FALSE(base::PathExists(file_name));
+  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"));
   file_util::CreateDirectory(subdir_path);
-  ASSERT_TRUE(base::PathExists(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(base::PathExists(file_name));
+  EXPECT_FALSE(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(base::PathExists(file_name));
+  EXPECT_TRUE(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);
+  EXPECT_TRUE(GetPosixFilePermissions(subdir_path, &mode));
+  EXPECT_EQ(FILE_PERMISSION_USER_MASK, mode & 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);
+  EXPECT_TRUE(SetPosixFilePermissions(subdir_path, 0u));
+  EXPECT_TRUE(GetPosixFilePermissions(subdir_path, &mode));
+  EXPECT_FALSE(mode & FILE_PERMISSION_USER_MASK);
 
   // Make sure the file in the directory can't be enumerated.
   FileEnumerator f1(subdir_path, true, FileEnumerator::FILES);
-  EXPECT_TRUE(base::PathExists(subdir_path));
+  EXPECT_TRUE(PathExists(subdir_path));
   FindResultCollector c1(f1);
   EXPECT_EQ(c1.size(), 0);
-  EXPECT_FALSE(file_util::GetPosixFilePermissions(file_name, &mode));
+  EXPECT_FALSE(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);
+  EXPECT_TRUE(SetPosixFilePermissions(subdir_path, FILE_PERMISSION_USER_MASK));
+  EXPECT_TRUE(GetPosixFilePermissions(subdir_path, &mode));
+  EXPECT_EQ(FILE_PERMISSION_USER_MASK, mode & 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::DeleteFile(subdir_path, true));
-  EXPECT_FALSE(base::PathExists(subdir_path));
+  EXPECT_TRUE(DeleteFile(subdir_path, true));
+  EXPECT_FALSE(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(base::PathExists(file_name));
+  ASSERT_TRUE(PathExists(file_name));
 
   FilePath subdir_path = temp_dir_.path().Append(FPL("DeleteWildCardDir"));
   file_util::CreateDirectory(subdir_path);
-  ASSERT_TRUE(base::PathExists(subdir_path));
+  ASSERT_TRUE(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::DeleteFile(directory_contents, false));
-  EXPECT_FALSE(base::PathExists(file_name));
-  EXPECT_TRUE(base::PathExists(subdir_path));
+  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(base::DeleteFile(directory_contents, true));
-  EXPECT_FALSE(base::PathExists(file_name));
-  EXPECT_FALSE(base::PathExists(subdir_path));
+  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"));
   file_util::CreateDirectory(subdir_path);
-  ASSERT_TRUE(base::PathExists(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(base::DeleteFile(directory_contents, false));
-  EXPECT_TRUE(base::PathExists(subdir_path));
+  EXPECT_TRUE(DeleteFile(directory_contents, false));
+  EXPECT_TRUE(PathExists(subdir_path));
 
   // Delete recursively and check nothing got deleted
-  EXPECT_TRUE(base::DeleteFile(directory_contents, true));
-  EXPECT_TRUE(base::PathExists(subdir_path));
+  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"));
   file_util::CreateDirectory(test_subdir);
-  ASSERT_TRUE(base::PathExists(test_subdir));
+  ASSERT_TRUE(PathExists(test_subdir));
 
   FilePath file_name = test_subdir.Append(FPL("Test DeleteDir.txt"));
   CreateTextFile(file_name, bogus_content);
-  ASSERT_TRUE(base::PathExists(file_name));
+  ASSERT_TRUE(PathExists(file_name));
 
   FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
   file_util::CreateDirectory(subdir_path1);
-  ASSERT_TRUE(base::PathExists(subdir_path1));
+  ASSERT_TRUE(PathExists(subdir_path1));
 
   FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
   file_util::CreateDirectory(subdir_path2);
-  ASSERT_TRUE(base::PathExists(subdir_path2));
+  ASSERT_TRUE(PathExists(subdir_path2));
 
   // Delete non-recursively and check that the empty dir got deleted
-  EXPECT_TRUE(base::DeleteFile(subdir_path2, false));
-  EXPECT_FALSE(base::PathExists(subdir_path2));
+  EXPECT_TRUE(DeleteFile(subdir_path2, false));
+  EXPECT_FALSE(PathExists(subdir_path2));
 
   // Delete non-recursively and check that nothing got deleted
-  EXPECT_FALSE(base::DeleteFile(test_subdir, false));
-  EXPECT_TRUE(base::PathExists(test_subdir));
-  EXPECT_TRUE(base::PathExists(file_name));
-  EXPECT_TRUE(base::PathExists(subdir_path1));
+  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"));
   file_util::CreateDirectory(test_subdir);
-  ASSERT_TRUE(base::PathExists(test_subdir));
+  ASSERT_TRUE(PathExists(test_subdir));
 
   FilePath file_name = test_subdir.Append(FPL("Test DeleteDirRecursive.txt"));
   CreateTextFile(file_name, bogus_content);
-  ASSERT_TRUE(base::PathExists(file_name));
+  ASSERT_TRUE(PathExists(file_name));
 
   FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
   file_util::CreateDirectory(subdir_path1);
-  ASSERT_TRUE(base::PathExists(subdir_path1));
+  ASSERT_TRUE(PathExists(subdir_path1));
 
   FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
   file_util::CreateDirectory(subdir_path2);
-  ASSERT_TRUE(base::PathExists(subdir_path2));
+  ASSERT_TRUE(PathExists(subdir_path2));
 
   // Delete recursively and check that the empty dir got deleted
-  EXPECT_TRUE(base::DeleteFile(subdir_path2, true));
-  EXPECT_FALSE(base::PathExists(subdir_path2));
+  EXPECT_TRUE(DeleteFile(subdir_path2, true));
+  EXPECT_FALSE(PathExists(subdir_path2));
 
   // Delete recursively and check that everything got deleted
-  EXPECT_TRUE(base::DeleteFile(test_subdir, true));
-  EXPECT_FALSE(base::PathExists(file_name));
-  EXPECT_FALSE(base::PathExists(subdir_path1));
-  EXPECT_FALSE(base::PathExists(test_subdir));
+  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"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
-  ASSERT_TRUE(base::PathExists(file_name_from));
+  ASSERT_TRUE(PathExists(file_name_from));
 
   // The destination.
   FilePath file_name_to = temp_dir_.path().Append(
       FILE_PATH_LITERAL("Move_Test_File_Destination.txt"));
-  ASSERT_FALSE(base::PathExists(file_name_to));
+  ASSERT_FALSE(PathExists(file_name_to));
 
-  EXPECT_TRUE(base::Move(file_name_from, file_name_to));
+  EXPECT_TRUE(Move(file_name_from, file_name_to));
 
   // Check everything has been moved.
-  EXPECT_FALSE(base::PathExists(file_name_from));
-  EXPECT_TRUE(base::PathExists(file_name_to));
+  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"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
-  ASSERT_TRUE(base::PathExists(file_name_from));
+  ASSERT_TRUE(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(base::PathExists(file_name_to));
+  ASSERT_TRUE(PathExists(file_name_to));
 
-  EXPECT_TRUE(base::Move(file_name_from, file_name_to));
+  EXPECT_TRUE(Move(file_name_from, file_name_to));
 
   // Check everything has been moved.
-  EXPECT_FALSE(base::PathExists(file_name_from));
-  EXPECT_TRUE(base::PathExists(file_name_to));
+  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"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
-  ASSERT_TRUE(base::PathExists(file_name_from));
+  ASSERT_TRUE(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(base::PathExists(dir_name_to));
+  ASSERT_TRUE(PathExists(dir_name_to));
 
-  EXPECT_FALSE(base::Move(file_name_from, 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"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(base::PathExists(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(base::PathExists(file_name_from));
+  ASSERT_TRUE(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(base::PathExists(dir_name_to));
+  ASSERT_FALSE(PathExists(dir_name_to));
 
-  EXPECT_TRUE(base::Move(dir_name_from, dir_name_to));
+  EXPECT_TRUE(Move(dir_name_from, dir_name_to));
 
   // Check everything has been moved.
-  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));
+  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(base::Move(file_name_from, 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(base::PathExists(file_name_from));
-  EXPECT_TRUE(base::PathExists(file_name_to));
+  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"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(base::PathExists(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(base::PathExists(file_name_from));
+  ASSERT_TRUE(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(base::PathExists(dir_name_exists));
+  ASSERT_TRUE(PathExists(dir_name_exists));
 
-  EXPECT_TRUE(base::Move(dir_name_from, dir_name_to));
+  EXPECT_TRUE(Move(dir_name_from, dir_name_to));
 
   // Check everything has been moved.
-  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));
+  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"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(base::PathExists(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(base::PathExists(file_name_from));
+  ASSERT_TRUE(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(base::PathExists(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(base::PathExists(file_name2_from));
+  ASSERT_TRUE(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(base::PathExists(dir_name_to));
+  ASSERT_FALSE(PathExists(dir_name_to));
 
-  EXPECT_TRUE(base::CopyDirectory(dir_name_from, dir_name_to, true));
+  EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_to, true));
 
   // Check everything has been copied.
-  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));
+  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"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(base::PathExists(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(base::PathExists(file_name_from));
+  ASSERT_TRUE(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(base::PathExists(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(base::PathExists(file_name2_from));
+  ASSERT_TRUE(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(base::PathExists(dir_name_exists));
+  ASSERT_TRUE(PathExists(dir_name_exists));
 
-  EXPECT_TRUE(base::CopyDirectory(dir_name_from, dir_name_exists, true));
+  EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_exists, true));
 
   // Check everything has been copied.
-  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));
+  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, 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(base::PathExists(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(base::PathExists(file_name_from));
+  ASSERT_TRUE(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(base::PathExists(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(base::PathExists(file_name2_from));
+  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"));
   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(base::PathExists(dir_name_to));
+  ASSERT_FALSE(PathExists(dir_name_to));
 
-  EXPECT_TRUE(base::CopyDirectory(dir_name_from, dir_name_to, false));
+  EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_to, false));
 
   // Check everything has been copied.
-  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));
+  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"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(base::PathExists(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(base::PathExists(file_name_from));
+  ASSERT_TRUE(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(base::PathExists(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(base::PathExists(file_name2_from));
+  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"));
   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(base::PathExists(dir_name_to));
+  ASSERT_TRUE(PathExists(dir_name_to));
 
-  EXPECT_TRUE(base::CopyDirectory(dir_name_from, dir_name_to, false));
+  EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_to, false));
 
   // Check everything has been copied.
-  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));
+  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"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
-  ASSERT_TRUE(base::PathExists(file_name_from));
+  ASSERT_TRUE(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(base::PathExists(file_name_to));
+  ASSERT_FALSE(PathExists(file_name_to));
 
-  EXPECT_TRUE(base::CopyDirectory(file_name_from, file_name_to, true));
+  EXPECT_TRUE(CopyDirectory(file_name_from, file_name_to, true));
 
   // Check the has been copied
-  EXPECT_TRUE(base::PathExists(file_name_to));
+  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"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
-  ASSERT_TRUE(base::PathExists(file_name_from));
+  ASSERT_TRUE(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(base::PathExists(file_name_to));
+  ASSERT_TRUE(PathExists(file_name_to));
 
-  EXPECT_TRUE(base::CopyDirectory(file_name_from, file_name_to, true));
+  EXPECT_TRUE(CopyDirectory(file_name_from, file_name_to, true));
 
   // Check the has been copied
-  EXPECT_TRUE(base::PathExists(file_name_to));
+  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"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
-  ASSERT_TRUE(base::PathExists(file_name_from));
+  ASSERT_TRUE(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(base::PathExists(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(base::CopyDirectory(file_name_from, dir_name_to, true));
+  EXPECT_TRUE(CopyDirectory(file_name_from, dir_name_to, true));
 
   // Check the has been copied
-  EXPECT_TRUE(base::PathExists(file_name_to));
+  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"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(base::PathExists(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(base::PathExists(file_name_from));
+  ASSERT_TRUE(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));
+  EXPECT_TRUE(CopyDirectory(from_path, dir_name_to, true));
 
   // Check everything has been copied.
-  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));
+  EXPECT_TRUE(PathExists(dir_name_from));
+  EXPECT_TRUE(PathExists(file_name_from));
+  EXPECT_TRUE(PathExists(dir_name_to));
+  EXPECT_TRUE(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(base::PathExists(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(base::PathExists(file_name_from));
+  ASSERT_TRUE(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));
+  ASSERT_TRUE(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));
+  ASSERT_FALSE(CopyFile(file_name_from, dest_file2));
+  ASSERT_TRUE(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(base::PathExists(file_name_from));
-  EXPECT_TRUE(base::PathExists(dest_file));
+  EXPECT_TRUE(PathExists(file_name_from));
+  EXPECT_TRUE(PathExists(dest_file));
   const std::wstring read_contents = ReadTextFile(dest_file);
   EXPECT_EQ(file_contents, read_contents);
-  EXPECT_TRUE(base::PathExists(dest_file2_test));
-  EXPECT_TRUE(base::PathExists(dest_file2));
+  EXPECT_TRUE(PathExists(dest_file2_test));
+  EXPECT_TRUE(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));
+  ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &data_dir));
   data_dir = data_dir.AppendASCII("file_util");
-  ASSERT_TRUE(base::PathExists(data_dir));
+  ASSERT_TRUE(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 23 matching lines @@
   EXPECT_FALSE(ContentsEqual(original_file, different_last_file));
   EXPECT_TRUE(ContentsEqual(empty1_file, empty2_file));
   EXPECT_FALSE(ContentsEqual(original_file, shortened_file));
   EXPECT_FALSE(ContentsEqual(shortened_file, original_file));
   EXPECT_TRUE(ContentsEqual(binary_file, binary_file_same));
   EXPECT_FALSE(ContentsEqual(binary_file, binary_file_diff));
 }
 
 TEST_F(ReadOnlyFileUtilTest, TextContentsEqual) {
   FilePath data_dir;
-  ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &data_dir));
+  ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &data_dir));
   data_dir = data_dir.AppendASCII("file_util");
-  ASSERT_TRUE(base::PathExists(data_dir));
+  ASSERT_TRUE(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 27 matching lines @@
   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"));
   file_util::CreateDirectory(dir_name_from);
-  ASSERT_TRUE(base::PathExists(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(base::PathExists(file_name_from));
+  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 file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("CopyAndDelete_Test_File.txt"));
 
-  ASSERT_FALSE(base::PathExists(dir_name_to));
+  ASSERT_FALSE(PathExists(dir_name_to));
 
-  EXPECT_TRUE(base::internal::CopyAndDeleteDirectory(dir_name_from,
+  EXPECT_TRUE(internal::CopyAndDeleteDirectory(dir_name_from,
                                                      dir_name_to));
 
   // Check everything has been moved.
-  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));
+  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, 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(base::PathExists(temp_files[i]));
+    EXPECT_TRUE(PathExists(temp_files[i]));
     EXPECT_FALSE(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::DeleteFile(temp_files[i], false));
+    EXPECT_TRUE(DeleteFile(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(base::PathExists(names[i]));
+    EXPECT_TRUE(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::DeleteFile(names[i], false));
+    EXPECT_TRUE(DeleteFile(names[i], false));
   }
 }
 
 TEST_F(FileUtilTest, CreateNewTempDirectoryTest) {
   FilePath temp_dir;
   ASSERT_TRUE(file_util::CreateNewTempDirectory(FilePath::StringType(),
                                                 &temp_dir));
-  EXPECT_TRUE(base::PathExists(temp_dir));
-  EXPECT_TRUE(base::DeleteFile(temp_dir, false));
+  EXPECT_TRUE(PathExists(temp_dir));
+  EXPECT_TRUE(DeleteFile(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(base::PathExists(new_dir));
+  EXPECT_TRUE(PathExists(new_dir));
   EXPECT_TRUE(temp_dir_.path().IsParent(new_dir));
-  EXPECT_TRUE(base::DeleteFile(new_dir, false));
+  EXPECT_TRUE(DeleteFile(new_dir, false));
 }
 
 TEST_F(FileUtilTest, GetShmemTempDirTest) {
   FilePath dir;
   EXPECT_TRUE(file_util::GetShmemTempDir(&dir, false));
   EXPECT_TRUE(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(base::PathExists(test_path));
+  EXPECT_FALSE(PathExists(test_path));
   EXPECT_TRUE(file_util::CreateDirectory(test_path));
-  EXPECT_TRUE(base::PathExists(test_path));
+  EXPECT_TRUE(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(base::PathExists(test_path));
+  EXPECT_FALSE(PathExists(test_path));
   CreateTextFile(test_path, L"test file");
-  EXPECT_TRUE(base::PathExists(test_path));
+  EXPECT_TRUE(PathExists(test_path));
   EXPECT_FALSE(file_util::CreateDirectory(test_path));
 
-  EXPECT_TRUE(base::DeleteFile(test_root, true));
-  EXPECT_FALSE(base::PathExists(test_root));
-  EXPECT_FALSE(base::PathExists(test_path));
+  EXPECT_TRUE(DeleteFile(test_root, true));
+  EXPECT_FALSE(PathExists(test_root));
+  EXPECT_FALSE(PathExists(test_path));
 
   // Verify assumptions made by the Windows implementation:
   // 1. The current directory always exists.
   // 2. The root directory always exists.
   ASSERT_TRUE(DirectoryExists(FilePath(FilePath::kCurrentDirectory)));
   FilePath top_level = test_root;
   while (top_level != top_level.DirName()) {
     top_level = top_level.DirName();
   }
   ASSERT_TRUE(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 (!base::PathExists(invalid_drive)) {
+  if (!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(base::PathExists(test_root));
+  EXPECT_FALSE(PathExists(test_root));
   EXPECT_TRUE(file_util::CreateDirectory(test_root));
-  EXPECT_TRUE(base::PathExists(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(base::PathExists(test_path));
+  EXPECT_FALSE(PathExists(test_path));
   CreateTextFile(test_path, L"test file");
-  EXPECT_TRUE(base::PathExists(test_path));
+  EXPECT_TRUE(PathExists(test_path));
   EXPECT_FALSE(DirectoryExists(test_path));
-  EXPECT_TRUE(base::DeleteFile(test_path, false));
+  EXPECT_TRUE(DeleteFile(test_path, false));
 
-  EXPECT_TRUE(base::DeleteFile(test_root, true));
+  EXPECT_TRUE(DeleteFile(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(), FPL(""));
   EXPECT_EQ(f0.Next().value(), FPL(""));
 
   // Test an empty directory, non-recursively, including "..".
   FileEnumerator f0_dotdot(temp_dir_.path(), false,
@@ skipping 87 matching lines @@
   EXPECT_TRUE(c5.HasFile(dir2inner));
   EXPECT_TRUE(c5.HasFile(dir2innerfile));
   EXPECT_EQ(c5.size(), 5);
 
 #if defined(OS_WIN)
   {
     // Make dir1 point to dir2.
     ReparsePoint reparse_point(dir1, dir2);
     EXPECT_TRUE(reparse_point.IsValid());
 
-    if ((base::win::GetVersion() >= base::win::VERSION_VISTA)) {
+    if ((win::GetVersion() >= base::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(c6.size(), 3);
@@ skipping 27 matching lines @@
   FileEnumerator f9(temp_dir_.path(), 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"));
 
   // Create a fresh, empty copy of this directory.
-  if (base::PathExists(data_dir)) {
-    ASSERT_TRUE(base::DeleteFile(data_dir, true));
+  if (PathExists(data_dir)) {
+    ASSERT_TRUE(DeleteFile(data_dir, true));
   }
   ASSERT_TRUE(file_util::CreateDirectory(data_dir));
 
   // Create a fresh, empty copy of this directory.
-  if (base::PathExists(data_dir)) {
-    ASSERT_TRUE(base::DeleteFile(data_dir, true));
+  if (PathExists(data_dir)) {
+    ASSERT_TRUE(DeleteFile(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 (base::PathExists(data_dir)) {
-    ASSERT_TRUE(base::DeleteFile(data_dir, true));
+  if (PathExists(data_dir)) {
+    ASSERT_TRUE(DeleteFile(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;
+  Time access_time;
   // This timestamp is divisible by one day (in local timezone),
   // to make it work on FAT too.
-  ASSERT_TRUE(base::Time::FromString("Wed, 16 Nov 1994, 00:00:00",
+  ASSERT_TRUE(Time::FromString("Wed, 16 Nov 1994, 00:00:00",
                                      &access_time));
 
-  base::Time modification_time;
+  Time modification_time;
   // Note that this timestamp is divisible by two (seconds) - FAT stores
   // modification times with 2s resolution.
-  ASSERT_TRUE(base::Time::FromString("Tue, 15 Nov 1994, 12:45:26 GMT",
+  ASSERT_TRUE(Time::FromString("Tue, 15 Nov 1994, 12:45:26 GMT",
               &modification_time));
 
   ASSERT_TRUE(file_util::TouchFile(foobar, access_time, modification_time));
-  base::PlatformFileInfo file_info;
+  PlatformFileInfo file_info;
   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(base::PathExists(empty_dir));
+  ASSERT_FALSE(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 37 matching lines @@
 
     ASSERT_EQ(uid_, getuid());  // This process should be the owner.
 
     // To ensure that umask settings do not cause the initial state
     // of permissions to be different from what we expect, explicitly
     // set permissions on the directories we create.
     // Make all files and directories non-world-writable.
 
     // Users and group can read, write, traverse
     int enabled_permissions =
-        file_util::FILE_PERMISSION_USER_MASK |
-        file_util::FILE_PERMISSION_GROUP_MASK;
+        FILE_PERMISSION_USER_MASK | FILE_PERMISSION_GROUP_MASK;
     // Other users can't read, write, traverse
-    int disabled_permissions =
-        file_util::FILE_PERMISSION_OTHERS_MASK;
+    int disabled_permissions = FILE_PERMISSION_OTHERS_MASK;
 
     ASSERT_NO_FATAL_FAILURE(
         ChangePosixFilePermissions(
             base_dir_, enabled_permissions, disabled_permissions));
     ASSERT_NO_FATAL_FAILURE(
         ChangePosixFilePermissions(
             sub_dir_, enabled_permissions, disabled_permissions));
   }
 
   FilePath base_dir_;
@@ skipping 29 matching lines @@
   EXPECT_TRUE(
       file_util::VerifyPathControlledByUser(
           base_dir_, sub_dir_, uid_, ok_gids_));
 }
 
 TEST_F(VerifyPathControlledByUserTest, Symlinks) {
   // Symlinks in the path should cause failure.
 
   // Symlink to the file at the end of the path.
   FilePath file_link =  base_dir_.AppendASCII("file_link");
-  ASSERT_TRUE(file_util::CreateSymbolicLink(text_file_, file_link))
+  ASSERT_TRUE(CreateSymbolicLink(text_file_, file_link))
       << "Failed to create symlink.";
 
   EXPECT_FALSE(
       file_util::VerifyPathControlledByUser(
           base_dir_, file_link, uid_, ok_gids_));
   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))
+  ASSERT_TRUE(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(base::PathExists(file_path_with_link));
+  ASSERT_TRUE(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 238 matching lines @@
           base_dir_, text_file_, uid_, ok_gids_));
   EXPECT_TRUE(
       file_util::VerifyPathControlledByUser(
           sub_dir_, text_file_, uid_, ok_gids_));
 }
 
 #if defined(OS_ANDROID)
 TEST_F(FileUtilTest, ValidContentUriTest) {
   // Get the test image path.
   FilePath data_dir;
-  ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &data_dir));
+  ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &data_dir));
   data_dir = data_dir.AppendASCII("file_util");
-  ASSERT_TRUE(base::PathExists(data_dir));
+  ASSERT_TRUE(PathExists(data_dir));
   FilePath image_file = data_dir.Append(FILE_PATH_LITERAL("red.png"));
   int64 image_size;
   file_util::GetFileSize(image_file, &image_size);
   EXPECT_LT(0, image_size);
 
   // Insert the image into MediaStore. MediaStore will do some conversions, and
   // return the content URI.
-  base::FilePath path = file_util::InsertImageIntoMediaStore(image_file);
+  FilePath path = file_util::InsertImageIntoMediaStore(image_file);
   EXPECT_TRUE(path.IsContentUri());
-  EXPECT_TRUE(base::PathExists(path));
+  EXPECT_TRUE(PathExists(path));
   // The file size may not equal to the input image as MediaStore may convert
   // the image.
   int64 content_uri_size;
   file_util::GetFileSize(path, &content_uri_size);
   EXPECT_EQ(image_size, content_uri_size);
 
   // We should be able to read the file.
   char* buffer = new char[image_size];
-  int fd = base::OpenContentUriForRead(path);
+  int fd = OpenContentUriForRead(path);
   EXPECT_LT(0, fd);
-  EXPECT_TRUE(file_util::ReadFromFD(fd, buffer, image_size));
+  EXPECT_TRUE(ReadFromFD(fd, buffer, image_size));
   delete[] buffer;
 }
 
 TEST_F(FileUtilTest, NonExistentContentUriTest) {
-  base::FilePath path("content://foo.bar");
+  FilePath path("content://foo.bar");
   EXPECT_TRUE(path.IsContentUri());
-  EXPECT_FALSE(base::PathExists(path));
+  EXPECT_FALSE(PathExists(path));
   // Size should be smaller than 0.
   int64 size;
   file_util::GetFileSize(path, &size);
   EXPECT_GT(0, size);
 
   // We should not be able to read the file.
-  int fd = base::OpenContentUriForRead(path);
+  int fd = OpenContentUriForRead(path);
   EXPECT_EQ(-1, fd);
 }
 #endif
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace
+
+}  // namespace base