Simplify VideoDecodeEngine interface by making everything synchronous.

content/renderer/media/capture_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 "base/bind.h"
 #include "content/renderer/media/capture_video_decoder.h"
 #include "content/renderer/media/video_capture_impl.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "media/base/filters.h"
 #include "media/base/limits.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filter_host.h"
 #include "media/base/mock_filters.h"
 #include "media/base/pipeline_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 static const media::VideoCaptureSessionId kVideoStreamId = 1;
 
-ACTION_P(ReturnFrameFromRenderer, decoder) {
-  decoder->ProduceVideoFrame(arg0);
-}
-
 ACTION_P3(CreateDataBufferFromCapture, decoder, vc_impl, data_buffer_number) {
   for (int i = 0; i < data_buffer_number; i++) {
     media::VideoCapture::VideoFrameBuffer* buffer;
     buffer = new media::VideoCapture::VideoFrameBuffer();
     buffer->width = arg1.width;
     buffer->height = arg1.height;
     int length = buffer->width * buffer->height * 3 / 2;
     buffer->memory_pointer = new uint8[length];
     buffer->buffer_size = length;
     decoder->OnBufferReady(vc_impl, buffer);
@@ skipping 53 matching lines @@
     media::VideoCapture::VideoCaptureCapability capability;
     capability.width = 176;
     capability.height = 144;
     capability.max_fps = 30;
     capability.expected_capture_delay = 0;
     capability.raw_type = media::VideoFrame::I420;
     capability.interlaced = false;
 
     decoder_ = new CaptureVideoDecoder(message_loop_proxy_,
                                        kVideoStreamId, vc_manager_, capability);
-    renderer_ = new media::MockVideoRenderer();
-
     decoder_->set_host(&host_);
-    decoder_->set_consume_video_frame_callback(
-        base::Bind(&media::MockVideoRenderer::ConsumeVideoFrame,
-                   base::Unretained(renderer_.get())));
     EXPECT_CALL(statistics_callback_object_, OnStatistics(_))
         .Times(AnyNumber());
+
+    read_cb_ = base::Bind(&CaptureVideoDecoderTest::FrameReady,
+                          base::Unretained(this));
   }
 
   virtual ~CaptureVideoDecoderTest() {
     message_loop_->RunAllPending();
   }
 
   media::StatisticsCallback NewStatisticsCallback() {
     return base::Bind(&media::MockStatisticsCallback::OnStatistics,
                       base::Unretained(&statistics_callback_object_));
   }
 
+  MOCK_METHOD1(FrameReady, void(scoped_refptr<media::VideoFrame>));
+
   // Fixture members.
   scoped_refptr<CaptureVideoDecoder> decoder_;
   scoped_refptr<MockVideoCaptureImplManager> vc_manager_;
-  scoped_refptr<media::MockVideoRenderer> renderer_;
   media::MockStatisticsCallback statistics_callback_object_;
   StrictMock<media::MockFilterHost> host_;
   scoped_ptr<MessageLoop> message_loop_;
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
+  media::VideoDecoder::ReadCB read_cb_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CaptureVideoDecoderTest);
 };
 
 TEST_F(CaptureVideoDecoderTest, Play) {
   int data_buffer_number = 1;
   media::VideoCapture::EventHandler* capture_client =
       static_cast<media::VideoCapture::EventHandler*>(decoder_);
   scoped_ptr<MockVideoCaptureImpl> vc_impl(
       new MockVideoCaptureImpl(kVideoStreamId,
                                message_loop_proxy_,
                                new VideoCaptureMessageFilter()));
 
   EXPECT_CALL(*vc_manager_, AddDevice(_, _))
       .WillOnce(Return(vc_impl.get()));
   decoder_->Initialize(NULL,
                        media::NewExpectedClosure(),
                        NewStatisticsCallback());
   message_loop_->RunAllPending();
 
-  EXPECT_CALL(*renderer_, ConsumeVideoFrame(_))
-      .WillRepeatedly(ReturnFrameFromRenderer(decoder_.get()));
+  EXPECT_CALL(*this, FrameReady(_));
+  decoder_->Read(read_cb_);
+
   EXPECT_CALL(*vc_impl, StartCapture(capture_client, _))
       .Times(1)
       .WillOnce(CreateDataBufferFromCapture(capture_client, vc_impl.get(),
                                             data_buffer_number));
   EXPECT_CALL(*vc_impl, FeedBuffer(_))
       .Times(data_buffer_number)
       .WillRepeatedly(DeleteDataBuffer());
   decoder_->Seek(base::TimeDelta(),
                  media::NewExpectedStatusCB(media::PIPELINE_OK));
   decoder_->Play(media::NewExpectedClosure());
   message_loop_->RunAllPending();
 
   EXPECT_CALL(*vc_impl, StopCapture(capture_client))
       .Times(1)
       .WillOnce(CaptureStopped(capture_client, vc_impl.get()));
   EXPECT_CALL(*vc_manager_, RemoveDevice(_, _))
       .WillOnce(Return());
   decoder_->Stop(media::NewExpectedClosure());
   message_loop_->RunAllPending();
 }