Integrate VDA with WebRTC.

content/renderer/media/media_stream_dependency_factory.cc

Index: content/renderer/media/media_stream_dependency_factory.cc
diff --git a/content/renderer/media/media_stream_dependency_factory.cc b/content/renderer/media/media_stream_dependency_factory.cc
index 421bfacfb8e34bdc5c8a0827b5a886f712e0a01a..d01d4dd617517194506f2bf6c70c3a477b777a7f 100644
--- a/content/renderer/media/media_stream_dependency_factory.cc
+++ b/content/renderer/media/media_stream_dependency_factory.cc
@@ -12,6 +12,7 @@
 #include "content/renderer/media/rtc_media_constraints.h"
 #include "content/renderer/media/rtc_peer_connection_handler.h"
 #include "content/renderer/media/rtc_video_capturer.h"
+#include "content/renderer/media/rtc_video_decoder_factory.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/media/webaudio_capturer_source.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
@@ -200,13 +201,16 @@ class SourceStateObserver : public webrtc::ObserverInterface,
 
 MediaStreamDependencyFactory::MediaStreamDependencyFactory(
     VideoCaptureImplManager* vc_manager,
+    const scoped_refptr<media::GpuVideoDecoder::Factories>& gpu_factories,
     P2PSocketDispatcher* p2p_socket_dispatcher)
     : network_manager_(NULL),
       vc_manager_(vc_manager),
+      gpu_factories_(gpu_factories),
       p2p_socket_dispatcher_(p2p_socket_dispatcher),
       signaling_thread_(NULL),
       worker_thread_(NULL),
-      chrome_worker_thread_("Chrome_libJingle_WorkerThread") {
+      chrome_worker_thread_("Chrome_libJingle_WorkerThread"),
+      decoder_worker_thread_("DecoderWorkerThread") {
 }
 
 MediaStreamDependencyFactory::~MediaStreamDependencyFactory() {
@@ -459,10 +463,18 @@ bool MediaStreamDependencyFactory::CreatePeerConnectionFactory() {
   if (!pc_factory_) {
     DCHECK(!audio_device_);
     audio_device_ = new WebRtcAudioDeviceImpl();
+
+    scoped_ptr<RTCVideoDecoderFactory> decoder_factory;
+    if (gpu_factories_ != NULL && decoder_worker_thread_.IsRunning()) {
+      decoder_factory.reset(new RTCVideoDecoderFactory(
+              decoder_worker_thread_.message_loop_proxy(), gpu_factories_));

[Ami GONE FROM CHROMIUM, 2013/05/14 22:57:24]

Does this mean that the same gpu_factories will be used for every
mediastream-backed <video> tag in a given renderer process?  That's broken: a
given gpu_factories_ object can only be used with a single <video> tag (e.g.
look at its impl use of waitableevents).

[wuchengli, 2013/05/15 15:30:46]

I'm not sure which waitableevents are you talking about. Can you give me the URL
of the source?

Do you mean we need to cretae a gpu_factories_ every time
CreatePeerConnectionFactory is called?

[wuchengli, 2013/05/20 14:32:15]

I was thinking to move the creation of gpu_factories to
RTCVideoDecoderFactory::CreateVideoDecoder. CreateVideoDecoder is called on
WebRTC decoding thread. So it will need to post the task back to main renderer
thread to create the gpu_factories. Do you think that's the right place?

I tried to implement this today. But the main renderer thread does not run the
task at all. I'm still trying to figure out why.

What method or data structure can map to one mediastream-backed <video> tag?
Does one WebMediaPlayerMS mean one mediastream-backed <video> tag?
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/r...

+    }
+
     scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
         webrtc::CreatePeerConnectionFactory(worker_thread_,
                                             signaling_thread_,
-                                            audio_device_));
+                                            audio_device_,
+                                            decoder_factory.release()));
     if (factory)
       pc_factory_ = factory;
     else
@@ -702,6 +714,12 @@ bool MediaStreamDependencyFactory::EnsurePeerConnectionFactory() {
     DCHECK(worker_thread_);
   }
 
+  if (gpu_factories_ != NULL && !decoder_worker_thread_.IsRunning()) {
+    if (!decoder_worker_thread_.Start()) {
+      LOG(ERROR) << "Could not start decoder worker thread";
+    }
+  }
+
   if (!network_manager_) {
     base::WaitableEvent event(true, false);
     chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(