[WIP] Proxy RtcVideoDecoder calls to a media::VideoDecoder.

content/renderer/media/webrtc/peer_connection_dependency_factory.cc

 // Copyright 2014 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/webrtc/peer_connection_dependency_factory.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 48 matching lines @@
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/webrtc/api/mediaconstraintsinterface.h"
 #include "third_party/webrtc/api/videosourceproxy.h"
 #include "third_party/webrtc/base/ssladapter.h"
 #include "third_party/webrtc/modules/video_coding/codecs/h264/include/h264.h"
 
+// Debug Only! Remove this!
+#include "media/filters/ffmpeg_video_decoder.h"
+#include "media/mojo/clients/mojo_video_decoder.h"
+#include "services/shell/public/cpp/interface_provider.h"
+
 #if defined(OS_ANDROID)
 #include "media/base/android/media_codec_util.h"
 #endif
 
 namespace content {
 
 namespace {
 
 enum WebRTCIPHandlingPolicy {
   DEFAULT,
@@ skipping 11 matching lines @@
   if (preference == kWebRTCIPHandlingDisableNonProxiedUdp)
     return DISABLE_NON_PROXIED_UDP;
   return DEFAULT;
 }
 
 bool IsValidPortRange(uint16_t min_port, uint16_t max_port) {
   DCHECK(min_port <= max_port);
   return min_port != 0 && max_port != 0;
 }
 
+// Debug Only! Remove this!
+std::unique_ptr<media::VideoDecoder> CreateFFmpegVideoDecoder() {
+  return base::WrapUnique(new media::FFmpegVideoDecoder());
+}
+
+// Debug Only! (Maybe)
+std::unique_ptr<media::VideoDecoder> CreateMojoVideoDecoder(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    media::GpuVideoAcceleratorFactories* gpu_factories,
+    shell::InterfaceProvider* remote_interfaces) {
+  DCHECK(remote_interfaces);
+  DCHECK(task_runner->BelongsToCurrentThread());
+  media::mojom::VideoDecoderPtr remote_video_decoder;
+  remote_interfaces->GetInterface(mojo::GetProxy(&remote_video_decoder));
+  return base::MakeUnique<media::MojoVideoDecoder>(
+      task_runner, gpu_factories, std::move(remote_video_decoder));
+}
+
 }  // namespace
 
 PeerConnectionDependencyFactory::PeerConnectionDependencyFactory(
     P2PSocketDispatcher* p2p_socket_dispatcher)
     : network_manager_(NULL),
       p2p_socket_dispatcher_(p2p_socket_dispatcher),
       signaling_thread_(NULL),
       worker_thread_(NULL),
       chrome_signaling_thread_("Chrome_libJingle_Signaling"),
-      chrome_worker_thread_("Chrome_libJingle_WorkerThread") {
+      chrome_worker_thread_("Chrome_libJingle_WorkerThread"),
+      task_runner_(base::ThreadTaskRunnerHandle::Get()) {
   TryScheduleStunProbeTrial();
 }
 
 PeerConnectionDependencyFactory::~PeerConnectionDependencyFactory() {
   DVLOG(1) << "~PeerConnectionDependencyFactory()";
   DCHECK(!pc_factory_);
 }
 
 blink::WebRTCPeerConnectionHandler*
 PeerConnectionDependencyFactory::CreateRTCPeerConnectionHandler(
@@ skipping 78 matching lines @@
   // Init SSL, which will be needed by PeerConnection.
   if (!rtc::InitializeSSL()) {
     LOG(ERROR) << "Failed on InitializeSSL.";
     NOTREACHED();
     return;
   }
 
   base::WaitableEvent start_signaling_event(
       base::WaitableEvent::ResetPolicy::MANUAL,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
+
+#define USE_MOJO_VIDEO_DECODER
+#if defined(USE_LOCAL_FFMPEG_DECODER)
+  auto create_video_decoder_cb = base::Bind(&CreateFFmpegVideoDecoder);
+  auto decoder_task_runner =
+      RenderThreadImpl::current()->GetGpuFactories()->GetTaskRunner();
+#elif defined(USE_MOJO_VIDEO_DECODER)
+  auto create_video_decoder_cb =
+      base::Bind(&CreateMojoVideoDecoder, task_runner_,
+                 RenderThreadImpl::current()->GetGpuFactories(),
+                 RenderThreadImpl::current()->GetRemoteInterfaces());
+  auto decoder_task_runner = task_runner_;
+#else
+  INTENTIONAL ERROR: MUST DEFINE ONE OF THESE
+#endif
   chrome_signaling_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&PeerConnectionDependencyFactory::InitializeSignalingThread,
                  base::Unretained(this),
                  RenderThreadImpl::current()->GetGpuFactories(),
+                 create_video_decoder_cb, decoder_task_runner,
                  &start_signaling_event));
 
   start_signaling_event.Wait();
   CHECK(signaling_thread_);
 }
 
 void PeerConnectionDependencyFactory::InitializeSignalingThread(
     media::GpuVideoAcceleratorFactories* gpu_factories,
+    const CreateVideoDecoderCB& create_video_decoder_cb,
+    const scoped_refptr<base::SingleThreadTaskRunner>& decoder_task_runner,
     base::WaitableEvent* event) {
   DCHECK(chrome_signaling_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK(worker_thread_);
   DCHECK(p2p_socket_dispatcher_.get());
 
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
   signaling_thread_ = jingle_glue::JingleThreadWrapper::current();
 
   socket_factory_.reset(
       new IpcPacketSocketFactory(p2p_socket_dispatcher_.get()));
 
   std::unique_ptr<cricket::WebRtcVideoDecoderFactory> decoder_factory;
   std::unique_ptr<cricket::WebRtcVideoEncoderFactory> encoder_factory;
 
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
-  if (gpu_factories && gpu_factories->IsGpuVideoAcceleratorEnabled()) {
-    if (!cmd_line->HasSwitch(switches::kDisableWebRtcHWDecoding))
-      decoder_factory.reset(new RTCVideoDecoderFactory(gpu_factories));
+  // if (gpu_factories && gpu_factories->IsGpuVideoAcceleratorEnabled()) {
+  //   if (!cmd_line->HasSwitch(switches::kDisableWebRtcHWDecoding))
+  //     decoder_factory.reset(new RTCVideoDecoderFactory(gpu_factories));
 
-    if (!cmd_line->HasSwitch(switches::kDisableWebRtcHWEncoding))
-      encoder_factory.reset(new RTCVideoEncoderFactory(gpu_factories));
-  }
+  //   if (!cmd_line->HasSwitch(switches::kDisableWebRtcHWEncoding))
+  //     encoder_factory.reset(new RTCVideoEncoderFactory(gpu_factories));
+  // }
+  decoder_factory.reset(
+      new RTCVideoDecoderFactory(create_video_decoder_cb, decoder_task_runner));
 
 #if defined(OS_ANDROID)
   if (!media::MediaCodecUtil::SupportsSetParameters())
     encoder_factory.reset();
 #endif
 
   pc_factory_ = webrtc::CreatePeerConnectionFactory(
       worker_thread_, signaling_thread_, audio_device_.get(),
       encoder_factory.release(), decoder_factory.release());
   CHECK(pc_factory_.get());
@@ skipping 301 matching lines @@
 
 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() {
   DCHECK(CalledOnValidThread());
   if (audio_device_.get())
     return;
 
   audio_device_ = new WebRtcAudioDeviceImpl();
 }
 
 }  // namespace content