Move more file_util functions 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 236 matching lines @@
 TEST_F(FileUtilTest, FileAndDirectorySize) {
   // Create three files of 20, 30 and 3 chars (utf8). ComputeDirectorySize
   // should return 53 bytes.
   FilePath file_01 = temp_dir_.path().Append(FPL("The file 01.txt"));
   CreateTextFile(file_01, L"12345678901234567890");
   int64 size_f1 = 0;
   ASSERT_TRUE(GetFileSize(file_01, &size_f1));
   EXPECT_EQ(20ll, size_f1);
 
   FilePath subdir_path = temp_dir_.path().Append(FPL("Level2"));
-  base::CreateDirectory(subdir_path);
+  CreateDirectory(subdir_path);
 
   FilePath file_02 = subdir_path.Append(FPL("The file 02.txt"));
   CreateTextFile(file_02, L"123456789012345678901234567890");
   int64 size_f2 = 0;
   ASSERT_TRUE(GetFileSize(file_02, &size_f2));
   EXPECT_EQ(30ll, size_f2);
 
   FilePath subsubdir_path = subdir_path.Append(FPL("Level3"));
-  base::CreateDirectory(subsubdir_path);
+  CreateDirectory(subsubdir_path);
 
   FilePath file_03 = subsubdir_path.Append(FPL("The file 03.txt"));
   CreateTextFile(file_03, L"123");
 
   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"));
-  base::CreateDirectory(dir_path);
+  CreateDirectory(dir_path);
 
   FilePath normalized_file_a_path, normalized_file_b_path;
   ASSERT_FALSE(PathExists(file_a_path));
   ASSERT_FALSE(NormalizeFilePath(file_a_path, &normalized_file_a_path))
     << "NormalizeFilePath() should fail on nonexistent paths.";
 
   CreateTextFile(file_a_path, bogus_content);
   ASSERT_TRUE(PathExists(file_a_path));
   ASSERT_TRUE(NormalizeFilePath(file_a_path, &normalized_file_a_path));
 
@@ skipping 19 matching lines @@
   // |       |-> file.txt
   // |       |-> long_name___... (Very long name.)
   // |           |-> sub_long
   // |              |-> deep.txt
   // |-> base_b
   //     |-> to_sub_a (reparse point to temp_dir\base_a\sub_a)
   //     |-> to_base_b (reparse point to temp_dir\base_b)
   //     |-> to_sub_long (reparse point to temp_dir\sub_a\long_name_\sub_long)
 
   FilePath base_a = temp_dir_.path().Append(FPL("base_a"));
-  ASSERT_TRUE(base::CreateDirectory(base_a));
+  ASSERT_TRUE(CreateDirectory(base_a));
 
   FilePath sub_a = base_a.Append(FPL("sub_a"));
-  ASSERT_TRUE(base::CreateDirectory(sub_a));
+  ASSERT_TRUE(CreateDirectory(sub_a));
 
   FilePath file_txt = sub_a.Append(FPL("file.txt"));
   CreateTextFile(file_txt, bogus_content);
 
   // Want a directory whose name is long enough to make the path to the file
   // inside just under MAX_PATH chars.  This will be used to test that when
   // a junction expands to a path over MAX_PATH chars in length,
   // NormalizeFilePath() fails without crashing.
   FilePath sub_long_rel(FPL("sub_long"));
   FilePath deep_txt(FPL("deep.txt"));
 
   int target_length = MAX_PATH;
   target_length -= (sub_a.value().length() + 1);  // +1 for the sepperator '\'.
   target_length -= (sub_long_rel.Append(deep_txt).value().length() + 1);
   // Without making the path a bit shorter, CreateDirectory() fails.
   // the resulting path is still long enough to hit the failing case in
   // NormalizePath().
   const int kCreateDirLimit = 4;
   target_length -= kCreateDirLimit;
   FilePath::StringType long_name_str = FPL("long_name_");
   long_name_str.resize(target_length, '_');
 
   FilePath long_name = sub_a.Append(FilePath(long_name_str));
   FilePath deep_file = long_name.Append(sub_long_rel).Append(deep_txt);
   ASSERT_EQ(MAX_PATH - kCreateDirLimit, deep_file.value().length());
 
   FilePath sub_long = deep_file.DirName();
-  ASSERT_TRUE(base::CreateDirectory(sub_long));
+  ASSERT_TRUE(CreateDirectory(sub_long));
   CreateTextFile(deep_file, bogus_content);
 
   FilePath base_b = temp_dir_.path().Append(FPL("base_b"));
-  ASSERT_TRUE(base::CreateDirectory(base_b));
+  ASSERT_TRUE(CreateDirectory(base_b));
 
   FilePath to_sub_a = base_b.Append(FPL("to_sub_a"));
-  ASSERT_TRUE(base::CreateDirectory(to_sub_a));
+  ASSERT_TRUE(CreateDirectory(to_sub_a));
   FilePath normalized_path;
   {
     ReparsePoint reparse_to_sub_a(to_sub_a, sub_a);
     ASSERT_TRUE(reparse_to_sub_a.IsValid());
 
     FilePath to_base_b = base_b.Append(FPL("to_base_b"));
-    ASSERT_TRUE(base::CreateDirectory(to_base_b));
+    ASSERT_TRUE(CreateDirectory(to_base_b));
     ReparsePoint reparse_to_base_b(to_base_b, base_b);
     ASSERT_TRUE(reparse_to_base_b.IsValid());
 
     FilePath to_sub_long = base_b.Append(FPL("to_sub_long"));
-    ASSERT_TRUE(base::CreateDirectory(to_sub_long));
+    ASSERT_TRUE(CreateDirectory(to_sub_long));
     ReparsePoint reparse_to_sub_long(to_sub_long, sub_long);
     ASSERT_TRUE(reparse_to_sub_long.IsValid());
 
     // Normalize a junction free path: base_a\sub_a\file.txt .
     ASSERT_TRUE(NormalizeFilePath(file_txt, &normalized_path));
     ASSERT_STREQ(file_txt.value().c_str(), normalized_path.value().c_str());
 
     // Check that the path base_b\to_sub_a\file.txt can be normalized to exclude
     // the junction to_sub_a.
     ASSERT_TRUE(NormalizeFilePath(to_sub_a.Append(FPL("file.txt")),
@@ skipping 98 matching lines @@
       real_device_path_plus_numbers,
       &win32_path));
 
   ASSERT_FALSE(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(base::CreateDirectory(empty_dir));
+  ASSERT_TRUE(CreateDirectory(empty_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());
   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(base::CreateDirectory(long_test_dir));
+  ASSERT_TRUE(CreateDirectory(long_test_dir));
 
   // kLongDirName is not a 8.3 component. So GetShortName() should give us a
   // different short name.
   WCHAR path_buffer[MAX_PATH];
   DWORD path_buffer_length = GetShortPathName(long_test_dir.value().c_str(),
                                               path_buffer, MAX_PATH);
   ASSERT_LT(path_buffer_length, DWORD(MAX_PATH));
   ASSERT_NE(DWORD(0), path_buffer_length);
   FilePath short_test_dir(path_buffer);
   ASSERT_STRNE(kLongDirName, short_test_dir.BaseName().value().c_str());
 
   FilePath temp_file;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(short_test_dir, &temp_file));
+  ASSERT_TRUE(CreateTemporaryFileInDir(short_test_dir, &temp_file));
   EXPECT_STREQ(kLongDirName, temp_file.DirName().BaseName().value().c_str());
   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(base::CreateDirectory(access_test_dir));
+  ASSERT_TRUE(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(base::CreateTemporaryFileInDir(
+  ASSERT_TRUE(CreateTemporaryFileInDir(
       short_test_dir.Append(kTestSubDirName), &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);
 }
 
@@ skipping 14 matching lines @@
   std::wstring contents = ReadTextFile(link_from);
   EXPECT_EQ(bogus_content, contents);
 
   FilePath result;
   ASSERT_TRUE(ReadSymbolicLink(link_from, &result));
   EXPECT_EQ(link_to.value(), result.value());
 
   // Link to a directory.
   link_from = temp_dir_.path().Append(FPL("from_dir"));
   link_to = temp_dir_.path().Append(FPL("to_dir"));
-  ASSERT_TRUE(base::CreateDirectory(link_to));
+  ASSERT_TRUE(CreateDirectory(link_to));
   ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
     << "Failed to create directory symlink.";
 
   // Test failures.
   EXPECT_FALSE(CreateSymbolicLink(link_to, link_to));
   EXPECT_FALSE(ReadSymbolicLink(link_to, &result));
   FilePath missing = temp_dir_.path().Append(FPL("missing"));
   EXPECT_FALSE(ReadSymbolicLink(missing, &result));
 }
 
@@ skipping 14 matching lines @@
   // Check that NormalizeFilePath sees the link.
   FilePath normalized_path;
   ASSERT_TRUE(NormalizeFilePath(link_from, &normalized_path));
   EXPECT_NE(link_from, link_to);
   EXPECT_EQ(link_to.BaseName().value(), normalized_path.BaseName().value());
   EXPECT_EQ(link_to.BaseName().value(), normalized_path.BaseName().value());
 
   // Link to a directory.
   link_from = temp_dir_.path().Append(FPL("from_dir"));
   link_to = temp_dir_.path().Append(FPL("to_dir"));
-  ASSERT_TRUE(base::CreateDirectory(link_to));
+  ASSERT_TRUE(CreateDirectory(link_to));
   ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
     << "Failed to create directory symlink.";
 
   EXPECT_FALSE(NormalizeFilePath(link_from, &normalized_path))
     << "Links to directories should return false.";
 
   // Test that a loop in the links causes NormalizeFilePath() to return false.
   link_from = temp_dir_.path().Append(FPL("link_a"));
   link_to = temp_dir_.path().Append(FPL("link_b"));
   ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
@@ skipping 95 matching lines @@
   // Make sure the file is readable.
   int32 mode = 0;
   EXPECT_TRUE(GetPosixFilePermissions(file_name, &mode));
   EXPECT_TRUE(mode & FILE_PERMISSION_READ_BY_USER);
 
   // Get rid of the read permission.
   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));
+  EXPECT_EQ(-1, ReadFile(file_name, buffer, buffer_size));
 
   // Give the read permission.
   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));
+            ReadFile(file_name, buffer, buffer_size));
 
   // Delete the file.
   EXPECT_TRUE(DeleteFile(file_name, false));
   EXPECT_FALSE(PathExists(file_name));
 
   delete[] buffer;
 }
 
 TEST_F(FileUtilTest, ChangeFilePermissionsAndWrite) {
   // Create a file path.
@@ skipping 34 matching lines @@
 
   // Delete the file.
   EXPECT_TRUE(DeleteFile(file_name, false));
   EXPECT_FALSE(PathExists(file_name));
 }
 
 TEST_F(FileUtilTest, ChangeDirectoryPermissionsAndEnumerate) {
   // Create a directory path.
   FilePath subdir_path =
       temp_dir_.path().Append(FPL("PermissionTest1"));
-  base::CreateDirectory(subdir_path);
+  CreateDirectory(subdir_path);
   ASSERT_TRUE(PathExists(subdir_path));
 
   // Create a dummy file to enumerate.
   FilePath file_name = subdir_path.Append(FPL("Test Readable File.txt"));
   EXPECT_FALSE(PathExists(file_name));
   const std::string kData("hello");
   EXPECT_EQ(static_cast<int>(kData.length()),
             file_util::WriteFile(file_name, kData.data(), kData.length()));
   EXPECT_TRUE(PathExists(file_name));
 
@@ skipping 36 matching lines @@
 // 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(PathExists(file_name));
 
   FilePath subdir_path = temp_dir_.path().Append(FPL("DeleteWildCardDir"));
-  base::CreateDirectory(subdir_path);
+  CreateDirectory(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(DeleteFile(directory_contents, false));
   EXPECT_FALSE(PathExists(file_name));
   EXPECT_TRUE(PathExists(subdir_path));
 
   // Delete recursively and make sure all contents are deleted
   EXPECT_TRUE(DeleteFile(directory_contents, true));
   EXPECT_FALSE(PathExists(file_name));
   EXPECT_FALSE(PathExists(subdir_path));
 }
 
 // TODO(erikkay): see if anyone's actually using this feature of the API
 TEST_F(FileUtilTest, DeleteNonExistantWildCard) {
   // Create a file and a directory
   FilePath subdir_path =
       temp_dir_.path().Append(FPL("DeleteNonExistantWildCard"));
-  base::CreateDirectory(subdir_path);
+  CreateDirectory(subdir_path);
   ASSERT_TRUE(PathExists(subdir_path));
 
   // Create the wildcard path
   FilePath directory_contents = subdir_path;
   directory_contents = directory_contents.Append(FPL("*"));
 
   // Delete non-recursively and check nothing got deleted
   EXPECT_TRUE(DeleteFile(directory_contents, false));
   EXPECT_TRUE(PathExists(subdir_path));
 
   // Delete recursively and check nothing got deleted
   EXPECT_TRUE(DeleteFile(directory_contents, true));
   EXPECT_TRUE(PathExists(subdir_path));
 }
 #endif
 
 // Tests non-recursive Delete() for a directory.
 TEST_F(FileUtilTest, DeleteDirNonRecursive) {
   // Create a subdirectory and put a file and two directories inside.
   FilePath test_subdir = temp_dir_.path().Append(FPL("DeleteDirNonRecursive"));
-  base::CreateDirectory(test_subdir);
+  CreateDirectory(test_subdir);
   ASSERT_TRUE(PathExists(test_subdir));
 
   FilePath file_name = test_subdir.Append(FPL("Test DeleteDir.txt"));
   CreateTextFile(file_name, bogus_content);
   ASSERT_TRUE(PathExists(file_name));
 
   FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
-  base::CreateDirectory(subdir_path1);
+  CreateDirectory(subdir_path1);
   ASSERT_TRUE(PathExists(subdir_path1));
 
   FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
-  base::CreateDirectory(subdir_path2);
+  CreateDirectory(subdir_path2);
   ASSERT_TRUE(PathExists(subdir_path2));
 
   // Delete non-recursively and check that the empty dir got deleted
   EXPECT_TRUE(DeleteFile(subdir_path2, false));
   EXPECT_FALSE(PathExists(subdir_path2));
 
   // Delete non-recursively and check that nothing got deleted
   EXPECT_FALSE(DeleteFile(test_subdir, false));
   EXPECT_TRUE(PathExists(test_subdir));
   EXPECT_TRUE(PathExists(file_name));
   EXPECT_TRUE(PathExists(subdir_path1));
 }
 
 // Tests recursive Delete() for a directory.
 TEST_F(FileUtilTest, DeleteDirRecursive) {
   // Create a subdirectory and put a file and two directories inside.
   FilePath test_subdir = temp_dir_.path().Append(FPL("DeleteDirRecursive"));
-  base::CreateDirectory(test_subdir);
+  CreateDirectory(test_subdir);
   ASSERT_TRUE(PathExists(test_subdir));
 
   FilePath file_name = test_subdir.Append(FPL("Test DeleteDirRecursive.txt"));
   CreateTextFile(file_name, bogus_content);
   ASSERT_TRUE(PathExists(file_name));
 
   FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
-  base::CreateDirectory(subdir_path1);
+  CreateDirectory(subdir_path1);
   ASSERT_TRUE(PathExists(subdir_path1));
 
   FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
-  base::CreateDirectory(subdir_path2);
+  CreateDirectory(subdir_path2);
   ASSERT_TRUE(PathExists(subdir_path2));
 
   // Delete recursively and check that the empty dir got deleted
   EXPECT_TRUE(DeleteFile(subdir_path2, true));
   EXPECT_FALSE(PathExists(subdir_path2));
 
   // Delete recursively and check that everything got deleted
   EXPECT_TRUE(DeleteFile(test_subdir, true));
   EXPECT_FALSE(PathExists(file_name));
   EXPECT_FALSE(PathExists(subdir_path1));
@@ skipping 43 matching lines @@
 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(PathExists(file_name_from));
 
   // The destination directory
   FilePath dir_name_to =
       temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
-  base::CreateDirectory(dir_name_to);
+  CreateDirectory(dir_name_to);
   ASSERT_TRUE(PathExists(dir_name_to));
 
   EXPECT_FALSE(Move(file_name_from, dir_name_to));
 }
 
 
 TEST_F(FileUtilTest, MoveNew) {
   // Create a directory
   FilePath dir_name_from =
       temp_dir_.path().Append(FILE_PATH_LITERAL("Move_From_Subdir"));
-  base::CreateDirectory(dir_name_from);
+  CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory
   FilePath txt_file_name(FILE_PATH_LITERAL("Move_Test_File.txt"));
   FilePath file_name_from = dir_name_from.Append(txt_file_name);
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Move the directory.
   FilePath dir_name_to =
@@ skipping 20 matching lines @@
   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"));
-  base::CreateDirectory(dir_name_from);
+  CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Move the directory
   FilePath dir_name_exists =
       temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
 
   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.
-  base::CreateDirectory(dir_name_exists);
+  CreateDirectory(dir_name_exists);
   ASSERT_TRUE(PathExists(dir_name_exists));
 
   EXPECT_TRUE(Move(dir_name_from, dir_name_to));
 
   // Check everything has been moved.
   EXPECT_FALSE(PathExists(dir_name_from));
   EXPECT_FALSE(PathExists(file_name_from));
   EXPECT_TRUE(PathExists(dir_name_to));
   EXPECT_TRUE(PathExists(file_name_to));
 }
 
 TEST_F(FileUtilTest, CopyDirectoryRecursivelyNew) {
   // Create a directory.
   FilePath dir_name_from =
       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
-  base::CreateDirectory(dir_name_from);
+  CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory.
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Create a subdirectory.
   FilePath subdir_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
-  base::CreateDirectory(subdir_name_from);
+  CreateDirectory(subdir_name_from);
   ASSERT_TRUE(PathExists(subdir_name_from));
 
   // Create a file under the subdirectory.
   FilePath file_name2_from =
       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name2_from));
 
   // Copy the directory recursively.
   FilePath dir_name_to =
