Make RendererGpuVideoDecoderFactories live on arbitrary threads.

content/renderer/media/rtc_video_decoder_unittest.cc

 // Copyright 2013 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/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "content/renderer/media/rtc_video_decoder.h"
 #include "media/base/gmock_callback_support.h"
@@ skipping 19 matching lines @@
         idle_waiter_(false, false) {
     memset(&codec_, 0, sizeof(codec_));
   }
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(vda_thread_.Start());
     vda_loop_proxy_ = vda_thread_.message_loop_proxy();
     mock_vda_ = new media::MockVideoDecodeAccelerator;
     EXPECT_CALL(*mock_gpu_factories_, GetMessageLoop())
         .WillRepeatedly(Return(vda_loop_proxy_));
+    EXPECT_CALL(*mock_gpu_factories_, CreateVideoDecodeAccelerator(_, _))
+        .WillRepeatedly(
+             Return(static_cast<media::VideoDecodeAccelerator*>(NULL)));
     EXPECT_CALL(*mock_gpu_factories_,
                 CreateVideoDecodeAccelerator(media::VP8PROFILE_MAIN, _))
-        .WillOnce(Return(mock_vda_));
+        .WillRepeatedly(Return(mock_vda_));
     EXPECT_CALL(*mock_gpu_factories_, Abort()).WillRepeatedly(Return());
     EXPECT_CALL(*mock_gpu_factories_, CreateSharedMemory(_))
         .WillRepeatedly(Return(static_cast<base::SharedMemory*>(NULL)));
     EXPECT_CALL(*mock_vda_, Destroy());
-    rtc_decoder_ = RTCVideoDecoder::Create(mock_gpu_factories_);
+    rtc_decoder_ =
+        RTCVideoDecoder::Create(webrtc::kVideoCodecVP8, vda_loop_proxy_,
+                                mock_gpu_factories_);
   }
 
   virtual void TearDown() OVERRIDE {
     VLOG(2) << "TearDown";
     if (vda_thread_.IsRunning()) {
+      if (rtc_decoder_)
+        rtc_decoder_->Release();
       RunUntilIdle();  // Wait until all callbascks complete.
       vda_loop_proxy_->DeleteSoon(FROM_HERE, rtc_decoder_.release());
       // Make sure the decoder is released before stopping the thread.
       RunUntilIdle();
       vda_thread_.Stop();
     } else {
       rtc_decoder_.reset();
     }
   }
 
@@ skipping 33 matching lines @@
   webrtc::VideoCodec codec_;
   base::Thread vda_thread_;
 
  private:
   scoped_refptr<base::MessageLoopProxy> vda_loop_proxy_;
 
   base::Lock lock_;
   base::WaitableEvent idle_waiter_;
 };
 
+TEST_F(RTCVideoDecoderTest, CreateReturnsNullOnUnsupportedCodec) {
+  scoped_ptr<RTCVideoDecoder> null_rtc_decoder(
+      RTCVideoDecoder::Create(webrtc::kVideoCodecI420,
+                              vda_thread_.message_loop_proxy(),
+                              mock_gpu_factories_));
+  EXPECT_EQ(NULL, null_rtc_decoder.get());
+}
+
 TEST_F(RTCVideoDecoderTest, InitDecodeReturnsErrorOnFeedbackMode) {
   codec_.codecType = webrtc::kVideoCodecVP8;
   codec_.codecSpecific.VP8.feedbackModeOn = true;
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR, rtc_decoder_->InitDecode(&codec_, 1));
 }
 
 TEST_F(RTCVideoDecoderTest, DecodeReturnsErrorWithoutInitDecode) {
   webrtc::EncodedImage input_image;
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_UNINITIALIZED,
             rtc_decoder_->Decode(input_image, false, NULL, NULL, 0));
@@ skipping 18 matching lines @@
 
 TEST_F(RTCVideoDecoderTest, ResetReturnsOk) {
   Initialize();
   EXPECT_CALL(*mock_vda_, Reset())
       .WillOnce(Invoke(this, &RTCVideoDecoderTest::NotifyResetDone));
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->Reset());
 }
 
 TEST_F(RTCVideoDecoderTest, ReleaseReturnsOk) {
   Initialize();
-  EXPECT_CALL(*mock_vda_, Reset())
-      .WillOnce(Invoke(this, &RTCVideoDecoderTest::NotifyResetDone));
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->Release());
 }
 
 TEST_F(RTCVideoDecoderTest, VdaThreadStops) { vda_thread_.Stop(); }
 
 TEST_F(RTCVideoDecoderTest, IsBufferAfterReset) {
   EXPECT_TRUE(rtc_decoder_->IsBufferAfterReset(0, RTCVideoDecoder::ID_INVALID));
   EXPECT_TRUE(rtc_decoder_->IsBufferAfterReset(RTCVideoDecoder::ID_LAST,
                                                RTCVideoDecoder::ID_INVALID));
   EXPECT_FALSE(rtc_decoder_->IsBufferAfterReset(RTCVideoDecoder::ID_HALF - 2,
@@ skipping 11 matching lines @@
   EXPECT_FALSE(rtc_decoder_->IsBufferAfterReset(RTCVideoDecoder::ID_LAST, 0));
   EXPECT_FALSE(rtc_decoder_->IsBufferAfterReset(RTCVideoDecoder::ID_LAST,
                                                 RTCVideoDecoder::ID_HALF - 2));
   EXPECT_TRUE(rtc_decoder_->IsBufferAfterReset(RTCVideoDecoder::ID_LAST,
                                                RTCVideoDecoder::ID_HALF + 2));
   EXPECT_FALSE(rtc_decoder_->IsBufferAfterReset(RTCVideoDecoder::ID_LAST,
                                                 RTCVideoDecoder::ID_LAST));
 }
 
 }  // content