Move GetFileSize, NormalizeFilePath 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 232 matching lines @@
   return u.QuadPart;
 }
 #endif
 
 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(file_util::GetFileSize(file_01, &size_f1));
+  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);
 
   FilePath file_02 = subdir_path.Append(FPL("The file 02.txt"));
   CreateTextFile(file_02, L"123456789012345678901234567890");
   int64 size_f2 = 0;
-  ASSERT_TRUE(file_util::GetFileSize(file_02, &size_f2));
+  ASSERT_TRUE(GetFileSize(file_02, &size_f2));
   EXPECT_EQ(30ll, size_f2);
 
   FilePath subsubdir_path = subdir_path.Append(FPL("Level3"));
   base::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);
 
   FilePath normalized_file_a_path, normalized_file_b_path;
   ASSERT_FALSE(PathExists(file_a_path));
-  ASSERT_FALSE(file_util::NormalizeFilePath(file_a_path,
-                                            &normalized_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(file_util::NormalizeFilePath(file_a_path,
-                                           &normalized_file_a_path));
+  ASSERT_TRUE(NormalizeFilePath(file_a_path, &normalized_file_a_path));
 
   CreateTextFile(file_b_path, bogus_content);
   ASSERT_TRUE(PathExists(file_b_path));
-  ASSERT_TRUE(file_util::NormalizeFilePath(file_b_path,
-                                           &normalized_file_b_path));
+  ASSERT_TRUE(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()));
 }
 
 #if defined(OS_WIN)
 
@@ skipping 61 matching lines @@
     ASSERT_TRUE(base::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));
     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(file_util::NormalizeFilePath(file_txt, &normalized_path));
+    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(file_util::NormalizeFilePath(to_sub_a.Append(FPL("file.txt")),
+    ASSERT_TRUE(NormalizeFilePath(to_sub_a.Append(FPL("file.txt")),
                                              &normalized_path));
     ASSERT_STREQ(file_txt.value().c_str(), normalized_path.value().c_str());
 
     // Check that the path base_b\to_base_b\to_base_b\to_sub_a\file.txt can be
     // normalized to exclude junctions to_base_b and to_sub_a .
-    ASSERT_TRUE(file_util::NormalizeFilePath(base_b.Append(FPL("to_base_b"))
+    ASSERT_TRUE(NormalizeFilePath(base_b.Append(FPL("to_base_b"))
                                                    .Append(FPL("to_base_b"))
                                                    .Append(FPL("to_sub_a"))
                                                    .Append(FPL("file.txt")),
                                              &normalized_path));
     ASSERT_STREQ(file_txt.value().c_str(), normalized_path.value().c_str());
 
     // A long enough path will cause NormalizeFilePath() to fail.  Make a long
     // path using to_base_b many times, and check that paths long enough to fail
     // do not cause a crash.
     FilePath long_path = base_b;
     const int kLengthLimit = MAX_PATH + 200;
     while (long_path.value().length() <= kLengthLimit) {
       long_path = long_path.Append(FPL("to_base_b"));
     }
     long_path = long_path.Append(FPL("to_sub_a"))
                          .Append(FPL("file.txt"));
 
-    ASSERT_FALSE(file_util::NormalizeFilePath(long_path, &normalized_path));
+    ASSERT_FALSE(NormalizeFilePath(long_path, &normalized_path));
 
     // Normalizing the junction to deep.txt should fail, because the expanded
     // path to deep.txt is longer than MAX_PATH.
-    ASSERT_FALSE(file_util::NormalizeFilePath(to_sub_long.Append(deep_txt),
+    ASSERT_FALSE(NormalizeFilePath(to_sub_long.Append(deep_txt),
                                               &normalized_path));
 
     // Delete the reparse points, and see that NormalizeFilePath() fails
     // to traverse them.
   }
 
-  ASSERT_FALSE(file_util::NormalizeFilePath(to_sub_a.Append(FPL("file.txt")),
+  ASSERT_FALSE(NormalizeFilePath(to_sub_a.Append(FPL("file.txt")),
                                             &normalized_path));
 }
 
 TEST_F(FileUtilTest, DevicePathToDriveLetter) {
   // Get a drive letter.
   std::wstring real_drive_letter = temp_dir_.path().value().substr(0, 2);
   if (!isalpha(real_drive_letter[0]) || ':' != real_drive_letter[1]) {
     LOG(ERROR) << "Can't get a drive letter to test with.";
     return;
   }
@@ skipping 173 matching lines @@
   // 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(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));
+  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(CreateSymbolicLink(link_to, link_from))
     << "Failed to create directory symlink.";
 
-  EXPECT_FALSE(file_util::NormalizeFilePath(link_from, &normalized_path))
+  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))
     << "Failed to create loop symlink a.";
   ASSERT_TRUE(CreateSymbolicLink(link_from, link_to))
     << "Failed to create loop symlink b.";
 
   // Infinite loop!
-  EXPECT_FALSE(file_util::NormalizeFilePath(link_from, &normalized_path));
+  EXPECT_FALSE(NormalizeFilePath(link_from, &normalized_path));
 }
 #endif  // defined(OS_POSIX)
 
 TEST_F(FileUtilTest, DeleteNonExistent) {
   FilePath non_existent = temp_dir_.path().AppendASCII("bogus_file_dne.foobar");
   ASSERT_FALSE(PathExists(non_existent));
 
   EXPECT_TRUE(DeleteFile(non_existent, false));
   ASSERT_FALSE(PathExists(non_existent));
   EXPECT_TRUE(DeleteFile(non_existent, true));
@@ skipping 1663 matching lines @@
 
 #if defined(OS_ANDROID)
 TEST_F(FileUtilTest, ValidContentUriTest) {
   // Get the test image path.
   FilePath data_dir;
   ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &data_dir));
   data_dir = data_dir.AppendASCII("file_util");
   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);
+  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.
   FilePath path = file_util::InsertImageIntoMediaStore(image_file);
   EXPECT_TRUE(path.IsContentUri());
   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);
+  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 = OpenContentUriForRead(path);
   EXPECT_LT(0, fd);
   EXPECT_TRUE(ReadFromFD(fd, buffer, image_size));
   delete[] buffer;
 }
 
 TEST_F(FileUtilTest, NonExistentContentUriTest) {
   FilePath path("content://foo.bar");
   EXPECT_TRUE(path.IsContentUri());
   EXPECT_FALSE(PathExists(path));
   // Size should be smaller than 0.
   int64 size;
-  EXPECT_FALSE(file_util::GetFileSize(path, &size));
+  EXPECT_FALSE(GetFileSize(path, &size));
 
   // We should not be able to read the file.
   int fd = OpenContentUriForRead(path);
   EXPECT_EQ(-1, fd);
 }
 #endif
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace
 
 }  // namespace base