@@ skipping 17 matching lines @@
   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"));
-  base::CreateDirectory(dir_name_from);
+  CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory.
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Create a subdirectory.
   FilePath subdir_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
-  base::CreateDirectory(subdir_name_from);
+  CreateDirectory(subdir_name_from);
   ASSERT_TRUE(PathExists(subdir_name_from));
 
   // Create a file under the subdirectory.
   FilePath file_name2_from =
       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name2_from));
 
   // Copy the directory recursively.
   FilePath dir_name_exists =
       temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
 
   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.
-  base::CreateDirectory(dir_name_exists);
+  CreateDirectory(dir_name_exists);
   ASSERT_TRUE(PathExists(dir_name_exists));
 
   EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_exists, true));
 
   // Check everything has been copied.
   EXPECT_TRUE(PathExists(dir_name_from));
   EXPECT_TRUE(PathExists(file_name_from));
   EXPECT_TRUE(PathExists(subdir_name_from));
   EXPECT_TRUE(PathExists(file_name2_from));
   EXPECT_TRUE(PathExists(dir_name_to));
   EXPECT_TRUE(PathExists(file_name_to));
   EXPECT_TRUE(PathExists(subdir_name_to));
   EXPECT_TRUE(PathExists(file_name2_to));
 }
 
 TEST_F(FileUtilTest, CopyDirectoryNew) {
   // Create a directory.
   FilePath dir_name_from =
       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
-  base::CreateDirectory(dir_name_from);
+  CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory.
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Create a subdirectory.
   FilePath subdir_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
-  base::CreateDirectory(subdir_name_from);
+  CreateDirectory(subdir_name_from);
   ASSERT_TRUE(PathExists(subdir_name_from));
 
   // Create a file under the subdirectory.
   FilePath file_name2_from =
       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name2_from));
 
   // Copy the directory not recursively.
   FilePath dir_name_to =
