Remove reference counting from media::VideoDecoder and friends.

media/base/pipeline_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 <vector>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/test/simple_test_clock.h"
@@ skipping 69 matching lines @@
 // initialization is moved to a separate thread this test will become flaky.
 class PipelineTest : public ::testing::Test {
  public:
   PipelineTest()
       : pipeline_(new Pipeline(message_loop_.message_loop_proxy(),
                                new MediaLog())),
         filter_collection_(new FilterCollection()) {
     demuxer_ = new MockDemuxer();
     filter_collection_->SetDemuxer(demuxer_);
 
-    video_decoder_ = new MockVideoDecoder();
-    filter_collection_->GetVideoDecoders()->push_back(video_decoder_);
-
     video_renderer_ = new MockVideoRenderer();
     scoped_ptr<VideoRenderer> video_renderer(video_renderer_);
     filter_collection_->SetVideoRenderer(video_renderer.Pass());
 
     audio_renderer_ = new MockAudioRenderer();
     scoped_ptr<AudioRenderer> audio_renderer(audio_renderer_);
     filter_collection_->SetAudioRenderer(audio_renderer.Pass());
 
     // InitializeDemuxer() adds overriding expectations for expected non-NULL
     // streams.
@@ skipping 56 matching lines @@
   StrictMock<MockDemuxerStream>* CreateStream(DemuxerStream::Type type) {
     StrictMock<MockDemuxerStream>* stream =
         new StrictMock<MockDemuxerStream>();
     EXPECT_CALL(*stream, type())
         .WillRepeatedly(Return(type));
     return stream;
   }
 
   // Sets up expectations to allow the video renderer to initialize.
   void InitializeVideoRenderer(const scoped_refptr<DemuxerStream>& stream) {
-    EXPECT_CALL(*video_renderer_,
-                Initialize(stream, _, _, _, _, _, _, _, _, _))
-        .WillOnce(RunCallback<2>(PIPELINE_OK));
+    EXPECT_CALL(*video_renderer_, Initialize(stream, _, _, _, _, _, _, _, _))
+        .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*video_renderer_, SetPlaybackRate(0.0f));
 
     // Startup sequence.
-    EXPECT_CALL(*video_renderer_,
-                Preroll(demuxer_->GetStartTime(), _))
+    EXPECT_CALL(*video_renderer_, Preroll(demuxer_->GetStartTime(), _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*video_renderer_, Play(_))
         .WillOnce(RunClosure<0>());
   }
 
   // Sets up expectations to allow the audio renderer to initialize.
   void InitializeAudioRenderer(const scoped_refptr<DemuxerStream>& stream,
                                bool disable_after_init_cb) {
     if (disable_after_init_cb) {
       EXPECT_CALL(*audio_renderer_, Initialize(stream, _, _, _, _, _, _, _))
@@ skipping 107 matching lines @@
   }
 
   // Fixture members.
   StrictMock<CallbackHelper> callbacks_;
   base::SimpleTestClock test_clock_;
   MessageLoop message_loop_;
   scoped_refptr<Pipeline> pipeline_;
 
   scoped_ptr<FilterCollection> filter_collection_;
   scoped_refptr<MockDemuxer> demuxer_;
-  scoped_refptr<MockVideoDecoder> video_decoder_;
   MockVideoRenderer* video_renderer_;
   MockAudioRenderer* audio_renderer_;
   scoped_refptr<StrictMock<MockDemuxerStream> > audio_stream_;
   scoped_refptr<StrictMock<MockDemuxerStream> > video_stream_;
   AudioRenderer::TimeCB audio_time_cb_;
   VideoDecoderConfig video_decoder_config_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PipelineTest);
 };
@@ skipping 694 matching lines @@
       EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
       EXPECT_CALL(*audio_renderer_, Stop(_)).WillOnce(RunClosure<0>());
       return status;
     }
 
     EXPECT_CALL(*audio_renderer_, Initialize(_, _, _, _, _, _, _, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     if (state == kInitVideoRenderer) {
       if (stop_or_error == kStop) {
-        EXPECT_CALL(*video_renderer_,
-                    Initialize(_, _, _, _, _, _, _, _, _, _))
+        EXPECT_CALL(*video_renderer_, Initialize(_, _, _, _, _, _, _, _, _))
             .WillOnce(DoAll(Stop(pipeline_, stop_cb),
-                            RunCallback<2>(PIPELINE_OK)));
+                            RunCallback<1>(PIPELINE_OK)));
         EXPECT_CALL(callbacks_, OnStop());
       } else {
         status = PIPELINE_ERROR_INITIALIZATION_FAILED;
-        EXPECT_CALL(*video_renderer_,
-                    Initialize(_, _, _, _, _, _, _, _, _, _))
-            .WillOnce(RunCallback<2>(status));
+        EXPECT_CALL(*video_renderer_, Initialize(_, _, _, _, _, _, _, _, _))
+            .WillOnce(RunCallback<1>(status));
       }
 
       EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
       EXPECT_CALL(*audio_renderer_, Stop(_)).WillOnce(RunClosure<0>());
       EXPECT_CALL(*video_renderer_, Stop(_)).WillOnce(RunClosure<0>());
       return status;
     }
 
-    EXPECT_CALL(*video_renderer_,
-                Initialize(_, _, _, _, _, _, _, _, _, _))
-        .WillOnce(RunCallback<2>(PIPELINE_OK));
+    EXPECT_CALL(*video_renderer_, Initialize(_, _, _, _, _, _, _, _, _))
+        .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kHaveMetadata));
 
     // If we get here it's a successful initialization.
     EXPECT_CALL(*audio_renderer_, Preroll(base::TimeDelta(), _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*video_renderer_, Preroll(base::TimeDelta(), _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     EXPECT_CALL(*demuxer_, SetPlaybackRate(0.0f));
@@ skipping 167 matching lines @@
 INSTANTIATE_TEARDOWN_TEST(Error, InitAudioRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, InitVideoRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, Pausing);
 INSTANTIATE_TEARDOWN_TEST(Error, Flushing);
 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Error, Prerolling);
 INSTANTIATE_TEARDOWN_TEST(Error, Starting);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 
 }  // namespace media