Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(685)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/base/file_stream_unittest.cc

Issue 189393002: net: Update FileStream to use base::File instead of PlatformFile. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Rebase Created 6 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« net/base/file_stream_context.h ('K') | « net/base/file_stream_context_win.cc ('k') | net/base/upload_file_element_reader.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/base/file_stream_unittest.cc
diff --git a/net/base/file_stream_unittest.cc b/net/base/file_stream_unittest.cc
index d86010d28762256505440e7f5f38c11d89877cbd..4252c51cb0105c7852140b42c8f7ef3884264af8 100644
--- a/net/base/file_stream_unittest.cc
+++ b/net/base/file_stream_unittest.cc
@@ -7,10 +7,10 @@
#include "base/bind.h"
#include "base/callback.h"
#include "base/file_util.h"
+#include "base/files/file.h"
#include "base/message_loop/message_loop.h"
#include "base/message_loop/message_loop_proxy.h"
#include "base/path_service.h"
-#include "base/platform_file.h"
#include "base/run_loop.h"
#include "base/synchronization/waitable_event.h"
#include "base/test/test_timeouts.h"
@@ -66,117 +66,65 @@ class FileStreamTest : public PlatformTest {
namespace {
-TEST_F(FileStreamTest, BasicOpenClose) {
- base::PlatformFile file = base::kInvalidPlatformFileValue;
- {
- FileStream stream(NULL, base::MessageLoopProxy::current());
- int rv = stream.OpenSync(temp_file_path(),
- base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ);
- EXPECT_EQ(OK, rv);
- EXPECT_TRUE(stream.IsOpen());
- file = stream.GetPlatformFileForTesting();
- }
- EXPECT_NE(base::kInvalidPlatformFileValue, file);
- base::PlatformFileInfo info;
- // The file should be closed.
- EXPECT_FALSE(base::GetPlatformFileInfo(file, &info));
-}
-
TEST_F(FileStreamTest, BasicOpenExplicitClose) {
- base::PlatformFile file = base::kInvalidPlatformFileValue;
FileStream stream(NULL);
int rv = stream.OpenSync(temp_file_path(),
- base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ);
+ base::File::FLAG_OPEN | base::File::FLAG_READ);
EXPECT_EQ(OK, rv);
EXPECT_TRUE(stream.IsOpen());
- file = stream.GetPlatformFileForTesting();
- EXPECT_NE(base::kInvalidPlatformFileValue, file);
+ EXPECT_TRUE(stream.GetFileForTesting().IsValid());
EXPECT_EQ(OK, stream.CloseSync());
EXPECT_FALSE(stream.IsOpen());
- base::PlatformFileInfo info;
- // The file should be closed.
- EXPECT_FALSE(base::GetPlatformFileInfo(file, &info));
+ EXPECT_FALSE(stream.GetFileForTesting().IsValid());
}
TEST_F(FileStreamTest, AsyncOpenExplicitClose) {
- base::PlatformFile file = base::kInvalidPlatformFileValue;
TestCompletionCallback callback;
FileStream stream(NULL);
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_ASYNC;
+ int flags = base::File::FLAG_OPEN |
+ base::File::FLAG_READ |
+ base::File::FLAG_ASYNC;
int rv = stream.Open(temp_file_path(), flags, callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(OK, callback.WaitForResult());
EXPECT_TRUE(stream.IsOpen());
- file = stream.GetPlatformFileForTesting();
+ EXPECT_TRUE(stream.GetFileForTesting().IsValid());
EXPECT_EQ(ERR_IO_PENDING, stream.Close(callback.callback()));
EXPECT_EQ(OK, callback.WaitForResult());
EXPECT_FALSE(stream.IsOpen());
- base::PlatformFileInfo info;
- // The file should be closed.
- EXPECT_FALSE(base::GetPlatformFileInfo(file, &info));
+ EXPECT_FALSE(stream.GetFileForTesting().IsValid());
}
TEST_F(FileStreamTest, AsyncOpenExplicitCloseOrphaned) {
- base::PlatformFile file = base::kInvalidPlatformFileValue;
TestCompletionCallback callback;
- base::PlatformFileInfo info;
scoped_ptr<FileStream> stream(new FileStream(
NULL, base::MessageLoopProxy::current()));
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_ASYNC;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
+ base::File::FLAG_ASYNC;
int rv = stream->Open(temp_file_path(), flags, callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(OK, callback.WaitForResult());
EXPECT_TRUE(stream->IsOpen());
- file = stream->GetPlatformFileForTesting();
+ EXPECT_TRUE(stream->GetFileForTesting().IsValid());
EXPECT_EQ(ERR_IO_PENDING, stream->Close(callback.callback()));
stream.reset();
// File isn't actually closed yet.
- EXPECT_TRUE(base::GetPlatformFileInfo(file, &info));
base::RunLoop runloop;
runloop.RunUntilIdle();
// The file should now be closed, though the callback has not been called.
- EXPECT_FALSE(base::GetPlatformFileInfo(file, &info));
-}
-
-TEST_F(FileStreamTest, FileHandleNotLeftOpen) {
- bool created = false;
- ASSERT_EQ(kTestDataSize,
- base::WriteFile(temp_file_path(), kTestData, kTestDataSize));
- int flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ;
- base::PlatformFile file = base::CreatePlatformFile(
- temp_file_path(), flags, &created, NULL);
-
- {
- // Seek to the beginning of the file and read.
- FileStream read_stream(file, flags, NULL,
- base::MessageLoopProxy::current());
- EXPECT_TRUE(read_stream.IsOpen());
- }
-
- EXPECT_NE(base::kInvalidPlatformFileValue, file);
- base::PlatformFileInfo info;
- // The file should be closed.
- EXPECT_FALSE(base::GetPlatformFileInfo(file, &info));
}
// Test the use of FileStream with a file handle provided at construction.
TEST_F(FileStreamTest, UseFileHandle) {
- bool created = false;
-
// 1. Test reading with a file handle.
ASSERT_EQ(kTestDataSize,
- base::WriteFile(temp_file_path(), kTestData, kTestDataSize));
- int flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_READ;
- base::PlatformFile file = base::CreatePlatformFile(
- temp_file_path(), flags, &created, NULL);
+ base::WriteFile(temp_file_path(), kTestData, kTestDataSize));
+ int flags = base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ;
+ base::File file(temp_file_path(), flags);
// Seek to the beginning of the file and read.
scoped_ptr<FileStream> read_stream(
- new FileStream(file, flags, NULL, base::MessageLoopProxy::current()));
+ new FileStream(file.Pass(), NULL, base::MessageLoopProxy::current()));
ASSERT_EQ(0, read_stream->SeekSync(FROM_BEGIN, 0));
ASSERT_EQ(kTestDataSize, read_stream->Available());
// Read into buffer and compare.
@@ -188,11 +136,11 @@ TEST_F(FileStreamTest, UseFileHandle) {
// 2. Test writing with a file handle.
base::DeleteFile(temp_file_path(), false);
- flags = base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_WRITE;
- file = base::CreatePlatformFile(temp_file_path(), flags, &created, NULL);
+ flags = base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE;
+ file.Initialize(temp_file_path(), flags);
scoped_ptr<FileStream> write_stream(
- new FileStream(file, flags, NULL, base::MessageLoopProxy::current()));
+ new FileStream(file.Pass(), NULL, base::MessageLoopProxy::current()));
ASSERT_EQ(0, write_stream->SeekSync(FROM_BEGIN, 0));
ASSERT_EQ(kTestDataSize,
write_stream->WriteSync(kTestData, kTestDataSize));
@@ -225,12 +173,10 @@ TEST_F(FileStreamTest, UseClosedStream) {
TEST_F(FileStreamTest, BasicRead) {
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
FileStream stream(NULL, base::MessageLoopProxy::current());
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_READ;
int rv = stream.OpenSync(temp_file_path(), flags);
EXPECT_EQ(OK, rv);
@@ -255,13 +201,11 @@ TEST_F(FileStreamTest, BasicRead) {
TEST_F(FileStreamTest, AsyncRead) {
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
FileStream stream(NULL, base::MessageLoopProxy::current());
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_ASYNC;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
+ base::File::FLAG_ASYNC;
TestCompletionCallback callback;
int rv = stream.Open(temp_file_path(), flags, callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -290,14 +234,12 @@ TEST_F(FileStreamTest, AsyncRead) {
TEST_F(FileStreamTest, AsyncRead_EarlyDelete) {
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
scoped_ptr<FileStream> stream(
new FileStream(NULL, base::MessageLoopProxy::current()));
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_ASYNC;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
+ base::File::FLAG_ASYNC;
TestCompletionCallback callback;
int rv = stream->Open(temp_file_path(), flags, callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -321,12 +263,10 @@ TEST_F(FileStreamTest, AsyncRead_EarlyDelete) {
TEST_F(FileStreamTest, BasicRead_FromOffset) {
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
FileStream stream(NULL, base::MessageLoopProxy::current());
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_READ;
int rv = stream.OpenSync(temp_file_path(), flags);
EXPECT_EQ(OK, rv);
@@ -356,13 +296,11 @@ TEST_F(FileStreamTest, BasicRead_FromOffset) {
TEST_F(FileStreamTest, AsyncRead_FromOffset) {
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
FileStream stream(NULL, base::MessageLoopProxy::current());
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_ASYNC;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
+ base::File::FLAG_ASYNC;
TestCompletionCallback callback;
int rv = stream.Open(temp_file_path(), flags, callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -398,8 +336,7 @@ TEST_F(FileStreamTest, AsyncRead_FromOffset) {
TEST_F(FileStreamTest, SeekAround) {
FileStream stream(NULL, base::MessageLoopProxy::current());
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_READ;
int rv = stream.OpenSync(temp_file_path(), flags);
EXPECT_EQ(OK, rv);
@@ -421,9 +358,8 @@ TEST_F(FileStreamTest, SeekAround) {
TEST_F(FileStreamTest, AsyncSeekAround) {
FileStream stream(NULL, base::MessageLoopProxy::current());
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_ASYNC |
- base::PLATFORM_FILE_READ;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_ASYNC |
+ base::File::FLAG_READ;
TestCompletionCallback callback;
int rv = stream.Open(temp_file_path(), flags, callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -458,38 +394,33 @@ TEST_F(FileStreamTest, AsyncSeekAround) {
TEST_F(FileStreamTest, BasicWrite) {
scoped_ptr<FileStream> stream(
new FileStream(NULL, base::MessageLoopProxy::current()));
- int flags = base::PLATFORM_FILE_CREATE_ALWAYS |
- base::PLATFORM_FILE_WRITE;
+ int flags = base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE;
int rv = stream->OpenSync(temp_file_path(), flags);
EXPECT_EQ(OK, rv);
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
EXPECT_EQ(0, file_size);
rv = stream->WriteSync(kTestData, kTestDataSize);
EXPECT_EQ(kTestDataSize, rv);
stream.reset();
- ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
EXPECT_EQ(kTestDataSize, file_size);
}
TEST_F(FileStreamTest, AsyncWrite) {
FileStream stream(NULL, base::MessageLoopProxy::current());
- int flags = base::PLATFORM_FILE_CREATE_ALWAYS |
- base::PLATFORM_FILE_WRITE |
- base::PLATFORM_FILE_ASYNC;
+ int flags = base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE |
+ base::File::FLAG_ASYNC;
TestCompletionCallback callback;
int rv = stream.Open(temp_file_path(), flags, callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(OK, callback.WaitForResult());
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
EXPECT_EQ(0, file_size);
int total_bytes_written = 0;
@@ -498,8 +429,8 @@ TEST_F(FileStreamTest, AsyncWrite) {
scoped_refptr<DrainableIOBuffer> drainable =
new DrainableIOBuffer(buf.get(), buf->size());
while (total_bytes_written != kTestDataSize) {
- rv = stream.Write(
- drainable.get(), drainable->BytesRemaining(), callback.callback());
+ rv = stream.Write(drainable.get(), drainable->BytesRemaining(),
+ callback.callback());
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
EXPECT_LT(0, rv);
@@ -508,25 +439,22 @@ TEST_F(FileStreamTest, AsyncWrite) {
drainable->DidConsume(rv);
total_bytes_written += rv;
}
- ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
EXPECT_EQ(file_size, total_bytes_written);
}
TEST_F(FileStreamTest, AsyncWrite_EarlyDelete) {
scoped_ptr<FileStream> stream(
new FileStream(NULL, base::MessageLoopProxy::current()));
- int flags = base::PLATFORM_FILE_CREATE_ALWAYS |
- base::PLATFORM_FILE_WRITE |
- base::PLATFORM_FILE_ASYNC;
+ int flags = base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE |
+ base::File::FLAG_ASYNC;
TestCompletionCallback callback;
int rv = stream->Open(temp_file_path(), flags, callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(OK, callback.WaitForResult());
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
EXPECT_EQ(0, file_size);
scoped_refptr<IOBufferWithSize> buf = CreateTestDataBuffer();
@@ -538,8 +466,7 @@ TEST_F(FileStreamTest, AsyncWrite_EarlyDelete) {
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(callback.have_result());
} else {
- ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
EXPECT_EQ(file_size, rv);
}
}
@@ -547,14 +474,12 @@ TEST_F(FileStreamTest, AsyncWrite_EarlyDelete) {
TEST_F(FileStreamTest, BasicWrite_FromOffset) {
scoped_ptr<FileStream> stream(
new FileStream(NULL, base::MessageLoopProxy::current()));
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_WRITE;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_WRITE;
int rv = stream->OpenSync(temp_file_path(), flags);
EXPECT_EQ(OK, rv);
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
EXPECT_EQ(kTestDataSize, file_size);
const int64 kOffset = 0;
@@ -565,20 +490,17 @@ TEST_F(FileStreamTest, BasicWrite_FromOffset) {
EXPECT_EQ(kTestDataSize, rv);
stream.reset();
- ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
EXPECT_EQ(kTestDataSize * 2, file_size);
}
TEST_F(FileStreamTest, AsyncWrite_FromOffset) {
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
FileStream stream(NULL, base::MessageLoopProxy::current());
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_WRITE |
- base::PLATFORM_FILE_ASYNC;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_WRITE |
+ base::File::FLAG_ASYNC;
TestCompletionCallback callback;
int rv = stream.Open(temp_file_path(), flags, callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -597,8 +519,8 @@ TEST_F(FileStreamTest, AsyncWrite_FromOffset) {
scoped_refptr<DrainableIOBuffer> drainable =
new DrainableIOBuffer(buf.get(), buf->size());
while (total_bytes_written != kTestDataSize) {
- rv = stream.Write(
- drainable.get(), drainable->BytesRemaining(), callback.callback());
+ rv = stream.Write(drainable.get(), drainable->BytesRemaining(),
+ callback.callback());
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
EXPECT_LT(0, rv);
@@ -607,21 +529,18 @@ TEST_F(FileStreamTest, AsyncWrite_FromOffset) {
drainable->DidConsume(rv);
total_bytes_written += rv;
}
- ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
EXPECT_EQ(file_size, kTestDataSize * 2);
}
TEST_F(FileStreamTest, BasicReadWrite) {
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
scoped_ptr<FileStream> stream(
new FileStream(NULL, base::MessageLoopProxy::current()));
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_WRITE;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
+ base::File::FLAG_WRITE;
int rv = stream->OpenSync(temp_file_path(), flags);
EXPECT_EQ(OK, rv);
@@ -647,21 +566,18 @@ TEST_F(FileStreamTest, BasicReadWrite) {
EXPECT_EQ(kTestDataSize, rv);
stream.reset();
- ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
EXPECT_EQ(kTestDataSize * 2, file_size);
}
TEST_F(FileStreamTest, BasicWriteRead) {
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
scoped_ptr<FileStream> stream(
new FileStream(NULL, base::MessageLoopProxy::current()));
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_WRITE;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
+ base::File::FLAG_WRITE;
int rv = stream->OpenSync(temp_file_path(), flags);
EXPECT_EQ(OK, rv);
@@ -691,8 +607,7 @@ TEST_F(FileStreamTest, BasicWriteRead) {
}
stream.reset();
- ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
EXPECT_EQ(kTestDataSize * 2, file_size);
EXPECT_EQ(kTestDataSize * 2, total_bytes_read);
@@ -703,15 +618,12 @@ TEST_F(FileStreamTest, BasicWriteRead) {
TEST_F(FileStreamTest, BasicAsyncReadWrite) {
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
scoped_ptr<FileStream> stream(
new FileStream(NULL, base::MessageLoopProxy::current()));
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_WRITE |
- base::PLATFORM_FILE_ASYNC;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
+ base::File::FLAG_WRITE | base::File::FLAG_ASYNC;
TestCompletionCallback callback;
int rv = stream->Open(temp_file_path(), flags, callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -743,8 +655,8 @@ TEST_F(FileStreamTest, BasicAsyncReadWrite) {
scoped_refptr<DrainableIOBuffer> drainable =
new DrainableIOBuffer(buf.get(), buf->size());
while (total_bytes_written != kTestDataSize) {
- rv = stream->Write(
- drainable.get(), drainable->BytesRemaining(), callback.callback());
+ rv = stream->Write(drainable.get(), drainable->BytesRemaining(),
+ callback.callback());
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
EXPECT_LT(0, rv);
@@ -756,22 +668,18 @@ TEST_F(FileStreamTest, BasicAsyncReadWrite) {
stream.reset();
- ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
EXPECT_EQ(kTestDataSize * 2, file_size);
}
TEST_F(FileStreamTest, BasicAsyncWriteRead) {
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
scoped_ptr<FileStream> stream(
new FileStream(NULL, base::MessageLoopProxy::current()));
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_WRITE |
- base::PLATFORM_FILE_ASYNC;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
+ base::File::FLAG_WRITE | base::File::FLAG_ASYNC;
TestCompletionCallback callback;
int rv = stream->Open(temp_file_path(), flags, callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -792,8 +700,8 @@ TEST_F(FileStreamTest, BasicAsyncWriteRead) {
scoped_refptr<DrainableIOBuffer> drainable =
new DrainableIOBuffer(buf.get(), buf->size());
while (total_bytes_written != kTestDataSize) {
- rv = stream->Write(
- drainable.get(), drainable->BytesRemaining(), callback.callback());
+ rv = stream->Write(drainable.get(), drainable->BytesRemaining(),
+ callback.callback());
if (rv == ERR_IO_PENDING)
rv = callback.WaitForResult();
EXPECT_LT(0, rv);
@@ -826,8 +734,7 @@ TEST_F(FileStreamTest, BasicAsyncWriteRead) {
}
stream.reset();
- ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
EXPECT_EQ(kTestDataSize * 2, file_size);
EXPECT_EQ(kTestDataSize * 2, total_bytes_read);
@@ -930,15 +837,12 @@ class TestWriteReadCompletionCallback {
TEST_F(FileStreamTest, AsyncWriteRead) {
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
scoped_ptr<FileStream> stream(
new FileStream(NULL, base::MessageLoopProxy::current()));
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_WRITE |
- base::PLATFORM_FILE_ASYNC;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
+ base::File::FLAG_WRITE | base::File::FLAG_ASYNC;
TestCompletionCallback open_callback;
int rv = stream->Open(temp_file_path(), flags, open_callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -965,8 +869,7 @@ TEST_F(FileStreamTest, AsyncWriteRead) {
stream.reset();
- ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
EXPECT_EQ(kTestDataSize * 2, file_size);
EXPECT_EQ(kTestDataSize * 2, total_bytes_read);
@@ -1040,15 +943,12 @@ class TestWriteCloseCompletionCallback {
TEST_F(FileStreamTest, AsyncWriteClose) {
int64 file_size;
- bool ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
scoped_ptr<FileStream> stream(
new FileStream(NULL, base::MessageLoopProxy::current()));
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_WRITE |
- base::PLATFORM_FILE_ASYNC;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
+ base::File::FLAG_WRITE | base::File::FLAG_ASYNC;
TestCompletionCallback open_callback;
int rv = stream->Open(temp_file_path(), flags, open_callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -1072,14 +972,13 @@ TEST_F(FileStreamTest, AsyncWriteClose) {
stream.reset();
- ok = base::GetFileSize(temp_file_path(), &file_size);
- EXPECT_TRUE(ok);
+ EXPECT_TRUE(base::GetFileSize(temp_file_path(), &file_size));
EXPECT_EQ(kTestDataSize * 2, file_size);
}
// Tests truncating a file.
TEST_F(FileStreamTest, Truncate) {
- int flags = base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_WRITE;
+ int flags = base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE;
scoped_ptr<FileStream> write_stream(
new FileStream(NULL, base::MessageLoopProxy::current()));
@@ -1108,9 +1007,8 @@ TEST_F(FileStreamTest, Truncate) {
TEST_F(FileStreamTest, AsyncOpenAndDelete) {
scoped_ptr<FileStream> stream(
new FileStream(NULL, base::MessageLoopProxy::current()));
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_WRITE |
- base::PLATFORM_FILE_ASYNC;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_WRITE |
+ base::File::FLAG_ASYNC;
TestCompletionCallback open_callback;
int rv = stream->Open(temp_file_path(), flags, open_callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -1126,18 +1024,14 @@ TEST_F(FileStreamTest, AsyncOpenAndDelete) {
// Verify that async Write() errors are mapped correctly.
TEST_F(FileStreamTest, AsyncWriteError) {
// Try opening file as read-only and then writing to it using FileStream.
- base::PlatformFile file = base::CreatePlatformFile(
- temp_file_path(),
- base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_ASYNC,
- NULL,
- NULL);
- ASSERT_NE(base::kInvalidPlatformFileValue, file);
-
- int flags = base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_WRITE |
- base::PLATFORM_FILE_ASYNC;
+ uint32 flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
+ base::File::FLAG_ASYNC;
+
+ base::File file(temp_file_path(), flags);
+ ASSERT_TRUE(file.IsValid());
+
scoped_ptr<FileStream> stream(
- new FileStream(file, flags, NULL, base::MessageLoopProxy::current()));
+ new FileStream(file.Pass(), NULL, base::MessageLoopProxy::current()));
scoped_refptr<IOBuffer> buf = new IOBuffer(1);
buf->data()[0] = 0;
@@ -1148,24 +1042,21 @@ TEST_F(FileStreamTest, AsyncWriteError) {
rv = callback.WaitForResult();
EXPECT_LT(rv, 0);
- base::ClosePlatformFile(file);
+ stream.reset();
+ base::RunLoop().RunUntilIdle();
}
// Verify that async Read() errors are mapped correctly.
TEST_F(FileStreamTest, AsyncReadError) {
// Try opening file for write and then reading from it using FileStream.
- base::PlatformFile file = base::CreatePlatformFile(
- temp_file_path(),
- base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE |
- base::PLATFORM_FILE_ASYNC,
- NULL,
- NULL);
- ASSERT_NE(base::kInvalidPlatformFileValue, file);
-
- int flags = base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_ASYNC;
+ uint32 flags = base::File::FLAG_OPEN | base::File::FLAG_WRITE |
+ base::File::FLAG_ASYNC;
+
+ base::File file(temp_file_path(), flags);
+ ASSERT_TRUE(file.IsValid());
+
scoped_ptr<FileStream> stream(
- new FileStream(file, flags, NULL, base::MessageLoopProxy::current()));
+ new FileStream(file.Pass(), NULL, base::MessageLoopProxy::current()));
scoped_refptr<IOBuffer> buf = new IOBuffer(1);
TestCompletionCallback callback;
@@ -1174,7 +1065,8 @@ TEST_F(FileStreamTest, AsyncReadError) {
rv = callback.WaitForResult();
EXPECT_LT(rv, 0);
- base::ClosePlatformFile(file);
+ stream.reset();
+ base::RunLoop().RunUntilIdle();
}
#if defined(OS_ANDROID)
@@ -1197,9 +1089,8 @@ TEST_F(FileStreamTest, ContentUriAsyncRead) {
EXPECT_LT(0, file_size);
FileStream stream(NULL, base::MessageLoopProxy::current());
- int flags = base::PLATFORM_FILE_OPEN |
- base::PLATFORM_FILE_READ |
- base::PLATFORM_FILE_ASYNC;
+ int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
+ base::File::FLAG_ASYNC;
TestCompletionCallback callback;
int rv = stream.Open(path, flags, callback.callback());
EXPECT_EQ(ERR_IO_PENDING, rv);
« net/base/file_stream_context.h ('K') | « net/base/file_stream_context_win.cc ('k') | net/base/upload_file_element_reader.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698