Integrate VDA with WebRTC.

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/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
+#include "content/public/common/content_switches.h"
 #include "content/renderer/media/media_stream_source_extra_data.h"
 #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"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "content/renderer/p2p/ipc_network_manager.h"
 #include "content/renderer/p2p/ipc_socket_factory.h"
 #include "content/renderer/p2p/port_allocator.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebMediaConstraints.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebMediaStream.h"
@@ skipping 167 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,
+    const scoped_refptr<media::GpuVideoDecoder::Factories>& gpu_factories,
     P2PSocketDispatcher* p2p_socket_dispatcher)
     : network_manager_(NULL),
       vc_manager_(vc_manager),
+      gpu_factories_(gpu_factories),

[Ami GONE FROM CHROMIUM, 2013/04/26 00:42:05]

DCHECK this is NULL iff the cmd-line flag is missing?

[wuchengli, 2013/04/26 11:49:14]

I changed the place where MediaStreamDependencyFactory is created. If
gpu_factories is non NULL, kEnableWebRTCHWDecoding is enabled.

       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") {
+      if (!decoder_worker_thread_.Start()) {

[Ami GONE FROM CHROMIUM, 2013/04/26 00:42:05]

Shouldn't this be conditional on wanting to use GVD?

[wuchengli, 2013/04/26 11:49:14]

I moved this to EnsurePeerConnectionFactory and started the thread only when
gpu_factories is non-null.

[wuchengli, 2013/05/08 15:58:56]

Sounds good. I've used gpu_factories_ to decide whether to create
RTCVideoDecoderFactory.
On 2013/04/26 11:49:14, wuchengli wrote:

+        LOG(ERROR) << "Could not start decoder worker thread";
+      }
 }
 
 MediaStreamDependencyFactory::~MediaStreamDependencyFactory() {
   CleanupPeerConnectionFactory();
 }
 
 WebKit::WebRTCPeerConnectionHandler*
 MediaStreamDependencyFactory::CreateRTCPeerConnectionHandler(
     WebKit::WebRTCPeerConnectionHandlerClient* client) {
   // Save histogram data so we can see how much PeerConnetion is used.
@@ skipping 197 matching lines @@
   return type == WebKit::WebMediaStreamSource::TypeAudio ?
       native_stream->RemoveTrack(native_stream->FindAudioTrack(track_id)) :
       native_stream->RemoveTrack(native_stream->FindVideoTrack(track_id));
 }
 
 bool MediaStreamDependencyFactory::CreatePeerConnectionFactory() {
   DVLOG(1) << "MediaStreamDependencyFactory::CreatePeerConnectionFactory()";
   if (!pc_factory_.get()) {
     DCHECK(!audio_device_);
     audio_device_ = new WebRtcAudioDeviceImpl();
+
+    RTCVideoDecoderFactory* decoder_factory = NULL;
+    const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+    if (command_line.HasSwitch(switches::kEnableWebRTCHWDecoding)) {
+      decoder_factory = new RTCVideoDecoderFactory(
+              decoder_worker_thread_.message_loop_proxy(), gpu_factories_);
+    }
+
     scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
         webrtc::CreatePeerConnectionFactory(worker_thread_,
                                             signaling_thread_,
-                                            audio_device_));
+                                            audio_device_,
+                                            decoder_factory));
     if (factory.get())
       pc_factory_ = factory;
     else
       audio_device_ = NULL;

[Ami GONE FROM CHROMIUM, 2013/04/26 00:42:05]

need to delete the decoder_factory in this case?
(generally, a useful idiom for this is to place the new'd object directly into a
scoped_ptr<> and pass it to CreatePeerConnectionFactory() as
decoder_factory.Pass()

[wuchengli, 2013/05/08 15:58:56]

No need to delete the decoder_factory because CreatePeerConnectionFactory takes
the ownership and will delete it in all cases. CreatePeerConnectionFactory takes
a pointer so I changed it to decoder_factory.release().
On 2013/04/26 00:42:05, Ami Fischman wrote:

   }
   return pc_factory_.get() != NULL;
 }
 
 bool MediaStreamDependencyFactory::PeerConnectionFactoryCreated() {
   return pc_factory_.get() != NULL;
 }
 
 scoped_refptr<webrtc::PeerConnectionInterface>
 MediaStreamDependencyFactory::CreatePeerConnection(
@@ skipping 245 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