Add callback in VideoDecoder and AudioDecoder to return decoded frames.

media/filters/video_renderer_impl_unittest.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 <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/debug/stack_trace.h"
@@ skipping 14 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::NiceMock;
 using ::testing::NotNull;
 using ::testing::Return;
+using ::testing::SaveArg;
 using ::testing::StrictMock;
 
 namespace media {
 
 ACTION_P(RunClosure, closure) {
   closure.Run();
 }
 
 MATCHER_P(HasTimestamp, ms, "") {
   *result_listener << "has timestamp " << arg->timestamp().InMilliseconds();
@@ skipping 15 matching lines @@
         new VideoRendererImpl(message_loop_.message_loop_proxy(),
                               decoders.Pass(),
                               media::SetDecryptorReadyCB(),
                               base::Bind(&StrictMock<MockDisplayCB>::Display,
                                          base::Unretained(&mock_display_cb_)),
                               true));
 
     demuxer_stream_.set_video_decoder_config(TestVideoConfig::Normal());
 
     // We expect these to be called but we don't care how/when.
-    EXPECT_CALL(demuxer_stream_, Read(_))
-        .WillRepeatedly(RunCallback<0>(DemuxerStream::kOk,
-                                       DecoderBuffer::CreateEOSBuffer()));
+    EXPECT_CALL(demuxer_stream_, Read(_)).WillRepeatedly(
+        RunCallback<0>(DemuxerStream::kOk,
+                       scoped_refptr<DecoderBuffer>(new DecoderBuffer(0))));
     EXPECT_CALL(*decoder_, Stop())
         .WillRepeatedly(Invoke(this, &VideoRendererImplTest::StopRequested));
     EXPECT_CALL(statistics_cb_object_, OnStatistics(_))
         .Times(AnyNumber());
     EXPECT_CALL(*this, OnTimeUpdate(_))
         .Times(AnyNumber());
   }
 
   virtual ~VideoRendererImplTest() {}
 
   // Callbacks passed into Initialize().
   MOCK_METHOD1(OnTimeUpdate, void(base::TimeDelta));
 
   void Initialize() {
     InitializeWithLowDelay(false);
   }
 
   void InitializeWithLowDelay(bool low_delay) {
     // Monitor decodes from the decoder.
     EXPECT_CALL(*decoder_, Decode(_, _))
-        .WillRepeatedly(Invoke(this, &VideoRendererImplTest::FrameRequested));
+        .WillRepeatedly(Invoke(this, &VideoRendererImplTest::DecodeRequested));
 
     EXPECT_CALL(*decoder_, Reset(_))
         .WillRepeatedly(Invoke(this, &VideoRendererImplTest::FlushRequested));
 
     InSequence s;
 
-    EXPECT_CALL(*decoder_, Initialize(_, _, _))
-        .WillOnce(RunCallback<2>(PIPELINE_OK));
-
     // Set playback rate before anything else happens.
     renderer_->SetPlaybackRate(1.0f);
 
     // Initialize, we shouldn't have any reads.
     InitializeRenderer(PIPELINE_OK, low_delay);
   }
 
   void InitializeRenderer(PipelineStatus expected, bool low_delay) {
     SCOPED_TRACE(base::StringPrintf("InitializeRenderer(%d)", expected));
     WaitableMessageLoopEvent event;
-    CallInitialize(event.GetPipelineStatusCB(), low_delay);
+    CallInitialize(event.GetPipelineStatusCB(), low_delay, expected);
     event.RunAndWaitForStatus(expected);
   }
 
