Move GetFileSize, NormalizeFilePath to base namespace
BUG=
R=viettrungluu@chromium.org
Review URL: https://codereview.chromium.org/102873002
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@238722 0039d316-1c4b-4281-b951-d872f2087c98
CrOS-Libchrome-Original-Commit: 5628570f1bef7e3fd152bcff189fc13d3fbf5c9b
diff --git a/base/file_util.cc b/base/file_util.cc
index 1639cce..1198636 100644
--- a/base/file_util.cc
+++ b/base/file_util.cc
@@ -165,6 +165,14 @@
return CreateDirectoryAndGetError(full_path, NULL);
}
+bool GetFileSize(const FilePath& file_path, int64* file_size) {
+ PlatformFileInfo info;
+ if (!file_util::GetFileInfo(file_path, &info))
+ return false;
+ *file_size = info.size;
+ return true;
+}
+
} // namespace base
// -----------------------------------------------------------------------------
@@ -175,14 +183,6 @@
using base::FilePath;
using base::kMaxUniqueFiles;
-bool GetFileSize(const FilePath& file_path, int64* file_size) {
- base::PlatformFileInfo info;
- if (!GetFileInfo(file_path, &info))
- return false;
- *file_size = info.size;
- return true;
-}
-
bool TouchFile(const FilePath& path,
const base::Time& last_accessed,
const base::Time& last_modified) {
diff --git a/base/file_util.h b/base/file_util.h
index 30d9d09..8407f5a 100644
--- a/base/file_util.h
+++ b/base/file_util.h
@@ -261,14 +261,8 @@
// Backward-compatible convenience method for the above.
BASE_EXPORT bool CreateDirectory(const FilePath& full_path);
-} // namespace base
-
-// -----------------------------------------------------------------------------
-
-namespace file_util {
-
// Returns the file size. Returns true on success.
-BASE_EXPORT bool GetFileSize(const base::FilePath& file_path, int64* file_size);
+BASE_EXPORT bool GetFileSize(const FilePath& file_path, int64* file_size);
// Sets |real_path| to |path| with symbolic links and junctions expanded.
// On windows, make sure the path starts with a lettered drive.
@@ -276,8 +270,13 @@
// a directory or to a nonexistent path. On windows, this function will
// fail if |path| is a junction or symlink that points to an empty file,
// or if |real_path| would be longer than MAX_PATH characters.
-BASE_EXPORT bool NormalizeFilePath(const base::FilePath& path,
- base::FilePath* real_path);
+BASE_EXPORT bool NormalizeFilePath(const FilePath& path, FilePath* real_path);
+
+} // namespace base
+
+// -----------------------------------------------------------------------------
+
+namespace file_util {
#if defined(OS_WIN)
diff --git a/base/file_util_posix.cc b/base/file_util_posix.cc
index f566efb..f3a7553 100644
--- a/base/file_util_posix.cc
+++ b/base/file_util_posix.cc
@@ -623,6 +623,22 @@
return true;
}
+bool NormalizeFilePath(const FilePath& path, FilePath* normalized_path) {
+ FilePath real_path_result;
+ if (!RealPath(path, &real_path_result))
+ return false;
+
+ // To be consistant with windows, fail if |real_path_result| is a
+ // directory.
+ stat_wrapper_t file_info;
+ if (CallStat(real_path_result.value().c_str(), &file_info) != 0 ||
+ S_ISDIR(file_info.st_mode))
+ return false;
+
+ *normalized_path = real_path_result;
+ return true;
+}
+
} // namespace base
// -----------------------------------------------------------------------------
@@ -637,7 +653,6 @@
using base::FileEnumerator;
using base::FilePath;
using base::MakeAbsoluteFilePath;
-using base::RealPath;
using base::VerifySpecificPathControlledByUser;
base::FilePath MakeUniqueDirectory(const base::FilePath& path) {
@@ -804,22 +819,6 @@
return !ret;
}
-bool NormalizeFilePath(const FilePath& path, FilePath* normalized_path) {
- FilePath real_path_result;
- if (!RealPath(path, &real_path_result))
- return false;
-
- // To be consistant with windows, fail if |real_path_result| is a
- // directory.
- stat_wrapper_t file_info;
- if (CallStat(real_path_result.value().c_str(), &file_info) != 0 ||
- S_ISDIR(file_info.st_mode))
- return false;
-
- *normalized_path = real_path_result;
- return true;
-}
-
bool VerifyPathControlledByUser(const FilePath& base,
const FilePath& path,
uid_t owner_uid,
diff --git a/base/file_util_unittest.cc b/base/file_util_unittest.cc
index 9289438..0460c6e 100644
--- a/base/file_util_unittest.cc
+++ b/base/file_util_unittest.cc
@@ -250,7 +250,7 @@
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"));
@@ -259,7 +259,7 @@
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"));
@@ -282,19 +282,16 @@
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
@@ -376,18 +373,18 @@
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")),
@@ -405,18 +402,18 @@
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));
}
@@ -610,7 +607,7 @@
// 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());
@@ -622,7 +619,7 @@
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.
@@ -634,7 +631,7 @@
<< "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)
@@ -2318,7 +2315,7 @@
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
@@ -2329,7 +2326,7 @@
// 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.
@@ -2346,7 +2343,7 @@
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);
diff --git a/base/files/file_unittest.cc b/base/files/file_unittest.cc
index 178f867..b2e855d 100644
--- a/base/files/file_unittest.cc
+++ b/base/files/file_unittest.cc
@@ -158,7 +158,7 @@
// Make sure the file was extended.
int64 file_size = 0;
- EXPECT_TRUE(file_util::GetFileSize(file_path, &file_size));
+ EXPECT_TRUE(GetFileSize(file_path, &file_size));
EXPECT_EQ(kOffsetBeyondEndOfFile + kPartialWriteLength, file_size);
// Make sure the file was zero-padded.
@@ -240,7 +240,7 @@
const int kExtendedFileLength = 10;
int64 file_size = 0;
EXPECT_TRUE(file.Truncate(kExtendedFileLength));
- EXPECT_TRUE(file_util::GetFileSize(file_path, &file_size));
+ EXPECT_TRUE(GetFileSize(file_path, &file_size));
EXPECT_EQ(kExtendedFileLength, file_size);
// Make sure the file was zero-padded.
@@ -255,7 +255,7 @@
// Truncate the file.
const int kTruncatedFileLength = 2;
EXPECT_TRUE(file.Truncate(kTruncatedFileLength));
- EXPECT_TRUE(file_util::GetFileSize(file_path, &file_size));
+ EXPECT_TRUE(GetFileSize(file_path, &file_size));
EXPECT_EQ(kTruncatedFileLength, file_size);
// Make sure the file was truncated.
diff --git a/base/platform_file_unittest.cc b/base/platform_file_unittest.cc
index 0da3cf0..9cf66a9 100644
--- a/base/platform_file_unittest.cc
+++ b/base/platform_file_unittest.cc
@@ -8,151 +8,151 @@
#include "base/time/time.h"
#include "testing/gtest/include/gtest/gtest.h"
-using base::FilePath;
+namespace base {
namespace {
// Reads from a file the given number of bytes, or until EOF is reached.
// Returns the number of bytes read.
-int ReadFully(base::PlatformFile file, int64 offset, char* data, int size) {
- return base::ReadPlatformFile(file, offset, data, size);
+int ReadFully(PlatformFile file, int64 offset, char* data, int size) {
+ return ReadPlatformFile(file, offset, data, size);
}
// Writes the given number of bytes to a file.
// Returns the number of bytes written.
-int WriteFully(base::PlatformFile file, int64 offset,
+int WriteFully(PlatformFile file, int64 offset,
const char* data, int size) {
- return base::WritePlatformFile(file, offset, data, size);
+ return WritePlatformFile(file, offset, data, size);
}
} // namespace
TEST(PlatformFile, CreatePlatformFile) {
- base::ScopedTempDir temp_dir;
+ ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.path().AppendASCII("create_file_1");
// Open a file that doesn't exist.
- base::PlatformFileError error_code = base::PLATFORM_FILE_OK;
- base::PlatformFile file = base::CreatePlatformFile(
+ PlatformFileError error_code = PLATFORM_FILE_OK;
+ PlatformFile file = CreatePlatformFile(
file_path,
- base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ,
+ PLATFORM_FILE_OPEN | PLATFORM_FILE_READ,
NULL,
&error_code);
- EXPECT_EQ(base::kInvalidPlatformFileValue, file);
- EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, error_code);
+ EXPECT_EQ(kInvalidPlatformFileValue, file);
+ EXPECT_EQ(PLATFORM_FILE_ERROR_NOT_FOUND, error_code);
// Open or create a file.
bool created = false;
- error_code = base::PLATFORM_FILE_OK;
- file = base::CreatePlatformFile(
+ error_code = PLATFORM_FILE_OK;
+ file = CreatePlatformFile(
file_path,
- base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ,
+ PLATFORM_FILE_OPEN_ALWAYS | PLATFORM_FILE_READ,
&created,
&error_code);
- EXPECT_NE(base::kInvalidPlatformFileValue, file);
+ EXPECT_NE(kInvalidPlatformFileValue, file);
EXPECT_TRUE(created);
- EXPECT_EQ(base::PLATFORM_FILE_OK, error_code);
- base::ClosePlatformFile(file);
+ EXPECT_EQ(PLATFORM_FILE_OK, error_code);
+ ClosePlatformFile(file);
// Open an existing file.
created = false;
- file = base::CreatePlatformFile(
+ file = CreatePlatformFile(
file_path,
- base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ,
+ PLATFORM_FILE_OPEN | PLATFORM_FILE_READ,
&created,
&error_code);
- EXPECT_NE(base::kInvalidPlatformFileValue, file);
+ EXPECT_NE(kInvalidPlatformFileValue, file);
EXPECT_FALSE(created);
- EXPECT_EQ(base::PLATFORM_FILE_OK, error_code);
- base::ClosePlatformFile(file);
+ EXPECT_EQ(PLATFORM_FILE_OK, error_code);
+ ClosePlatformFile(file);
// Create a file that exists.
- file = base::CreatePlatformFile(
+ file = CreatePlatformFile(
file_path,
- base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_READ,
+ PLATFORM_FILE_CREATE | PLATFORM_FILE_READ,
&created,
&error_code);
- EXPECT_EQ(base::kInvalidPlatformFileValue, file);
+ EXPECT_EQ(kInvalidPlatformFileValue, file);
EXPECT_FALSE(created);
- EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, error_code);
+ EXPECT_EQ(PLATFORM_FILE_ERROR_EXISTS, error_code);
// Create or overwrite a file.
- error_code = base::PLATFORM_FILE_OK;
- file = base::CreatePlatformFile(
+ error_code = PLATFORM_FILE_OK;
+ file = CreatePlatformFile(
file_path,
- base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_READ,
+ PLATFORM_FILE_CREATE_ALWAYS | PLATFORM_FILE_READ,
&created,
&error_code);
- EXPECT_NE(base::kInvalidPlatformFileValue, file);
+ EXPECT_NE(kInvalidPlatformFileValue, file);
EXPECT_TRUE(created);
- EXPECT_EQ(base::PLATFORM_FILE_OK, error_code);
- base::ClosePlatformFile(file);
+ EXPECT_EQ(PLATFORM_FILE_OK, error_code);
+ ClosePlatformFile(file);
// Create a delete-on-close file.
created = false;
file_path = temp_dir.path().AppendASCII("create_file_2");
- file = base::CreatePlatformFile(
+ file = CreatePlatformFile(
file_path,
- base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_DELETE_ON_CLOSE |
- base::PLATFORM_FILE_READ,
+ PLATFORM_FILE_OPEN_ALWAYS | PLATFORM_FILE_DELETE_ON_CLOSE |
+ PLATFORM_FILE_READ,
&created,
&error_code);
- EXPECT_NE(base::kInvalidPlatformFileValue, file);
+ EXPECT_NE(kInvalidPlatformFileValue, file);
EXPECT_TRUE(created);
- EXPECT_EQ(base::PLATFORM_FILE_OK, error_code);
+ EXPECT_EQ(PLATFORM_FILE_OK, error_code);
- EXPECT_TRUE(base::ClosePlatformFile(file));
- EXPECT_FALSE(base::PathExists(file_path));
+ EXPECT_TRUE(ClosePlatformFile(file));
+ EXPECT_FALSE(PathExists(file_path));
}
TEST(PlatformFile, DeleteOpenFile) {
- base::ScopedTempDir temp_dir;
+ ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.path().AppendASCII("create_file_1");
// Create a file.
bool created = false;
- base::PlatformFileError error_code = base::PLATFORM_FILE_OK;
- base::PlatformFile file = base::CreatePlatformFile(
+ PlatformFileError error_code = PLATFORM_FILE_OK;
+ PlatformFile file = CreatePlatformFile(
file_path,
- base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_SHARE_DELETE,
+ PLATFORM_FILE_OPEN_ALWAYS | PLATFORM_FILE_READ |
+ PLATFORM_FILE_SHARE_DELETE,
&created,
&error_code);
- EXPECT_NE(base::kInvalidPlatformFileValue, file);
+ EXPECT_NE(kInvalidPlatformFileValue, file);
EXPECT_TRUE(created);
- EXPECT_EQ(base::PLATFORM_FILE_OK, error_code);
+ EXPECT_EQ(PLATFORM_FILE_OK, error_code);
// Open an existing file and mark it as delete on close.
created = false;
- base::PlatformFile same_file = base::CreatePlatformFile(
+ PlatformFile same_file = CreatePlatformFile(
file_path,
- base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_DELETE_ON_CLOSE |
- base::PLATFORM_FILE_READ,
+ PLATFORM_FILE_OPEN | PLATFORM_FILE_DELETE_ON_CLOSE |
+ PLATFORM_FILE_READ,
&created,
&error_code);
- EXPECT_NE(base::kInvalidPlatformFileValue, file);
+ EXPECT_NE(kInvalidPlatformFileValue, file);
EXPECT_FALSE(created);
- EXPECT_EQ(base::PLATFORM_FILE_OK, error_code);
+ EXPECT_EQ(PLATFORM_FILE_OK, error_code);
// Close both handles and check that the file is gone.
- base::ClosePlatformFile(file);
- base::ClosePlatformFile(same_file);
- EXPECT_FALSE(base::PathExists(file_path));
+ ClosePlatformFile(file);
+ ClosePlatformFile(same_file);
+ EXPECT_FALSE(PathExists(file_path));
}
TEST(PlatformFile, ReadWritePlatformFile) {
- base::ScopedTempDir temp_dir;
+ ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.path().AppendASCII("read_write_file");
- base::PlatformFile file = base::CreatePlatformFile(
+ PlatformFile file = CreatePlatformFile(
file_path,
- base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_WRITE,
+ PLATFORM_FILE_CREATE | PLATFORM_FILE_READ |
+ PLATFORM_FILE_WRITE,
NULL,
NULL);
- EXPECT_NE(base::kInvalidPlatformFileValue, file);
+ EXPECT_NE(kInvalidPlatformFileValue, file);
char data_to_write[] = "test";
const int kTestDataSize = 4;
@@ -188,7 +188,7 @@
EXPECT_EQ(data_to_write[i], data_read_1[i]);
// Read again, but using the trivial native wrapper.
- bytes_read = base::ReadPlatformFileNoBestEffort(file, 0, data_read_1,
+ bytes_read = ReadPlatformFileNoBestEffort(file, 0, data_read_1,
kTestDataSize);
EXPECT_LE(bytes_read, kTestDataSize);
for (int i = 0; i < bytes_read; i++)
@@ -203,7 +203,7 @@
// Make sure the file was extended.
int64 file_size = 0;
- EXPECT_TRUE(file_util::GetFileSize(file_path, &file_size));
+ EXPECT_TRUE(GetFileSize(file_path, &file_size));
EXPECT_EQ(kOffsetBeyondEndOfFile + kPartialWriteLength, file_size);
// Make sure the file was zero-padded.
@@ -218,19 +218,19 @@
EXPECT_EQ(data_to_write[i - kOffsetBeyondEndOfFile], data_read_2[i]);
// Close the file handle to allow the temp directory to be deleted.
- base::ClosePlatformFile(file);
+ ClosePlatformFile(file);
}
TEST(PlatformFile, AppendPlatformFile) {
- base::ScopedTempDir temp_dir;
+ ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.path().AppendASCII("append_file");
- base::PlatformFile file = base::CreatePlatformFile(
+ PlatformFile file = CreatePlatformFile(
file_path,
- base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_APPEND,
+ PLATFORM_FILE_CREATE | PLATFORM_FILE_APPEND,
NULL,
NULL);
- EXPECT_NE(base::kInvalidPlatformFileValue, file);
+ EXPECT_NE(kInvalidPlatformFileValue, file);
char data_to_write[] = "test";
const int kTestDataSize = 4;
@@ -243,14 +243,14 @@
bytes_written = WriteFully(file, 0, data_to_write, kTestDataSize);
EXPECT_EQ(kTestDataSize, bytes_written);
- base::ClosePlatformFile(file);
- file = base::CreatePlatformFile(
+ ClosePlatformFile(file);
+ file = CreatePlatformFile(
file_path,
- base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_APPEND,
+ PLATFORM_FILE_OPEN | PLATFORM_FILE_READ |
+ PLATFORM_FILE_APPEND,
NULL,
NULL);
- EXPECT_NE(base::kInvalidPlatformFileValue, file);
+ EXPECT_NE(kInvalidPlatformFileValue, file);
char append_data_to_write[] = "78";
const int kAppendDataSize = 2;
@@ -270,21 +270,21 @@
EXPECT_EQ(append_data_to_write[i], data_read_1[kTestDataSize + i]);
// Close the file handle to allow the temp directory to be deleted.
- base::ClosePlatformFile(file);
+ ClosePlatformFile(file);
}
TEST(PlatformFile, TruncatePlatformFile) {
- base::ScopedTempDir temp_dir;
+ ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.path().AppendASCII("truncate_file");
- base::PlatformFile file = base::CreatePlatformFile(
+ PlatformFile file = CreatePlatformFile(
file_path,
- base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_WRITE,
+ PLATFORM_FILE_CREATE | PLATFORM_FILE_READ |
+ PLATFORM_FILE_WRITE,
NULL,
NULL);
- EXPECT_NE(base::kInvalidPlatformFileValue, file);
+ EXPECT_NE(kInvalidPlatformFileValue, file);
// Write "test" to the file.
char data_to_write[] = "test";
@@ -295,8 +295,8 @@
// Extend the file.
const int kExtendedFileLength = 10;
int64 file_size = 0;
- EXPECT_TRUE(base::TruncatePlatformFile(file, kExtendedFileLength));
- EXPECT_TRUE(file_util::GetFileSize(file_path, &file_size));
+ EXPECT_TRUE(TruncatePlatformFile(file, kExtendedFileLength));
+ EXPECT_TRUE(GetFileSize(file_path, &file_size));
EXPECT_EQ(kExtendedFileLength, file_size);
// Make sure the file was zero-padded.
@@ -310,8 +310,8 @@
// Truncate the file.
const int kTruncatedFileLength = 2;
- EXPECT_TRUE(base::TruncatePlatformFile(file, kTruncatedFileLength));
- EXPECT_TRUE(file_util::GetFileSize(file_path, &file_size));
+ EXPECT_TRUE(TruncatePlatformFile(file, kTruncatedFileLength));
+ EXPECT_TRUE(GetFileSize(file_path, &file_size));
EXPECT_EQ(kTruncatedFileLength, file_size);
// Make sure the file was truncated.
@@ -321,7 +321,7 @@
EXPECT_EQ(data_to_write[i], data_read[i]);
// Close the file handle to allow the temp directory to be deleted.
- base::ClosePlatformFile(file);
+ ClosePlatformFile(file);
}
// Flakily fails: http://crbug.com/86494
@@ -330,30 +330,30 @@
#else
TEST(PlatformFile, DISABLED_TouchGetInfoPlatformFile) {
#endif
- base::ScopedTempDir temp_dir;
+ ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
- base::PlatformFile file = base::CreatePlatformFile(
+ PlatformFile file = CreatePlatformFile(
temp_dir.path().AppendASCII("touch_get_info_file"),
- base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE |
- base::PLATFORM_FILE_WRITE_ATTRIBUTES,
+ PLATFORM_FILE_CREATE | PLATFORM_FILE_WRITE |
+ PLATFORM_FILE_WRITE_ATTRIBUTES,
NULL,
NULL);
- EXPECT_NE(base::kInvalidPlatformFileValue, file);
+ EXPECT_NE(kInvalidPlatformFileValue, file);
// Get info for a newly created file.
- base::PlatformFileInfo info;
- EXPECT_TRUE(base::GetPlatformFileInfo(file, &info));
+ PlatformFileInfo info;
+ EXPECT_TRUE(GetPlatformFileInfo(file, &info));
// Add 2 seconds to account for possible rounding errors on
// filesystems that use a 1s or 2s timestamp granularity.
- base::Time now = base::Time::Now() + base::TimeDelta::FromSeconds(2);
+ Time now = Time::Now() + TimeDelta::FromSeconds(2);
EXPECT_EQ(0, info.size);
EXPECT_FALSE(info.is_directory);
EXPECT_FALSE(info.is_symbolic_link);
EXPECT_LE(info.last_accessed.ToInternalValue(), now.ToInternalValue());
EXPECT_LE(info.last_modified.ToInternalValue(), now.ToInternalValue());
EXPECT_LE(info.creation_time.ToInternalValue(), now.ToInternalValue());
- base::Time creation_time = info.creation_time;
+ Time creation_time = info.creation_time;
// Write "test" to the file.
char data[] = "test";
@@ -365,16 +365,15 @@
// It's best to add values that are multiples of 2 (in seconds)
// to the current last_accessed and last_modified times, because
// FATxx uses a 2s timestamp granularity.
- base::Time new_last_accessed =
- info.last_accessed + base::TimeDelta::FromSeconds(234);
- base::Time new_last_modified =
- info.last_modified + base::TimeDelta::FromMinutes(567);
+ Time new_last_accessed =
+ info.last_accessed + TimeDelta::FromSeconds(234);
+ Time new_last_modified =
+ info.last_modified + TimeDelta::FromMinutes(567);
- EXPECT_TRUE(base::TouchPlatformFile(file, new_last_accessed,
- new_last_modified));
+ EXPECT_TRUE(TouchPlatformFile(file, new_last_accessed, new_last_modified));
// Make sure the file info was updated accordingly.
- EXPECT_TRUE(base::GetPlatformFileInfo(file, &info));
+ EXPECT_TRUE(GetPlatformFileInfo(file, &info));
EXPECT_EQ(info.size, kTestDataSize);
EXPECT_FALSE(info.is_directory);
EXPECT_FALSE(info.is_symbolic_link);
@@ -396,39 +395,40 @@
creation_time.ToInternalValue());
// Close the file handle to allow the temp directory to be deleted.
- base::ClosePlatformFile(file);
+ ClosePlatformFile(file);
}
TEST(PlatformFile, ReadFileAtCurrentPosition) {
- base::ScopedTempDir temp_dir;
+ ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path =
temp_dir.path().AppendASCII("read_file_at_current_position");
- base::PlatformFile file = base::CreatePlatformFile(
+ PlatformFile file = CreatePlatformFile(
file_path,
- base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_WRITE,
+ PLATFORM_FILE_CREATE | PLATFORM_FILE_READ |
+ PLATFORM_FILE_WRITE,
NULL, NULL);
- EXPECT_NE(base::kInvalidPlatformFileValue, file);
+ EXPECT_NE(kInvalidPlatformFileValue, file);
const char kData[] = "test";
const int kDataSize = arraysize(kData) - 1;
EXPECT_EQ(kDataSize, WriteFully(file, 0, kData, kDataSize));
- EXPECT_EQ(0, SeekPlatformFile(
- file, base::PLATFORM_FILE_FROM_BEGIN, 0));
+ EXPECT_EQ(0, SeekPlatformFile(file, PLATFORM_FILE_FROM_BEGIN, 0));
char buffer[kDataSize];
int first_chunk_size = kDataSize / 2;
EXPECT_EQ(first_chunk_size,
- base::ReadPlatformFileAtCurrentPos(
+ ReadPlatformFileAtCurrentPos(
file, buffer, first_chunk_size));
EXPECT_EQ(kDataSize - first_chunk_size,
- base::ReadPlatformFileAtCurrentPos(
+ ReadPlatformFileAtCurrentPos(
file, buffer + first_chunk_size,
kDataSize - first_chunk_size));
EXPECT_EQ(std::string(buffer, buffer + kDataSize),
std::string(kData));
- base::ClosePlatformFile(file);
+ ClosePlatformFile(file);
}
+
+} // namespace base