Make RendererGpuVideoDecoderFactories live on arbitrary threads.

content/renderer/media/media_stream_dependency_factory.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 "content/renderer/media/media_stream_dependency_factory.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 207 matching lines @@
   WebKit::WebMediaStream* description_;
   MediaStreamDependencyFactory::MediaSourcesCreatedCallback ready_callback_;
   bool live_;
   typedef std::vector<scoped_refptr<webrtc::MediaSourceInterface> >
       ObservedSources;
   ObservedSources sources_;
 };
 
 MediaStreamDependencyFactory::MediaStreamDependencyFactory(
     VideoCaptureImplManager* vc_manager,
-    P2PSocketDispatcher* p2p_socket_dispatcher)
+    P2PSocketDispatcher* p2p_socket_dispatcher,
+    const scoped_refptr<base::MessageLoopProxy>& media_loop_proxy)
     : network_manager_(NULL),
 #if defined(GOOGLE_TV)
       decoder_factory_tv_(NULL),
 #endif
       vc_manager_(vc_manager),
       p2p_socket_dispatcher_(p2p_socket_dispatcher),
       signaling_thread_(NULL),
       worker_thread_(NULL),
-      chrome_worker_thread_("Chrome_libJingle_WorkerThread") {
+      chrome_worker_thread_("Chrome_libJingle_WorkerThread"),
+      media_loop_proxy_(media_loop_proxy) {
 }
 
 MediaStreamDependencyFactory::~MediaStreamDependencyFactory() {
   CleanupPeerConnectionFactory();
 }
 
 WebKit::WebRTCPeerConnectionHandler*
 MediaStreamDependencyFactory::CreateRTCPeerConnectionHandler(
     WebKit::WebRTCPeerConnectionHandlerClient* client) {
   // Save histogram data so we can see how much PeerConnetion is used.
@@ skipping 242 matching lines @@
   DVLOG(1) << "MediaStreamDependencyFactory::CreatePeerConnectionFactory()";
   if (!pc_factory_.get()) {
     DCHECK(!audio_device_.get());
     audio_device_ = new WebRtcAudioDeviceImpl();
 
     scoped_ptr<cricket::WebRtcVideoDecoderFactory> decoder_factory;
     scoped_ptr<cricket::WebRtcVideoEncoderFactory> encoder_factory;
 
     const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
     if (cmd_line->HasSwitch(switches::kEnableWebRtcHWDecoding)) {
-      scoped_refptr<media::GpuVideoDecoder::Factories> gpu_factories =
-          RenderThreadImpl::current()->GetGpuFactories();
-      if (gpu_factories.get() != NULL)
-        decoder_factory.reset(new RTCVideoDecoderFactory(gpu_factories));
+      scoped_refptr<content::RendererGpuVideoDecoderFactories> gpu_factories =
+          RenderThreadImpl::current()->GetGpuFactories(media_loop_proxy_);

[scherkus (not reviewing), 2013/07/19 18:13:58]

how about replacing media_loop_proxy_ with a call to
RenderThreadImpl::current()->GetMediaThreadMessageLoopProxy() ?

[wuchengli, 2013/07/20 06:04:14]

Good idea. Done.

+      if (gpu_factories.get() != NULL) {
+        decoder_factory.reset(
+            new RTCVideoDecoderFactory(media_loop_proxy_, gpu_factories));
+      }
     }
 #if defined(GOOGLE_TV)
     // PeerConnectionFactory will hold the ownership of this
     // VideoDecoderFactory.
     decoder_factory.reset(decoder_factory_tv_ = new RTCVideoDecoderFactoryTv);
 #endif
 
 #if defined(ENABLE_WEBRTC) && defined(OS_CHROMEOS)
     const CommandLine& command_line = *CommandLine::ForCurrentProcess();
     if (command_line.HasSwitch(switches::kEnableEncodedScreenCapture)) {
@@ skipping 311 matching lines @@
       // processed before returning. We wait for the above task to finish before
       // letting the the function continue to avoid any potential race issues.
       chrome_worker_thread_.Stop();
     } else {
       NOTREACHED() << "Worker thread not running.";
     }
   }
 }
 
 }  // namespace content