-  void CallInitialize(const PipelineStatusCB& status_cb, bool low_delay) {
+  void CallInitialize(const PipelineStatusCB& status_cb,
+                      bool low_delay,
+                      PipelineStatus decoder_status) {
+    EXPECT_CALL(*decoder_, Initialize(_, _, _, _)).WillOnce(
+        DoAll(SaveArg<3>(&output_cb_), RunCallback<2>(decoder_status)));
     renderer_->Initialize(
         &demuxer_stream_,
         low_delay,
         status_cb,
         base::Bind(&MockStatisticsCB::OnStatistics,
                    base::Unretained(&statistics_cb_object_)),
         base::Bind(&VideoRendererImplTest::OnTimeUpdate,
                    base::Unretained(this)),
         ended_event_.GetClosure(),
         error_event_.GetPipelineStatusCB(),
@@ skipping 84 matching lines @@
             base::TimeDelta::FromMilliseconds(timestamp_in_ms));
         decode_results_.push_back(std::make_pair(VideoDecoder::kOk, frame));
         continue;
       }
 
       CHECK(false) << "Unrecognized decoder buffer token: " << tokens[i];
     }
   }
 
   bool IsReadPending() {
-    return !read_cb_.is_null();
+    return !decode_cb_.is_null();
   }
 
   void WaitForError(PipelineStatus expected) {
     SCOPED_TRACE(base::StringPrintf("WaitForError(%d)", expected));
     error_event_.RunAndWaitForStatus(expected);
   }
 
   void WaitForEnded() {
     SCOPED_TRACE("WaitForEnded()");
     ended_event_.RunAndWait();
   }
 
   void WaitForPendingRead() {
     SCOPED_TRACE("WaitForPendingRead()");
-    if (!read_cb_.is_null())
+    if (!decode_cb_.is_null())
       return;
 
-    DCHECK(wait_for_pending_read_cb_.is_null());
+    DCHECK(wait_for_pending_decode_cb_.is_null());
 
     WaitableMessageLoopEvent event;
-    wait_for_pending_read_cb_ = event.GetClosure();
+    wait_for_pending_decode_cb_ = event.GetClosure();
     event.RunAndWait();
 
-    DCHECK(!read_cb_.is_null());
-    DCHECK(wait_for_pending_read_cb_.is_null());
+    DCHECK(!decode_cb_.is_null());
+    DCHECK(wait_for_pending_decode_cb_.is_null());
   }
 
   void SatisfyPendingRead() {
-    CHECK(!read_cb_.is_null());
+    CHECK(!decode_cb_.is_null());
     CHECK(!decode_results_.empty());
 
-    base::Closure closure = base::Bind(
-        read_cb_, decode_results_.front().first,
-        decode_results_.front().second);
-
-    read_cb_.Reset();
+    // Post tasks for OutputCB and DecodeCB.
+    scoped_refptr<VideoFrame> frame = decode_results_.front().second;
+    if (frame)
+      message_loop_.PostTask(FROM_HERE, base::Bind(output_cb_, frame));
+    message_loop_.PostTask(
+        FROM_HERE, base::Bind(base::ResetAndReturn(&decode_cb_),
+                              decode_results_.front().first));
     decode_results_.pop_front();
-
-    message_loop_.PostTask(FROM_HERE, closure);
   }
 
   void AdvanceTimeInMs(int time_ms) {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     base::AutoLock l(lock_);
     time_ += base::TimeDelta::FromMilliseconds(time_ms);
     DCHECK_LE(time_.InMicroseconds(), GetDuration().InMicroseconds());
   }
 
  protected:
@@ skipping 13 matching lines @@
  private:
   base::TimeDelta GetTime() {
     base::AutoLock l(lock_);
     return time_;
   }
 
   base::TimeDelta GetDuration() {
     return base::TimeDelta::FromMilliseconds(kVideoDurationInMs);
   }
 