@@ skipping 14 matching lines @@
   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"));
-  base::CreateDirectory(dir_name_from);
+  CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory.
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Create a subdirectory.
   FilePath subdir_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
-  base::CreateDirectory(subdir_name_from);
+  CreateDirectory(subdir_name_from);
   ASSERT_TRUE(PathExists(subdir_name_from));
 
   // Create a file under the subdirectory.
   FilePath file_name2_from =
       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name2_from));
 
   // Copy the directory not recursively.
   FilePath dir_name_to =
       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
   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.
-  base::CreateDirectory(dir_name_to);
+  CreateDirectory(dir_name_to);
   ASSERT_TRUE(PathExists(dir_name_to));
 
   EXPECT_TRUE(CopyDirectory(dir_name_from, dir_name_to, false));
 
   // Check everything has been copied.
   EXPECT_TRUE(PathExists(dir_name_from));
   EXPECT_TRUE(PathExists(file_name_from));
   EXPECT_TRUE(PathExists(subdir_name_from));
   EXPECT_TRUE(PathExists(file_name2_from));
   EXPECT_TRUE(PathExists(dir_name_to));
@@ skipping 42 matching lines @@
 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(PathExists(file_name_from));
 
   // The destination
   FilePath dir_name_to =
       temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
-  base::CreateDirectory(dir_name_to);
+  CreateDirectory(dir_name_to);
   ASSERT_TRUE(PathExists(dir_name_to));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
 
   EXPECT_TRUE(CopyDirectory(file_name_from, dir_name_to, true));
 
   // Check the has been copied
   EXPECT_TRUE(PathExists(file_name_to));
 }
 
 TEST_F(FileUtilTest, CopyDirectoryWithTrailingSeparators) {
   // Create a directory.
   FilePath dir_name_from =
       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
-  base::CreateDirectory(dir_name_from);
+  CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory.
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Copy the directory recursively.
   FilePath dir_name_to =
@@ skipping 16 matching lines @@
   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"));
-  base::CreateDirectory(dir_name_from);
+  CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   const std::wstring file_contents(L"Gooooooooooooooooooooogle");
   CreateTextFile(file_name_from, file_contents);
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Copy the file.
@@ skipping 114 matching lines @@
   EXPECT_FALSE(TextContentsEqual(original_file, empty1_file));
   EXPECT_TRUE(TextContentsEqual(blank_line_file, blank_line_crlf_file));
 }
 
 // We don't need equivalent functionality outside of Windows.
 #if defined(OS_WIN)
 TEST_F(FileUtilTest, CopyAndDeleteDirectoryTest) {
   // Create a directory
   FilePath dir_name_from =
       temp_dir_.path().Append(FILE_PATH_LITERAL("CopyAndDelete_From_Subdir"));
-  base::CreateDirectory(dir_name_from);
+  CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("CopyAndDelete_Test_File.txt"));
   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Move the directory by using CopyAndDeleteDirectory
   FilePath dir_name_to = temp_dir_.path().Append(
@@ skipping 20 matching lines @@
   };
   // Save the original $TMP.
   size_t original_tmp_size;
   TCHAR* original_tmp;
   ASSERT_EQ(0, ::_tdupenv_s(&original_tmp, &original_tmp_size, kTmpKey));
   // original_tmp may be NULL.
 
   for (unsigned int i = 0; i < arraysize(kTmpValues); ++i) {
     FilePath path;
     ::_tputenv_s(kTmpKey, kTmpValues[i]);
-    base::GetTempDir(&path);
+    GetTempDir(&path);
     EXPECT_TRUE(path.IsAbsolute()) << "$TMP=" << kTmpValues[i] <<
         " result=" << path.value();
   }
 
   // Restore the original $TMP.
   if (original_tmp) {
     ::_tputenv_s(kTmpKey, original_tmp);
     free(original_tmp);
   } 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(base::CreateTemporaryFile(&(temp_files[i])));
