elements_upload_data_stream_unittest.cc 33 KB

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