Reland: Remove reference counting from media::VideoDecoder and friends.

media/filters/video_frame_stream_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 "base/callback_helpers.h"
 #include "base/message_loop.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
@@ skipping 13 matching lines @@
 namespace media {
 
 static const VideoFrame::Format kVideoFormat = VideoFrame::YV12;
 static const gfx::Size kCodedSize(320, 240);
 static const gfx::Rect kVisibleRect(320, 240);
 static const gfx::Size kNaturalSize(320, 240);
 
 class VideoFrameStreamTest : public testing::TestWithParam<bool> {
  public:
   VideoFrameStreamTest()
-      : video_frame_stream_(new VideoFrameStream(
-            message_loop_.message_loop_proxy(),
-            base::Bind(&VideoFrameStreamTest::SetDecryptorReadyCallback,
-                       base::Unretained(this)))),
-        video_config_(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
+      : video_config_(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
                       kCodedSize, kVisibleRect, kNaturalSize, NULL, 0,
                       GetParam()),
         demuxer_stream_(new StrictMock<MockDemuxerStream>()),
         decryptor_(new NiceMock<MockDecryptor>()),
         decoder_(new StrictMock<MockVideoDecoder>()),
         is_initialized_(false) {
-    decoders_.push_back(decoder_);
+    ScopedVector<VideoDecoder> decoders;
+    decoders.push_back(decoder_);
+
+    video_frame_stream_ = new VideoFrameStream(
+        message_loop_.message_loop_proxy(),
+        decoders.Pass(),
+        base::Bind(&VideoFrameStreamTest::SetDecryptorReadyCallback,
+                   base::Unretained(this)));
 
     EXPECT_CALL(*demuxer_stream_, type())
         .WillRepeatedly(Return(DemuxerStream::VIDEO));
     EXPECT_CALL(*demuxer_stream_, video_decoder_config())
         .WillRepeatedly(ReturnRef(video_config_));
     EXPECT_CALL(*demuxer_stream_, Read(_))
         .WillRepeatedly(RunCallback<0>(DemuxerStream::kOk,
                                        scoped_refptr<DecoderBuffer>()));
 
     EXPECT_CALL(*this, SetDecryptorReadyCallback(_))
@@ skipping 25 matching lines @@
   MOCK_METHOD2(OnFrameRead, void(VideoDecoder::Status,
                                  const scoped_refptr<VideoFrame>&));
   MOCK_METHOD0(OnReset, void());
   MOCK_METHOD0(OnStopped, void());
 
   void EnterPendingInitializationState() {
     EXPECT_CALL(*decoder_, Initialize(_, _, _))
         .WillOnce(SaveArg<1>(&decoder_init_cb_));
     video_frame_stream_->Initialize(
         demuxer_stream_,
-        decoders_,
         base::Bind(&VideoFrameStreamTest::OnStatistics, base::Unretained(this)),
         base::Bind(&VideoFrameStreamTest::OnInitialized,
                    base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   void SatisfyPendingInitialization(bool success) {
     EXPECT_CALL(*this, OnInitialized(success, false))
         .WillOnce(SaveArg<0>(&is_initialized_));
     base::ResetAndReturn(&decoder_init_cb_).Run(
         success ? PIPELINE_OK : DECODER_ERROR_NOT_SUPPORTED);
     message_loop_.RunUntilIdle();
+
+    // Failed initialization will delete unused decoders.
+    if (!success)
+      decoder_ = NULL;
   }
 
   void EnterPendingReadFrameState() {
     EXPECT_CALL(*decoder_, Read(_))
         .WillOnce(SaveArg<0>(&decoder_read_cb_));
     EXPECT_CALL(*this, OnFrameRead(VideoDecoder::kOk, _));
     video_frame_stream_->ReadFrame(base::Bind(
         &VideoFrameStreamTest::OnFrameRead, base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
@@ skipping 14 matching lines @@
   }
 
   void SatisfyPendingReset() {
     base::ResetAndReturn(&decoder_reset_cb_).Run();
     message_loop_.RunUntilIdle();
   }
 
   void EnterPendingStopState() {
     // If initialization failed, we won't call VideoDecoder::Stop() during
     // the stopping process.
-    EXPECT_CALL(*decoder_, Stop(_))
-        .Times(AtMost(1))
-        .WillRepeatedly(SaveArg<0>(&decoder_stop_cb_));
+    if (decoder_) {
+      EXPECT_CALL(*decoder_, Stop(_))
+          .WillRepeatedly(SaveArg<0>(&decoder_stop_cb_));
+    }
+
     EXPECT_CALL(*this, OnStopped())
         .WillOnce(Assign(&is_initialized_, false));
     video_frame_stream_->Stop(base::Bind(&VideoFrameStreamTest::OnStopped,
                                          base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
 
   void SatisfyPendingStop() {
     // If decoder is not initialized, |decoder_stop_cb_| can be null. In that
     // case, we don't actually need to satisfy the stop callback.
@@ skipping 30 matching lines @@
 
  private:
   MessageLoop message_loop_;
 
   scoped_refptr<VideoFrameStream> video_frame_stream_;
   VideoDecoderConfig video_config_;
   scoped_refptr<StrictMock<MockDemuxerStream> > demuxer_stream_;
   // Use NiceMock since we don't care about most of calls on the decryptor, e.g.
   // RegisterNewKeyCB().
   scoped_ptr<NiceMock<MockDecryptor> > decryptor_;
-  scoped_refptr<StrictMock<MockVideoDecoder> > decoder_;
-  VideoFrameStream::VideoDecoderList decoders_;
+  StrictMock<MockVideoDecoder>* decoder_;  // Owned by |video_frame_stream_|.
 
   // Callbacks to simulate pending decoder operations.
   PipelineStatusCB decoder_init_cb_;
   VideoDecoder::ReadCB decoder_read_cb_;
   base::Closure decoder_reset_cb_;
   base::Closure decoder_stop_cb_;
 
   bool is_initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameStreamTest);
@@ skipping 123 matching lines @@
 }
 
 TEST_P(VideoFrameStreamTest, Stop_AfterReadFrame_AfterReset) {
   Initialize();
   ReadFrame();
   Reset();
   Stop();
 }
 
 }  // namespace media