Simplify VideoDecodeEngine interface by making everything synchronous.

content/renderer/media/rtc_video_decoder_unittest.cc

 // Copyright (c) 2011 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 "content/renderer/media/rtc_video_decoder.h"
 
 #include <deque>
 
 #include "base/bind.h"
 #include "base/memory/singleton.h"
@@ skipping 123 matching lines @@
     decoder_->Initialize(NULL,
                          NewExpectedClosure(), NewStatisticsCallback());
     message_loop_.RunAllPending();
   }
 
   StatisticsCallback NewStatisticsCallback() {
     return base::Bind(&MockStatisticsCallback::OnStatistics,
                       base::Unretained(&stats_callback_object_));
   }
 
+  MOCK_METHOD1(FrameReady, void(scoped_refptr<media::VideoFrame>));
+
   // Fixture members.
   scoped_refptr<RTCVideoDecoder> decoder_;
   scoped_refptr<MockVideoRenderer> renderer_;
   MockStatisticsCallback stats_callback_object_;
   StrictMock<MockFilterHost> host_;
   MessageLoop message_loop_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RTCVideoDecoderTest);
 };
@@ skipping 10 matching lines @@
   // matches the dimensions specified by RTC.
   EXPECT_EQ(kWidth, decoder_->natural_size().width());
   EXPECT_EQ(kHeight, decoder_->natural_size().height());
 }
 
 TEST_F(RTCVideoDecoderTest, DoSeek) {
   const base::TimeDelta kZero;
 
   InitializeDecoderSuccessfully();
 
-  decoder_->set_consume_video_frame_callback(
-      base::Bind(&MockVideoRenderer::ConsumeVideoFrame,
-                 base::Unretained(renderer_.get())));
-
-  // Expect Seek and verify the results.
-  EXPECT_CALL(*renderer_.get(), ConsumeVideoFrame(_))
-      .Times(Limits::kMaxVideoFrames);
+  // Expect seek and verify the results.
   decoder_->Seek(kZero, NewExpectedStatusCB(PIPELINE_OK));
 
   message_loop_.RunAllPending();
   EXPECT_EQ(RTCVideoDecoder::kNormal, decoder_->state_);
 }
 
 TEST_F(RTCVideoDecoderTest, DoRenderFrame) {
   const base::TimeDelta kZero;
   EXPECT_CALL(host_, GetTime()).WillRepeatedly(Return(base::TimeDelta()));
 
   InitializeDecoderSuccessfully();
 
-  // Pass the frame back to decoder
-  decoder_->set_consume_video_frame_callback(
-      base::Bind(&RTCVideoDecoder::ProduceVideoFrame,
-                 base::Unretained(decoder_.get())));
-  decoder_->Seek(kZero, NewExpectedStatusCB(PIPELINE_OK));
-
-  decoder_->set_consume_video_frame_callback(
-      base::Bind(&MockVideoRenderer::ConsumeVideoFrame,
-                 base::Unretained(renderer_.get())));
-  EXPECT_CALL(*renderer_.get(), ConsumeVideoFrame(_))
-      .Times(Limits::kMaxVideoFrames);
-
   NullVideoFrame video_frame;
 
   for (size_t i = 0; i < Limits::kMaxVideoFrames; ++i) {
     decoder_->RenderFrame(&video_frame);
   }
 
   message_loop_.RunAllPending();
   EXPECT_EQ(RTCVideoDecoder::kNormal, decoder_->state_);
 }
 
 TEST_F(RTCVideoDecoderTest, DoSetSize) {
   InitializeDecoderSuccessfully();
 
   int new_width = kWidth * 2;
   int new_height = kHeight * 2;
   gfx::Size new_natural_size(new_width, new_height);
   int new_reserved = 0;
 
   EXPECT_CALL(host_,
               SetNaturalVideoSize(new_natural_size)).WillRepeatedly(Return());
 
   decoder_->SetSize(new_width, new_height, new_reserved);
 
   EXPECT_EQ(new_width, decoder_->natural_size().width());
   EXPECT_EQ(new_height, decoder_->natural_size().height());
 
   message_loop_.RunAllPending();
 }