Move PathExists to base namespace.
BUG=
TBR=jam@chromium.org
Review URL: https://codereview.chromium.org/18286004
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@211147 0039d316-1c4b-4281-b951-d872f2087c98
CrOS-Libchrome-Original-Commit: 7567484144da059e2c2c2a818b06660a5459052f
diff --git a/base/android/path_utils_unittest.cc b/base/android/path_utils_unittest.cc
index 52b1928..c4c12fe 100644
--- a/base/android/path_utils_unittest.cc
+++ b/base/android/path_utils_unittest.cc
@@ -39,7 +39,7 @@
// the base tests shared object.
FilePath path;
GetNativeLibraryDirectory(&path);
- EXPECT_TRUE(file_util::PathExists(path.Append(("libbase_unittests.so"))));
+ EXPECT_TRUE(base::PathExists(path.Append(("libbase_unittests.so"))));
}
} // namespace android
diff --git a/base/base_paths.cc b/base/base_paths.cc
index b90efba..9f2b250 100644
--- a/base/base_paths.cc
+++ b/base/base_paths.cc
@@ -33,7 +33,7 @@
cur = cur.Append(FILE_PATH_LITERAL("base"));
cur = cur.Append(FILE_PATH_LITERAL("test"));
cur = cur.Append(FILE_PATH_LITERAL("data"));
- if (!file_util::PathExists(cur)) // We don't want to create this.
+ if (!base::PathExists(cur)) // We don't want to create this.
return false;
break;
default:
diff --git a/base/base_paths_posix.cc b/base/base_paths_posix.cc
index 59be094..6d7b5e1 100644
--- a/base/base_paths_posix.cc
+++ b/base/base_paths_posix.cc
@@ -80,7 +80,7 @@
std::string cr_source_root;
if (env->GetVar("CR_SOURCE_ROOT", &cr_source_root)) {
path = FilePath(cr_source_root);
- if (file_util::PathExists(path)) {
+ if (base::PathExists(path)) {
*result = path;
return true;
} else {
diff --git a/base/file_util.h b/base/file_util.h
index 321070f..095734b 100644
--- a/base/file_util.h
+++ b/base/file_util.h
@@ -112,16 +112,16 @@
const FilePath& to_path,
bool recursive);
+// Returns true if the given path exists on the local filesystem,
+// false otherwise.
+BASE_EXPORT bool PathExists(const FilePath& path);
+
} // namespace base
// -----------------------------------------------------------------------------
namespace file_util {
-// Returns true if the given path exists on the local filesystem,
-// false otherwise.
-BASE_EXPORT bool PathExists(const base::FilePath& path);
-
// Returns true if the given path is writable by the user, false otherwise.
BASE_EXPORT bool PathIsWritable(const base::FilePath& path);
diff --git a/base/file_util_posix.cc b/base/file_util_posix.cc
index 018a48d..f438253 100644
--- a/base/file_util_posix.cc
+++ b/base/file_util_posix.cc
@@ -227,7 +227,7 @@
// This function does not properly handle destinations within the source
FilePath real_to_path = to_path;
- if (file_util::PathExists(real_to_path)) {
+ if (PathExists(real_to_path)) {
real_to_path = MakeAbsoluteFilePath(real_to_path);
if (real_to_path.empty())
return false;
@@ -309,6 +309,11 @@
return success;
}
+bool PathExists(const FilePath& path) {
+ ThreadRestrictions::AssertIOAllowed();
+ return access(path.value().c_str(), F_OK) == 0;
+}
+
} // namespace base
// -----------------------------------------------------------------------------
@@ -324,11 +329,6 @@
using base::RealPath;
using base::VerifySpecificPathControlledByUser;
-bool PathExists(const FilePath& path) {
- base::ThreadRestrictions::AssertIOAllowed();
- return access(path.value().c_str(), F_OK) == 0;
-}
-
bool PathIsWritable(const FilePath& path) {
base::ThreadRestrictions::AssertIOAllowed();
return access(path.value().c_str(), W_OK) == 0;
diff --git a/base/file_util_unittest.cc b/base/file_util_unittest.cc
index 5576548..c73d079 100644
--- a/base/file_util_unittest.cc
+++ b/base/file_util_unittest.cc
@@ -349,18 +349,18 @@
file_util::CreateDirectory(dir_path);
FilePath normalized_file_a_path, normalized_file_b_path;
- ASSERT_FALSE(file_util::PathExists(file_a_path));
+ ASSERT_FALSE(base::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(file_util::PathExists(file_a_path));
+ ASSERT_TRUE(base::PathExists(file_a_path));
ASSERT_TRUE(file_util::NormalizeFilePath(file_a_path,
&normalized_file_a_path));
CreateTextFile(file_b_path, bogus_content);
- ASSERT_TRUE(file_util::PathExists(file_b_path));
+ ASSERT_TRUE(base::PathExists(file_b_path));
ASSERT_TRUE(file_util::NormalizeFilePath(file_b_path,
&normalized_file_b_path));
@@ -626,7 +626,7 @@
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(file_util::PathExists(temp_file));
+ EXPECT_TRUE(base::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
@@ -643,7 +643,7 @@
// 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(file_util::PathExists(temp_file));
+ EXPECT_TRUE(base::PathExists(temp_file));
EXPECT_TRUE(short_test_dir.IsParent(temp_file.DirName()));
// Check that the long path can't be determined for |temp_file|.
@@ -733,32 +733,32 @@
TEST_F(FileUtilTest, DeleteNonExistent) {
FilePath non_existent = temp_dir_.path().AppendASCII("bogus_file_dne.foobar");
- ASSERT_FALSE(file_util::PathExists(non_existent));
+ ASSERT_FALSE(base::PathExists(non_existent));
EXPECT_TRUE(base::Delete(non_existent, false));
- ASSERT_FALSE(file_util::PathExists(non_existent));
+ ASSERT_FALSE(base::PathExists(non_existent));
EXPECT_TRUE(base::Delete(non_existent, true));
- ASSERT_FALSE(file_util::PathExists(non_existent));
+ ASSERT_FALSE(base::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(file_util::PathExists(file_name));
+ ASSERT_TRUE(base::PathExists(file_name));
// Make sure it's deleted
EXPECT_TRUE(base::Delete(file_name, false));
- EXPECT_FALSE(file_util::PathExists(file_name));
+ EXPECT_FALSE(base::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(file_util::PathExists(file_name));
+ ASSERT_TRUE(base::PathExists(file_name));
// Make sure it's deleted
EXPECT_TRUE(base::Delete(file_name, true));
- EXPECT_FALSE(file_util::PathExists(file_name));
+ EXPECT_FALSE(base::PathExists(file_name));
}
#if defined(OS_POSIX)
@@ -766,7 +766,7 @@
// Create a file.
FilePath file_name = temp_dir_.path().Append(FPL("Test DeleteFile 2.txt"));
CreateTextFile(file_name, bogus_content);
- ASSERT_TRUE(file_util::PathExists(file_name));
+ ASSERT_TRUE(base::PathExists(file_name));
// Create a symlink to the file.
FilePath file_link = temp_dir_.path().Append("file_link_2");
@@ -777,14 +777,14 @@
EXPECT_TRUE(base::Delete(file_link, false));
// Make sure original file is not deleted.
- EXPECT_FALSE(file_util::PathExists(file_link));
- EXPECT_TRUE(file_util::PathExists(file_name));
+ EXPECT_FALSE(base::PathExists(file_link));
+ EXPECT_TRUE(base::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(file_util::PathExists(non_existent));
+ EXPECT_FALSE(base::PathExists(non_existent));
// Create a symlink to the non-existent file.
FilePath file_link = temp_dir_.path().Append("file_link_3");
@@ -793,7 +793,7 @@
// Make sure the symbolic link is exist.
EXPECT_TRUE(file_util::IsLink(file_link));
- EXPECT_FALSE(file_util::PathExists(file_link));
+ EXPECT_FALSE(base::PathExists(file_link));
// Delete the symbolic link.
EXPECT_TRUE(base::Delete(file_link, false));
@@ -805,7 +805,7 @@
TEST_F(FileUtilTest, ChangeFilePermissionsAndRead) {
// Create a file path.
FilePath file_name = temp_dir_.path().Append(FPL("Test Readable File.txt"));
- EXPECT_FALSE(file_util::PathExists(file_name));
+ EXPECT_FALSE(base::PathExists(file_name));
const std::string kData("hello");
@@ -815,7 +815,7 @@
// Write file.
EXPECT_EQ(static_cast<int>(kData.length()),
file_util::WriteFile(file_name, kData.data(), kData.length()));
- EXPECT_TRUE(file_util::PathExists(file_name));
+ EXPECT_TRUE(base::PathExists(file_name));
// Make sure the file is readable.
int32 mode = 0;
@@ -841,7 +841,7 @@
// Delete the file.
EXPECT_TRUE(base::Delete(file_name, false));
- EXPECT_FALSE(file_util::PathExists(file_name));
+ EXPECT_FALSE(base::PathExists(file_name));
delete[] buffer;
}
@@ -849,14 +849,14 @@
TEST_F(FileUtilTest, ChangeFilePermissionsAndWrite) {
// Create a file path.
FilePath file_name = temp_dir_.path().Append(FPL("Test Readable File.txt"));
- EXPECT_FALSE(file_util::PathExists(file_name));
+ EXPECT_FALSE(base::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(file_util::PathExists(file_name));
+ EXPECT_TRUE(base::PathExists(file_name));
// Make sure the file is writable.
int mode = 0;
@@ -886,7 +886,7 @@
// Delete the file.
EXPECT_TRUE(base::Delete(file_name, false));
- EXPECT_FALSE(file_util::PathExists(file_name));
+ EXPECT_FALSE(base::PathExists(file_name));
}
TEST_F(FileUtilTest, ChangeDirectoryPermissionsAndEnumerate) {
@@ -894,15 +894,15 @@
FilePath subdir_path =
temp_dir_.path().Append(FPL("PermissionTest1"));
file_util::CreateDirectory(subdir_path);
- ASSERT_TRUE(file_util::PathExists(subdir_path));
+ ASSERT_TRUE(base::PathExists(subdir_path));
// Create a dummy file to enumerate.
FilePath file_name = subdir_path.Append(FPL("Test Readable File.txt"));
- EXPECT_FALSE(file_util::PathExists(file_name));
+ EXPECT_FALSE(base::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(file_util::PathExists(file_name));
+ EXPECT_TRUE(base::PathExists(file_name));
// Make sure the directory has the all permissions.
int mode = 0;
@@ -917,7 +917,7 @@
// Make sure the file in the directory can't be enumerated.
FileEnumerator f1(subdir_path, true, FileEnumerator::FILES);
- EXPECT_TRUE(file_util::PathExists(subdir_path));
+ EXPECT_TRUE(base::PathExists(subdir_path));
FindResultCollector c1(f1);
EXPECT_EQ(c1.size(), 0);
EXPECT_FALSE(file_util::GetPosixFilePermissions(file_name, &mode));
@@ -938,7 +938,7 @@
// Delete the file.
EXPECT_TRUE(base::Delete(subdir_path, true));
- EXPECT_FALSE(file_util::PathExists(subdir_path));
+ EXPECT_FALSE(base::PathExists(subdir_path));
}
#endif // defined(OS_POSIX)
@@ -951,11 +951,11 @@
// Create a file and a directory
FilePath file_name = temp_dir_.path().Append(FPL("Test DeleteWildCard.txt"));
CreateTextFile(file_name, bogus_content);
- ASSERT_TRUE(file_util::PathExists(file_name));
+ ASSERT_TRUE(base::PathExists(file_name));
FilePath subdir_path = temp_dir_.path().Append(FPL("DeleteWildCardDir"));
file_util::CreateDirectory(subdir_path);
- ASSERT_TRUE(file_util::PathExists(subdir_path));
+ ASSERT_TRUE(base::PathExists(subdir_path));
// Create the wildcard path
FilePath directory_contents = temp_dir_.path();
@@ -963,13 +963,13 @@
// Delete non-recursively and check that only the file is deleted
EXPECT_TRUE(base::Delete(directory_contents, false));
- EXPECT_FALSE(file_util::PathExists(file_name));
- EXPECT_TRUE(file_util::PathExists(subdir_path));
+ EXPECT_FALSE(base::PathExists(file_name));
+ EXPECT_TRUE(base::PathExists(subdir_path));
// Delete recursively and make sure all contents are deleted
EXPECT_TRUE(base::Delete(directory_contents, true));
- EXPECT_FALSE(file_util::PathExists(file_name));
- EXPECT_FALSE(file_util::PathExists(subdir_path));
+ EXPECT_FALSE(base::PathExists(file_name));
+ EXPECT_FALSE(base::PathExists(subdir_path));
}
// TODO(erikkay): see if anyone's actually using this feature of the API
@@ -978,7 +978,7 @@
FilePath subdir_path =
temp_dir_.path().Append(FPL("DeleteNonExistantWildCard"));
file_util::CreateDirectory(subdir_path);
- ASSERT_TRUE(file_util::PathExists(subdir_path));
+ ASSERT_TRUE(base::PathExists(subdir_path));
// Create the wildcard path
FilePath directory_contents = subdir_path;
@@ -986,11 +986,11 @@
// Delete non-recursively and check nothing got deleted
EXPECT_TRUE(base::Delete(directory_contents, false));
- EXPECT_TRUE(file_util::PathExists(subdir_path));
+ EXPECT_TRUE(base::PathExists(subdir_path));
// Delete recursively and check nothing got deleted
EXPECT_TRUE(base::Delete(directory_contents, true));
- EXPECT_TRUE(file_util::PathExists(subdir_path));
+ EXPECT_TRUE(base::PathExists(subdir_path));
}
#endif
@@ -999,29 +999,29 @@
// 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(file_util::PathExists(test_subdir));
+ ASSERT_TRUE(base::PathExists(test_subdir));
FilePath file_name = test_subdir.Append(FPL("Test DeleteDir.txt"));
CreateTextFile(file_name, bogus_content);
- ASSERT_TRUE(file_util::PathExists(file_name));
+ ASSERT_TRUE(base::PathExists(file_name));
FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
file_util::CreateDirectory(subdir_path1);
- ASSERT_TRUE(file_util::PathExists(subdir_path1));
+ ASSERT_TRUE(base::PathExists(subdir_path1));
FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
file_util::CreateDirectory(subdir_path2);
- ASSERT_TRUE(file_util::PathExists(subdir_path2));
+ ASSERT_TRUE(base::PathExists(subdir_path2));
// Delete non-recursively and check that the empty dir got deleted
EXPECT_TRUE(base::Delete(subdir_path2, false));
- EXPECT_FALSE(file_util::PathExists(subdir_path2));
+ EXPECT_FALSE(base::PathExists(subdir_path2));
// Delete non-recursively and check that nothing got deleted
EXPECT_FALSE(base::Delete(test_subdir, false));
- EXPECT_TRUE(file_util::PathExists(test_subdir));
- EXPECT_TRUE(file_util::PathExists(file_name));
- EXPECT_TRUE(file_util::PathExists(subdir_path1));
+ EXPECT_TRUE(base::PathExists(test_subdir));
+ EXPECT_TRUE(base::PathExists(file_name));
+ EXPECT_TRUE(base::PathExists(subdir_path1));
}
// Tests recursive Delete() for a directory.
@@ -1029,29 +1029,29 @@
// 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(file_util::PathExists(test_subdir));
+ ASSERT_TRUE(base::PathExists(test_subdir));
FilePath file_name = test_subdir.Append(FPL("Test DeleteDirRecursive.txt"));
CreateTextFile(file_name, bogus_content);
- ASSERT_TRUE(file_util::PathExists(file_name));
+ ASSERT_TRUE(base::PathExists(file_name));
FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
file_util::CreateDirectory(subdir_path1);
- ASSERT_TRUE(file_util::PathExists(subdir_path1));
+ ASSERT_TRUE(base::PathExists(subdir_path1));
FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
file_util::CreateDirectory(subdir_path2);
- ASSERT_TRUE(file_util::PathExists(subdir_path2));
+ ASSERT_TRUE(base::PathExists(subdir_path2));
// Delete recursively and check that the empty dir got deleted
EXPECT_TRUE(base::Delete(subdir_path2, true));
- EXPECT_FALSE(file_util::PathExists(subdir_path2));
+ EXPECT_FALSE(base::PathExists(subdir_path2));
// Delete recursively and check that everything got deleted
EXPECT_TRUE(base::Delete(test_subdir, true));
- EXPECT_FALSE(file_util::PathExists(file_name));
- EXPECT_FALSE(file_util::PathExists(subdir_path1));
- EXPECT_FALSE(file_util::PathExists(test_subdir));
+ EXPECT_FALSE(base::PathExists(file_name));
+ EXPECT_FALSE(base::PathExists(subdir_path1));
+ EXPECT_FALSE(base::PathExists(test_subdir));
}
TEST_F(FileUtilTest, MoveFileNew) {
@@ -1059,18 +1059,18 @@
FilePath file_name_from =
temp_dir_.path().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(file_util::PathExists(file_name_from));
+ ASSERT_TRUE(base::PathExists(file_name_from));
// The destination.
FilePath file_name_to = temp_dir_.path().Append(
FILE_PATH_LITERAL("Move_Test_File_Destination.txt"));
- ASSERT_FALSE(file_util::PathExists(file_name_to));
+ ASSERT_FALSE(base::PathExists(file_name_to));
EXPECT_TRUE(base::Move(file_name_from, file_name_to));
// Check everything has been moved.
- EXPECT_FALSE(file_util::PathExists(file_name_from));
- EXPECT_TRUE(file_util::PathExists(file_name_to));
+ EXPECT_FALSE(base::PathExists(file_name_from));
+ EXPECT_TRUE(base::PathExists(file_name_to));
}
TEST_F(FileUtilTest, MoveFileExists) {
@@ -1078,19 +1078,19 @@
FilePath file_name_from =
temp_dir_.path().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(file_util::PathExists(file_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name_to));
+ ASSERT_TRUE(base::PathExists(file_name_to));
EXPECT_TRUE(base::Move(file_name_from, file_name_to));
// Check everything has been moved.
- EXPECT_FALSE(file_util::PathExists(file_name_from));
- EXPECT_TRUE(file_util::PathExists(file_name_to));
+ EXPECT_FALSE(base::PathExists(file_name_from));
+ EXPECT_TRUE(base::PathExists(file_name_to));
EXPECT_TRUE(L"Gooooooooooooooooooooogle" == ReadTextFile(file_name_to));
}
@@ -1099,13 +1099,13 @@
FilePath file_name_from =
temp_dir_.path().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(file_util::PathExists(file_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(dir_name_to));
+ ASSERT_TRUE(base::PathExists(dir_name_to));
EXPECT_FALSE(base::Move(file_name_from, dir_name_to));
}
@@ -1116,13 +1116,13 @@
FilePath dir_name_from =
temp_dir_.path().Append(FILE_PATH_LITERAL("Move_From_Subdir"));
file_util::CreateDirectory(dir_name_from);
- ASSERT_TRUE(file_util::PathExists(dir_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+ ASSERT_TRUE(base::PathExists(file_name_from));
// Move the directory.
FilePath dir_name_to =
@@ -1130,26 +1130,26 @@
FilePath file_name_to =
dir_name_to.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
- ASSERT_FALSE(file_util::PathExists(dir_name_to));
+ ASSERT_FALSE(base::PathExists(dir_name_to));
EXPECT_TRUE(base::Move(dir_name_from, dir_name_to));
// Check everything has been moved.
- EXPECT_FALSE(file_util::PathExists(dir_name_from));
- EXPECT_FALSE(file_util::PathExists(file_name_from));
- EXPECT_TRUE(file_util::PathExists(dir_name_to));
- EXPECT_TRUE(file_util::PathExists(file_name_to));
+ 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));
// 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(file_util::PathExists(file_name_from));
- EXPECT_FALSE(file_util::PathExists(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(file_util::PathExists(file_name_from));
- EXPECT_TRUE(file_util::PathExists(file_name_to));
+ EXPECT_FALSE(base::PathExists(file_name_from));
+ EXPECT_TRUE(base::PathExists(file_name_to));
}
TEST_F(FileUtilTest, MoveExist) {
@@ -1157,13 +1157,13 @@
FilePath dir_name_from =
temp_dir_.path().Append(FILE_PATH_LITERAL("Move_From_Subdir"));
file_util::CreateDirectory(dir_name_from);
- ASSERT_TRUE(file_util::PathExists(dir_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+ ASSERT_TRUE(base::PathExists(file_name_from));
// Move the directory
FilePath dir_name_exists =
@@ -1176,15 +1176,15 @@
// Create the destination directory.
file_util::CreateDirectory(dir_name_exists);
- ASSERT_TRUE(file_util::PathExists(dir_name_exists));
+ ASSERT_TRUE(base::PathExists(dir_name_exists));
EXPECT_TRUE(base::Move(dir_name_from, dir_name_to));
// Check everything has been moved.
- EXPECT_FALSE(file_util::PathExists(dir_name_from));
- EXPECT_FALSE(file_util::PathExists(file_name_from));
- EXPECT_TRUE(file_util::PathExists(dir_name_to));
- EXPECT_TRUE(file_util::PathExists(file_name_to));
+ 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));
}
TEST_F(FileUtilTest, CopyDirectoryRecursivelyNew) {
@@ -1192,25 +1192,25 @@
FilePath dir_name_from =
temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
file_util::CreateDirectory(dir_name_from);
- ASSERT_TRUE(file_util::PathExists(dir_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(subdir_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name2_from));
+ ASSERT_TRUE(base::PathExists(file_name2_from));
// Copy the directory recursively.
FilePath dir_name_to =
@@ -1222,19 +1222,19 @@
FilePath file_name2_to =
subdir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
- ASSERT_FALSE(file_util::PathExists(dir_name_to));
+ ASSERT_FALSE(base::PathExists(dir_name_to));
EXPECT_TRUE(base::CopyDirectory(dir_name_from, dir_name_to, true));
// Check everything has been copied.
- EXPECT_TRUE(file_util::PathExists(dir_name_from));
- EXPECT_TRUE(file_util::PathExists(file_name_from));
- EXPECT_TRUE(file_util::PathExists(subdir_name_from));
- EXPECT_TRUE(file_util::PathExists(file_name2_from));
- EXPECT_TRUE(file_util::PathExists(dir_name_to));
- EXPECT_TRUE(file_util::PathExists(file_name_to));
- EXPECT_TRUE(file_util::PathExists(subdir_name_to));
- EXPECT_TRUE(file_util::PathExists(file_name2_to));
+ 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));
}
TEST_F(FileUtilTest, CopyDirectoryRecursivelyExists) {
@@ -1242,25 +1242,25 @@
FilePath dir_name_from =
temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
file_util::CreateDirectory(dir_name_from);
- ASSERT_TRUE(file_util::PathExists(dir_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(subdir_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name2_from));
+ ASSERT_TRUE(base::PathExists(file_name2_from));
// Copy the directory recursively.
FilePath dir_name_exists =
@@ -1277,19 +1277,19 @@
// Create the destination directory.
file_util::CreateDirectory(dir_name_exists);
- ASSERT_TRUE(file_util::PathExists(dir_name_exists));
+ ASSERT_TRUE(base::PathExists(dir_name_exists));
EXPECT_TRUE(base::CopyDirectory(dir_name_from, dir_name_exists, true));
// Check everything has been copied.
- EXPECT_TRUE(file_util::PathExists(dir_name_from));
- EXPECT_TRUE(file_util::PathExists(file_name_from));
- EXPECT_TRUE(file_util::PathExists(subdir_name_from));
- EXPECT_TRUE(file_util::PathExists(file_name2_from));
- EXPECT_TRUE(file_util::PathExists(dir_name_to));
- EXPECT_TRUE(file_util::PathExists(file_name_to));
- EXPECT_TRUE(file_util::PathExists(subdir_name_to));
- EXPECT_TRUE(file_util::PathExists(file_name2_to));
+ 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));
}
TEST_F(FileUtilTest, CopyDirectoryNew) {
@@ -1297,25 +1297,25 @@
FilePath dir_name_from =
temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
file_util::CreateDirectory(dir_name_from);
- ASSERT_TRUE(file_util::PathExists(dir_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(subdir_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name2_from));
+ ASSERT_TRUE(base::PathExists(file_name2_from));
// Copy the directory not recursively.
FilePath dir_name_to =
@@ -1325,18 +1325,18 @@
FilePath subdir_name_to =
dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
- ASSERT_FALSE(file_util::PathExists(dir_name_to));
+ ASSERT_FALSE(base::PathExists(dir_name_to));
EXPECT_TRUE(base::CopyDirectory(dir_name_from, dir_name_to, false));
// Check everything has been copied.
- EXPECT_TRUE(file_util::PathExists(dir_name_from));
- EXPECT_TRUE(file_util::PathExists(file_name_from));
- EXPECT_TRUE(file_util::PathExists(subdir_name_from));
- EXPECT_TRUE(file_util::PathExists(file_name2_from));
- EXPECT_TRUE(file_util::PathExists(dir_name_to));
- EXPECT_TRUE(file_util::PathExists(file_name_to));
- EXPECT_FALSE(file_util::PathExists(subdir_name_to));
+ 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));
}
TEST_F(FileUtilTest, CopyDirectoryExists) {
@@ -1344,25 +1344,25 @@
FilePath dir_name_from =
temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
file_util::CreateDirectory(dir_name_from);
- ASSERT_TRUE(file_util::PathExists(dir_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(subdir_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name2_from));
+ ASSERT_TRUE(base::PathExists(file_name2_from));
// Copy the directory not recursively.
FilePath dir_name_to =
@@ -1374,18 +1374,18 @@
// Create the destination directory.
file_util::CreateDirectory(dir_name_to);
- ASSERT_TRUE(file_util::PathExists(dir_name_to));
+ ASSERT_TRUE(base::PathExists(dir_name_to));
EXPECT_TRUE(base::CopyDirectory(dir_name_from, dir_name_to, false));
// Check everything has been copied.
- EXPECT_TRUE(file_util::PathExists(dir_name_from));
- EXPECT_TRUE(file_util::PathExists(file_name_from));
- EXPECT_TRUE(file_util::PathExists(subdir_name_from));
- EXPECT_TRUE(file_util::PathExists(file_name2_from));
- EXPECT_TRUE(file_util::PathExists(dir_name_to));
- EXPECT_TRUE(file_util::PathExists(file_name_to));
- EXPECT_FALSE(file_util::PathExists(subdir_name_to));
+ 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));
}
TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToNew) {
@@ -1393,17 +1393,17 @@
FilePath file_name_from =
temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(file_util::PathExists(file_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name_to));
+ ASSERT_FALSE(base::PathExists(file_name_to));
EXPECT_TRUE(base::CopyDirectory(file_name_from, file_name_to, true));
// Check the has been copied
- EXPECT_TRUE(file_util::PathExists(file_name_to));
+ EXPECT_TRUE(base::PathExists(file_name_to));
}
TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToExisting) {
@@ -1411,18 +1411,18 @@
FilePath file_name_from =
temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(file_util::PathExists(file_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name_to));
+ ASSERT_TRUE(base::PathExists(file_name_to));
EXPECT_TRUE(base::CopyDirectory(file_name_from, file_name_to, true));
// Check the has been copied
- EXPECT_TRUE(file_util::PathExists(file_name_to));
+ EXPECT_TRUE(base::PathExists(file_name_to));
EXPECT_TRUE(L"Gooooooooooooooooooooogle" == ReadTextFile(file_name_to));
}
@@ -1431,20 +1431,20 @@
FilePath file_name_from =
temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
- ASSERT_TRUE(file_util::PathExists(file_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(dir_name_to));
+ ASSERT_TRUE(base::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));
// Check the has been copied
- EXPECT_TRUE(file_util::PathExists(file_name_to));
+ EXPECT_TRUE(base::PathExists(file_name_to));
}
TEST_F(FileUtilTest, CopyDirectoryWithTrailingSeparators) {
@@ -1452,13 +1452,13 @@
FilePath dir_name_from =
temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
file_util::CreateDirectory(dir_name_from);
- ASSERT_TRUE(file_util::PathExists(dir_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+ ASSERT_TRUE(base::PathExists(file_name_from));
// Copy the directory recursively.
FilePath dir_name_to =
@@ -1478,10 +1478,10 @@
EXPECT_TRUE(base::CopyDirectory(from_path, dir_name_to, true));
// Check everything has been copied.
- EXPECT_TRUE(file_util::PathExists(dir_name_from));
- EXPECT_TRUE(file_util::PathExists(file_name_from));
- EXPECT_TRUE(file_util::PathExists(dir_name_to));
- EXPECT_TRUE(file_util::PathExists(file_name_to));
+ 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));
}
TEST_F(FileUtilTest, CopyFile) {
@@ -1489,14 +1489,14 @@
FilePath dir_name_from =
temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
file_util::CreateDirectory(dir_name_from);
- ASSERT_TRUE(file_util::PathExists(dir_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+ ASSERT_TRUE(base::PathExists(file_name_from));
// Copy the file.
FilePath dest_file = dir_name_from.Append(FILE_PATH_LITERAL("DestFile.txt"));
@@ -1514,12 +1514,12 @@
dest_file2_test = dest_file2_test.AppendASCII("DestFile.txt");
// Check everything has been copied.
- EXPECT_TRUE(file_util::PathExists(file_name_from));
- EXPECT_TRUE(file_util::PathExists(dest_file));
+ EXPECT_TRUE(base::PathExists(file_name_from));
+ EXPECT_TRUE(base::PathExists(dest_file));
const std::wstring read_contents = ReadTextFile(dest_file);
EXPECT_EQ(file_contents, read_contents);
- EXPECT_TRUE(file_util::PathExists(dest_file2_test));
- EXPECT_TRUE(file_util::PathExists(dest_file2));
+ EXPECT_TRUE(base::PathExists(dest_file2_test));
+ EXPECT_TRUE(base::PathExists(dest_file2));
}
// file_util winds up using autoreleased objects on the Mac, so this needs
@@ -1530,7 +1530,7 @@
FilePath data_dir;
ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &data_dir));
data_dir = data_dir.AppendASCII("file_util");
- ASSERT_TRUE(file_util::PathExists(data_dir));
+ ASSERT_TRUE(base::PathExists(data_dir));
FilePath original_file =
data_dir.Append(FILE_PATH_LITERAL("original.txt"));
@@ -1577,7 +1577,7 @@
FilePath data_dir;
ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &data_dir));
data_dir = data_dir.AppendASCII("file_util");
- ASSERT_TRUE(file_util::PathExists(data_dir));
+ ASSERT_TRUE(base::PathExists(data_dir));
FilePath original_file =
data_dir.Append(FILE_PATH_LITERAL("original.txt"));
@@ -1628,13 +1628,13 @@
FilePath dir_name_from =
temp_dir_.path().Append(FILE_PATH_LITERAL("CopyAndDelete_From_Subdir"));
file_util::CreateDirectory(dir_name_from);
- ASSERT_TRUE(file_util::PathExists(dir_name_from));
+ ASSERT_TRUE(base::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(file_util::PathExists(file_name_from));
+ ASSERT_TRUE(base::PathExists(file_name_from));
// Move the directory by using CopyAndDeleteDirectory
FilePath dir_name_to = temp_dir_.path().Append(
@@ -1642,16 +1642,16 @@
FilePath file_name_to =
dir_name_to.Append(FILE_PATH_LITERAL("CopyAndDelete_Test_File.txt"));
- ASSERT_FALSE(file_util::PathExists(dir_name_to));
+ ASSERT_FALSE(base::PathExists(dir_name_to));
EXPECT_TRUE(base::internal::CopyAndDeleteDirectory(dir_name_from,
dir_name_to));
// Check everything has been moved.
- EXPECT_FALSE(file_util::PathExists(dir_name_from));
- EXPECT_FALSE(file_util::PathExists(file_name_from));
- EXPECT_TRUE(file_util::PathExists(dir_name_to));
- EXPECT_TRUE(file_util::PathExists(file_name_to));
+ 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));
}
TEST_F(FileUtilTest, GetTempDirTest) {
@@ -1687,7 +1687,7 @@
FilePath temp_files[3];
for (int i = 0; i < 3; i++) {
ASSERT_TRUE(file_util::CreateTemporaryFile(&(temp_files[i])));
- EXPECT_TRUE(file_util::PathExists(temp_files[i]));
+ EXPECT_TRUE(base::PathExists(temp_files[i]));
EXPECT_FALSE(file_util::DirectoryExists(temp_files[i]));
}
for (int i = 0; i < 3; i++)
@@ -1705,7 +1705,7 @@
for (i = 0; i < 3; ++i) {
fps[i] = file_util::CreateAndOpenTemporaryFile(&(names[i]));
ASSERT_TRUE(fps[i]);
- EXPECT_TRUE(file_util::PathExists(names[i]));
+ EXPECT_TRUE(base::PathExists(names[i]));
}
// Make sure all names are unique.
@@ -1724,7 +1724,7 @@
FilePath temp_dir;
ASSERT_TRUE(file_util::CreateNewTempDirectory(FilePath::StringType(),
&temp_dir));
- EXPECT_TRUE(file_util::PathExists(temp_dir));
+ EXPECT_TRUE(base::PathExists(temp_dir));
EXPECT_TRUE(base::Delete(temp_dir, false));
}
@@ -1734,7 +1734,7 @@
temp_dir_.path(),
FILE_PATH_LITERAL("CreateNewTemporaryDirInDirTest"),
&new_dir));
- EXPECT_TRUE(file_util::PathExists(new_dir));
+ EXPECT_TRUE(base::PathExists(new_dir));
EXPECT_TRUE(temp_dir_.path().IsParent(new_dir));
EXPECT_TRUE(base::Delete(new_dir, false));
}
@@ -1756,22 +1756,22 @@
test_root.Append(FILE_PATH_LITERAL("dir/tree/likely/doesnt/exist/"));
#endif
- EXPECT_FALSE(file_util::PathExists(test_path));
+ EXPECT_FALSE(base::PathExists(test_path));
EXPECT_TRUE(file_util::CreateDirectory(test_path));
- EXPECT_TRUE(file_util::PathExists(test_path));
+ EXPECT_TRUE(base::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(file_util::PathExists(test_path));
+ EXPECT_FALSE(base::PathExists(test_path));
CreateTextFile(test_path, L"test file");
- EXPECT_TRUE(file_util::PathExists(test_path));
+ EXPECT_TRUE(base::PathExists(test_path));
EXPECT_FALSE(file_util::CreateDirectory(test_path));
EXPECT_TRUE(base::Delete(test_root, true));
- EXPECT_FALSE(file_util::PathExists(test_root));
- EXPECT_FALSE(file_util::PathExists(test_path));
+ EXPECT_FALSE(base::PathExists(test_root));
+ EXPECT_FALSE(base::PathExists(test_path));
// Verify assumptions made by the Windows implementation:
// 1. The current directory always exists.
@@ -1794,7 +1794,7 @@
FilePath invalid_drive(FILE_PATH_LITERAL("o:\\"));
FilePath invalid_path =
invalid_drive.Append(FILE_PATH_LITERAL("some\\inaccessible\\dir"));
- if (!file_util::PathExists(invalid_drive)) {
+ if (!base::PathExists(invalid_drive)) {
EXPECT_FALSE(file_util::CreateDirectory(invalid_path));
}
#endif
@@ -1804,16 +1804,16 @@
// Check a directory
FilePath test_root =
temp_dir_.path().Append(FILE_PATH_LITERAL("detect_directory_test"));
- EXPECT_FALSE(file_util::PathExists(test_root));
+ EXPECT_FALSE(base::PathExists(test_root));
EXPECT_TRUE(file_util::CreateDirectory(test_root));
- EXPECT_TRUE(file_util::PathExists(test_root));
+ EXPECT_TRUE(base::PathExists(test_root));
EXPECT_TRUE(file_util::DirectoryExists(test_root));
// Check a file
FilePath test_path =
test_root.Append(FILE_PATH_LITERAL("foobar.txt"));
- EXPECT_FALSE(file_util::PathExists(test_path));
+ EXPECT_FALSE(base::PathExists(test_path));
CreateTextFile(test_path, L"test file");
- EXPECT_TRUE(file_util::PathExists(test_path));
+ EXPECT_TRUE(base::PathExists(test_path));
EXPECT_FALSE(file_util::DirectoryExists(test_path));
EXPECT_TRUE(base::Delete(test_path, false));
@@ -1934,13 +1934,13 @@
temp_dir_.path().Append(FILE_PATH_LITERAL("FilePathTest"));
// Create a fresh, empty copy of this directory.
- if (file_util::PathExists(data_dir)) {
+ if (base::PathExists(data_dir)) {
ASSERT_TRUE(base::Delete(data_dir, true));
}
ASSERT_TRUE(file_util::CreateDirectory(data_dir));
// Create a fresh, empty copy of this directory.
- if (file_util::PathExists(data_dir)) {
+ if (base::PathExists(data_dir)) {
ASSERT_TRUE(base::Delete(data_dir, true));
}
ASSERT_TRUE(file_util::CreateDirectory(data_dir));
@@ -1962,7 +1962,7 @@
temp_dir_.path().Append(FILE_PATH_LITERAL("FilePathTest"));
// Create a fresh, empty copy of this directory.
- if (file_util::PathExists(data_dir)) {
+ if (base::PathExists(data_dir)) {
ASSERT_TRUE(base::Delete(data_dir, true));
}
ASSERT_TRUE(file_util::CreateDirectory(data_dir));
@@ -1995,7 +1995,7 @@
TEST_F(FileUtilTest, IsDirectoryEmpty) {
FilePath empty_dir = temp_dir_.path().Append(FILE_PATH_LITERAL("EmptyDir"));
- ASSERT_FALSE(file_util::PathExists(empty_dir));
+ ASSERT_FALSE(base::PathExists(empty_dir));
ASSERT_TRUE(file_util::CreateDirectory(empty_dir));
@@ -2123,7 +2123,7 @@
<< "Failed to create symlink.";
FilePath file_path_with_link = link_to_sub_dir.AppendASCII("file.txt");
- ASSERT_TRUE(file_util::PathExists(file_path_with_link));
+ ASSERT_TRUE(base::PathExists(file_path_with_link));
EXPECT_FALSE(
file_util::VerifyPathControlledByUser(
diff --git a/base/files/file_path_watcher_linux.cc b/base/files/file_path_watcher_linux.cc
index 8cf95ed..b9270ee 100644
--- a/base/files/file_path_watcher_linux.cc
+++ b/base/files/file_path_watcher_linux.cc
@@ -351,7 +351,7 @@
// recheck.
if (target_changed ||
(change_on_target_path && !created) ||
- (change_on_target_path && file_util::PathExists(target_))) {
+ (change_on_target_path && PathExists(target_))) {
callback_.Run(target_, false);
return;
}
diff --git a/base/files/file_util_proxy.cc b/base/files/file_util_proxy.cc
index 9f65da8..5eb9fe5 100644
--- a/base/files/file_util_proxy.cc
+++ b/base/files/file_util_proxy.cc
@@ -107,7 +107,7 @@
: error_(PLATFORM_FILE_OK) {}
void RunWorkForFilePath(const FilePath& file_path) {
- if (!file_util::PathExists(file_path)) {
+ if (!PathExists(file_path)) {
error_ = PLATFORM_FILE_ERROR_NOT_FOUND;
return;
}
@@ -210,7 +210,7 @@
}
PlatformFileError DeleteAdapter(const FilePath& file_path, bool recursive) {
- if (!file_util::PathExists(file_path)) {
+ if (!PathExists(file_path)) {
return PLATFORM_FILE_ERROR_NOT_FOUND;
}
if (!base::Delete(file_path, recursive)) {
diff --git a/base/files/file_util_proxy_unittest.cc b/base/files/file_util_proxy_unittest.cc
index f524ba4..e8680bb 100644
--- a/base/files/file_util_proxy_unittest.cc
+++ b/base/files/file_util_proxy_unittest.cc
@@ -128,13 +128,13 @@
EXPECT_EQ(PLATFORM_FILE_OK, error_);
EXPECT_TRUE(created_);
EXPECT_NE(kInvalidPlatformFileValue, file_);
- EXPECT_TRUE(file_util::PathExists(test_path()));
+ EXPECT_TRUE(PathExists(test_path()));
}
TEST_F(FileUtilProxyTest, CreateOrOpen_Open) {
// Creates a file.
file_util::WriteFile(test_path(), NULL, 0);
- ASSERT_TRUE(file_util::PathExists(test_path()));
+ ASSERT_TRUE(PathExists(test_path()));
// Opens the created file.
FileUtilProxy::CreateOrOpen(
@@ -159,7 +159,7 @@
EXPECT_EQ(PLATFORM_FILE_ERROR_NOT_FOUND, error_);
EXPECT_FALSE(created_);
EXPECT_EQ(kInvalidPlatformFileValue, file_);
- EXPECT_FALSE(file_util::PathExists(test_path()));
+ EXPECT_FALSE(PathExists(test_path()));
}
TEST_F(FileUtilProxyTest, Close) {
@@ -190,7 +190,7 @@
Bind(&FileUtilProxyTest::DidCreateTemporary, weak_factory_.GetWeakPtr()));
MessageLoop::current()->Run();
EXPECT_EQ(PLATFORM_FILE_OK, error_);
- EXPECT_TRUE(file_util::PathExists(path_));
+ EXPECT_TRUE(PathExists(path_));
EXPECT_NE(kInvalidPlatformFileValue, file_);
// The file should be writable.
diff --git a/base/files/important_file_writer_unittest.cc b/base/files/important_file_writer_unittest.cc
index 759436c..3f24d10 100644
--- a/base/files/important_file_writer_unittest.cc
+++ b/base/files/important_file_writer_unittest.cc
@@ -61,11 +61,11 @@
TEST_F(ImportantFileWriterTest, Basic) {
ImportantFileWriter writer(file_, MessageLoopProxy::current().get());
- EXPECT_FALSE(file_util::PathExists(writer.path()));
+ EXPECT_FALSE(PathExists(writer.path()));
writer.WriteNow("foo");
RunLoop().RunUntilIdle();
- ASSERT_TRUE(file_util::PathExists(writer.path()));
+ ASSERT_TRUE(PathExists(writer.path()));
EXPECT_EQ("foo", GetFileContent(writer.path()));
}
@@ -82,7 +82,7 @@
TimeDelta::FromMilliseconds(100));
MessageLoop::current()->Run();
EXPECT_FALSE(writer.HasPendingWrite());
- ASSERT_TRUE(file_util::PathExists(writer.path()));
+ ASSERT_TRUE(PathExists(writer.path()));
EXPECT_EQ("foo", GetFileContent(writer.path()));
}
@@ -99,7 +99,7 @@
TimeDelta::FromMilliseconds(100));
MessageLoop::current()->Run();
EXPECT_FALSE(writer.HasPendingWrite());
- ASSERT_TRUE(file_util::PathExists(writer.path()));
+ ASSERT_TRUE(PathExists(writer.path()));
EXPECT_EQ("foo", GetFileContent(writer.path()));
}
@@ -115,7 +115,7 @@
MessageLoop::QuitWhenIdleClosure(),
TimeDelta::FromMilliseconds(100));
MessageLoop::current()->Run();
- ASSERT_TRUE(file_util::PathExists(writer.path()));
+ ASSERT_TRUE(PathExists(writer.path()));
EXPECT_EQ("baz", GetFileContent(writer.path()));
}
diff --git a/base/json/json_file_value_serializer.cc b/base/json/json_file_value_serializer.cc
index d6cff33..37371e8 100644
--- a/base/json/json_file_value_serializer.cc
+++ b/base/json/json_file_value_serializer.cc
@@ -55,7 +55,7 @@
return JSON_ACCESS_DENIED;
}
#endif
- if (!file_util::PathExists(json_file_path_))
+ if (!base::PathExists(json_file_path_))
return JSON_NO_SUCH_FILE;
else
return JSON_CANNOT_READ_FILE;
diff --git a/base/json/json_reader_unittest.cc b/base/json/json_reader_unittest.cc
index 0180f48..41650b4 100644
--- a/base/json/json_reader_unittest.cc
+++ b/base/json/json_reader_unittest.cc
@@ -544,7 +544,7 @@
FilePath path;
ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &path));
path = path.AppendASCII("json");
- ASSERT_TRUE(file_util::PathExists(path));
+ ASSERT_TRUE(base::PathExists(path));
std::string input;
ASSERT_TRUE(file_util::ReadFileToString(
diff --git a/base/json/json_value_serializer_unittest.cc b/base/json/json_value_serializer_unittest.cc
index 78be11e..ce7129f 100644
--- a/base/json/json_value_serializer_unittest.cc
+++ b/base/json/json_value_serializer_unittest.cc
@@ -385,7 +385,7 @@
original_file_path =
original_file_path.Append(FILE_PATH_LITERAL("serializer_test.json"));
- ASSERT_TRUE(file_util::PathExists(original_file_path));
+ ASSERT_TRUE(PathExists(original_file_path));
JSONFileValueSerializer deserializer(original_file_path);
scoped_ptr<Value> root;
@@ -417,10 +417,10 @@
const base::FilePath written_file_path =
temp_dir_.path().Append(FILE_PATH_LITERAL("test_output.js"));
- ASSERT_FALSE(file_util::PathExists(written_file_path));
+ ASSERT_FALSE(PathExists(written_file_path));
JSONFileValueSerializer serializer(written_file_path);
ASSERT_TRUE(serializer.Serialize(*root));
- ASSERT_TRUE(file_util::PathExists(written_file_path));
+ ASSERT_TRUE(PathExists(written_file_path));
// Now compare file contents.
EXPECT_TRUE(file_util::TextContentsEqual(original_file_path,
@@ -434,7 +434,7 @@
original_file_path = original_file_path.Append(
FILE_PATH_LITERAL("serializer_nested_test.json"));
- ASSERT_TRUE(file_util::PathExists(original_file_path));
+ ASSERT_TRUE(PathExists(original_file_path));
JSONFileValueSerializer deserializer(original_file_path);
scoped_ptr<Value> root;
@@ -445,10 +445,10 @@
base::FilePath written_file_path = temp_dir_.path().Append(
FILE_PATH_LITERAL("test_output.json"));
- ASSERT_FALSE(file_util::PathExists(written_file_path));
+ ASSERT_FALSE(PathExists(written_file_path));
JSONFileValueSerializer serializer(written_file_path);
ASSERT_TRUE(serializer.Serialize(*root));
- ASSERT_TRUE(file_util::PathExists(written_file_path));
+ ASSERT_TRUE(PathExists(written_file_path));
// Now compare file contents.
EXPECT_TRUE(file_util::TextContentsEqual(original_file_path,
@@ -461,7 +461,7 @@
ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &source_file_path));
source_file_path = source_file_path.Append(
FILE_PATH_LITERAL("serializer_test_nowhitespace.json"));
- ASSERT_TRUE(file_util::PathExists(source_file_path));
+ ASSERT_TRUE(PathExists(source_file_path));
JSONFileValueSerializer serializer(source_file_path);
scoped_ptr<Value> root;
root.reset(serializer.Deserialize(NULL, NULL));
diff --git a/base/memory/shared_memory_posix.cc b/base/memory/shared_memory_posix.cc
index 2be787d..93e0b76 100644
--- a/base/memory/shared_memory_posix.cc
+++ b/base/memory/shared_memory_posix.cc
@@ -236,9 +236,8 @@
if (!FilePathForMemoryName(name, &path))
return false;
- if (file_util::PathExists(path)) {
+ if (PathExists(path))
return base::Delete(path, false);
- }
// Doesn't exist, so success.
return true;
diff --git a/base/nix/mime_util_xdg.cc b/base/nix/mime_util_xdg.cc
index a611e4d..7c1d660 100644
--- a/base/nix/mime_util_xdg.cc
+++ b/base/nix/mime_util_xdg.cc
@@ -171,7 +171,7 @@
if (!file_util::DirectoryExists(theme_path))
continue;
FilePath theme_index = theme_path.Append("index.theme");
- if (!index_theme_loaded_ && file_util::PathExists(theme_index)) {
+ if (!index_theme_loaded_ && PathExists(theme_index)) {
if (!LoadIndexTheme(theme_index))
return;
index_theme_loaded_ = true;
@@ -248,7 +248,7 @@
for (size_t i = 0; i < icon_formats->size(); ++i) {
icon_path = dir_iter->Append(subdir);
icon_path = icon_path.Append(icon_name + (*icon_formats)[i]);
- if (file_util::PathExists(icon_path))
+ if (PathExists(icon_path))
return icon_path;
}
}
@@ -490,7 +490,7 @@
for (iter = icon_dirs->begin(); iter != icon_dirs->end(); ++iter) {
for (size_t i = 0; i < icon_formats->size(); ++i) {
FilePath icon = iter->first.Append(icon_name + (*icon_formats)[i]);
- if (file_util::PathExists(icon))
+ if (PathExists(icon))
return icon;
}
}
@@ -640,7 +640,7 @@
for (size_t i = 0; i < icon_names.size(); i++) {
if (icon_names[i][0] == '/') {
icon_file = FilePath(icon_names[i]);
- if (file_util::PathExists(icon_file))
+ if (PathExists(icon_file))
return icon_file;
} else {
icon_file = LookupIconInDefaultTheme(icon_names[i], size);
diff --git a/base/path_service.cc b/base/path_service.cc
index 5cfb1ef..89e58b2 100644
--- a/base/path_service.cc
+++ b/base/path_service.cc
@@ -253,7 +253,7 @@
// Make sure the directory exists. We need to do this before we translate
// this to the absolute path because on POSIX, MakeAbsoluteFilePath fails
// if called on a non-existent path.
- if (!file_util::PathExists(file_path) &&
+ if (!base::PathExists(file_path) &&
!file_util::CreateDirectory(file_path))
return false;
}
diff --git a/base/path_service_unittest.cc b/base/path_service_unittest.cc
index 68565cc..fbb2d76 100644
--- a/base/path_service_unittest.cc
+++ b/base/path_service_unittest.cc
@@ -73,7 +73,7 @@
return false;
#endif
return result && !path.empty() && (!check_path_exists ||
- file_util::PathExists(path));
+ base::PathExists(path));
}
#if defined(OS_WIN)
@@ -156,18 +156,18 @@
// PathService::Override should always create the path provided if it doesn't
// exist.
EXPECT_TRUE(PathService::Override(my_special_key, fake_cache_dir));
- EXPECT_TRUE(file_util::PathExists(fake_cache_dir));
+ EXPECT_TRUE(base::PathExists(fake_cache_dir));
base::FilePath fake_cache_dir2(temp_dir.path().AppendASCII("cache2"));
// PathService::OverrideAndCreateIfNeeded should obey the |create| parameter.
PathService::OverrideAndCreateIfNeeded(my_special_key,
fake_cache_dir2,
false);
- EXPECT_FALSE(file_util::PathExists(fake_cache_dir2));
+ EXPECT_FALSE(base::PathExists(fake_cache_dir2));
EXPECT_TRUE(PathService::OverrideAndCreateIfNeeded(my_special_key,
fake_cache_dir2,
true));
- EXPECT_TRUE(file_util::PathExists(fake_cache_dir2));
+ EXPECT_TRUE(base::PathExists(fake_cache_dir2));
}
// Check if multiple overrides can co-exist.
@@ -177,21 +177,21 @@
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
base::FilePath fake_cache_dir1(temp_dir.path().AppendASCII("1"));
EXPECT_TRUE(PathService::Override(my_special_key, fake_cache_dir1));
- EXPECT_TRUE(file_util::PathExists(fake_cache_dir1));
+ EXPECT_TRUE(base::PathExists(fake_cache_dir1));
ASSERT_EQ(1, file_util::WriteFile(fake_cache_dir1.AppendASCII("t1"), ".", 1));
base::FilePath fake_cache_dir2(temp_dir.path().AppendASCII("2"));
EXPECT_TRUE(PathService::Override(my_special_key + 1, fake_cache_dir2));
- EXPECT_TRUE(file_util::PathExists(fake_cache_dir2));
+ EXPECT_TRUE(base::PathExists(fake_cache_dir2));
ASSERT_EQ(1, file_util::WriteFile(fake_cache_dir2.AppendASCII("t2"), ".", 1));
base::FilePath result;
EXPECT_TRUE(PathService::Get(my_special_key, &result));
// Override might have changed the path representation but our test file
// should be still there.
- EXPECT_TRUE(file_util::PathExists(result.AppendASCII("t1")));
+ EXPECT_TRUE(base::PathExists(result.AppendASCII("t1")));
EXPECT_TRUE(PathService::Get(my_special_key + 1, &result));
- EXPECT_TRUE(file_util::PathExists(result.AppendASCII("t2")));
+ EXPECT_TRUE(base::PathExists(result.AppendASCII("t2")));
}
TEST_F(PathServiceTest, RemoveOverride) {
diff --git a/base/platform_file_unittest.cc b/base/platform_file_unittest.cc
index 0ba7782..a1f3927 100644
--- a/base/platform_file_unittest.cc
+++ b/base/platform_file_unittest.cc
@@ -103,7 +103,7 @@
EXPECT_EQ(base::PLATFORM_FILE_OK, error_code);
EXPECT_TRUE(base::ClosePlatformFile(file));
- EXPECT_FALSE(file_util::PathExists(file_path));
+ EXPECT_FALSE(base::PathExists(file_path));
}
TEST(PlatformFile, DeleteOpenFile) {
@@ -139,7 +139,7 @@
// Close both handles and check that the file is gone.
base::ClosePlatformFile(file);
base::ClosePlatformFile(same_file);
- EXPECT_FALSE(file_util::PathExists(file_path));
+ EXPECT_FALSE(base::PathExists(file_path));
}
TEST(PlatformFile, ReadWritePlatformFile) {
diff --git a/base/prefs/json_pref_store.cc b/base/prefs/json_pref_store.cc
index ff3c232..0b93f74 100644
--- a/base/prefs/json_pref_store.cc
+++ b/base/prefs/json_pref_store.cc
@@ -69,7 +69,7 @@
JSONFileValueSerializer serializer(path);
base::Value* value = serializer.Deserialize(&error_code, &error_msg);
HandleErrors(value, path, error_code, error_msg, error);
- *no_dir = !file_util::PathExists(path.DirName());
+ *no_dir = !base::PathExists(path.DirName());
return value;
}
@@ -128,7 +128,7 @@
// If they've ever had a parse error before, put them in another bucket.
// TODO(erikkay) if we keep this error checking for very long, we may
// want to differentiate between recent and long ago errors.
- if (file_util::PathExists(bad))
+ if (base::PathExists(bad))
*error = PersistentPrefStore::PREF_READ_ERROR_JSON_REPEAT;
base::Move(path, bad);
break;
diff --git a/base/prefs/json_pref_store_unittest.cc b/base/prefs/json_pref_store_unittest.cc
index c3b89a0..5c506d4 100644
--- a/base/prefs/json_pref_store_unittest.cc
+++ b/base/prefs/json_pref_store_unittest.cc
@@ -44,7 +44,7 @@
ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &data_dir_));
data_dir_ = data_dir_.AppendASCII("prefs");
- ASSERT_TRUE(file_util::PathExists(data_dir_));
+ ASSERT_TRUE(PathExists(data_dir_));
}
// The path to temporary directory used to contain the test operations.
@@ -58,7 +58,7 @@
// Test fallback behavior for a nonexistent file.
TEST_F(JsonPrefStoreTest, NonExistentFile) {
base::FilePath bogus_input_file = data_dir_.AppendASCII("read.txt");
- ASSERT_FALSE(file_util::PathExists(bogus_input_file));
+ ASSERT_FALSE(PathExists(bogus_input_file));
scoped_refptr<JsonPrefStore> pref_store = new JsonPrefStore(
bogus_input_file, message_loop_.message_loop_proxy().get());
EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NO_FILE,
@@ -78,9 +78,9 @@
EXPECT_FALSE(pref_store->ReadOnly());
// The file should have been moved aside.
- EXPECT_FALSE(file_util::PathExists(invalid_file));
+ EXPECT_FALSE(PathExists(invalid_file));
base::FilePath moved_aside = temp_dir_.path().AppendASCII("invalid.bad");
- EXPECT_TRUE(file_util::PathExists(moved_aside));
+ EXPECT_TRUE(PathExists(moved_aside));
EXPECT_TRUE(file_util::TextContentsEqual(invalid_file_original,
moved_aside));
}
@@ -144,7 +144,7 @@
EXPECT_EQ(214748364842LL, value);
// Serialize and compare to expected output.
- ASSERT_TRUE(file_util::PathExists(golden_output_file));
+ ASSERT_TRUE(PathExists(golden_output_file));
pref_store->CommitPendingWrite();
RunLoop().RunUntilIdle();
EXPECT_TRUE(file_util::TextContentsEqual(golden_output_file, output_file));
@@ -157,7 +157,7 @@
// Test that the persistent value can be loaded.
base::FilePath input_file = temp_dir_.path().AppendASCII("write.json");
- ASSERT_TRUE(file_util::PathExists(input_file));
+ ASSERT_TRUE(PathExists(input_file));
scoped_refptr<JsonPrefStore> pref_store =
new JsonPrefStore(input_file, message_loop_.message_loop_proxy().get());
ASSERT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE, pref_store->ReadPrefs());
@@ -183,7 +183,7 @@
// Test that the persistent value can be loaded.
base::FilePath input_file = temp_dir_.path().AppendASCII("write.json");
- ASSERT_TRUE(file_util::PathExists(input_file));
+ ASSERT_TRUE(PathExists(input_file));
scoped_refptr<JsonPrefStore> pref_store =
new JsonPrefStore(input_file, message_loop_.message_loop_proxy().get());
@@ -220,7 +220,7 @@
// Tests asynchronous reading of the file when there is no file.
TEST_F(JsonPrefStoreTest, AsyncNonExistingFile) {
base::FilePath bogus_input_file = data_dir_.AppendASCII("read.txt");
- ASSERT_FALSE(file_util::PathExists(bogus_input_file));
+ ASSERT_FALSE(PathExists(bogus_input_file));
scoped_refptr<JsonPrefStore> pref_store = new JsonPrefStore(
bogus_input_file, message_loop_.message_loop_proxy().get());
MockPrefStoreObserver mock_observer;
@@ -246,7 +246,7 @@
pref_file));
// Test that the persistent value can be loaded.
- ASSERT_TRUE(file_util::PathExists(pref_file));
+ ASSERT_TRUE(PathExists(pref_file));
scoped_refptr<JsonPrefStore> pref_store =
new JsonPrefStore(pref_file, message_loop_.message_loop_proxy().get());
ASSERT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE, pref_store->ReadPrefs());
@@ -281,7 +281,7 @@
// Compare to expected output.
base::FilePath golden_output_file =
data_dir_.AppendASCII("write.golden.need_empty_value.json");
- ASSERT_TRUE(file_util::PathExists(golden_output_file));
+ ASSERT_TRUE(PathExists(golden_output_file));
EXPECT_TRUE(file_util::TextContentsEqual(golden_output_file, pref_file));
}
diff --git a/base/process/memory_linux.cc b/base/process/memory_linux.cc
index 81cf20c..53afa1a 100644
--- a/base/process/memory_linux.cc
+++ b/base/process/memory_linux.cc
@@ -150,7 +150,7 @@
// Attempt to write the newer oom_score_adj file first.
FilePath oom_file = oom_path.AppendASCII("oom_score_adj");
- if (file_util::PathExists(oom_file)) {
+ if (PathExists(oom_file)) {
std::string score_str = IntToString(score);
DVLOG(1) << "Adjusting oom_score_adj of " << process << " to "
<< score_str;
@@ -163,7 +163,7 @@
// If the oom_score_adj file doesn't exist, then we write the old
// style file and translate the oom_adj score to the range 0-15.
oom_file = oom_path.AppendASCII("oom_adj");
- if (file_util::PathExists(oom_file)) {
+ if (PathExists(oom_file)) {
// Max score for the old oom_adj range. Used for conversion of new
// values to old values.
const int kMaxOldOomScore = 15;
diff --git a/ipc/ipc_channel_posix.cc b/ipc/ipc_channel_posix.cc
index d637232..f685dc0 100644
--- a/ipc/ipc_channel_posix.cc
+++ b/ipc/ipc_channel_posix.cc
@@ -580,7 +580,7 @@
// static
bool Channel::ChannelImpl::IsNamedServerInitialized(
const std::string& channel_id) {
- return file_util::PathExists(base::FilePath(channel_id));
+ return base::PathExists(base::FilePath(channel_id));
}
#if defined(OS_LINUX)