Implement and use VideoTrackSource directly.

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 44 matching lines @@
 #include "media/filters/ffmpeg_glue.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #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"
 
 #if defined(OS_ANDROID)
 #include "media/base/android/media_codec_util.h"
 #endif
 
 namespace content {
 
 namespace {
@@ skipping 43 matching lines @@
 PeerConnectionDependencyFactory::CreateRTCPeerConnectionHandler(
     blink::WebRTCPeerConnectionHandlerClient* client) {
   // Save histogram data so we can see how much PeerConnetion is used.
   // The histogram counts the number of calls to the JS API
   // webKitRTCPeerConnection.
   UpdateWebRTCMethodCount(WEBKIT_RTC_PEER_CONNECTION);
 
   return new RTCPeerConnectionHandler(client, this);
 }
 
-WebRtcVideoCapturerAdapter*
-PeerConnectionDependencyFactory::CreateVideoCapturer(
-    bool is_screeencast) {
-  // We need to make sure the libjingle thread wrappers have been created
-  // before we can use an instance of a WebRtcVideoCapturerAdapter. This is
-  // since the base class of WebRtcVideoCapturerAdapter is a
-  // cricket::VideoCapturer and it uses the libjingle thread wrappers.
-  if (!GetPcFactory().get())
-    return NULL;
-  return new WebRtcVideoCapturerAdapter(is_screeencast);
-}
-
-scoped_refptr<webrtc::VideoTrackSourceInterface>
-PeerConnectionDependencyFactory::CreateVideoSource(
-    cricket::VideoCapturer* capturer) {
-  scoped_refptr<webrtc::VideoTrackSourceInterface> source =
-      GetPcFactory()->CreateVideoSource(capturer).get();
-  return source;
-}
-
 const scoped_refptr<webrtc::PeerConnectionFactoryInterface>&
 PeerConnectionDependencyFactory::GetPcFactory() {
   if (!pc_factory_.get())
     CreatePeerConnectionFactory();
   CHECK(pc_factory_.get());
   return pc_factory_;
 }
 
 void PeerConnectionDependencyFactory::WillDestroyCurrentMessageLoop() {
   CleanupPeerConnectionFactory();
@@ skipping 257 matching lines @@
                              nullptr, observer)
       .get();
 }
 
 scoped_refptr<webrtc::MediaStreamInterface>
 PeerConnectionDependencyFactory::CreateLocalMediaStream(
     const std::string& label) {
   return GetPcFactory()->CreateLocalMediaStream(label).get();
 }
 
+scoped_refptr<webrtc::VideoTrackSourceInterface>
+PeerConnectionDependencyFactory::CreateVideoTrackSourceProxy(
+    webrtc::VideoTrackSourceInterface* source) {
+  // PeerConnectionFactory needs to be instantiated to make sure that
+  // signaling_thread_ and worker_thread_ exist.
+  if (!PeerConnectionFactoryCreated())
+    CreatePeerConnectionFactory();
+
+  return webrtc::VideoTrackSourceProxy::Create(signaling_thread_,
+                                               worker_thread_, source)
+      .get();
+}
+
 scoped_refptr<webrtc::VideoTrackInterface>
 PeerConnectionDependencyFactory::CreateLocalVideoTrack(
     const std::string& id,
     webrtc::VideoTrackSourceInterface* source) {
   return GetPcFactory()->CreateVideoTrack(id, source).get();
 }
 
-scoped_refptr<webrtc::VideoTrackInterface>
-PeerConnectionDependencyFactory::CreateLocalVideoTrack(
-    const std::string& id, cricket::VideoCapturer* capturer) {
-  if (!capturer) {
-    LOG(ERROR) << "CreateLocalVideoTrack called with null VideoCapturer.";
-    return NULL;
-  }
-
-  // Create video source from the |capturer|.
-  scoped_refptr<webrtc::VideoTrackSourceInterface> source =
-      GetPcFactory()->CreateVideoSource(capturer, NULL).get();
-
-  // Create native track from the source.
-  return GetPcFactory()->CreateVideoTrack(id, source.get()).get();
-}
-
 webrtc::SessionDescriptionInterface*
 PeerConnectionDependencyFactory::CreateSessionDescription(
     const std::string& type,
     const std::string& sdp,
     webrtc::SdpParseError* error) {
   return webrtc::CreateSessionDescription(type, sdp, error);
 }
 
 webrtc::IceCandidateInterface*
 PeerConnectionDependencyFactory::CreateIceCandidate(
@@ skipping 117 matching lines @@
 
 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() {
   DCHECK(CalledOnValidThread());
   if (audio_device_.get())
     return;
 
   audio_device_ = new WebRtcAudioDeviceImpl();
 }
 
 }  // namespace content