net/base/upload_data_stream_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/base/upload_data_stream.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "base/bind.h"
  12 #include "base/files/file_path.h"
  13 #include "base/files/file_util.h"
  14 #include "base/files/scoped_temp_dir.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/message_loop/message_loop.h"
  17 #include "base/run_loop.h"
  18 #include "base/time/time.h"
  19 #include "net/base/io_buffer.h"
  20 #include "net/base/net_errors.h"
  21 #include "net/base/test_completion_callback.h"
  22 #include "net/base/upload_bytes_element_reader.h"
  23 #include "net/base/upload_file_element_reader.h"
  24 #include "testing/gmock/include/gmock/gmock.h"
  25 #include "testing/gtest/include/gtest/gtest.h"
  26 #include "testing/platform_test.h"
  27
  28 using ::testing::DoAll;
  29 using ::testing::Invoke;
  30 using ::testing::Return;
  31 using ::testing::_;
  32
  33 namespace net {
  34
  35 namespace {
  36
  37 const char kTestData[] = "0123456789";
  38 const size_t kTestDataSize = arraysize(kTestData) - 1;
  39 const size_t kTestBufferSize = 1 << 14;  // 16KB.
  40
  41 // Reads data from the upload data stream, and returns the data as string.
  42 std::string ReadFromUploadDataStream(UploadDataStream* stream) {
  43   std::string data_read;
  44   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
  45   while (!stream->IsEOF()) {
  46     TestCompletionCallback callback;
  47     const int result =
  48         stream->Read(buf.get(), kTestBufferSize, callback.callback());
  49     const int bytes_read =
  50         result != ERR_IO_PENDING ? result : callback.WaitForResult();
  51     data_read.append(buf->data(), bytes_read);
  52   }
  53   return data_read;
  54 }
  55
  56 // A mock class of UploadElementReader.
  57 class MockUploadElementReader : public UploadElementReader {
  58  public:
  59   MockUploadElementReader(int content_length, bool is_in_memory)
  60       : content_length_(content_length),
  61         bytes_remaining_(content_length),
  62         is_in_memory_(is_in_memory),
  63         init_result_(OK),
  64         read_result_(OK) {}
  65
  66   virtual ~MockUploadElementReader() {}
  67
  68   // UploadElementReader overrides.
  69   MOCK_METHOD1(Init, int(const CompletionCallback& callback));
  70   virtual uint64 GetContentLength() const OVERRIDE { return content_length_; }
  71   virtual uint64 BytesRemaining() const OVERRIDE { return bytes_remaining_; }
  72   virtual bool IsInMemory() const OVERRIDE { return is_in_memory_; }
  73   MOCK_METHOD3(Read, int(IOBuffer* buf,
  74                          int buf_length,
  75                          const CompletionCallback& callback));
  76
  77   // Sets expectation to return the specified result from Init() asynchronously.
  78   void SetAsyncInitExpectation(int result) {
  79     init_result_ = result;
  80     EXPECT_CALL(*this, Init(_))
  81         .WillOnce(DoAll(Invoke(this, &MockUploadElementReader::OnInit),
  82                         Return(ERR_IO_PENDING)));
  83   }
  84
  85   // Sets expectation to return the specified result from Read().
  86   void SetReadExpectation(int result) {
  87     read_result_ = result;
  88     EXPECT_CALL(*this, Read(_, _, _))
  89         .WillOnce(Invoke(this, &MockUploadElementReader::OnRead));
  90   }
  91
  92  private:
  93   void OnInit(const CompletionCallback& callback) {
  94     base::MessageLoop::current()->PostTask(FROM_HERE,
  95                                            base::Bind(callback, init_result_));
  96   }
  97
  98   int OnRead(IOBuffer* buf,
  99              int buf_length,
 100              const CompletionCallback& callback) {
 101     if (read_result_ > 0)
 102       bytes_remaining_ = std::max(0, bytes_remaining_ - read_result_);
 103     if (IsInMemory()) {
 104       return read_result_;
 105     } else {
 106       base::MessageLoop::current()->PostTask(
 107           FROM_HERE, base::Bind(callback, read_result_));
 108       return ERR_IO_PENDING;
 109     }
 110   }
 111
 112   int content_length_;
 113   int bytes_remaining_;
 114   bool is_in_memory_;
 115
 116   // Result value returned from Init().
 117   int init_result_;
 118
 119   // Result value returned from Read().
 120   int read_result_;
 121 };
 122
 123 }  // namespace
 124
 125 class UploadDataStreamTest : public PlatformTest {
 126  public:
 127   virtual void SetUp() {
 128     PlatformTest::SetUp();
 129     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 130   }
 131   virtual ~UploadDataStreamTest() {
 132     element_readers_.clear();
 133     base::RunLoop().RunUntilIdle();
 134   }
 135
 136   void FileChangedHelper(const base::FilePath& file_path,
 137                          const base::Time& time,
 138                          bool error_expected);
 139
 140   base::ScopedTempDir temp_dir_;
 141   ScopedVector<UploadElementReader> element_readers_;
 142 };
 143
 144 TEST_F(UploadDataStreamTest, EmptyUploadData) {
 145   UploadDataStream stream(element_readers_.Pass(), 0);
 146   ASSERT_EQ(OK, stream.Init(CompletionCallback()));
 147   EXPECT_TRUE(stream.IsInMemory());
 148   EXPECT_EQ(0U, stream.size());
 149   EXPECT_EQ(0U, stream.position());
 150   EXPECT_TRUE(stream.IsEOF());
 151 }
 152
 153 TEST_F(UploadDataStreamTest, ConsumeAllBytes) {
 154   element_readers_.push_back(new UploadBytesElementReader(
 155       kTestData, kTestDataSize));
 156   UploadDataStream stream(element_readers_.Pass(), 0);
 157   ASSERT_EQ(OK, stream.Init(CompletionCallback()));
 158   EXPECT_TRUE(stream.IsInMemory());
 159   EXPECT_EQ(kTestDataSize, stream.size());
 160   EXPECT_EQ(0U, stream.position());
 161   EXPECT_FALSE(stream.IsEOF());
 162   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
 163   while (!stream.IsEOF()) {
 164     int bytes_read =
 165         stream.Read(buf.get(), kTestBufferSize, CompletionCallback());
 166     ASSERT_LE(0, bytes_read);  // Not an error.
 167   }
 168   EXPECT_EQ(kTestDataSize, stream.position());
 169   ASSERT_TRUE(stream.IsEOF());
 170 }
 171
 172 TEST_F(UploadDataStreamTest, File) {
 173   base::FilePath temp_file_path;
 174   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
 175                                              &temp_file_path));
 176   ASSERT_EQ(static_cast<int>(kTestDataSize),
 177             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 178
 179   element_readers_.push_back(
 180       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
 181                                   temp_file_path,
 182                                   0,
 183                                   kuint64max,
 184                                   base::Time()));
 185
 186   TestCompletionCallback init_callback;
 187   UploadDataStream stream(element_readers_.Pass(), 0);
 188   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
 189   ASSERT_EQ(OK, init_callback.WaitForResult());
 190   EXPECT_FALSE(stream.IsInMemory());
 191   EXPECT_EQ(kTestDataSize, stream.size());
 192   EXPECT_EQ(0U, stream.position());
 193   EXPECT_FALSE(stream.IsEOF());
 194   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
 195   while (!stream.IsEOF()) {
 196     TestCompletionCallback read_callback;
 197     ASSERT_EQ(
 198         ERR_IO_PENDING,
 199         stream.Read(buf.get(), kTestBufferSize, read_callback.callback()));
 200     ASSERT_LE(0, read_callback.WaitForResult());  // Not an error.
 201   }
 202   EXPECT_EQ(kTestDataSize, stream.position());
 203   ASSERT_TRUE(stream.IsEOF());
 204 }
 205
 206 TEST_F(UploadDataStreamTest, FileSmallerThanLength) {
 207   base::FilePath temp_file_path;
 208   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
 209                                              &temp_file_path));
 210   ASSERT_EQ(static_cast<int>(kTestDataSize),
 211             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 212   const uint64 kFakeSize = kTestDataSize*2;
 213
 214   UploadFileElementReader::ScopedOverridingContentLengthForTests
 215       overriding_content_length(kFakeSize);
 216
 217   element_readers_.push_back(
 218       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
 219                                   temp_file_path,
 220                                   0,
 221                                   kuint64max,
 222                                   base::Time()));
 223
 224   TestCompletionCallback init_callback;
 225   UploadDataStream stream(element_readers_.Pass(), 0);
 226   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
 227   ASSERT_EQ(OK, init_callback.WaitForResult());
 228   EXPECT_FALSE(stream.IsInMemory());
 229   EXPECT_EQ(kFakeSize, stream.size());
 230   EXPECT_EQ(0U, stream.position());
 231   EXPECT_FALSE(stream.IsEOF());
 232   uint64 read_counter = 0;
 233   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
 234   while (!stream.IsEOF()) {
 235     TestCompletionCallback read_callback;
 236     ASSERT_EQ(
 237         ERR_IO_PENDING,
 238         stream.Read(buf.get(), kTestBufferSize, read_callback.callback()));
 239     int bytes_read = read_callback.WaitForResult();
 240     ASSERT_LE(0, bytes_read);  // Not an error.
 241     read_counter += bytes_read;
 242     EXPECT_EQ(read_counter, stream.position());
 243   }
 244   // UpdateDataStream will pad out the file with 0 bytes so that the HTTP
 245   // transaction doesn't hang.  Therefore we expected the full size.
 246   EXPECT_EQ(kFakeSize, read_counter);
 247   EXPECT_EQ(read_counter, stream.position());
 248 }
 249
 250 TEST_F(UploadDataStreamTest, ReadErrorSync) {
 251   // This element cannot be read.
 252   MockUploadElementReader* reader =
 253       new MockUploadElementReader(kTestDataSize, true);
 254   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
 255   reader->SetReadExpectation(ERR_FAILED);
 256   element_readers_.push_back(reader);
 257
 258   // This element is ignored because of the error from the previous reader.
 259   element_readers_.push_back(new UploadBytesElementReader(
 260       kTestData, kTestDataSize));
 261
 262   UploadDataStream stream(element_readers_.Pass(), 0);
 263
 264   // Run Init().
 265   ASSERT_EQ(OK, stream.Init(CompletionCallback()));
 266   EXPECT_EQ(kTestDataSize*2, stream.size());
 267   EXPECT_EQ(0U, stream.position());
 268   EXPECT_FALSE(stream.IsEOF());
 269
 270   // Prepare a buffer filled with non-zero data.
 271   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
 272   std::fill_n(buf->data(), kTestBufferSize, -1);
 273
 274   // Read() results in success even when the reader returns error.
 275   EXPECT_EQ(static_cast<int>(kTestDataSize * 2),
 276             stream.Read(buf.get(), kTestBufferSize, CompletionCallback()));
 277   EXPECT_EQ(kTestDataSize * 2, stream.position());
 278   EXPECT_TRUE(stream.IsEOF());
 279
 280   // The buffer is filled with zero.
 281   EXPECT_EQ(static_cast<int>(kTestDataSize*2),
 282             std::count(buf->data(), buf->data() + kTestBufferSize, 0));
 283 }
 284
 285 TEST_F(UploadDataStreamTest, ReadErrorAsync) {
 286   // This element cannot be read.
 287   MockUploadElementReader* reader =
 288       new MockUploadElementReader(kTestDataSize, false);
 289   reader->SetAsyncInitExpectation(OK);
 290   reader->SetReadExpectation(ERR_FAILED);
 291   element_readers_.push_back(reader);
 292
 293   // This element is ignored because of the error from the previous reader.
 294   element_readers_.push_back(new UploadBytesElementReader(
 295       kTestData, kTestDataSize));
 296
 297   UploadDataStream stream(element_readers_.Pass(), 0);
 298
 299   // Run Init().
 300   TestCompletionCallback init_callback;
 301   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
 302   EXPECT_EQ(OK, init_callback.WaitForResult());
 303   EXPECT_EQ(kTestDataSize*2, stream.size());
 304   EXPECT_EQ(0U, stream.position());
 305   EXPECT_FALSE(stream.IsEOF());
 306
 307   // Prepare a buffer filled with non-zero data.
 308   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
 309   std::fill_n(buf->data(), kTestBufferSize, -1);
 310
 311   // Read() results in success even when the reader returns error.
 312   TestCompletionCallback read_callback;
 313   ASSERT_EQ(ERR_IO_PENDING,
 314             stream.Read(buf.get(), kTestBufferSize, read_callback.callback()));
 315   EXPECT_EQ(static_cast<int>(kTestDataSize * 2), read_callback.WaitForResult());
 316   EXPECT_EQ(kTestDataSize*2, stream.position());
 317   EXPECT_TRUE(stream.IsEOF());
 318
 319   // The buffer is filled with zero.
 320   EXPECT_EQ(static_cast<int>(kTestDataSize*2),
 321             std::count(buf->data(), buf->data() + kTestBufferSize, 0));
 322 }
 323
 324 TEST_F(UploadDataStreamTest, FileAndBytes) {
 325   base::FilePath temp_file_path;
 326   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
 327                                              &temp_file_path));
 328   ASSERT_EQ(static_cast<int>(kTestDataSize),
 329             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 330
 331   const uint64 kFileRangeOffset = 1;
 332   const uint64 kFileRangeLength = 4;
 333   element_readers_.push_back(
 334       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
 335                                   temp_file_path,
 336                                   kFileRangeOffset,
 337                                   kFileRangeLength,
 338                                   base::Time()));
 339
 340   element_readers_.push_back(new UploadBytesElementReader(
 341       kTestData, kTestDataSize));
 342
 343   const uint64 kStreamSize = kTestDataSize + kFileRangeLength;
 344   TestCompletionCallback init_callback;
 345   UploadDataStream stream(element_readers_.Pass(), 0);
 346   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
 347   ASSERT_EQ(OK, init_callback.WaitForResult());
 348   EXPECT_FALSE(stream.IsInMemory());
 349   EXPECT_EQ(kStreamSize, stream.size());
 350   EXPECT_EQ(0U, stream.position());
 351   EXPECT_FALSE(stream.IsEOF());
 352   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
 353   while (!stream.IsEOF()) {
 354     TestCompletionCallback read_callback;
 355     const int result =
 356         stream.Read(buf.get(), kTestBufferSize, read_callback.callback());
 357     const int bytes_read =
 358         result != ERR_IO_PENDING ? result : read_callback.WaitForResult();
 359     ASSERT_LE(0, bytes_read);  // Not an error.
 360   }
 361   EXPECT_EQ(kStreamSize, stream.position());
 362   ASSERT_TRUE(stream.IsEOF());
 363 }
 364
 365 TEST_F(UploadDataStreamTest, Chunk) {
 366   const uint64 kStreamSize = kTestDataSize*2;
 367   UploadDataStream stream(UploadDataStream::CHUNKED, 0);
 368   stream.AppendChunk(kTestData, kTestDataSize, false);
 369   stream.AppendChunk(kTestData, kTestDataSize, true);
 370
 371   ASSERT_EQ(OK, stream.Init(CompletionCallback()));
 372   EXPECT_FALSE(stream.IsInMemory());
 373   EXPECT_EQ(0U, stream.size());  // Content-Length is 0 for chunked data.
 374   EXPECT_EQ(0U, stream.position());
 375   EXPECT_FALSE(stream.IsEOF());
 376   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
 377   while (!stream.IsEOF()) {
 378     int bytes_read =
 379         stream.Read(buf.get(), kTestBufferSize, CompletionCallback());
 380     ASSERT_LE(0, bytes_read);  // Not an error.
 381   }
 382   EXPECT_EQ(kStreamSize, stream.position());
 383   ASSERT_TRUE(stream.IsEOF());
 384 }
 385
 386 // Init() with on-memory and not-on-memory readers.
 387 TEST_F(UploadDataStreamTest, InitAsync) {
 388   // Create UploadDataStream with mock readers.
 389   MockUploadElementReader* reader = NULL;
 390
 391   reader = new MockUploadElementReader(kTestDataSize, true);
 392   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
 393   element_readers_.push_back(reader);
 394
 395   reader = new MockUploadElementReader(kTestDataSize, true);
 396   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
 397   element_readers_.push_back(reader);
 398
 399   reader = new MockUploadElementReader(kTestDataSize, false);
 400   reader->SetAsyncInitExpectation(OK);
 401   element_readers_.push_back(reader);
 402
 403   reader = new MockUploadElementReader(kTestDataSize, false);
 404   reader->SetAsyncInitExpectation(OK);
 405   element_readers_.push_back(reader);
 406
 407   reader = new MockUploadElementReader(kTestDataSize, true);
 408   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
 409   element_readers_.push_back(reader);
 410
 411   UploadDataStream stream(element_readers_.Pass(), 0);
 412
 413   // Run Init().
 414   TestCompletionCallback callback;
 415   ASSERT_EQ(ERR_IO_PENDING, stream.Init(callback.callback()));
 416   EXPECT_EQ(OK, callback.WaitForResult());
 417 }
 418
 419 // Init() of a reader fails asynchronously.
 420 TEST_F(UploadDataStreamTest, InitAsyncFailureAsync) {
 421   // Create UploadDataStream with a mock reader.
 422   MockUploadElementReader* reader = NULL;
 423
 424   reader = new MockUploadElementReader(kTestDataSize, false);
 425   reader->SetAsyncInitExpectation(ERR_FAILED);
 426   element_readers_.push_back(reader);
 427
 428   UploadDataStream stream(element_readers_.Pass(), 0);
 429
 430   // Run Init().
 431   TestCompletionCallback callback;
 432   ASSERT_EQ(ERR_IO_PENDING, stream.Init(callback.callback()));
 433   EXPECT_EQ(ERR_FAILED, callback.WaitForResult());
 434 }
 435
 436 // Init() of a reader fails synchronously.
 437 TEST_F(UploadDataStreamTest, InitAsyncFailureSync) {
 438   // Create UploadDataStream with mock readers.
 439   MockUploadElementReader* reader = NULL;
 440
 441   reader = new MockUploadElementReader(kTestDataSize, false);
 442   reader->SetAsyncInitExpectation(OK);
 443   element_readers_.push_back(reader);
 444
 445   reader = new MockUploadElementReader(kTestDataSize, true);
 446   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(ERR_FAILED));
 447   element_readers_.push_back(reader);
 448
 449   UploadDataStream stream(element_readers_.Pass(), 0);
 450
 451   // Run Init().
 452   TestCompletionCallback callback;
 453   ASSERT_EQ(ERR_IO_PENDING, stream.Init(callback.callback()));
 454   EXPECT_EQ(ERR_FAILED, callback.WaitForResult());
 455 }
 456
 457 // Read with a buffer whose size is same as the data.
 458 TEST_F(UploadDataStreamTest, ReadAsyncWithExactSizeBuffer) {
 459   element_readers_.push_back(new UploadBytesElementReader(
 460       kTestData, kTestDataSize));
 461   UploadDataStream stream(element_readers_.Pass(), 0);
 462
 463   ASSERT_EQ(OK, stream.Init(CompletionCallback()));
 464   EXPECT_TRUE(stream.IsInMemory());
 465   EXPECT_EQ(kTestDataSize, stream.size());
 466   EXPECT_EQ(0U, stream.position());
 467   EXPECT_FALSE(stream.IsEOF());
 468   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestDataSize);
 469   int bytes_read = stream.Read(buf.get(), kTestDataSize, CompletionCallback());
 470   ASSERT_EQ(static_cast<int>(kTestDataSize), bytes_read);  // Not an error.
 471   EXPECT_EQ(kTestDataSize, stream.position());
 472   ASSERT_TRUE(stream.IsEOF());
 473 }
 474
 475 // Async Read() with on-memory and not-on-memory readers.
 476 TEST_F(UploadDataStreamTest, ReadAsync) {
 477   // Create UploadDataStream with mock readers.
 478   MockUploadElementReader* reader = NULL;
 479
 480   reader = new MockUploadElementReader(kTestDataSize, true);
 481   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
 482   reader->SetReadExpectation(kTestDataSize);
 483   element_readers_.push_back(reader);
 484
 485   reader = new MockUploadElementReader(kTestDataSize, false);
 486   reader->SetAsyncInitExpectation(OK);
 487   reader->SetReadExpectation(kTestDataSize);
 488   element_readers_.push_back(reader);
 489
 490   reader = new MockUploadElementReader(kTestDataSize, true);
 491   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
 492   reader->SetReadExpectation(kTestDataSize);
 493   element_readers_.push_back(reader);
 494
 495   reader = new MockUploadElementReader(kTestDataSize, false);
 496   reader->SetAsyncInitExpectation(OK);
 497   reader->SetReadExpectation(kTestDataSize);
 498   element_readers_.push_back(reader);
 499
 500   UploadDataStream stream(element_readers_.Pass(), 0);
 501
 502   // Run Init().
 503   TestCompletionCallback init_callback;
 504   EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
 505   EXPECT_EQ(OK, init_callback.WaitForResult());
 506
 507   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
 508
 509   // Consume the first element.
 510   TestCompletionCallback read_callback1;
 511   EXPECT_EQ(static_cast<int>(kTestDataSize),
 512             stream.Read(buf.get(), kTestDataSize, read_callback1.callback()));
 513   base::MessageLoop::current()->RunUntilIdle();
 514   EXPECT_FALSE(read_callback1.have_result());
 515
 516   // Consume the second element.
 517   TestCompletionCallback read_callback2;
 518   ASSERT_EQ(ERR_IO_PENDING,
 519             stream.Read(buf.get(), kTestDataSize, read_callback2.callback()));
 520   EXPECT_EQ(static_cast<int>(kTestDataSize), read_callback2.WaitForResult());
 521
 522   // Consume the third and the fourth elements.
 523   TestCompletionCallback read_callback3;
 524   ASSERT_EQ(
 525       ERR_IO_PENDING,
 526       stream.Read(buf.get(), kTestDataSize * 2, read_callback3.callback()));
 527   EXPECT_EQ(static_cast<int>(kTestDataSize * 2),
 528             read_callback3.WaitForResult());
 529 }
 530
 531 void UploadDataStreamTest::FileChangedHelper(const base::FilePath& file_path,
 532                                              const base::Time& time,
 533                                              bool error_expected) {
 534   // Don't use element_readers_ here, as this function is called twice, and
 535   // reusing element_readers_ is wrong.
 536   ScopedVector<UploadElementReader> element_readers;
 537   element_readers.push_back(new UploadFileElementReader(
 538       base::MessageLoopProxy::current().get(), file_path, 1, 2, time));
 539
 540   TestCompletionCallback init_callback;
 541   UploadDataStream stream(element_readers.Pass(), 0);
 542   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
 543   int error_code = init_callback.WaitForResult();
 544   if (error_expected)
 545     ASSERT_EQ(ERR_UPLOAD_FILE_CHANGED, error_code);
 546   else
 547     ASSERT_EQ(OK, error_code);
 548 }
 549
 550 TEST_F(UploadDataStreamTest, FileChanged) {
 551   base::FilePath temp_file_path;
 552   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
 553                                              &temp_file_path));
 554   ASSERT_EQ(static_cast<int>(kTestDataSize),
 555             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 556
 557   base::File::Info file_info;
 558   ASSERT_TRUE(base::GetFileInfo(temp_file_path, &file_info));
 559
 560   // Test file not changed.
 561   FileChangedHelper(temp_file_path, file_info.last_modified, false);
 562
 563   // Test file changed.
 564   FileChangedHelper(temp_file_path,
 565                     file_info.last_modified - base::TimeDelta::FromSeconds(1),
 566                     true);
 567 }
 568
 569 TEST_F(UploadDataStreamTest, MultipleInit) {
 570   base::FilePath temp_file_path;
 571   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
 572                                              &temp_file_path));
 573   ASSERT_EQ(static_cast<int>(kTestDataSize),
 574             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 575
 576   // Prepare data.
 577   element_readers_.push_back(new UploadBytesElementReader(
 578       kTestData, kTestDataSize));
 579   element_readers_.push_back(
 580       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
 581                                   temp_file_path,
 582                                   0,
 583                                   kuint64max,
 584                                   base::Time()));
 585   UploadDataStream stream(element_readers_.Pass(), 0);
 586
 587   std::string expected_data(kTestData, kTestData + kTestDataSize);
 588   expected_data += expected_data;
 589
 590   // Call Init().
 591   TestCompletionCallback init_callback1;
 592   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
 593   ASSERT_EQ(OK, init_callback1.WaitForResult());
 594   EXPECT_FALSE(stream.IsEOF());
 595   EXPECT_EQ(kTestDataSize*2, stream.size());
 596
 597   // Read.
 598   EXPECT_EQ(expected_data, ReadFromUploadDataStream(&stream));
 599   EXPECT_TRUE(stream.IsEOF());
 600
 601   // Call Init() again to reset.
 602   TestCompletionCallback init_callback2;
 603   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback()));
 604   ASSERT_EQ(OK, init_callback2.WaitForResult());
 605   EXPECT_FALSE(stream.IsEOF());
 606   EXPECT_EQ(kTestDataSize*2, stream.size());
 607
 608   // Read again.
 609   EXPECT_EQ(expected_data, ReadFromUploadDataStream(&stream));
 610   EXPECT_TRUE(stream.IsEOF());
 611 }
 612
 613 TEST_F(UploadDataStreamTest, MultipleInitAsync) {
 614   base::FilePath temp_file_path;
 615   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
 616                                              &temp_file_path));
 617   ASSERT_EQ(static_cast<int>(kTestDataSize),
 618             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 619   TestCompletionCallback test_callback;
 620
 621   // Prepare data.
 622   element_readers_.push_back(new UploadBytesElementReader(
 623       kTestData, kTestDataSize));
 624   element_readers_.push_back(
 625       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
 626                                   temp_file_path,
 627                                   0,
 628                                   kuint64max,
 629                                   base::Time()));
 630   UploadDataStream stream(element_readers_.Pass(), 0);
 631
 632   std::string expected_data(kTestData, kTestData + kTestDataSize);
 633   expected_data += expected_data;
 634
 635   // Call Init().
 636   ASSERT_EQ(ERR_IO_PENDING, stream.Init(test_callback.callback()));
 637   EXPECT_EQ(OK, test_callback.WaitForResult());
 638   EXPECT_FALSE(stream.IsEOF());
 639   EXPECT_EQ(kTestDataSize*2, stream.size());
 640
 641   // Read.
 642   EXPECT_EQ(expected_data, ReadFromUploadDataStream(&stream));
 643   EXPECT_TRUE(stream.IsEOF());
 644
 645   // Call Init() again to reset.
 646   ASSERT_EQ(ERR_IO_PENDING, stream.Init(test_callback.callback()));
 647   EXPECT_EQ(OK, test_callback.WaitForResult());
 648   EXPECT_FALSE(stream.IsEOF());
 649   EXPECT_EQ(kTestDataSize*2, stream.size());
 650
 651   // Read again.
 652   EXPECT_EQ(expected_data, ReadFromUploadDataStream(&stream));
 653   EXPECT_TRUE(stream.IsEOF());
 654 }
 655
 656 TEST_F(UploadDataStreamTest, InitToReset) {
 657   base::FilePath temp_file_path;
 658   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
 659                                              &temp_file_path));
 660   ASSERT_EQ(static_cast<int>(kTestDataSize),
 661             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 662
 663   // Prepare data.
 664   element_readers_.push_back(new UploadBytesElementReader(
 665       kTestData, kTestDataSize));
 666   element_readers_.push_back(
 667       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
 668                                   temp_file_path,
 669                                   0,
 670                                   kuint64max,
 671                                   base::Time()));
 672   UploadDataStream stream(element_readers_.Pass(), 0);
 673
 674   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
 675   expected_data.insert(expected_data.end(), expected_data.begin(),
 676                        expected_data.begin() + kTestDataSize);
 677
 678   // Call Init().
 679   TestCompletionCallback init_callback1;
 680   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
 681   EXPECT_EQ(OK, init_callback1.WaitForResult());
 682   EXPECT_FALSE(stream.IsEOF());
 683   EXPECT_EQ(kTestDataSize*2, stream.size());
 684
 685   // Read some.
 686   TestCompletionCallback read_callback1;
 687   std::vector<char> buf(kTestDataSize + kTestDataSize/2);
 688   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
 689   EXPECT_EQ(
 690       ERR_IO_PENDING,
 691       stream.Read(wrapped_buffer.get(), buf.size(), read_callback1.callback()));
 692   EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult());
 693   EXPECT_EQ(buf.size(), stream.position());
 694
 695   // Call Init to reset the state.
 696   TestCompletionCallback init_callback2;
 697   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback()));
 698   EXPECT_EQ(OK, init_callback2.WaitForResult());
 699   EXPECT_FALSE(stream.IsEOF());
 700   EXPECT_EQ(kTestDataSize*2, stream.size());
 701
 702   // Read.
 703   TestCompletionCallback read_callback2;
 704   std::vector<char> buf2(kTestDataSize*2);
 705   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
 706   EXPECT_EQ(ERR_IO_PENDING,
 707             stream.Read(
 708                 wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
 709   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
 710   EXPECT_EQ(expected_data, buf2);
 711 }
 712
 713 TEST_F(UploadDataStreamTest, InitDuringAsyncInit) {
 714   base::FilePath temp_file_path;
 715   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
 716                                              &temp_file_path));
 717   ASSERT_EQ(static_cast<int>(kTestDataSize),
 718             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 719
 720   // Prepare data.
 721   element_readers_.push_back(new UploadBytesElementReader(
 722       kTestData, kTestDataSize));
 723   element_readers_.push_back(
 724       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
 725                                   temp_file_path,
 726                                   0,
 727                                   kuint64max,
 728                                   base::Time()));
 729   UploadDataStream stream(element_readers_.Pass(), 0);
 730
 731   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
 732   expected_data.insert(expected_data.end(), expected_data.begin(),
 733                        expected_data.begin() + kTestDataSize);
 734
 735   // Start Init.
 736   TestCompletionCallback init_callback1;
 737   EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
 738
 739   // Call Init again to cancel the previous init.
 740   TestCompletionCallback init_callback2;
 741   EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback()));
 742   EXPECT_EQ(OK, init_callback2.WaitForResult());
 743   EXPECT_FALSE(stream.IsEOF());
 744   EXPECT_EQ(kTestDataSize*2, stream.size());
 745
 746   // Read.
 747   TestCompletionCallback read_callback2;
 748   std::vector<char> buf2(kTestDataSize*2);
 749   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
 750   EXPECT_EQ(ERR_IO_PENDING,
 751             stream.Read(
 752                 wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
 753   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
 754   EXPECT_EQ(expected_data, buf2);
 755   EXPECT_TRUE(stream.IsEOF());
 756
 757   // Make sure callbacks are not called for cancelled operations.
 758   EXPECT_FALSE(init_callback1.have_result());
 759 }
 760
 761 TEST_F(UploadDataStreamTest, InitDuringAsyncRead) {
 762   base::FilePath temp_file_path;
 763   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
 764                                              &temp_file_path));
 765   ASSERT_EQ(static_cast<int>(kTestDataSize),
 766             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 767
 768   // Prepare data.
 769   element_readers_.push_back(new UploadBytesElementReader(
 770       kTestData, kTestDataSize));
 771   element_readers_.push_back(
 772       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
 773                                   temp_file_path,
 774                                   0,
 775                                   kuint64max,
 776                                   base::Time()));
 777   UploadDataStream stream(element_readers_.Pass(), 0);
 778
 779   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
 780   expected_data.insert(expected_data.end(), expected_data.begin(),
 781                        expected_data.begin() + kTestDataSize);
 782
 783   // Call Init().
 784   TestCompletionCallback init_callback1;
 785   ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
 786   EXPECT_EQ(OK, init_callback1.WaitForResult());
 787   EXPECT_FALSE(stream.IsEOF());
 788   EXPECT_EQ(kTestDataSize*2, stream.size());
 789
 790   // Start reading.
 791   TestCompletionCallback read_callback1;
 792   std::vector<char> buf(kTestDataSize*2);
 793   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
 794   EXPECT_EQ(
 795       ERR_IO_PENDING,
 796       stream.Read(wrapped_buffer.get(), buf.size(), read_callback1.callback()));
 797
 798   // Call Init to cancel the previous read.
 799   TestCompletionCallback init_callback2;
 800   EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback()));
 801   EXPECT_EQ(OK, init_callback2.WaitForResult());
 802   EXPECT_FALSE(stream.IsEOF());
 803   EXPECT_EQ(kTestDataSize*2, stream.size());
 804
 805   // Read.
 806   TestCompletionCallback read_callback2;
 807   std::vector<char> buf2(kTestDataSize*2);
 808   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
 809   EXPECT_EQ(ERR_IO_PENDING,
 810             stream.Read(
 811                 wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
 812   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
 813   EXPECT_EQ(expected_data, buf2);
 814   EXPECT_TRUE(stream.IsEOF());
 815
 816   // Make sure callbacks are not called for cancelled operations.
 817   EXPECT_FALSE(read_callback1.have_result());
 818 }
 819
 820 }  // namespace net