+    ASSERT_TRUE(CreateTemporaryFile(&(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(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] = base::CreateAndOpenTemporaryFile(&(names[i]));
+    fps[i] = CreateAndOpenTemporaryFile(&(names[i]));
     ASSERT_TRUE(fps[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(CloseFile(fps[i]));
     EXPECT_TRUE(DeleteFile(names[i], false));
   }
 }
 
 TEST_F(FileUtilTest, CreateNewTempDirectoryTest) {
   FilePath temp_dir;
-  ASSERT_TRUE(base::CreateNewTempDirectory(FilePath::StringType(), &temp_dir));
+  ASSERT_TRUE(CreateNewTempDirectory(FilePath::StringType(), &temp_dir));
   EXPECT_TRUE(PathExists(temp_dir));
   EXPECT_TRUE(DeleteFile(temp_dir, false));
 }
 
 TEST_F(FileUtilTest, CreateNewTemporaryDirInDirTest) {
   FilePath new_dir;
-  ASSERT_TRUE(base::CreateTemporaryDirInDir(
+  ASSERT_TRUE(CreateTemporaryDirInDir(
                   temp_dir_.path(),
                   FILE_PATH_LITERAL("CreateNewTemporaryDirInDirTest"),
                   &new_dir));
   EXPECT_TRUE(PathExists(new_dir));
   EXPECT_TRUE(temp_dir_.path().IsParent(new_dir));
   EXPECT_TRUE(DeleteFile(new_dir, false));
 }
 
 TEST_F(FileUtilTest, GetShmemTempDirTest) {
   FilePath dir;
   EXPECT_TRUE(GetShmemTempDir(false, &dir));
   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(PathExists(test_path));
-  EXPECT_TRUE(base::CreateDirectory(test_path));
+  EXPECT_TRUE(CreateDirectory(test_path));
   EXPECT_TRUE(PathExists(test_path));
   // CreateDirectory returns true if the DirectoryExists returns true.
-  EXPECT_TRUE(base::CreateDirectory(test_path));
+  EXPECT_TRUE(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(PathExists(test_path));
   CreateTextFile(test_path, L"test file");
   EXPECT_TRUE(PathExists(test_path));
-  EXPECT_FALSE(base::CreateDirectory(test_path));
+  EXPECT_FALSE(CreateDirectory(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(base::CreateDirectory(
+  EXPECT_TRUE(CreateDirectory(
       FilePath(FilePath::kCurrentDirectory)));
-  EXPECT_TRUE(base::CreateDirectory(top_level));
+  EXPECT_TRUE(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 (!PathExists(invalid_drive)) {
-    EXPECT_FALSE(base::CreateDirectory(invalid_path));
+    EXPECT_FALSE(CreateDirectory(invalid_path));
   }
 #endif
 }
 
 TEST_F(FileUtilTest, DetectDirectoryTest) {
   // Check a directory
   FilePath test_root =
       temp_dir_.path().Append(FILE_PATH_LITERAL("detect_directory_test"));
   EXPECT_FALSE(PathExists(test_root));
-  EXPECT_TRUE(base::CreateDirectory(test_root));
+  EXPECT_TRUE(CreateDirectory(test_root));
   EXPECT_TRUE(PathExists(test_root));
   EXPECT_TRUE(DirectoryExists(test_root));
   // Check a file
   FilePath test_path =
       test_root.Append(FILE_PATH_LITERAL("foobar.txt"));
   EXPECT_FALSE(PathExists(test_path));
   CreateTextFile(test_path, L"test file");
   EXPECT_TRUE(PathExists(test_path));
   EXPECT_FALSE(DirectoryExists(test_path));
   EXPECT_TRUE(DeleteFile(test_path, false));
 
   EXPECT_TRUE(DeleteFile(test_root, true));
 }
 
 TEST_F(FileUtilTest, FileEnumeratorTest) {
   // Test an empty directory.
   FileEnumerator f0(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
   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,
       FILES_AND_DIRECTORIES | FileEnumerator::INCLUDE_DOT_DOT);
   EXPECT_EQ(temp_dir_.path().Append(FPL("..")).value(),
             f0_dotdot.Next().value());
   EXPECT_EQ(FPL(""), f0_dotdot.Next().value());
 
   // create the directories
   FilePath dir1 = temp_dir_.path().Append(FPL("dir1"));
-  EXPECT_TRUE(base::CreateDirectory(dir1));
+  EXPECT_TRUE(CreateDirectory(dir1));
   FilePath dir2 = temp_dir_.path().Append(FPL("dir2"));
-  EXPECT_TRUE(base::CreateDirectory(dir2));
+  EXPECT_TRUE(CreateDirectory(dir2));
   FilePath dir2inner = dir2.Append(FPL("inner"));
-  EXPECT_TRUE(base::CreateDirectory(dir2inner));
+  EXPECT_TRUE(CreateDirectory(dir2inner));
 
   // create the files
   FilePath dir2file = dir2.Append(FPL("dir2file.txt"));
   CreateTextFile(dir2file, std::wstring());
   FilePath dir2innerfile = dir2inner.Append(FPL("innerfile.txt"));
   CreateTextFile(dir2innerfile, std::wstring());
   FilePath file1 = temp_dir_.path().Append(FPL("file1.txt"));
   CreateTextFile(file1, std::wstring());
   FilePath file2_rel = dir2.Append(FilePath::kParentDirectory)
       .Append(FPL("file2.txt"));
@@ skipping 65 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 ((win::GetVersion() >= base::win::VERSION_VISTA)) {
+    if ((win::GetVersion() >= win::VERSION_VISTA)) {
       // There can be a delay for the enumeration code to see the change on
       // the file system so skip this test for XP.
       // Enumerate the reparse point.
       FileEnumerator f6(dir1, true, FILES_AND_DIRECTORIES);
       FindResultCollector c6(f6);
       FilePath inner2 = dir1.Append(FPL("inner"));
       EXPECT_TRUE(c6.HasFile(inner2));
       EXPECT_TRUE(c6.HasFile(inner2.Append(FPL("innerfile.txt"))));
       EXPECT_TRUE(c6.HasFile(dir1.Append(FPL("dir2file.txt"))));
       EXPECT_EQ(c6.size(), 3);
@@ skipping 30 matching lines @@
 }
 
 TEST_F(FileUtilTest, AppendToFile) {
   FilePath data_dir =
       temp_dir_.path().Append(FILE_PATH_LITERAL("FilePathTest"));
 
   // Create a fresh, empty copy of this directory.
   if (PathExists(data_dir)) {
     ASSERT_TRUE(DeleteFile(data_dir, true));
   }
-  ASSERT_TRUE(base::CreateDirectory(data_dir));
+  ASSERT_TRUE(CreateDirectory(data_dir));
 
   // Create a fresh, empty copy of this directory.
   if (PathExists(data_dir)) {
     ASSERT_TRUE(DeleteFile(data_dir, true));
   }
-  ASSERT_TRUE(base::CreateDirectory(data_dir));
+  ASSERT_TRUE(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);
@@ skipping 33 matching lines @@
             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(PathExists(empty_dir));
 
-  ASSERT_TRUE(base::CreateDirectory(empty_dir));
+  ASSERT_TRUE(CreateDirectory(empty_dir));
 
-  EXPECT_TRUE(base::IsDirectoryEmpty(empty_dir));
+  EXPECT_TRUE(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(base::IsDirectoryEmpty(empty_dir));
+  EXPECT_FALSE(IsDirectoryEmpty(empty_dir));
 }
 
 #if defined(OS_POSIX)
 
 // Testing VerifyPathControlledByAdmin() is hard, because there is no
 // way a test can make a file owned by root, or change file paths
 // at the root of the file system.  VerifyPathControlledByAdmin()
 // is implemented as a call to VerifyPathControlledByUser, which gives
 // us the ability to test with paths under the test's temp directory,
 // using a user id we control.
 // Pull tests of VerifyPathControlledByUserTest() into a separate test class
 // with a common SetUp() method.
 class VerifyPathControlledByUserTest : public FileUtilTest {
  protected:
   virtual void SetUp() OVERRIDE {
     FileUtilTest::SetUp();
 
     // Create a basic structure used by each test.
     // base_dir_
     //  |-> sub_dir_
     //       |-> text_file_
 
     base_dir_ = temp_dir_.path().AppendASCII("base_dir");
-    ASSERT_TRUE(base::CreateDirectory(base_dir_));
+    ASSERT_TRUE(CreateDirectory(base_dir_));
 
     sub_dir_ = base_dir_.AppendASCII("sub_dir");
-    ASSERT_TRUE(base::CreateDirectory(sub_dir_));
+    ASSERT_TRUE(CreateDirectory(sub_dir_));
 
     text_file_ = sub_dir_.AppendASCII("file.txt");
     CreateTextFile(text_file_, L"This text file has some text in it.");
 
     // Get the user and group files are created with from |base_dir_|.
     struct stat stat_buf;
     ASSERT_EQ(0, stat(base_dir_.value().c_str(), &stat_buf));
     uid_ = stat_buf.st_uid;
     ok_gids_.insert(stat_buf.st_gid);
     bad_gids_.insert(stat_buf.st_gid + 1);
@@ skipping 373 matching lines @@
   int fd = OpenContentUriForRead(path);
   EXPECT_EQ(-1, fd);
 }
 #endif
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace
 
 }  // namespace base