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 416 matching lines @@
 
   // Get the NT style path to that drive.
   wchar_t device_path[MAX_PATH] = {'\0'};
   ASSERT_TRUE(
       ::QueryDosDevice(real_drive_letter.c_str(), device_path, MAX_PATH));
   FilePath actual_device_path(device_path);
   FilePath win32_path;
 
   // Run DevicePathToDriveLetterPath() on the NT style path we got from
   // QueryDosDevice().  Expect the drive letter we started with.
-  ASSERT_TRUE(file_util::DevicePathToDriveLetterPath(actual_device_path,
-                                                     &win32_path));
+  ASSERT_TRUE(DevicePathToDriveLetterPath(actual_device_path, &win32_path));
   ASSERT_EQ(real_drive_letter, win32_path.value());
 
   // Add some directories to the path.  Expect those extra path componenets
   // to be preserved.
   FilePath kRelativePath(FPL("dir1\\dir2\\file.txt"));
-  ASSERT_TRUE(file_util::DevicePathToDriveLetterPath(
+  ASSERT_TRUE(DevicePathToDriveLetterPath(
       actual_device_path.Append(kRelativePath),
       &win32_path));
   EXPECT_EQ(FilePath(real_drive_letter + L"\\").Append(kRelativePath).value(),
             win32_path.value());
 
   // Deform the real path so that it is invalid by removing the last four
   // characters.  The way windows names devices that are hard disks
   // (\Device\HardDiskVolume${NUMBER}) guarantees that the string is longer
   // than three characters.  The only way the truncated string could be a
   // real drive is if more than 10^3 disks are mounted:
   // \Device\HardDiskVolume10000 would be truncated to \Device\HardDiskVolume1
   // Check that DevicePathToDriveLetterPath fails.
   int path_length = actual_device_path.value().length();
   int new_length = path_length - 4;
   ASSERT_LT(0, new_length);
   FilePath prefix_of_real_device_path(
       actual_device_path.value().substr(0, new_length));
-  ASSERT_FALSE(file_util::DevicePathToDriveLetterPath(
-      prefix_of_real_device_path,
-      &win32_path));
+  ASSERT_FALSE(DevicePathToDriveLetterPath(prefix_of_real_device_path,
+                                           &win32_path));
 
-  ASSERT_FALSE(file_util::DevicePathToDriveLetterPath(
+  ASSERT_FALSE(DevicePathToDriveLetterPath(
       prefix_of_real_device_path.Append(kRelativePath),
       &win32_path));
 
   // Deform the real path so that it is invalid by adding some characters. For
   // example, if C: maps to \Device\HardDiskVolume8, then we simulate a
   // request for the drive letter whose native path is
   // \Device\HardDiskVolume812345 .  We assume such a device does not exist,
   // because drives are numbered in order and mounting 112345 hard disks will
   // never happen.
   const FilePath::StringType kExtraChars = FPL("12345");
 
   FilePath real_device_path_plus_numbers(
       actual_device_path.value() + kExtraChars);
 
-  ASSERT_FALSE(file_util::DevicePathToDriveLetterPath(
+  ASSERT_FALSE(DevicePathToDriveLetterPath(
       real_device_path_plus_numbers,
       &win32_path));
 
-  ASSERT_FALSE(file_util::DevicePathToDriveLetterPath(
+  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));
   win::ScopedHandle dir(
       ::CreateFile(empty_dir.value().c_str(),
                    FILE_ALL_ACCESS,
@@ skipping 193 matching lines @@
   // Create a non-existent file path.
   FilePath non_existent = temp_dir_.path().Append(FPL("Test DeleteFile 3.txt"));
   EXPECT_FALSE(PathExists(non_existent));
 
   // Create a symlink to the non-existent file.
   FilePath file_link = temp_dir_.path().Append("file_link_3");
   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_TRUE(IsLink(file_link));
   EXPECT_FALSE(PathExists(file_link));
 
   // Delete the symbolic link.
   EXPECT_TRUE(DeleteFile(file_link, false));
 
   // Make sure the symbolic link is deleted.
-  EXPECT_FALSE(file_util::IsLink(file_link));
+  EXPECT_FALSE(IsLink(file_link));
 }
 
 TEST_F(FileUtilTest, ChangeFilePermissionsAndRead) {
   // Create a file path.
   FilePath file_name = temp_dir_.path().Append(FPL("Test Readable File.txt"));
   EXPECT_FALSE(PathExists(file_name));
 
   const std::string kData("hello");
 
   int buffer_size = kData.length();
@@ skipping 1191 matching lines @@
                                      &access_time));
 
   Time modification_time;
   // Note that this timestamp is divisible by two (seconds) - FAT stores
   // modification times with 2s resolution.
   ASSERT_TRUE(Time::FromString("Tue, 15 Nov 1994, 12:45:26 GMT",
               &modification_time));
 
   ASSERT_TRUE(file_util::TouchFile(foobar, access_time, modification_time));
   PlatformFileInfo file_info;
-  ASSERT_TRUE(file_util::GetFileInfo(foobar, &file_info));
+  ASSERT_TRUE(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(PathExists(empty_dir));
@@ skipping 420 matching lines @@
   int fd = OpenContentUriForRead(path);
   EXPECT_EQ(-1, fd);
 }
 #endif
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace
 
 }  // namespace base