-  void FrameRequested(const scoped_refptr<DecoderBuffer>& buffer,
-                      const VideoDecoder::DecodeCB& read_cb) {
+  void DecodeRequested(const scoped_refptr<DecoderBuffer>& buffer,
+                       const VideoDecoder::DecodeCB& decode_cb) {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
-    CHECK(read_cb_.is_null());
-    read_cb_ = read_cb;
+    CHECK(decode_cb_.is_null());
+    decode_cb_ = decode_cb;
 
     // Wake up WaitForPendingRead() if needed.
-    if (!wait_for_pending_read_cb_.is_null())
-      base::ResetAndReturn(&wait_for_pending_read_cb_).Run();
+    if (!wait_for_pending_decode_cb_.is_null())
+      base::ResetAndReturn(&wait_for_pending_decode_cb_).Run();
 
     if (decode_results_.empty())
       return;
 
     SatisfyPendingRead();
   }
 
   void FlushRequested(const base::Closure& callback) {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     decode_results_.clear();
-    if (!read_cb_.is_null()) {
+    if (!decode_cb_.is_null()) {
       QueueFrames("abort");
       SatisfyPendingRead();
     }
 
     message_loop_.PostTask(FROM_HERE, callback);
   }
 
   void StopRequested() {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     decode_results_.clear();
-    if (!read_cb_.is_null()) {
+    if (!decode_cb_.is_null()) {
       QueueFrames("abort");
       SatisfyPendingRead();
     }
   }
 
   base::MessageLoop message_loop_;
 
   // Used to protect |time_|.
   base::Lock lock_;
   base::TimeDelta time_;
 
   // Used for satisfying reads.
-  VideoDecoder::DecodeCB read_cb_;
+  VideoDecoder::OutputCB output_cb_;
+  VideoDecoder::DecodeCB decode_cb_;
   base::TimeDelta next_frame_timestamp_;
 
   WaitableMessageLoopEvent error_event_;
   WaitableMessageLoopEvent ended_event_;
 
-  // Run during FrameRequested() to unblock WaitForPendingRead().
-  base::Closure wait_for_pending_read_cb_;
+  // Run during DecodeRequested() to unblock WaitForPendingRead().
+  base::Closure wait_for_pending_decode_cb_;
 
   std::deque<std::pair<
       VideoDecoder::Status, scoped_refptr<VideoFrame> > > decode_results_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoRendererImplTest);
 };
 
 TEST_F(VideoRendererImplTest, DoNothing) {
   // Test that creation and deletion doesn't depend on calls to Initialize()
   // and/or Stop().
@@ skipping 15 matching lines @@
   Preroll(0, PIPELINE_OK);
   Shutdown();
 }
 
 static void ExpectNotCalled(PipelineStatus) {
   base::debug::StackTrace stack;
   ADD_FAILURE() << "Expected callback not to be called\n" << stack.ToString();
 }
 
 TEST_F(VideoRendererImplTest, StopWhileInitializing) {
-  EXPECT_CALL(*decoder_, Initialize(_, _, _))
-      .WillOnce(RunCallback<2>(PIPELINE_OK));
-  CallInitialize(base::Bind(&ExpectNotCalled), false);
+  CallInitialize(base::Bind(&ExpectNotCalled), false, PIPELINE_OK);
   Stop();
 
   // ~VideoRendererImpl() will CHECK() if we left anything initialized.
 }
 
 TEST_F(VideoRendererImplTest, StopWhileFlushing) {
   Initialize();
   renderer_->Flush(base::Bind(&ExpectNotCalled, PIPELINE_OK));
   Stop();
 
@@ skipping 224 matching lines @@
 TEST_F(VideoRendererImplTest, AbortPendingRead_Preroll) {
   Initialize();
   QueueFrames("0 10 abort");
   EXPECT_CALL(mock_display_cb_, Display(HasTimestamp(0)));
   Preroll(0, PIPELINE_OK);
   Shutdown();
 }
 
 TEST_F(VideoRendererImplTest, VideoDecoder_InitFailure) {
   InSequence s;
-
-  EXPECT_CALL(*decoder_, Initialize(_, _, _))
-      .WillOnce(RunCallback<2>(DECODER_ERROR_NOT_SUPPORTED));
   InitializeRenderer(DECODER_ERROR_NOT_SUPPORTED, false);
-
   Stop();
 }
 
 }  // namespace media