OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/base/upload_data_stream.h" | 5 #include "net/base/upload_data_stream.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/basictypes.h" | 10 #include "base/basictypes.h" |
(...skipping 25 matching lines...) Expand all Loading... |
36 const char kTestData[] = "0123456789"; | 36 const char kTestData[] = "0123456789"; |
37 const size_t kTestDataSize = arraysize(kTestData) - 1; | 37 const size_t kTestDataSize = arraysize(kTestData) - 1; |
38 const size_t kTestBufferSize = 1 << 14; // 16KB. | 38 const size_t kTestBufferSize = 1 << 14; // 16KB. |
39 | 39 |
40 // Reads data from the upload data stream, and returns the data as string. | 40 // Reads data from the upload data stream, and returns the data as string. |
41 std::string ReadFromUploadDataStream(UploadDataStream* stream) { | 41 std::string ReadFromUploadDataStream(UploadDataStream* stream) { |
42 std::string data_read; | 42 std::string data_read; |
43 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); | 43 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); |
44 while (!stream->IsEOF()) { | 44 while (!stream->IsEOF()) { |
45 TestCompletionCallback callback; | 45 TestCompletionCallback callback; |
46 const int result = stream->Read(buf, kTestBufferSize, callback.callback()); | 46 const int result = |
| 47 stream->Read(buf.get(), kTestBufferSize, callback.callback()); |
47 const int bytes_read = | 48 const int bytes_read = |
48 result != ERR_IO_PENDING ? result : callback.WaitForResult(); | 49 result != ERR_IO_PENDING ? result : callback.WaitForResult(); |
49 data_read.append(buf->data(), bytes_read); | 50 data_read.append(buf->data(), bytes_read); |
50 } | 51 } |
51 return data_read; | 52 return data_read; |
52 } | 53 } |
53 | 54 |
54 // A mock class of UploadElementReader. | 55 // A mock class of UploadElementReader. |
55 class MockUploadElementReader : public UploadElementReader { | 56 class MockUploadElementReader : public UploadElementReader { |
56 public: | 57 public: |
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
147 element_readers_.push_back(new UploadBytesElementReader( | 148 element_readers_.push_back(new UploadBytesElementReader( |
148 kTestData, kTestDataSize)); | 149 kTestData, kTestDataSize)); |
149 UploadDataStream stream(&element_readers_, 0); | 150 UploadDataStream stream(&element_readers_, 0); |
150 ASSERT_EQ(OK, stream.Init(CompletionCallback())); | 151 ASSERT_EQ(OK, stream.Init(CompletionCallback())); |
151 EXPECT_TRUE(stream.IsInMemory()); | 152 EXPECT_TRUE(stream.IsInMemory()); |
152 EXPECT_EQ(kTestDataSize, stream.size()); | 153 EXPECT_EQ(kTestDataSize, stream.size()); |
153 EXPECT_EQ(0U, stream.position()); | 154 EXPECT_EQ(0U, stream.position()); |
154 EXPECT_FALSE(stream.IsEOF()); | 155 EXPECT_FALSE(stream.IsEOF()); |
155 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); | 156 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); |
156 while (!stream.IsEOF()) { | 157 while (!stream.IsEOF()) { |
157 int bytes_read = stream.Read(buf, kTestBufferSize, CompletionCallback()); | 158 int bytes_read = |
| 159 stream.Read(buf.get(), kTestBufferSize, CompletionCallback()); |
158 ASSERT_LE(0, bytes_read); // Not an error. | 160 ASSERT_LE(0, bytes_read); // Not an error. |
159 } | 161 } |
160 EXPECT_EQ(kTestDataSize, stream.position()); | 162 EXPECT_EQ(kTestDataSize, stream.position()); |
161 ASSERT_TRUE(stream.IsEOF()); | 163 ASSERT_TRUE(stream.IsEOF()); |
162 } | 164 } |
163 | 165 |
164 TEST_F(UploadDataStreamTest, File) { | 166 TEST_F(UploadDataStreamTest, File) { |
165 base::FilePath temp_file_path; | 167 base::FilePath temp_file_path; |
166 ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(), | 168 ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(), |
167 &temp_file_path)); | 169 &temp_file_path)); |
168 ASSERT_EQ(static_cast<int>(kTestDataSize), | 170 ASSERT_EQ(static_cast<int>(kTestDataSize), |
169 file_util::WriteFile(temp_file_path, kTestData, kTestDataSize)); | 171 file_util::WriteFile(temp_file_path, kTestData, kTestDataSize)); |
170 | 172 |
171 element_readers_.push_back(new UploadFileElementReader( | 173 element_readers_.push_back(new UploadFileElementReader( |
172 base::MessageLoopProxy::current(), | 174 base::MessageLoopProxy::current(), |
173 temp_file_path, 0, kuint64max, base::Time())); | 175 temp_file_path, 0, kuint64max, base::Time())); |
174 | 176 |
175 TestCompletionCallback init_callback; | 177 TestCompletionCallback init_callback; |
176 UploadDataStream stream(&element_readers_, 0); | 178 UploadDataStream stream(&element_readers_, 0); |
177 ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback())); | 179 ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback())); |
178 ASSERT_EQ(OK, init_callback.WaitForResult()); | 180 ASSERT_EQ(OK, init_callback.WaitForResult()); |
179 EXPECT_FALSE(stream.IsInMemory()); | 181 EXPECT_FALSE(stream.IsInMemory()); |
180 EXPECT_EQ(kTestDataSize, stream.size()); | 182 EXPECT_EQ(kTestDataSize, stream.size()); |
181 EXPECT_EQ(0U, stream.position()); | 183 EXPECT_EQ(0U, stream.position()); |
182 EXPECT_FALSE(stream.IsEOF()); | 184 EXPECT_FALSE(stream.IsEOF()); |
183 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); | 185 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); |
184 while (!stream.IsEOF()) { | 186 while (!stream.IsEOF()) { |
185 TestCompletionCallback read_callback; | 187 TestCompletionCallback read_callback; |
186 ASSERT_EQ(ERR_IO_PENDING, | 188 ASSERT_EQ( |
187 stream.Read(buf, kTestBufferSize, read_callback.callback())); | 189 ERR_IO_PENDING, |
| 190 stream.Read(buf.get(), kTestBufferSize, read_callback.callback())); |
188 ASSERT_LE(0, read_callback.WaitForResult()); // Not an error. | 191 ASSERT_LE(0, read_callback.WaitForResult()); // Not an error. |
189 } | 192 } |
190 EXPECT_EQ(kTestDataSize, stream.position()); | 193 EXPECT_EQ(kTestDataSize, stream.position()); |
191 ASSERT_TRUE(stream.IsEOF()); | 194 ASSERT_TRUE(stream.IsEOF()); |
192 } | 195 } |
193 | 196 |
194 TEST_F(UploadDataStreamTest, FileSmallerThanLength) { | 197 TEST_F(UploadDataStreamTest, FileSmallerThanLength) { |
195 base::FilePath temp_file_path; | 198 base::FilePath temp_file_path; |
196 ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(), | 199 ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(), |
197 &temp_file_path)); | 200 &temp_file_path)); |
(...skipping 13 matching lines...) Expand all Loading... |
211 ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback())); | 214 ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback())); |
212 ASSERT_EQ(OK, init_callback.WaitForResult()); | 215 ASSERT_EQ(OK, init_callback.WaitForResult()); |
213 EXPECT_FALSE(stream.IsInMemory()); | 216 EXPECT_FALSE(stream.IsInMemory()); |
214 EXPECT_EQ(kFakeSize, stream.size()); | 217 EXPECT_EQ(kFakeSize, stream.size()); |
215 EXPECT_EQ(0U, stream.position()); | 218 EXPECT_EQ(0U, stream.position()); |
216 EXPECT_FALSE(stream.IsEOF()); | 219 EXPECT_FALSE(stream.IsEOF()); |
217 uint64 read_counter = 0; | 220 uint64 read_counter = 0; |
218 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); | 221 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); |
219 while (!stream.IsEOF()) { | 222 while (!stream.IsEOF()) { |
220 TestCompletionCallback read_callback; | 223 TestCompletionCallback read_callback; |
221 ASSERT_EQ(ERR_IO_PENDING, | 224 ASSERT_EQ( |
222 stream.Read(buf, kTestBufferSize, read_callback.callback())); | 225 ERR_IO_PENDING, |
| 226 stream.Read(buf.get(), kTestBufferSize, read_callback.callback())); |
223 int bytes_read = read_callback.WaitForResult(); | 227 int bytes_read = read_callback.WaitForResult(); |
224 ASSERT_LE(0, bytes_read); // Not an error. | 228 ASSERT_LE(0, bytes_read); // Not an error. |
225 read_counter += bytes_read; | 229 read_counter += bytes_read; |
226 EXPECT_EQ(read_counter, stream.position()); | 230 EXPECT_EQ(read_counter, stream.position()); |
227 } | 231 } |
228 // UpdateDataStream will pad out the file with 0 bytes so that the HTTP | 232 // UpdateDataStream will pad out the file with 0 bytes so that the HTTP |
229 // transaction doesn't hang. Therefore we expected the full size. | 233 // transaction doesn't hang. Therefore we expected the full size. |
230 EXPECT_EQ(kFakeSize, read_counter); | 234 EXPECT_EQ(kFakeSize, read_counter); |
231 EXPECT_EQ(read_counter, stream.position()); | 235 EXPECT_EQ(read_counter, stream.position()); |
232 } | 236 } |
(...skipping 16 matching lines...) Expand all Loading... |
249 ASSERT_EQ(OK, stream.Init(CompletionCallback())); | 253 ASSERT_EQ(OK, stream.Init(CompletionCallback())); |
250 EXPECT_EQ(kTestDataSize*2, stream.size()); | 254 EXPECT_EQ(kTestDataSize*2, stream.size()); |
251 EXPECT_EQ(0U, stream.position()); | 255 EXPECT_EQ(0U, stream.position()); |
252 EXPECT_FALSE(stream.IsEOF()); | 256 EXPECT_FALSE(stream.IsEOF()); |
253 | 257 |
254 // Prepare a buffer filled with non-zero data. | 258 // Prepare a buffer filled with non-zero data. |
255 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); | 259 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); |
256 std::fill_n(buf->data(), kTestBufferSize, -1); | 260 std::fill_n(buf->data(), kTestBufferSize, -1); |
257 | 261 |
258 // Read() results in success even when the reader returns error. | 262 // Read() results in success even when the reader returns error. |
259 EXPECT_EQ(static_cast<int>(kTestDataSize*2), | 263 EXPECT_EQ(static_cast<int>(kTestDataSize * 2), |
260 stream.Read(buf, kTestBufferSize, CompletionCallback())); | 264 stream.Read(buf.get(), kTestBufferSize, CompletionCallback())); |
261 EXPECT_EQ(kTestDataSize*2, stream.position()); | 265 EXPECT_EQ(kTestDataSize * 2, stream.position()); |
262 EXPECT_TRUE(stream.IsEOF()); | 266 EXPECT_TRUE(stream.IsEOF()); |
263 | 267 |
264 // The buffer is filled with zero. | 268 // The buffer is filled with zero. |
265 EXPECT_EQ(static_cast<int>(kTestDataSize*2), | 269 EXPECT_EQ(static_cast<int>(kTestDataSize*2), |
266 std::count(buf->data(), buf->data() + kTestBufferSize, 0)); | 270 std::count(buf->data(), buf->data() + kTestBufferSize, 0)); |
267 } | 271 } |
268 | 272 |
269 TEST_F(UploadDataStreamTest, ReadErrorAsync) { | 273 TEST_F(UploadDataStreamTest, ReadErrorAsync) { |
270 // This element cannot be read. | 274 // This element cannot be read. |
271 MockUploadElementReader* reader = | 275 MockUploadElementReader* reader = |
(...skipping 16 matching lines...) Expand all Loading... |
288 EXPECT_EQ(0U, stream.position()); | 292 EXPECT_EQ(0U, stream.position()); |
289 EXPECT_FALSE(stream.IsEOF()); | 293 EXPECT_FALSE(stream.IsEOF()); |
290 | 294 |
291 // Prepare a buffer filled with non-zero data. | 295 // Prepare a buffer filled with non-zero data. |
292 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); | 296 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); |
293 std::fill_n(buf->data(), kTestBufferSize, -1); | 297 std::fill_n(buf->data(), kTestBufferSize, -1); |
294 | 298 |
295 // Read() results in success even when the reader returns error. | 299 // Read() results in success even when the reader returns error. |
296 TestCompletionCallback read_callback; | 300 TestCompletionCallback read_callback; |
297 ASSERT_EQ(ERR_IO_PENDING, | 301 ASSERT_EQ(ERR_IO_PENDING, |
298 stream.Read(buf, kTestBufferSize, read_callback.callback())); | 302 stream.Read(buf.get(), kTestBufferSize, read_callback.callback())); |
299 EXPECT_EQ(static_cast<int>(kTestDataSize*2), read_callback.WaitForResult()); | 303 EXPECT_EQ(static_cast<int>(kTestDataSize * 2), read_callback.WaitForResult()); |
300 EXPECT_EQ(kTestDataSize*2, stream.position()); | 304 EXPECT_EQ(kTestDataSize*2, stream.position()); |
301 EXPECT_TRUE(stream.IsEOF()); | 305 EXPECT_TRUE(stream.IsEOF()); |
302 | 306 |
303 // The buffer is filled with zero. | 307 // The buffer is filled with zero. |
304 EXPECT_EQ(static_cast<int>(kTestDataSize*2), | 308 EXPECT_EQ(static_cast<int>(kTestDataSize*2), |
305 std::count(buf->data(), buf->data() + kTestBufferSize, 0)); | 309 std::count(buf->data(), buf->data() + kTestBufferSize, 0)); |
306 } | 310 } |
307 | 311 |
308 TEST_F(UploadDataStreamTest, FileAndBytes) { | 312 TEST_F(UploadDataStreamTest, FileAndBytes) { |
309 base::FilePath temp_file_path; | 313 base::FilePath temp_file_path; |
(...skipping 17 matching lines...) Expand all Loading... |
327 ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback())); | 331 ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback())); |
328 ASSERT_EQ(OK, init_callback.WaitForResult()); | 332 ASSERT_EQ(OK, init_callback.WaitForResult()); |
329 EXPECT_FALSE(stream.IsInMemory()); | 333 EXPECT_FALSE(stream.IsInMemory()); |
330 EXPECT_EQ(kStreamSize, stream.size()); | 334 EXPECT_EQ(kStreamSize, stream.size()); |
331 EXPECT_EQ(0U, stream.position()); | 335 EXPECT_EQ(0U, stream.position()); |
332 EXPECT_FALSE(stream.IsEOF()); | 336 EXPECT_FALSE(stream.IsEOF()); |
333 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); | 337 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); |
334 while (!stream.IsEOF()) { | 338 while (!stream.IsEOF()) { |
335 TestCompletionCallback read_callback; | 339 TestCompletionCallback read_callback; |
336 const int result = | 340 const int result = |
337 stream.Read(buf, kTestBufferSize, read_callback.callback()); | 341 stream.Read(buf.get(), kTestBufferSize, read_callback.callback()); |
338 const int bytes_read = | 342 const int bytes_read = |
339 result != ERR_IO_PENDING ? result : read_callback.WaitForResult(); | 343 result != ERR_IO_PENDING ? result : read_callback.WaitForResult(); |
340 ASSERT_LE(0, bytes_read); // Not an error. | 344 ASSERT_LE(0, bytes_read); // Not an error. |
341 } | 345 } |
342 EXPECT_EQ(kStreamSize, stream.position()); | 346 EXPECT_EQ(kStreamSize, stream.position()); |
343 ASSERT_TRUE(stream.IsEOF()); | 347 ASSERT_TRUE(stream.IsEOF()); |
344 } | 348 } |
345 | 349 |
346 TEST_F(UploadDataStreamTest, Chunk) { | 350 TEST_F(UploadDataStreamTest, Chunk) { |
347 const uint64 kStreamSize = kTestDataSize*2; | 351 const uint64 kStreamSize = kTestDataSize*2; |
348 UploadDataStream stream(UploadDataStream::CHUNKED, 0); | 352 UploadDataStream stream(UploadDataStream::CHUNKED, 0); |
349 stream.AppendChunk(kTestData, kTestDataSize, false); | 353 stream.AppendChunk(kTestData, kTestDataSize, false); |
350 stream.AppendChunk(kTestData, kTestDataSize, true); | 354 stream.AppendChunk(kTestData, kTestDataSize, true); |
351 | 355 |
352 ASSERT_EQ(OK, stream.Init(CompletionCallback())); | 356 ASSERT_EQ(OK, stream.Init(CompletionCallback())); |
353 EXPECT_FALSE(stream.IsInMemory()); | 357 EXPECT_FALSE(stream.IsInMemory()); |
354 EXPECT_EQ(0U, stream.size()); // Content-Length is 0 for chunked data. | 358 EXPECT_EQ(0U, stream.size()); // Content-Length is 0 for chunked data. |
355 EXPECT_EQ(0U, stream.position()); | 359 EXPECT_EQ(0U, stream.position()); |
356 EXPECT_FALSE(stream.IsEOF()); | 360 EXPECT_FALSE(stream.IsEOF()); |
357 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); | 361 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); |
358 while (!stream.IsEOF()) { | 362 while (!stream.IsEOF()) { |
359 int bytes_read = stream.Read(buf, kTestBufferSize, CompletionCallback()); | 363 int bytes_read = |
| 364 stream.Read(buf.get(), kTestBufferSize, CompletionCallback()); |
360 ASSERT_LE(0, bytes_read); // Not an error. | 365 ASSERT_LE(0, bytes_read); // Not an error. |
361 } | 366 } |
362 EXPECT_EQ(kStreamSize, stream.position()); | 367 EXPECT_EQ(kStreamSize, stream.position()); |
363 ASSERT_TRUE(stream.IsEOF()); | 368 ASSERT_TRUE(stream.IsEOF()); |
364 } | 369 } |
365 | 370 |
366 // Init() with on-memory and not-on-memory readers. | 371 // Init() with on-memory and not-on-memory readers. |
367 TEST_F(UploadDataStreamTest, InitAsync) { | 372 TEST_F(UploadDataStreamTest, InitAsync) { |
368 // Create UploadDataStream with mock readers. | 373 // Create UploadDataStream with mock readers. |
369 MockUploadElementReader* reader = NULL; | 374 MockUploadElementReader* reader = NULL; |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
439 element_readers_.push_back(new UploadBytesElementReader( | 444 element_readers_.push_back(new UploadBytesElementReader( |
440 kTestData, kTestDataSize)); | 445 kTestData, kTestDataSize)); |
441 UploadDataStream stream(&element_readers_, 0); | 446 UploadDataStream stream(&element_readers_, 0); |
442 | 447 |
443 ASSERT_EQ(OK, stream.Init(CompletionCallback())); | 448 ASSERT_EQ(OK, stream.Init(CompletionCallback())); |
444 EXPECT_TRUE(stream.IsInMemory()); | 449 EXPECT_TRUE(stream.IsInMemory()); |
445 EXPECT_EQ(kTestDataSize, stream.size()); | 450 EXPECT_EQ(kTestDataSize, stream.size()); |
446 EXPECT_EQ(0U, stream.position()); | 451 EXPECT_EQ(0U, stream.position()); |
447 EXPECT_FALSE(stream.IsEOF()); | 452 EXPECT_FALSE(stream.IsEOF()); |
448 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestDataSize); | 453 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestDataSize); |
449 int bytes_read = stream.Read(buf, kTestDataSize, CompletionCallback()); | 454 int bytes_read = stream.Read(buf.get(), kTestDataSize, CompletionCallback()); |
450 ASSERT_EQ(static_cast<int>(kTestDataSize), bytes_read); // Not an error. | 455 ASSERT_EQ(static_cast<int>(kTestDataSize), bytes_read); // Not an error. |
451 EXPECT_EQ(kTestDataSize, stream.position()); | 456 EXPECT_EQ(kTestDataSize, stream.position()); |
452 ASSERT_TRUE(stream.IsEOF()); | 457 ASSERT_TRUE(stream.IsEOF()); |
453 } | 458 } |
454 | 459 |
455 // Async Read() with on-memory and not-on-memory readers. | 460 // Async Read() with on-memory and not-on-memory readers. |
456 TEST_F(UploadDataStreamTest, ReadAsync) { | 461 TEST_F(UploadDataStreamTest, ReadAsync) { |
457 // Create UploadDataStream with mock readers. | 462 // Create UploadDataStream with mock readers. |
458 MockUploadElementReader* reader = NULL; | 463 MockUploadElementReader* reader = NULL; |
459 | 464 |
(...skipping 22 matching lines...) Expand all Loading... |
482 // Run Init(). | 487 // Run Init(). |
483 TestCompletionCallback init_callback; | 488 TestCompletionCallback init_callback; |
484 EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback())); | 489 EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback())); |
485 EXPECT_EQ(OK, init_callback.WaitForResult()); | 490 EXPECT_EQ(OK, init_callback.WaitForResult()); |
486 | 491 |
487 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); | 492 scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize); |
488 | 493 |
489 // Consume the first element. | 494 // Consume the first element. |
490 TestCompletionCallback read_callback1; | 495 TestCompletionCallback read_callback1; |
491 EXPECT_EQ(static_cast<int>(kTestDataSize), | 496 EXPECT_EQ(static_cast<int>(kTestDataSize), |
492 stream.Read(buf, kTestDataSize, read_callback1.callback())); | 497 stream.Read(buf.get(), kTestDataSize, read_callback1.callback())); |
493 base::MessageLoop::current()->RunUntilIdle(); | 498 base::MessageLoop::current()->RunUntilIdle(); |
494 EXPECT_FALSE(read_callback1.have_result()); | 499 EXPECT_FALSE(read_callback1.have_result()); |
495 | 500 |
496 // Consume the second element. | 501 // Consume the second element. |
497 TestCompletionCallback read_callback2; | 502 TestCompletionCallback read_callback2; |
498 ASSERT_EQ(ERR_IO_PENDING, | 503 ASSERT_EQ(ERR_IO_PENDING, |
499 stream.Read(buf, kTestDataSize, read_callback2.callback())); | 504 stream.Read(buf.get(), kTestDataSize, read_callback2.callback())); |
500 EXPECT_EQ(static_cast<int>(kTestDataSize), read_callback2.WaitForResult()); | 505 EXPECT_EQ(static_cast<int>(kTestDataSize), read_callback2.WaitForResult()); |
501 | 506 |
502 // Consume the third and the fourth elements. | 507 // Consume the third and the fourth elements. |
503 TestCompletionCallback read_callback3; | 508 TestCompletionCallback read_callback3; |
504 ASSERT_EQ(ERR_IO_PENDING, | 509 ASSERT_EQ( |
505 stream.Read(buf, kTestDataSize*2, read_callback3.callback())); | 510 ERR_IO_PENDING, |
506 EXPECT_EQ(static_cast<int>(kTestDataSize*2), read_callback3.WaitForResult()); | 511 stream.Read(buf.get(), kTestDataSize * 2, read_callback3.callback())); |
| 512 EXPECT_EQ(static_cast<int>(kTestDataSize * 2), |
| 513 read_callback3.WaitForResult()); |
507 } | 514 } |
508 | 515 |
509 void UploadDataStreamTest::FileChangedHelper(const base::FilePath& file_path, | 516 void UploadDataStreamTest::FileChangedHelper(const base::FilePath& file_path, |
510 const base::Time& time, | 517 const base::Time& time, |
511 bool error_expected) { | 518 bool error_expected) { |
512 // Don't use element_readers_ here, as this function is called twice, and | 519 // Don't use element_readers_ here, as this function is called twice, and |
513 // reusing element_readers_ is wrong. | 520 // reusing element_readers_ is wrong. |
514 ScopedVector<UploadElementReader> element_readers; | 521 ScopedVector<UploadElementReader> element_readers; |
515 element_readers.push_back(new UploadFileElementReader( | 522 element_readers.push_back(new UploadFileElementReader( |
516 base::MessageLoopProxy::current(), file_path, 1, 2, time)); | 523 base::MessageLoopProxy::current(), file_path, 1, 2, time)); |
(...skipping 131 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
648 TestCompletionCallback init_callback1; | 655 TestCompletionCallback init_callback1; |
649 ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback())); | 656 ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback())); |
650 EXPECT_EQ(OK, init_callback1.WaitForResult()); | 657 EXPECT_EQ(OK, init_callback1.WaitForResult()); |
651 EXPECT_FALSE(stream.IsEOF()); | 658 EXPECT_FALSE(stream.IsEOF()); |
652 EXPECT_EQ(kTestDataSize*2, stream.size()); | 659 EXPECT_EQ(kTestDataSize*2, stream.size()); |
653 | 660 |
654 // Read some. | 661 // Read some. |
655 TestCompletionCallback read_callback1; | 662 TestCompletionCallback read_callback1; |
656 std::vector<char> buf(kTestDataSize + kTestDataSize/2); | 663 std::vector<char> buf(kTestDataSize + kTestDataSize/2); |
657 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); | 664 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); |
658 EXPECT_EQ(ERR_IO_PENDING, stream.Read(wrapped_buffer, buf.size(), | 665 EXPECT_EQ( |
659 read_callback1.callback())); | 666 ERR_IO_PENDING, |
| 667 stream.Read(wrapped_buffer.get(), buf.size(), read_callback1.callback())); |
660 EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult()); | 668 EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult()); |
661 EXPECT_EQ(buf.size(), stream.position()); | 669 EXPECT_EQ(buf.size(), stream.position()); |
662 | 670 |
663 // Call Init to reset the state. | 671 // Call Init to reset the state. |
664 TestCompletionCallback init_callback2; | 672 TestCompletionCallback init_callback2; |
665 ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback())); | 673 ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback())); |
666 EXPECT_EQ(OK, init_callback2.WaitForResult()); | 674 EXPECT_EQ(OK, init_callback2.WaitForResult()); |
667 EXPECT_FALSE(stream.IsEOF()); | 675 EXPECT_FALSE(stream.IsEOF()); |
668 EXPECT_EQ(kTestDataSize*2, stream.size()); | 676 EXPECT_EQ(kTestDataSize*2, stream.size()); |
669 | 677 |
670 // Read. | 678 // Read. |
671 TestCompletionCallback read_callback2; | 679 TestCompletionCallback read_callback2; |
672 std::vector<char> buf2(kTestDataSize*2); | 680 std::vector<char> buf2(kTestDataSize*2); |
673 scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]); | 681 scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]); |
674 EXPECT_EQ(ERR_IO_PENDING, stream.Read(wrapped_buffer2, buf2.size(), | 682 EXPECT_EQ(ERR_IO_PENDING, |
675 read_callback2.callback())); | 683 stream.Read( |
| 684 wrapped_buffer2.get(), buf2.size(), read_callback2.callback())); |
676 EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult()); | 685 EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult()); |
677 EXPECT_EQ(expected_data, buf2); | 686 EXPECT_EQ(expected_data, buf2); |
678 } | 687 } |
679 | 688 |
680 TEST_F(UploadDataStreamTest, InitDuringAsyncInit) { | 689 TEST_F(UploadDataStreamTest, InitDuringAsyncInit) { |
681 base::FilePath temp_file_path; | 690 base::FilePath temp_file_path; |
682 ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(), | 691 ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_dir_.path(), |
683 &temp_file_path)); | 692 &temp_file_path)); |
684 ASSERT_EQ(static_cast<int>(kTestDataSize), | 693 ASSERT_EQ(static_cast<int>(kTestDataSize), |
685 file_util::WriteFile(temp_file_path, kTestData, kTestDataSize)); | 694 file_util::WriteFile(temp_file_path, kTestData, kTestDataSize)); |
(...skipping 18 matching lines...) Expand all Loading... |
704 TestCompletionCallback init_callback2; | 713 TestCompletionCallback init_callback2; |
705 EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback())); | 714 EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback())); |
706 EXPECT_EQ(OK, init_callback2.WaitForResult()); | 715 EXPECT_EQ(OK, init_callback2.WaitForResult()); |
707 EXPECT_FALSE(stream.IsEOF()); | 716 EXPECT_FALSE(stream.IsEOF()); |
708 EXPECT_EQ(kTestDataSize*2, stream.size()); | 717 EXPECT_EQ(kTestDataSize*2, stream.size()); |
709 | 718 |
710 // Read. | 719 // Read. |
711 TestCompletionCallback read_callback2; | 720 TestCompletionCallback read_callback2; |
712 std::vector<char> buf2(kTestDataSize*2); | 721 std::vector<char> buf2(kTestDataSize*2); |
713 scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]); | 722 scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]); |
714 EXPECT_EQ(ERR_IO_PENDING, stream.Read(wrapped_buffer2, buf2.size(), | 723 EXPECT_EQ(ERR_IO_PENDING, |
715 read_callback2.callback())); | 724 stream.Read( |
| 725 wrapped_buffer2.get(), buf2.size(), read_callback2.callback())); |
716 EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult()); | 726 EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult()); |
717 EXPECT_EQ(expected_data, buf2); | 727 EXPECT_EQ(expected_data, buf2); |
718 EXPECT_TRUE(stream.IsEOF()); | 728 EXPECT_TRUE(stream.IsEOF()); |
719 | 729 |
720 // Make sure callbacks are not called for cancelled operations. | 730 // Make sure callbacks are not called for cancelled operations. |
721 EXPECT_FALSE(init_callback1.have_result()); | 731 EXPECT_FALSE(init_callback1.have_result()); |
722 } | 732 } |
723 | 733 |
724 TEST_F(UploadDataStreamTest, InitDuringAsyncRead) { | 734 TEST_F(UploadDataStreamTest, InitDuringAsyncRead) { |
725 base::FilePath temp_file_path; | 735 base::FilePath temp_file_path; |
(...skipping 18 matching lines...) Expand all Loading... |
744 TestCompletionCallback init_callback1; | 754 TestCompletionCallback init_callback1; |
745 ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback())); | 755 ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback())); |
746 EXPECT_EQ(OK, init_callback1.WaitForResult()); | 756 EXPECT_EQ(OK, init_callback1.WaitForResult()); |
747 EXPECT_FALSE(stream.IsEOF()); | 757 EXPECT_FALSE(stream.IsEOF()); |
748 EXPECT_EQ(kTestDataSize*2, stream.size()); | 758 EXPECT_EQ(kTestDataSize*2, stream.size()); |
749 | 759 |
750 // Start reading. | 760 // Start reading. |
751 TestCompletionCallback read_callback1; | 761 TestCompletionCallback read_callback1; |
752 std::vector<char> buf(kTestDataSize*2); | 762 std::vector<char> buf(kTestDataSize*2); |
753 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); | 763 scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]); |
754 EXPECT_EQ(ERR_IO_PENDING, stream.Read(wrapped_buffer, buf.size(), | 764 EXPECT_EQ( |
755 read_callback1.callback())); | 765 ERR_IO_PENDING, |
| 766 stream.Read(wrapped_buffer.get(), buf.size(), read_callback1.callback())); |
756 | 767 |
757 // Call Init to cancel the previous read. | 768 // Call Init to cancel the previous read. |
758 TestCompletionCallback init_callback2; | 769 TestCompletionCallback init_callback2; |
759 EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback())); | 770 EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback())); |
760 EXPECT_EQ(OK, init_callback2.WaitForResult()); | 771 EXPECT_EQ(OK, init_callback2.WaitForResult()); |
761 EXPECT_FALSE(stream.IsEOF()); | 772 EXPECT_FALSE(stream.IsEOF()); |
762 EXPECT_EQ(kTestDataSize*2, stream.size()); | 773 EXPECT_EQ(kTestDataSize*2, stream.size()); |
763 | 774 |
764 // Read. | 775 // Read. |
765 TestCompletionCallback read_callback2; | 776 TestCompletionCallback read_callback2; |
766 std::vector<char> buf2(kTestDataSize*2); | 777 std::vector<char> buf2(kTestDataSize*2); |
767 scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]); | 778 scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]); |
768 EXPECT_EQ(ERR_IO_PENDING, stream.Read(wrapped_buffer2, buf2.size(), | 779 EXPECT_EQ(ERR_IO_PENDING, |
769 read_callback2.callback())); | 780 stream.Read( |
| 781 wrapped_buffer2.get(), buf2.size(), read_callback2.callback())); |
770 EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult()); | 782 EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult()); |
771 EXPECT_EQ(expected_data, buf2); | 783 EXPECT_EQ(expected_data, buf2); |
772 EXPECT_TRUE(stream.IsEOF()); | 784 EXPECT_TRUE(stream.IsEOF()); |
773 | 785 |
774 // Make sure callbacks are not called for cancelled operations. | 786 // Make sure callbacks are not called for cancelled operations. |
775 EXPECT_FALSE(read_callback1.have_result()); | 787 EXPECT_FALSE(read_callback1.have_result()); |
776 } | 788 } |
777 | 789 |
778 } // namespace net | 790 } // namespace net |
OLD | NEW |