Add AudioBufferStream.

media/filters/fake_video_decoder.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/filters/fake_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/test_helpers.h"
 
 namespace media {
 
 FakeVideoDecoder::FakeVideoDecoder(int decoding_delay)
     : task_runner_(base::MessageLoopProxy::current()),
       weak_factory_(this),
       decoding_delay_(decoding_delay),
       state_(UNINITIALIZED),
-      total_bytes_decoded_(0) {
+      total_bytes_decoded_(0),
+      reads_queued_(0) {
   DCHECK_GE(decoding_delay, 0);
 }
 
 FakeVideoDecoder::~FakeVideoDecoder() {
   DCHECK_EQ(state_, UNINITIALIZED);
 }
 
 void FakeVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                   const PipelineStatusCB& status_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 64 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   stop_cb_.SetCallback(BindToCurrentLoop(closure));
 
   // Defer the stop if an init, a decode or a reset is pending.
   if (!init_cb_.IsNull() || !decode_cb_.IsNull() || !reset_cb_.IsNull())
     return;
 
   DoStop();
 }
 
+scoped_refptr<VideoFrame> FakeVideoDecoder::GetDecodeOutput() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  if (!reads_queued_) {
+    return NULL;
+  }

[xhwang, 2014/03/06 23:32:40]

nit: no need for braces.

+  --reads_queued_;
+  return VideoFrame::CreateEOSFrame();

[xhwang, 2014/03/06 23:32:40]

This isn't quite right. Even though this decoder is a fake, it tries to be as
real as possible. An EOS frame in the middle of the decoding process is not real
:)

Actually we may not need to do anything to "queue read". FakeVideoDecoder
supports decoding delay, which will actually queue decoded frames internally.
GetDecodeOutput() can directly return those frames.

One problem with this is that we'll always drain the decoder before trying new
decodes. In reality, all of our video decoders don't support GetDecodeOutput().
So it's still worth testing the case where FakeVideoDecoder::GetDecodeOutput()
always return NULL. 

Can we change the ctor of FakeVideoDecoder to
FakeVideoDecoder(int decoding_delay, bool supportsGetDecodeOutput), so that in
VFSTest, we can add another test param to test both cases?

Am example of using multiple test parameters can be found here:
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/med...

+}
+
+void FakeVideoDecoder::QueueRead() {
+  ++reads_queued_;
+}
+
 void FakeVideoDecoder::HoldNextInit() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   init_cb_.HoldCallback();
 }
 
 void FakeVideoDecoder::HoldNextRead() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   decode_cb_.HoldCallback();
 }
 
@@ skipping 69 matching lines @@
     int buffer_size,
     const DecodeCB& decode_cb,
     Status status,
     const scoped_refptr<VideoFrame>& video_frame) {
   if (status == kOk || status == kNotEnoughData)
     total_bytes_decoded_ += buffer_size;
   decode_cb.Run(status, video_frame);
 }
 
 }  // namespace media