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 479 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_ptr<base::Thread> vda_thread(new base::Thread("vda_thread"));

[scherkus (not reviewing), 2013/07/18 00:54:43]

OOC what warrants using a separate thread? Is it your comment about the
libjingle worker thread being pegged?

Is it possible to use some other existing thread? (e.g., render thread, IO,
media thread, some other process-wide thread...)

If not, can we make this a lazily-allocated process-wide thread?

[wuchengli, 2013/07/18 09:42:00]

libjingle worker thread being pegged only means I cannot use it in
RtcVideoDecoder and RGVDF.

Using media thread sounds like a good idea. What RtcVideoDecoder does is similar
to GpuVideoDecoder. It makes them more consistent. I've changed the code to use
media thread.

By the way, I verified that the performance of using libjingle worker thread is
worse than using media thread or a new thread.

+      bool started = vda_thread->Start();
+      scoped_refptr<content::RendererGpuVideoDecoderFactories> gpu_factories;
+      if (started) {
+        gpu_factories = RenderThreadImpl::current()->GetGpuFactories(
+            vda_thread->message_loop_proxy());
+      }
+      if (gpu_factories.get() != NULL) {
+        decoder_factory.reset(
+            new RTCVideoDecoderFactory(vda_thread.Pass(), 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