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