From 4db27d802c70279a1e54f028c35eb9ff658fdd6c Mon Sep 17 00:00:00 2001 From: "hashimoto@chromium.org" Date: Thu, 20 Dec 2012 11:50:24 +0000 Subject: net: Split sync part of UploadFileElementReader as UploadFileElementReaderSync Add UploadFileElementReaderSync and use it from Chrome Frame. Remove UploadDataStream::InitSync/ReadSync Remove UploadElementReader::InitSync/ReadSync Allow passing null callbacks for Init/Read when callers can be confident that the operation finishes synchronously. BUG=None TEST=net_unittests, chrome_frame_net_tests TBR=ananta@chromium.org for chrome_frame/urlmon_upload_data_stream.cc Review URL: https://chromiumcodereview.appspot.com/11587007 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@174133 0039d316-1c4b-4281-b951-d872f2087c98 --- net/base/upload_file_element_reader_unittest.cc | 273 +++++++++++++++--------- 1 file changed, 173 insertions(+), 100 deletions(-) (limited to 'net/base/upload_file_element_reader_unittest.cc') diff --git a/net/base/upload_file_element_reader_unittest.cc b/net/base/upload_file_element_reader_unittest.cc index f43aad1..4915635 100644 --- a/net/base/upload_file_element_reader_unittest.cc +++ b/net/base/upload_file_element_reader_unittest.cc @@ -31,7 +31,9 @@ class UploadFileElementReaderTest : public PlatformTest { reader_.reset(new UploadFileElementReader( temp_file_path_, 0, kuint64max, base::Time())); - ASSERT_EQ(OK, reader_->InitSync()); + TestCompletionCallback callback; + ASSERT_EQ(ERR_IO_PENDING, reader_->Init(callback.callback())); + EXPECT_EQ(OK, callback.WaitForResult()); EXPECT_EQ(bytes_.size(), reader_->GetContentLength()); EXPECT_EQ(bytes_.size(), reader_->BytesRemaining()); EXPECT_FALSE(reader_->IsInMemory()); @@ -48,13 +50,17 @@ TEST_F(UploadFileElementReaderTest, ReadPartially) { ASSERT_EQ(bytes_.size(), kHalfSize * 2); std::vector buf(kHalfSize); scoped_refptr wrapped_buffer = new WrappedIOBuffer(&buf[0]); - EXPECT_EQ(static_cast(buf.size()), - reader_->ReadSync(wrapped_buffer, buf.size())); + TestCompletionCallback read_callback1; + ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(), + read_callback1.callback())); + EXPECT_EQ(static_cast(buf.size()), read_callback1.WaitForResult()); EXPECT_EQ(bytes_.size() - buf.size(), reader_->BytesRemaining()); EXPECT_EQ(std::vector(bytes_.begin(), bytes_.begin() + kHalfSize), buf); - EXPECT_EQ(static_cast(buf.size()), - reader_->ReadSync(wrapped_buffer, buf.size())); + TestCompletionCallback read_callback2; + EXPECT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(), + read_callback2.callback())); + EXPECT_EQ(static_cast(buf.size()), read_callback2.WaitForResult()); EXPECT_EQ(0U, reader_->BytesRemaining()); EXPECT_EQ(std::vector(bytes_.begin() + kHalfSize, bytes_.end()), buf); } @@ -62,20 +68,25 @@ TEST_F(UploadFileElementReaderTest, ReadPartially) { TEST_F(UploadFileElementReaderTest, ReadAll) { std::vector buf(bytes_.size()); scoped_refptr wrapped_buffer = new WrappedIOBuffer(&buf[0]); - EXPECT_EQ(static_cast(buf.size()), - reader_->ReadSync(wrapped_buffer, buf.size())); + TestCompletionCallback read_callback; + ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(), + read_callback.callback())); + EXPECT_EQ(static_cast(buf.size()), read_callback.WaitForResult()); EXPECT_EQ(0U, reader_->BytesRemaining()); EXPECT_EQ(bytes_, buf); // Try to read again. - EXPECT_EQ(0, reader_->ReadSync(wrapped_buffer, buf.size())); + EXPECT_EQ(0, reader_->Read(wrapped_buffer, buf.size(), + read_callback.callback())); } TEST_F(UploadFileElementReaderTest, ReadTooMuch) { const size_t kTooLargeSize = bytes_.size() * 2; std::vector buf(kTooLargeSize); scoped_refptr wrapped_buffer = new WrappedIOBuffer(&buf[0]); - EXPECT_EQ(static_cast(bytes_.size()), - reader_->ReadSync(wrapped_buffer, buf.size())); + TestCompletionCallback read_callback; + ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(), + read_callback.callback())); + EXPECT_EQ(static_cast(bytes_.size()), read_callback.WaitForResult()); EXPECT_EQ(0U, reader_->BytesRemaining()); buf.resize(bytes_.size()); // Resize to compare. EXPECT_EQ(bytes_, buf); @@ -86,99 +97,25 @@ TEST_F(UploadFileElementReaderTest, MultipleInit) { scoped_refptr wrapped_buffer = new WrappedIOBuffer(&buf[0]); // Read all. - EXPECT_EQ(static_cast(buf.size()), - reader_->ReadSync(wrapped_buffer, buf.size())); - EXPECT_EQ(0U, reader_->BytesRemaining()); - EXPECT_EQ(bytes_, buf); - - // Call InitSync() again to reset the state. - ASSERT_EQ(OK, reader_->InitSync()); - EXPECT_EQ(bytes_.size(), reader_->GetContentLength()); - EXPECT_EQ(bytes_.size(), reader_->BytesRemaining()); - - // Read again. - EXPECT_EQ(static_cast(buf.size()), - reader_->ReadSync(wrapped_buffer, buf.size())); - EXPECT_EQ(0U, reader_->BytesRemaining()); - EXPECT_EQ(bytes_, buf); -} - -TEST_F(UploadFileElementReaderTest, ReadPartiallyAsync) { - const size_t kHalfSize = bytes_.size() / 2; - ASSERT_EQ(bytes_.size(), kHalfSize * 2); - std::vector buf(kHalfSize); - scoped_refptr wrapped_buffer = new WrappedIOBuffer(&buf[0]); - TestCompletionCallback test_callback; - EXPECT_EQ(ERR_IO_PENDING, - reader_->Read(wrapped_buffer, buf.size(), - test_callback.callback())); - - EXPECT_EQ(static_cast(buf.size()), test_callback.WaitForResult()); - EXPECT_EQ(bytes_.size() - buf.size(), reader_->BytesRemaining()); - EXPECT_EQ(std::vector(bytes_.begin(), bytes_.begin() + kHalfSize), buf); - - EXPECT_EQ(ERR_IO_PENDING, - reader_->Read(wrapped_buffer, buf.size(), - test_callback.callback())); - - EXPECT_EQ(static_cast(buf.size()), test_callback.WaitForResult()); - EXPECT_EQ(0U, reader_->BytesRemaining()); - EXPECT_EQ(std::vector(bytes_.begin() + kHalfSize, bytes_.end()), buf); -} - -TEST_F(UploadFileElementReaderTest, ReadAllAsync) { - std::vector buf(bytes_.size()); - scoped_refptr wrapped_buffer = new WrappedIOBuffer(&buf[0]); - TestCompletionCallback test_callback; - EXPECT_EQ(ERR_IO_PENDING, - reader_->Read(wrapped_buffer, buf.size(), - test_callback.callback())); - - EXPECT_EQ(static_cast(buf.size()), test_callback.WaitForResult()); - EXPECT_EQ(0U, reader_->BytesRemaining()); - EXPECT_EQ(bytes_, buf); - // Try to read again. - EXPECT_EQ(0, reader_->ReadSync(wrapped_buffer, buf.size())); -} - -TEST_F(UploadFileElementReaderTest, ReadTooMuchAsync) { - const size_t kTooLargeSize = bytes_.size() * 2; - std::vector buf(kTooLargeSize); - scoped_refptr wrapped_buffer = new WrappedIOBuffer(&buf[0]); - TestCompletionCallback test_callback; - EXPECT_EQ(ERR_IO_PENDING, - reader_->Read(wrapped_buffer, buf.size(), - test_callback.callback())); - - EXPECT_EQ(static_cast(bytes_.size()), test_callback.WaitForResult()); - EXPECT_EQ(0U, reader_->BytesRemaining()); - buf.resize(bytes_.size()); // Resize to compare. - EXPECT_EQ(bytes_, buf); -} - -TEST_F(UploadFileElementReaderTest, MultipleInitAsync) { - std::vector buf(bytes_.size()); - scoped_refptr wrapped_buffer = new WrappedIOBuffer(&buf[0]); - TestCompletionCallback test_callback; - - // Read all. - EXPECT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(), - test_callback.callback())); - EXPECT_EQ(static_cast(buf.size()), test_callback.WaitForResult()); + TestCompletionCallback read_callback1; + ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(), + read_callback1.callback())); + EXPECT_EQ(static_cast(buf.size()), read_callback1.WaitForResult()); EXPECT_EQ(0U, reader_->BytesRemaining()); EXPECT_EQ(bytes_, buf); // Call Init() again to reset the state. - EXPECT_EQ(ERR_IO_PENDING, reader_->Init(test_callback.callback())); - EXPECT_EQ(OK, test_callback.WaitForResult()); + TestCompletionCallback init_callback; + ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback())); + EXPECT_EQ(OK, init_callback.WaitForResult()); EXPECT_EQ(bytes_.size(), reader_->GetContentLength()); EXPECT_EQ(bytes_.size(), reader_->BytesRemaining()); // Read again. - EXPECT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(), - test_callback.callback())); - - EXPECT_EQ(static_cast(buf.size()), test_callback.WaitForResult()); + TestCompletionCallback read_callback2; + ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, buf.size(), + read_callback2.callback())); + EXPECT_EQ(static_cast(buf.size()), read_callback2.WaitForResult()); EXPECT_EQ(0U, reader_->BytesRemaining()); EXPECT_EQ(bytes_, buf); } @@ -224,13 +161,17 @@ TEST_F(UploadFileElementReaderTest, Range) { const uint64 kLength = bytes_.size() - kOffset * 3; reader_.reset(new UploadFileElementReader( temp_file_path_, kOffset, kLength, base::Time())); - ASSERT_EQ(OK, reader_->InitSync()); + TestCompletionCallback init_callback; + ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback())); + EXPECT_EQ(OK, init_callback.WaitForResult()); EXPECT_EQ(kLength, reader_->GetContentLength()); EXPECT_EQ(kLength, reader_->BytesRemaining()); std::vector buf(kLength); scoped_refptr wrapped_buffer = new WrappedIOBuffer(&buf[0]); - EXPECT_EQ(static_cast(kLength), - reader_->ReadSync(wrapped_buffer, kLength)); + TestCompletionCallback read_callback; + ASSERT_EQ(ERR_IO_PENDING, reader_->Read(wrapped_buffer, kLength, + read_callback.callback())); + EXPECT_EQ(static_cast(kLength), read_callback.WaitForResult()); const std::vector expected(bytes_.begin() + kOffset, bytes_.begin() + kOffset + kLength); EXPECT_EQ(expected, buf); @@ -245,14 +186,146 @@ TEST_F(UploadFileElementReaderTest, FileChanged) { info.last_modified - base::TimeDelta::FromSeconds(1); reader_.reset(new UploadFileElementReader( temp_file_path_, 0, kuint64max, expected_modification_time)); - EXPECT_EQ(ERR_UPLOAD_FILE_CHANGED, reader_->InitSync()); + TestCompletionCallback init_callback; + ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback())); + EXPECT_EQ(ERR_UPLOAD_FILE_CHANGED, init_callback.WaitForResult()); } TEST_F(UploadFileElementReaderTest, WrongPath) { const FilePath wrong_path(FILE_PATH_LITERAL("wrong_path")); reader_.reset(new UploadFileElementReader( wrong_path, 0, kuint64max, base::Time())); - ASSERT_EQ(OK, reader_->InitSync()); + TestCompletionCallback init_callback; + ASSERT_EQ(ERR_IO_PENDING, reader_->Init(init_callback.callback())); + EXPECT_EQ(OK, init_callback.WaitForResult()); + EXPECT_EQ(0U, reader_->GetContentLength()); + EXPECT_EQ(0U, reader_->BytesRemaining()); +} + + +class UploadFileElementReaderSyncTest : public PlatformTest { + protected: + virtual void SetUp() OVERRIDE { + // Some tests (*.ReadPartially) rely on bytes_.size() being even. + const char kData[] = "123456789abcdefghi"; + bytes_.assign(kData, kData + arraysize(kData) - 1); + + ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); + + ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(), + &temp_file_path_)); + ASSERT_EQ( + static_cast(bytes_.size()), + file_util::WriteFile(temp_file_path_, &bytes_[0], bytes_.size())); + + reader_.reset(new UploadFileElementReaderSync( + temp_file_path_, 0, kuint64max, base::Time())); + ASSERT_EQ(OK, reader_->Init(CompletionCallback())); + EXPECT_EQ(bytes_.size(), reader_->GetContentLength()); + EXPECT_EQ(bytes_.size(), reader_->BytesRemaining()); + EXPECT_FALSE(reader_->IsInMemory()); + } + + std::vector bytes_; + scoped_ptr reader_; + base::ScopedTempDir temp_dir_; + FilePath temp_file_path_; +}; + +TEST_F(UploadFileElementReaderSyncTest, ReadPartially) { + const size_t kHalfSize = bytes_.size() / 2; + ASSERT_EQ(bytes_.size(), kHalfSize * 2); + std::vector buf(kHalfSize); + scoped_refptr wrapped_buffer = new WrappedIOBuffer(&buf[0]); + EXPECT_EQ(static_cast(buf.size()), + reader_->Read(wrapped_buffer, buf.size(), CompletionCallback())); + EXPECT_EQ(bytes_.size() - buf.size(), reader_->BytesRemaining()); + EXPECT_EQ(std::vector(bytes_.begin(), bytes_.begin() + kHalfSize), buf); + + EXPECT_EQ(static_cast(buf.size()), + reader_->Read(wrapped_buffer, buf.size(), CompletionCallback())); + EXPECT_EQ(0U, reader_->BytesRemaining()); + EXPECT_EQ(std::vector(bytes_.begin() + kHalfSize, bytes_.end()), buf); +} + +TEST_F(UploadFileElementReaderSyncTest, ReadAll) { + std::vector buf(bytes_.size()); + scoped_refptr wrapped_buffer = new WrappedIOBuffer(&buf[0]); + EXPECT_EQ(static_cast(buf.size()), + reader_->Read(wrapped_buffer, buf.size(), CompletionCallback())); + EXPECT_EQ(0U, reader_->BytesRemaining()); + EXPECT_EQ(bytes_, buf); + // Try to read again. + EXPECT_EQ(0, reader_->Read(wrapped_buffer, buf.size(), CompletionCallback())); +} + +TEST_F(UploadFileElementReaderSyncTest, ReadTooMuch) { + const size_t kTooLargeSize = bytes_.size() * 2; + std::vector buf(kTooLargeSize); + scoped_refptr wrapped_buffer = new WrappedIOBuffer(&buf[0]); + EXPECT_EQ(static_cast(bytes_.size()), + reader_->Read(wrapped_buffer, buf.size(), CompletionCallback())); + EXPECT_EQ(0U, reader_->BytesRemaining()); + buf.resize(bytes_.size()); // Resize to compare. + EXPECT_EQ(bytes_, buf); +} + +TEST_F(UploadFileElementReaderSyncTest, MultipleInit) { + std::vector buf(bytes_.size()); + scoped_refptr wrapped_buffer = new WrappedIOBuffer(&buf[0]); + + // Read all. + EXPECT_EQ(static_cast(buf.size()), + reader_->Read(wrapped_buffer, buf.size(), CompletionCallback())); + EXPECT_EQ(0U, reader_->BytesRemaining()); + EXPECT_EQ(bytes_, buf); + + // Call Init() again to reset the state. + ASSERT_EQ(OK, reader_->Init(CompletionCallback())); + EXPECT_EQ(bytes_.size(), reader_->GetContentLength()); + EXPECT_EQ(bytes_.size(), reader_->BytesRemaining()); + + // Read again. + EXPECT_EQ(static_cast(buf.size()), + reader_->Read(wrapped_buffer, buf.size(), CompletionCallback())); + EXPECT_EQ(0U, reader_->BytesRemaining()); + EXPECT_EQ(bytes_, buf); +} + +TEST_F(UploadFileElementReaderSyncTest, Range) { + const uint64 kOffset = 2; + const uint64 kLength = bytes_.size() - kOffset * 3; + reader_.reset(new UploadFileElementReaderSync( + temp_file_path_, kOffset, kLength, base::Time())); + ASSERT_EQ(OK, reader_->Init(CompletionCallback())); + EXPECT_EQ(kLength, reader_->GetContentLength()); + EXPECT_EQ(kLength, reader_->BytesRemaining()); + std::vector buf(kLength); + scoped_refptr wrapped_buffer = new WrappedIOBuffer(&buf[0]); + EXPECT_EQ(static_cast(kLength), + reader_->Read(wrapped_buffer, kLength, CompletionCallback())); + const std::vector expected(bytes_.begin() + kOffset, + bytes_.begin() + kOffset + kLength); + EXPECT_EQ(expected, buf); +} + +TEST_F(UploadFileElementReaderSyncTest, FileChanged) { + base::PlatformFileInfo info; + ASSERT_TRUE(file_util::GetFileInfo(temp_file_path_, &info)); + + // Expect one second before the actual modification time to simulate change. + const base::Time expected_modification_time = + info.last_modified - base::TimeDelta::FromSeconds(1); + reader_.reset(new UploadFileElementReaderSync( + temp_file_path_, 0, kuint64max, expected_modification_time)); + EXPECT_EQ(ERR_UPLOAD_FILE_CHANGED, reader_->Init(CompletionCallback())); +} + +TEST_F(UploadFileElementReaderSyncTest, WrongPath) { + const FilePath wrong_path(FILE_PATH_LITERAL("wrong_path")); + reader_.reset(new UploadFileElementReaderSync( + wrong_path, 0, kuint64max, base::Time())); + ASSERT_EQ(OK, reader_->Init(CompletionCallback())); EXPECT_EQ(0U, reader_->GetContentLength()); EXPECT_EQ(0U, reader_->BytesRemaining()); } -- cgit v1.1