Report VideoDecoder status through ReadCB instead of through FilterHost.

content/renderer/media/capture_video_decoder_unittest.cc

 // Copyright (c) 2012 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 "media/video/capture/video_capture_types.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::Return;
 using ::testing::StrictMock;
 
@@ skipping 68 matching lines @@
     media::VideoCaptureCapability capability;
     capability.width = kWidth;
     capability.height = kHeight;
     capability.frame_rate = kFPS;
     capability.expected_capture_delay = 0;
     capability.color = media::VideoFrame::I420;
     capability.interlaced = false;
 
     decoder_ = new CaptureVideoDecoder(message_loop_proxy_,
                                        kVideoStreamId, vc_manager_, capability);
-    decoder_->set_host(&host_);
     EXPECT_CALL(statistics_cb_object_, OnStatistics(_))
         .Times(AnyNumber());
 
     read_cb_ = base::Bind(&CaptureVideoDecoderTest::FrameReady,
                           base::Unretained(this));
 
     vc_impl_.reset(new MockVideoCaptureImpl(
         kVideoStreamId, message_loop_proxy_, new VideoCaptureMessageFilter()));
   }
 
   virtual ~CaptureVideoDecoderTest() {
     message_loop_->RunAllPending();
   }
 
   media::StatisticsCB NewStatisticsCB() {
     return base::Bind(&media::MockStatisticsCB::OnStatistics,
                       base::Unretained(&statistics_cb_object_));
   }
 
   void Initialize() {
     // Issue a read.
-    EXPECT_CALL(*this, FrameReady(_));
+    EXPECT_CALL(*this, FrameReady(media::VideoDecoder::kOk, _));
     decoder_->Read(read_cb_);
 
     EXPECT_CALL(*vc_manager_, AddDevice(_, _))
         .WillOnce(Return(vc_impl_.get()));
     int buffer_count = 1;
     EXPECT_CALL(*vc_impl_, StartCapture(capture_client(), _))
         .Times(1)
         .WillOnce(CreateDataBufferFromCapture(capture_client(),
                                               vc_impl_.get(),
                                               buffer_count));
     EXPECT_CALL(*vc_impl_, FeedBuffer(_))
         .Times(buffer_count)
         .WillRepeatedly(DeleteDataBuffer());
 
     decoder_->Initialize(NULL,
                          media::NewExpectedStatusCB(media::PIPELINE_OK),
                          NewStatisticsCB());
     message_loop_->RunAllPending();
   }
 
   void Play() {
     decoder_->Play(media::NewExpectedClosure());
     message_loop_->RunAllPending();
   }
 
   void Flush() {
     // Issue a read.
-    EXPECT_CALL(*this, FrameReady(_));
+    EXPECT_CALL(*this, FrameReady(media::VideoDecoder::kOk, _));
     decoder_->Read(read_cb_);
 
     decoder_->Pause(media::NewExpectedClosure());
     decoder_->Flush(media::NewExpectedClosure());
     message_loop_->RunAllPending();
   }
 
   void Stop() {
     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();
   }
 
   media::VideoCapture::EventHandler* capture_client() {
     return static_cast<media::VideoCapture::EventHandler*>(decoder_);
   }
 
-  MOCK_METHOD1(FrameReady, void(scoped_refptr<media::VideoFrame>));
+  MOCK_METHOD2(FrameReady, void(media::VideoDecoder::DecoderStatus status,
+                                scoped_refptr<media::VideoFrame>));
 
   // Fixture members.
   scoped_refptr<CaptureVideoDecoder> decoder_;
   scoped_refptr<MockVideoCaptureImplManager> vc_manager_;
   scoped_ptr<MockVideoCaptureImpl> vc_impl_;
   media::MockStatisticsCB statistics_cb_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) {
   // Test basic initialize, play, and teardown sequence.
@@ skipping 19 matching lines @@
   params.session_id = kVideoStreamId;
 
   decoder_->OnDeviceInfoReceived(vc_impl_.get(), params);
   message_loop_->RunAllPending();
 
   EXPECT_EQ(expected_size.width(), decoder_->natural_size().width());
   EXPECT_EQ(expected_size.height(), decoder_->natural_size().height());
 
   Stop();
 }