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
CountCallbacks(int * counter)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.
NewIOBuffer(size_t buffer_size)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.
Write(ByteStreamWriter * byte_stream_input,size_t buffer_size)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.
ValidateIOBuffer(scoped_refptr<net::IOBuffer> buffer,size_t buffer_size)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
ByteStreamTest()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.
TEST_F(ByteStreamTest,ByteStream_PushBack)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.
TEST_F(ByteStreamTest,ByteStream_Flush)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
TEST_F(ByteStreamTest,ByteStream_PushBackSplit)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.
TEST_F(ByteStreamTest,ByteStream_CompleteTransmits)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.
TEST_F(ByteStreamTest,ByteStream_SinkCallback)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.
TEST_F(ByteStreamTest,ByteStream_SourceCallback)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.
TEST_F(ByteStreamTest,ByteStream_SinkInterrupt)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.
TEST_F(ByteStreamTest,ByteStream_SourceInterrupt)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.
TEST_F(ByteStreamTest,ByteStream_ZeroCallback)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
TEST_F(ByteStreamTest,ByteStream_CloseWithoutAnyWrite)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
TEST_F(ByteStreamTest,ByteStream_FlushWithoutAnyWrite)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
TEST_F(ByteStreamTest,ByteStream_WriteOverflow)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