Remove threading from RendererGpuVideoAcceleratorFactories

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/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 25 matching lines @@
     vda_task_runner_ = vda_thread_.message_loop_proxy();
     mock_vda_ = new media::MockVideoDecodeAccelerator;
     EXPECT_CALL(*mock_gpu_factories_, GetTaskRunner())
         .WillRepeatedly(Return(vda_task_runner_));
     EXPECT_CALL(*mock_gpu_factories_, DoCreateVideoDecodeAccelerator(_, _))
         .WillRepeatedly(
              Return(static_cast<media::VideoDecodeAccelerator*>(NULL)));
     EXPECT_CALL(*mock_gpu_factories_,
                 DoCreateVideoDecodeAccelerator(media::VP8PROFILE_MAIN, _))
         .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(webrtc::kVideoCodecVP8, mock_gpu_factories_);
   }
 
   virtual void TearDown() OVERRIDE {
     VLOG(2) << "TearDown";
-    if (vda_thread_.IsRunning()) {
-      RunUntilIdle();  // Wait until all callbascks complete.
-      vda_task_runner_->DeleteSoon(FROM_HERE, rtc_decoder_.release());
-      // Make sure the decoder is released before stopping the thread.
-      RunUntilIdle();
-      vda_thread_.Stop();
-    } else {
-      rtc_decoder_.reset();
-    }
+    EXPECT_TRUE(vda_thread_.IsRunning());
+    RunUntilIdle();  // Wait until all callbascks complete.
+    vda_task_runner_->DeleteSoon(FROM_HERE, rtc_decoder_.release());
+    // Make sure the decoder is released before stopping the thread.
+    RunUntilIdle();
+    vda_thread_.Stop();
   }
 
   virtual int32_t Decoded(webrtc::I420VideoFrame& decoded_image) OVERRIDE {
     VLOG(2) << "Decoded";
     EXPECT_EQ(vda_task_runner_, base::MessageLoopProxy::current());
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
   void Initialize() {
     VLOG(2) << "Initialize";
@@ skipping 84 matching lines @@
 
 TEST_F(RTCVideoDecoderTest, InitDecodeAfterRelease) {
   EXPECT_CALL(*mock_vda_, Reset())
       .WillRepeatedly(Invoke(this, &RTCVideoDecoderTest::NotifyResetDone));
   Initialize();
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->Release());
   Initialize();
   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,
                                                 RTCVideoDecoder::ID_HALF + 2));
   EXPECT_TRUE(rtc_decoder_->IsBufferAfterReset(RTCVideoDecoder::ID_HALF + 2,
                                                RTCVideoDecoder::ID_HALF - 2));
 
   EXPECT_FALSE(rtc_decoder_->IsBufferAfterReset(0, 0));
@@ skipping 30 matching lines @@
 
   EXPECT_FALSE(rtc_decoder_->IsFirstBufferAfterReset(RTCVideoDecoder::ID_LAST,
                                                      RTCVideoDecoder::ID_LAST));
   EXPECT_TRUE(
       rtc_decoder_->IsFirstBufferAfterReset(0, RTCVideoDecoder::ID_LAST));
   EXPECT_FALSE(
       rtc_decoder_->IsFirstBufferAfterReset(1, RTCVideoDecoder::ID_LAST));
 }
 
 }  // content