Revert 194993 "Remove reference counting from media::VideoDecode..."

trunk/src/media/filters/video_decoder_selector_unittest.cc

Index: trunk/src/media/filters/video_decoder_selector_unittest.cc
===================================================================
--- trunk/src/media/filters/video_decoder_selector_unittest.cc	(revision 195011)
+++ trunk/src/media/filters/video_decoder_selector_unittest.cc	(working copy)
@@ -18,6 +18,7 @@
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::ReturnRef;
+using ::testing::SaveArg;
 using ::testing::StrictMock;
 
 namespace media {
@@ -51,17 +52,16 @@
 
     EXPECT_CALL(*demuxer_stream_, type())
         .WillRepeatedly(Return(DemuxerStream::VIDEO));
+  }
 
+  ~VideoDecoderSelectorTest() {
     EXPECT_CALL(*decoder_1_, Stop(_))
       .WillRepeatedly(RunClosure<0>());
     EXPECT_CALL(*decoder_2_, Stop(_))
       .WillRepeatedly(RunClosure<0>());
-  }
 
-  ~VideoDecoderSelectorTest() {
-    if (selected_decoder_) {
+    if (selected_decoder_)
       selected_decoder_->Stop(NewExpectedClosure());
-    }
 
     message_loop_.RunUntilIdle();
   }
@@ -69,16 +69,9 @@
   MOCK_METHOD1(OnStatistics, void(const PipelineStatistics&));
   MOCK_METHOD1(SetDecryptorReadyCallback, void(const media::DecryptorReadyCB&));
   MOCK_METHOD2(OnDecoderSelected,
-               void(VideoDecoder*,
+               void(const scoped_refptr<VideoDecoder>&,
                     const scoped_refptr<DecryptingDemuxerStream>&));
 
-  void MockOnDecoderSelected(
-      scoped_ptr<VideoDecoder> decoder,
-      const scoped_refptr<DecryptingDemuxerStream>& stream) {
-    OnDecoderSelected(decoder.get(), stream);
-    selected_decoder_ = decoder.Pass();
-  }
-
   void UseClearStream() {
     EXPECT_CALL(*demuxer_stream_, video_decoder_config())
         .WillRepeatedly(ReturnRef(clear_video_config_));
@@ -111,12 +104,12 @@
     }
 
     DCHECK_GE(all_decoders_.size(), static_cast<size_t>(num_decoders));
-    all_decoders_.erase(
-        all_decoders_.begin() + num_decoders, all_decoders_.end());
+    VideoDecoderSelector::VideoDecoderList decoders(
+        all_decoders_.begin(), all_decoders_.begin() + num_decoders);
 
     decoder_selector_.reset(new VideoDecoderSelector(
         message_loop_.message_loop_proxy(),
-        all_decoders_.Pass(),
+        decoders,
         set_decryptor_ready_cb));
   }
 
@@ -125,7 +118,7 @@
         demuxer_stream_,
         base::Bind(&VideoDecoderSelectorTest::OnStatistics,
                    base::Unretained(this)),
-        base::Bind(&VideoDecoderSelectorTest::MockOnDecoderSelected,
+        base::Bind(&VideoDecoderSelectorTest::OnDecoderSelected,
                    base::Unretained(this)));
     message_loop_.RunUntilIdle();
   }
@@ -138,11 +131,11 @@
   // Use NiceMock since we don't care about most of calls on the decryptor, e.g.
   // RegisterNewKeyCB().
   scoped_ptr<NiceMock<MockDecryptor> > decryptor_;
-  StrictMock<MockVideoDecoder>* decoder_1_;
-  StrictMock<MockVideoDecoder>* decoder_2_;
-  ScopedVector<VideoDecoder> all_decoders_;
+  scoped_refptr<StrictMock<MockVideoDecoder> > decoder_1_;
+  scoped_refptr<StrictMock<MockVideoDecoder> > decoder_2_;
+  std::vector<scoped_refptr<VideoDecoder> > all_decoders_;
 
-  scoped_ptr<VideoDecoder> selected_decoder_;
+  scoped_refptr<VideoDecoder> selected_decoder_;
 
   MessageLoop message_loop_;
 
@@ -169,7 +162,9 @@
 
   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
       .WillOnce(RunCallback<1>(PIPELINE_OK));
-  EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull()));
+  EXPECT_CALL(*this, OnDecoderSelected(scoped_refptr<VideoDecoder>(decoder_1_),
+                                       IsNull()))
+      .WillOnce(SaveArg<0>(&selected_decoder_));
 
   SelectDecoder();
 }
@@ -184,7 +179,9 @@
       .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
   EXPECT_CALL(*decoder_2_, Initialize(_, _, _))
       .WillOnce(RunCallback<1>(PIPELINE_OK));
-  EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull()));
+  EXPECT_CALL(*this, OnDecoderSelected(scoped_refptr<VideoDecoder>(decoder_2_),
+                                       IsNull()))
+      .WillOnce(SaveArg<0>(&selected_decoder_));
 
   SelectDecoder();
 }
@@ -197,7 +194,9 @@
 
   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
       .WillOnce(RunCallback<1>(PIPELINE_OK));
-  EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull()));
+  EXPECT_CALL(*this, OnDecoderSelected(scoped_refptr<VideoDecoder>(decoder_1_),
+                                       IsNull()))
+      .WillOnce(SaveArg<0>(&selected_decoder_));
 
   SelectDecoder();
 }
@@ -231,7 +230,9 @@
 
   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
       .WillOnce(RunCallback<1>(PIPELINE_OK));
-  EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, NotNull()));
+  EXPECT_CALL(*this, OnDecoderSelected(scoped_refptr<VideoDecoder>(decoder_1_),
+                                       NotNull()))
+      .WillOnce(SaveArg<0>(&selected_decoder_));
 
   SelectDecoder();
 }
@@ -248,7 +249,9 @@
       .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
   EXPECT_CALL(*decoder_2_, Initialize(_, _, _))
       .WillOnce(RunCallback<1>(PIPELINE_OK));
-  EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, NotNull()));
+  EXPECT_CALL(*this, OnDecoderSelected(scoped_refptr<VideoDecoder>(decoder_2_),
+                                       NotNull()))
+      .WillOnce(SaveArg<0>(&selected_decoder_));
 
   SelectDecoder();
 }
@@ -260,7 +263,8 @@
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptAndDecode, 1);
 
-  EXPECT_CALL(*this, OnDecoderSelected(NotNull(), IsNull()));
+  EXPECT_CALL(*this, OnDecoderSelected(NotNull(), IsNull()))
+      .WillOnce(SaveArg<0>(&selected_decoder_));
 
   SelectDecoder();
 }