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 "content/browser/byte_stream.h" 6 7 #include <deque> 8 #include <limits> 9 10 #include "base/bind.h" 11 #include "base/callback.h" 12 #include "base/memory/ref_counted.h" 13 #include "base/message_loop/message_loop.h" 14 #include "base/test/test_simple_task_runner.h" 15 #include "net/base/io_buffer.h" 16 #include "testing/gtest/include/gtest/gtest.h" 17 18 namespace content { 19 namespace { 20 21 void CountCallbacks(int* counter) { 22 ++*counter; 23 } 24 25 } // namespace 26 27 class ByteStreamTest : public testing::Test { 28 public: 29 ByteStreamTest(); 30 31 // Create a new IO buffer of the given |buffer_size|. Details of the 32 // contents of the created buffer will be kept, and can be validated 33 // by ValidateIOBuffer. 34 scoped_refptr<net::IOBuffer> NewIOBuffer(size_t buffer_size) { 35 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(buffer_size)); 36 char *bufferp = buffer->data(); 37 for (size_t i = 0; i < buffer_size; i++) 38 bufferp[i] = (i + producing_seed_key_) % (1 << sizeof(char)); 39 pointer_queue_.push_back(bufferp); 40 length_queue_.push_back(buffer_size); 41 ++producing_seed_key_; 42 return buffer; 43 } 44 45 // Create an IOBuffer of the appropriate size and add it to the 46 // ByteStream, returning the result of the ByteStream::Write. 47 // Separate function to avoid duplication of buffer_size in test 48 // calls. 49 bool Write(ByteStreamWriter* byte_stream_input, size_t buffer_size) { 50 return byte_stream_input->Write(NewIOBuffer(buffer_size), buffer_size); 51 } 52 53 // Validate that we have the IOBuffer we expect. This routine must be 54 // called on buffers that were allocated from NewIOBuffer, and in the 55 // order that they were allocated. Calls to NewIOBuffer && 56 // ValidateIOBuffer may be interleaved. 57 bool ValidateIOBuffer( 58 scoped_refptr<net::IOBuffer> buffer, size_t buffer_size) { 59 char *bufferp = buffer->data(); 60 61 char *expected_ptr = pointer_queue_.front(); 62 size_t expected_length = length_queue_.front(); 63 pointer_queue_.pop_front(); 64 length_queue_.pop_front(); 65 ++consuming_seed_key_; 66 67 EXPECT_EQ(expected_ptr, bufferp); 68 if (expected_ptr != bufferp) 69 return false; 70 71 EXPECT_EQ(expected_length, buffer_size); 72 if (expected_length != buffer_size) 73 return false; 74 75 for (size_t i = 0; i < buffer_size; i++) { 76 // Already incremented, so subtract one from the key. 77 EXPECT_EQ(static_cast<int>((i + consuming_seed_key_ - 1) 78 % (1 << sizeof(char))), 79 bufferp[i]); 80 if (static_cast<int>((i + consuming_seed_key_ - 1) % 81 (1 << sizeof(char))) != bufferp[i]) { 82 return false; 83 } 84 } 85 return true; 86 } 87 88 protected: 89 base::MessageLoop message_loop_; 90 91 private: 92 int producing_seed_key_; 93 int consuming_seed_key_; 94 std::deque<char*> pointer_queue_; 95 std::deque<size_t> length_queue_; 96 }; 97 98 ByteStreamTest::ByteStreamTest() 99 : producing_seed_key_(0), 100 consuming_seed_key_(0) { } 101 102 // Confirm that filling and emptying the stream works properly, and that 103 // we get full triggers when we expect. 104 TEST_F(ByteStreamTest, ByteStream_PushBack) { 105 scoped_ptr<ByteStreamWriter> byte_stream_input; 106 scoped_ptr<ByteStreamReader> byte_stream_output; 107 CreateByteStream( 108 message_loop_.message_loop_proxy(), message_loop_.message_loop_proxy(), 109 3 * 1024, &byte_stream_input, &byte_stream_output); 110 111 // Push a series of IO buffers on; test pushback happening and 112 // that it's advisory. 113 EXPECT_TRUE(Write(byte_stream_input.get(), 1024)); 114 EXPECT_TRUE(Write(byte_stream_input.get(), 1024)); 115 EXPECT_TRUE(Write(byte_stream_input.get(), 1024)); 116 EXPECT_FALSE(Write(byte_stream_input.get(), 1)); 117 EXPECT_FALSE(Write(byte_stream_input.get(), 1024)); 118 // Flush 119 byte_stream_input->Close(0); 120 EXPECT_EQ(4 * 1024U + 1U, byte_stream_input->GetTotalBufferedBytes()); 121 message_loop_.RunUntilIdle(); 122 // Data already sent to reader is also counted in. 123 EXPECT_EQ(4 * 1024U + 1U, byte_stream_input->GetTotalBufferedBytes()); 124 125 // Pull the IO buffers out; do we get the same buffers and do they 126 // have the same contents? 127 scoped_refptr<net::IOBuffer> output_io_buffer; 128 size_t output_length; 129 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 130 byte_stream_output->Read(&output_io_buffer, &output_length)); 131 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 132 133 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 134 byte_stream_output->Read(&output_io_buffer, &output_length)); 135 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 136 137 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 138 byte_stream_output->Read(&output_io_buffer, &output_length)); 139 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 140 141 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 142 byte_stream_output->Read(&output_io_buffer, &output_length)); 143 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 144 145 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 146 byte_stream_output->Read(&output_io_buffer, &output_length)); 147 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 148 149 EXPECT_EQ(ByteStreamReader::STREAM_COMPLETE, 150 byte_stream_output->Read(&output_io_buffer, &output_length)); 151 152 message_loop_.RunUntilIdle(); 153 // Reader now knows that all data is read out. 154 EXPECT_EQ(1024U, byte_stream_input->GetTotalBufferedBytes()); 155 } 156 157 // Confirm that Flush() method makes the writer to send written contents to 158 // the reader. 159 TEST_F(ByteStreamTest, ByteStream_Flush) { 160 scoped_ptr<ByteStreamWriter> byte_stream_input; 161 scoped_ptr<ByteStreamReader> byte_stream_output; 162 CreateByteStream( 163 message_loop_.message_loop_proxy(), message_loop_.message_loop_proxy(), 164 1024, &byte_stream_input, &byte_stream_output); 165 166 EXPECT_TRUE(Write(byte_stream_input.get(), 1)); 167 message_loop_.RunUntilIdle(); 168 169 scoped_refptr<net::IOBuffer> output_io_buffer; 170 size_t output_length = 0; 171 // Check that data is not sent to the reader yet. 172 EXPECT_EQ(ByteStreamReader::STREAM_EMPTY, 173 byte_stream_output->Read(&output_io_buffer, &output_length)); 174 175 byte_stream_input->Flush(); 176 message_loop_.RunUntilIdle(); 177 178 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 179 byte_stream_output->Read(&output_io_buffer, &output_length)); 180 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 181 182 // Check that it's ok to Flush() an empty writer. 183 byte_stream_input->Flush(); 184 message_loop_.RunUntilIdle(); 185 186 EXPECT_EQ(ByteStreamReader::STREAM_EMPTY, 187 byte_stream_output->Read(&output_io_buffer, &output_length)); 188 189 byte_stream_input->Close(0); 190 message_loop_.RunUntilIdle(); 191 192 EXPECT_EQ(ByteStreamReader::STREAM_COMPLETE, 193 byte_stream_output->Read(&output_io_buffer, &output_length)); 194 } 195 196 // Same as above, only use knowledge of the internals to confirm 197 // that we're getting pushback even when data's split across the two 198 // objects 199 TEST_F(ByteStreamTest, ByteStream_PushBackSplit) { 200 scoped_ptr<ByteStreamWriter> byte_stream_input; 201 scoped_ptr<ByteStreamReader> byte_stream_output; 202 CreateByteStream( 203 message_loop_.message_loop_proxy(), message_loop_.message_loop_proxy(), 204 9 * 1024, &byte_stream_input, &byte_stream_output); 205 206 // Push a series of IO buffers on; test pushback happening and 207 // that it's advisory. 208 EXPECT_TRUE(Write(byte_stream_input.get(), 1024)); 209 message_loop_.RunUntilIdle(); 210 EXPECT_TRUE(Write(byte_stream_input.get(), 1024)); 211 message_loop_.RunUntilIdle(); 212 EXPECT_TRUE(Write(byte_stream_input.get(), 1024)); 213 message_loop_.RunUntilIdle(); 214 EXPECT_TRUE(Write(byte_stream_input.get(), 1024)); 215 message_loop_.RunUntilIdle(); 216 EXPECT_FALSE(Write(byte_stream_input.get(), 6 * 1024)); 217 message_loop_.RunUntilIdle(); 218 219 // Pull the IO buffers out; do we get the same buffers and do they 220 // have the same contents? 221 scoped_refptr<net::IOBuffer> output_io_buffer; 222 size_t output_length; 223 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 224 byte_stream_output->Read(&output_io_buffer, &output_length)); 225 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 226 227 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 228 byte_stream_output->Read(&output_io_buffer, &output_length)); 229 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 230 231 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 232 byte_stream_output->Read(&output_io_buffer, &output_length)); 233 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 234 235 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 236 byte_stream_output->Read(&output_io_buffer, &output_length)); 237 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 238 239 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 240 byte_stream_output->Read(&output_io_buffer, &output_length)); 241 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 242 243 EXPECT_EQ(ByteStreamReader::STREAM_EMPTY, 244 byte_stream_output->Read(&output_io_buffer, &output_length)); 245 } 246 247 // Confirm that a Close() notification transmits in-order 248 // with data on the stream. 249 TEST_F(ByteStreamTest, ByteStream_CompleteTransmits) { 250 scoped_ptr<ByteStreamWriter> byte_stream_input; 251 scoped_ptr<ByteStreamReader> byte_stream_output; 252 253 scoped_refptr<net::IOBuffer> output_io_buffer; 254 size_t output_length; 255 256 // Empty stream, non-error case. 257 CreateByteStream( 258 message_loop_.message_loop_proxy(), message_loop_.message_loop_proxy(), 259 3 * 1024, &byte_stream_input, &byte_stream_output); 260 EXPECT_EQ(ByteStreamReader::STREAM_EMPTY, 261 byte_stream_output->Read(&output_io_buffer, &output_length)); 262 byte_stream_input->Close(0); 263 message_loop_.RunUntilIdle(); 264 ASSERT_EQ(ByteStreamReader::STREAM_COMPLETE, 265 byte_stream_output->Read(&output_io_buffer, &output_length)); 266 EXPECT_EQ(0, byte_stream_output->GetStatus()); 267 268 // Non-empty stream, non-error case. 269 CreateByteStream( 270 message_loop_.message_loop_proxy(), message_loop_.message_loop_proxy(), 271 3 * 1024, &byte_stream_input, &byte_stream_output); 272 EXPECT_EQ(ByteStreamReader::STREAM_EMPTY, 273 byte_stream_output->Read(&output_io_buffer, &output_length)); 274 EXPECT_TRUE(Write(byte_stream_input.get(), 1024)); 275 byte_stream_input->Close(0); 276 message_loop_.RunUntilIdle(); 277 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 278 byte_stream_output->Read(&output_io_buffer, &output_length)); 279 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 280 ASSERT_EQ(ByteStreamReader::STREAM_COMPLETE, 281 byte_stream_output->Read(&output_io_buffer, &output_length)); 282 EXPECT_EQ(0, byte_stream_output->GetStatus()); 283 284 const int kFakeErrorCode = 22; 285 286 // Empty stream, error case. 287 CreateByteStream( 288 message_loop_.message_loop_proxy(), message_loop_.message_loop_proxy(), 289 3 * 1024, &byte_stream_input, &byte_stream_output); 290 EXPECT_EQ(ByteStreamReader::STREAM_EMPTY, 291 byte_stream_output->Read(&output_io_buffer, &output_length)); 292 byte_stream_input->Close(kFakeErrorCode); 293 message_loop_.RunUntilIdle(); 294 ASSERT_EQ(ByteStreamReader::STREAM_COMPLETE, 295 byte_stream_output->Read(&output_io_buffer, &output_length)); 296 EXPECT_EQ(kFakeErrorCode, byte_stream_output->GetStatus()); 297 298 // Non-empty stream, error case. 299 CreateByteStream( 300 message_loop_.message_loop_proxy(), message_loop_.message_loop_proxy(), 301 3 * 1024, &byte_stream_input, &byte_stream_output); 302 EXPECT_EQ(ByteStreamReader::STREAM_EMPTY, 303 byte_stream_output->Read(&output_io_buffer, &output_length)); 304 EXPECT_TRUE(Write(byte_stream_input.get(), 1024)); 305 byte_stream_input->Close(kFakeErrorCode); 306 message_loop_.RunUntilIdle(); 307 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 308 byte_stream_output->Read(&output_io_buffer, &output_length)); 309 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 310 ASSERT_EQ(ByteStreamReader::STREAM_COMPLETE, 311 byte_stream_output->Read(&output_io_buffer, &output_length)); 312 EXPECT_EQ(kFakeErrorCode, byte_stream_output->GetStatus()); 313 } 314 315 // Confirm that callbacks on the sink side are triggered when they should be. 316 TEST_F(ByteStreamTest, ByteStream_SinkCallback) { 317 scoped_refptr<base::TestSimpleTaskRunner> task_runner( 318 new base::TestSimpleTaskRunner()); 319 320 scoped_ptr<ByteStreamWriter> byte_stream_input; 321 scoped_ptr<ByteStreamReader> byte_stream_output; 322 CreateByteStream( 323 message_loop_.message_loop_proxy(), task_runner, 324 10000, &byte_stream_input, &byte_stream_output); 325 326 scoped_refptr<net::IOBuffer> output_io_buffer; 327 size_t output_length; 328 329 // Note that the specifics of when the callbacks are called with regard 330 // to how much data is pushed onto the stream is not (currently) part 331 // of the interface contract. If it becomes part of the contract, the 332 // tests below should get much more precise. 333 334 // Confirm callback called when you add more than 33% of the buffer. 335 336 // Setup callback 337 int num_callbacks = 0; 338 byte_stream_output->RegisterCallback( 339 base::Bind(CountCallbacks, &num_callbacks)); 340 341 EXPECT_TRUE(Write(byte_stream_input.get(), 4000)); 342 message_loop_.RunUntilIdle(); 343 344 EXPECT_EQ(0, num_callbacks); 345 task_runner->RunUntilIdle(); 346 EXPECT_EQ(1, num_callbacks); 347 348 // Check data and stream state. 349 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 350 byte_stream_output->Read(&output_io_buffer, &output_length)); 351 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 352 EXPECT_EQ(ByteStreamReader::STREAM_EMPTY, 353 byte_stream_output->Read(&output_io_buffer, &output_length)); 354 355 // Confirm callback *isn't* called at less than 33% (by lack of 356 // unexpected call on task runner). 357 EXPECT_TRUE(Write(byte_stream_input.get(), 3000)); 358 message_loop_.RunUntilIdle(); 359 360 // This reflects an implementation artifact that data goes with callbacks, 361 // which should not be considered part of the interface guarantee. 362 EXPECT_EQ(ByteStreamReader::STREAM_EMPTY, 363 byte_stream_output->Read(&output_io_buffer, &output_length)); 364 } 365 366 // Confirm that callbacks on the source side are triggered when they should 367 // be. 368 TEST_F(ByteStreamTest, ByteStream_SourceCallback) { 369 scoped_refptr<base::TestSimpleTaskRunner> task_runner( 370 new base::TestSimpleTaskRunner()); 371 372 scoped_ptr<ByteStreamWriter> byte_stream_input; 373 scoped_ptr<ByteStreamReader> byte_stream_output; 374 CreateByteStream( 375 task_runner, message_loop_.message_loop_proxy(), 376 10000, &byte_stream_input, &byte_stream_output); 377 378 scoped_refptr<net::IOBuffer> output_io_buffer; 379 size_t output_length; 380 381 // Note that the specifics of when the callbacks are called with regard 382 // to how much data is pulled from the stream is not (currently) part 383 // of the interface contract. If it becomes part of the contract, the 384 // tests below should get much more precise. 385 386 // Confirm callback called when about 33% space available, and not 387 // at other transitions. 388 389 // Add data. 390 int num_callbacks = 0; 391 byte_stream_input->RegisterCallback( 392 base::Bind(CountCallbacks, &num_callbacks)); 393 EXPECT_TRUE(Write(byte_stream_input.get(), 2000)); 394 EXPECT_TRUE(Write(byte_stream_input.get(), 2001)); 395 EXPECT_FALSE(Write(byte_stream_input.get(), 6000)); 396 397 // Allow bytes to transition (needed for message passing implementation), 398 // and get and validate the data. 399 message_loop_.RunUntilIdle(); 400 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 401 byte_stream_output->Read(&output_io_buffer, &output_length)); 402 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 403 404 // Grab data, triggering callback. Recorded on dispatch, but doesn't 405 // happen because it's caught by the mock. 406 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 407 byte_stream_output->Read(&output_io_buffer, &output_length)); 408 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 409 410 // Confirm that the callback passed to the mock does what we expect. 411 EXPECT_EQ(0, num_callbacks); 412 task_runner->RunUntilIdle(); 413 EXPECT_EQ(1, num_callbacks); 414 415 // Same drill with final buffer. 416 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 417 byte_stream_output->Read(&output_io_buffer, &output_length)); 418 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 419 EXPECT_EQ(ByteStreamReader::STREAM_EMPTY, 420 byte_stream_output->Read(&output_io_buffer, &output_length)); 421 EXPECT_EQ(1, num_callbacks); 422 task_runner->RunUntilIdle(); 423 // Should have updated the internal structures but not called the 424 // callback. 425 EXPECT_EQ(1, num_callbacks); 426 } 427 428 // Confirm that racing a change to a sink callback with a post results 429 // in the new callback being called. 430 TEST_F(ByteStreamTest, ByteStream_SinkInterrupt) { 431 scoped_refptr<base::TestSimpleTaskRunner> task_runner( 432 new base::TestSimpleTaskRunner()); 433 434 scoped_ptr<ByteStreamWriter> byte_stream_input; 435 scoped_ptr<ByteStreamReader> byte_stream_output; 436 CreateByteStream( 437 message_loop_.message_loop_proxy(), task_runner, 438 10000, &byte_stream_input, &byte_stream_output); 439 440 scoped_refptr<net::IOBuffer> output_io_buffer; 441 size_t output_length; 442 base::Closure intermediate_callback; 443 444 // Record initial state. 445 int num_callbacks = 0; 446 byte_stream_output->RegisterCallback( 447 base::Bind(CountCallbacks, &num_callbacks)); 448 449 // Add data, and pass it across. 450 EXPECT_TRUE(Write(byte_stream_input.get(), 4000)); 451 message_loop_.RunUntilIdle(); 452 453 // The task runner should have been hit, but the callback count 454 // isn't changed until we actually run the callback. 455 EXPECT_EQ(0, num_callbacks); 456 457 // If we change the callback now, the new one should be run 458 // (simulates race with post task). 459 int num_alt_callbacks = 0; 460 byte_stream_output->RegisterCallback( 461 base::Bind(CountCallbacks, &num_alt_callbacks)); 462 task_runner->RunUntilIdle(); 463 EXPECT_EQ(0, num_callbacks); 464 EXPECT_EQ(1, num_alt_callbacks); 465 466 // Final cleanup. 467 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 468 byte_stream_output->Read(&output_io_buffer, &output_length)); 469 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 470 EXPECT_EQ(ByteStreamReader::STREAM_EMPTY, 471 byte_stream_output->Read(&output_io_buffer, &output_length)); 472 473 } 474 475 // Confirm that racing a change to a source callback with a post results 476 // in the new callback being called. 477 TEST_F(ByteStreamTest, ByteStream_SourceInterrupt) { 478 scoped_refptr<base::TestSimpleTaskRunner> task_runner( 479 new base::TestSimpleTaskRunner()); 480 481 scoped_ptr<ByteStreamWriter> byte_stream_input; 482 scoped_ptr<ByteStreamReader> byte_stream_output; 483 CreateByteStream( 484 task_runner, message_loop_.message_loop_proxy(), 485 10000, &byte_stream_input, &byte_stream_output); 486 487 scoped_refptr<net::IOBuffer> output_io_buffer; 488 size_t output_length; 489 base::Closure intermediate_callback; 490 491 // Setup state for test. 492 int num_callbacks = 0; 493 byte_stream_input->RegisterCallback( 494 base::Bind(CountCallbacks, &num_callbacks)); 495 EXPECT_TRUE(Write(byte_stream_input.get(), 2000)); 496 EXPECT_TRUE(Write(byte_stream_input.get(), 2001)); 497 EXPECT_FALSE(Write(byte_stream_input.get(), 6000)); 498 message_loop_.RunUntilIdle(); 499 500 // Initial get should not trigger callback. 501 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 502 byte_stream_output->Read(&output_io_buffer, &output_length)); 503 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 504 message_loop_.RunUntilIdle(); 505 506 // Second get *should* trigger callback. 507 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 508 byte_stream_output->Read(&output_io_buffer, &output_length)); 509 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 510 511 // Which should do the right thing when it's run. 512 int num_alt_callbacks = 0; 513 byte_stream_input->RegisterCallback( 514 base::Bind(CountCallbacks, &num_alt_callbacks)); 515 task_runner->RunUntilIdle(); 516 EXPECT_EQ(0, num_callbacks); 517 EXPECT_EQ(1, num_alt_callbacks); 518 519 // Third get should also trigger callback. 520 EXPECT_EQ(ByteStreamReader::STREAM_HAS_DATA, 521 byte_stream_output->Read(&output_io_buffer, &output_length)); 522 EXPECT_TRUE(ValidateIOBuffer(output_io_buffer, output_length)); 523 EXPECT_EQ(ByteStreamReader::STREAM_EMPTY, 524 byte_stream_output->Read(&output_io_buffer, &output_length)); 525 } 526 527 // Confirm that callback is called on zero data transfer but source 528 // complete. 529 TEST_F(ByteStreamTest, ByteStream_ZeroCallback) { 530 scoped_refptr<base::TestSimpleTaskRunner> task_runner( 531 new base::TestSimpleTaskRunner()); 532 533 scoped_ptr<ByteStreamWriter> byte_stream_input; 534 scoped_ptr<ByteStreamReader> byte_stream_output; 535 CreateByteStream( 536 message_loop_.message_loop_proxy(), task_runner, 537 10000, &byte_stream_input, &byte_stream_output); 538 539 base::Closure intermediate_callback; 540 541 // Record initial state. 542 int num_callbacks = 0; 543 byte_stream_output->RegisterCallback( 544 base::Bind(CountCallbacks, &num_callbacks)); 545 546 // Immediately close the stream. 547 byte_stream_input->Close(0); 548 task_runner->RunUntilIdle(); 549 EXPECT_EQ(1, num_callbacks); 550 } 551 552 TEST_F(ByteStreamTest, ByteStream_CloseWithoutAnyWrite) { 553 scoped_ptr<ByteStreamWriter> byte_stream_input; 554 scoped_ptr<ByteStreamReader> byte_stream_output; 555 CreateByteStream( 556 message_loop_.message_loop_proxy(), message_loop_.message_loop_proxy(), 557 3 * 1024, &byte_stream_input, &byte_stream_output); 558 559 byte_stream_input->Close(0); 560 message_loop_.RunUntilIdle(); 561 562 scoped_refptr<net::IOBuffer> output_io_buffer; 563 size_t output_length; 564 EXPECT_EQ(ByteStreamReader::STREAM_COMPLETE, 565 byte_stream_output->Read(&output_io_buffer, &output_length)); 566 } 567 568 TEST_F(ByteStreamTest, ByteStream_FlushWithoutAnyWrite) { 569 scoped_ptr<ByteStreamWriter> byte_stream_input; 570 scoped_ptr<ByteStreamReader> byte_stream_output; 571 CreateByteStream( 572 message_loop_.message_loop_proxy(), message_loop_.message_loop_proxy(), 573 3 * 1024, &byte_stream_input, &byte_stream_output); 574 575 byte_stream_input->Flush(); 576 message_loop_.RunUntilIdle(); 577 578 scoped_refptr<net::IOBuffer> output_io_buffer; 579 size_t output_length; 580 EXPECT_EQ(ByteStreamReader::STREAM_EMPTY, 581 byte_stream_output->Read(&output_io_buffer, &output_length)); 582 583 byte_stream_input->Close(0); 584 message_loop_.RunUntilIdle(); 585 586 EXPECT_EQ(ByteStreamReader::STREAM_COMPLETE, 587 byte_stream_output->Read(&output_io_buffer, &output_length)); 588 } 589 590 TEST_F(ByteStreamTest, ByteStream_WriteOverflow) { 591 scoped_ptr<ByteStreamWriter> byte_stream_input; 592 scoped_ptr<ByteStreamReader> byte_stream_output; 593 CreateByteStream( 594 message_loop_.message_loop_proxy(), message_loop_.message_loop_proxy(), 595 std::numeric_limits<size_t>::max(), 596 &byte_stream_input, &byte_stream_output); 597 598 EXPECT_TRUE(Write(byte_stream_input.get(), 1)); 599 // 1 + size_t max -> Overflow. 600 scoped_refptr<net::IOBuffer> empty_io_buffer; 601 EXPECT_FALSE(byte_stream_input->Write(empty_io_buffer, 602 std::numeric_limits<size_t>::max())); 603 message_loop_.RunUntilIdle(); 604 605 // The first write is below PostToPeer threshold. We shouldn't get anything 606 // from the output. 607 scoped_refptr<net::IOBuffer> output_io_buffer; 608 size_t output_length; 609 EXPECT_EQ(ByteStreamReader::STREAM_EMPTY, 610 byte_stream_output->Read(&output_io_buffer, &output_length)); 611 } 612 613 } // namespace content 614
