Move temp file 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 513 matching lines @@
   // 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));
+  ASSERT_TRUE(base::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(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(
+  ASSERT_TRUE(base::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 1013 matching lines @@
     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(file_util::CreateTemporaryFile(&(temp_files[i])));
+    ASSERT_TRUE(base::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] = file_util::CreateAndOpenTemporaryFile(&(names[i]));
+    fps[i] = base::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(DeleteFile(names[i], false));
   }
 }
 
 TEST_F(FileUtilTest, CreateNewTempDirectoryTest) {
   FilePath temp_dir;
-  ASSERT_TRUE(file_util::CreateNewTempDirectory(FilePath::StringType(),
-                                                &temp_dir));
+  ASSERT_TRUE(base::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(file_util::CreateTemporaryDirInDir(
+  ASSERT_TRUE(base::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;
@@ skipping 713 matching lines @@
   int fd = OpenContentUriForRead(path);
   EXPECT_EQ(-1, fd);
 }
 #endif
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace
 
 }  // namespace base