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
18namespace content {
19namespace {
20
21void CountCallbacks(int* counter) {
22  ++*counter;
23}
24
25}  // namespace
26
27class 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
98ByteStreamTest::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.
104TEST_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.
159TEST_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
199TEST_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.
249TEST_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.
316TEST_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.
368TEST_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.
430TEST_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.
477TEST_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.
529TEST_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
552TEST_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
568TEST_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
590TEST_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