Replace all uses of webrtc::VideoRendererInterface by rtc::VideoSinkInterface.

BUG=webrtc:5426

Review URL: https://codereview.chromium.org/1809623002

Cr-Commit-Position: refs/heads/master@{#381678}

content/renderer/media/webrtc/media_stream_remote_video_source.cc

@@ -18,6 +18,7 @@
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "third_party/webrtc/media/base/videoframe.h"
+#include "third_party/webrtc/media/base/videosinkinterface.h"
 #include "third_party/webrtc/system_wrappers/include/tick_util.h"
 
 namespace content {
@@ -26,7 +27,7 @@ namespace content {
 // libjingle thread and forward it to the IO-thread.
 class MediaStreamRemoteVideoSource::RemoteVideoSourceDelegate
     : public base::RefCountedThreadSafe<RemoteVideoSourceDelegate>,
-      public webrtc::VideoRendererInterface {
+      public rtc::VideoSinkInterface<cricket::VideoFrame> {
  public:
   RemoteVideoSourceDelegate(
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
@@ -36,10 +37,10 @@ class MediaStreamRemoteVideoSource::RemoteVideoSourceDelegate
   friend class base::RefCountedThreadSafe<RemoteVideoSourceDelegate>;
   ~RemoteVideoSourceDelegate() override;
 
-  // Implements webrtc::VideoRendererInterface used for receiving video frames
+  // Implements rtc::VideoSinkInterface used for receiving video frames
   // from the PeerConnection video track. May be called on a libjingle internal
   // thread.
-  void RenderFrame(const cricket::VideoFrame* frame) override;
+  void OnFrame(const cricket::VideoFrame& frame) override;
 
   void DoRenderFrameOnIOThread(
       const scoped_refptr<media::VideoFrame>& video_frame);
@@ -77,10 +78,10 @@ MediaStreamRemoteVideoSource::
 RemoteVideoSourceDelegate::~RemoteVideoSourceDelegate() {
 }
 
-void MediaStreamRemoteVideoSource::RemoteVideoSourceDelegate::RenderFrame(
-    const cricket::VideoFrame* incoming_frame) {
+void MediaStreamRemoteVideoSource::RemoteVideoSourceDelegate::OnFrame(
+    const cricket::VideoFrame& incoming_frame) {
   const base::TimeDelta incoming_timestamp = base::TimeDelta::FromMicroseconds(
-      incoming_frame->GetTimeStamp() / rtc::kNumNanosecsPerMicrosec);
+      incoming_frame.GetTimeStamp() / rtc::kNumNanosecsPerMicrosec);
   const base::TimeTicks render_time =
       base::TimeTicks() + incoming_timestamp + time_diff_;
 
@@ -94,13 +95,13 @@ void MediaStreamRemoteVideoSource::RemoteVideoSourceDelegate::RenderFrame(
       incoming_timestamp - start_timestamp_;
 
   scoped_refptr<media::VideoFrame> video_frame;
-  if (incoming_frame->GetNativeHandle() != NULL) {
+  if (incoming_frame.GetNativeHandle() != NULL) {
     video_frame =
-        static_cast<media::VideoFrame*>(incoming_frame->GetNativeHandle());
+        static_cast<media::VideoFrame*>(incoming_frame.GetNativeHandle());
     video_frame->set_timestamp(elapsed_timestamp);
   } else {
     const cricket::VideoFrame* frame =
-        incoming_frame->GetCopyWithRotationApplied();
+        incoming_frame.GetCopyWithRotationApplied();
 
     gfx::Size size(frame->GetWidth(), frame->GetHeight());
 
@@ -178,7 +179,7 @@ void MediaStreamRemoteVideoSource::StartSourceImpl(
   delegate_ = new RemoteVideoSourceDelegate(io_task_runner(), frame_callback);
   scoped_refptr<webrtc::VideoTrackInterface> video_track(
       static_cast<webrtc::VideoTrackInterface*>(observer_->track().get()));
-  video_track->AddRenderer(delegate_.get());
+  video_track->AddOrUpdateSink(delegate_.get(), rtc::VideoSinkWants());
   OnStartDone(MEDIA_DEVICE_OK);
 }
 
@@ -193,13 +194,13 @@ void MediaStreamRemoteVideoSource::StopSourceImpl() {
   DCHECK(state() != MediaStreamVideoSource::ENDED);
   scoped_refptr<webrtc::VideoTrackInterface> video_track(
       static_cast<webrtc::VideoTrackInterface*>(observer_->track().get()));
-  video_track->RemoveRenderer(delegate_.get());
+  video_track->RemoveSink(delegate_.get());
   // This removes the references to the webrtc video track.
   observer_.reset();
 }
 
-webrtc::VideoRendererInterface*
-MediaStreamRemoteVideoSource::RenderInterfaceForTest() {
+rtc::VideoSinkInterface<cricket::VideoFrame>*
+MediaStreamRemoteVideoSource::SinkInterfaceForTest() {
   return delegate_.get();
 }
 

content/renderer/media/webrtc/media_stream_remote_video_source.h

@@ -49,7 +49,7 @@ class CONTENT_EXPORT MediaStreamRemoteVideoSource
 
   // Used by tests to test that a frame can be received and that the
   // MediaStreamRemoteVideoSource behaves as expected.
-  webrtc::VideoRendererInterface* RenderInterfaceForTest();
+  rtc::VideoSinkInterface<cricket::VideoFrame>* SinkInterfaceForTest();
 
  private:
   void OnChanged(webrtc::MediaStreamTrackInterface::TrackState state);

content/renderer/media/webrtc/media_stream_remote_video_source_unittest.cc

@@ -32,7 +32,7 @@ class MediaStreamRemoteVideoSourceUnderTest
   explicit MediaStreamRemoteVideoSourceUnderTest(
       scoped_ptr<TrackObserver> observer)
       : MediaStreamRemoteVideoSource(std::move(observer)) {}
-  using MediaStreamRemoteVideoSource::RenderInterfaceForTest;
+  using MediaStreamRemoteVideoSource::SinkInterfaceForTest;
 };
 
 class MediaStreamRemoteVideoSourceTest
@@ -131,7 +131,7 @@ TEST_F(MediaStreamRemoteVideoSourceTest, StartTrack) {
       RunClosure(quit_closure));
   cricket::WebRtcVideoFrame webrtc_frame;
   webrtc_frame.InitToBlack(320, 240, 1);
-  source()->RenderInterfaceForTest()->RenderFrame(&webrtc_frame);
+  source()->SinkInterfaceForTest()->OnFrame(webrtc_frame);
   run_loop.Run();
 
   EXPECT_EQ(1, sink.number_of_frames());

content/renderer/media/webrtc/media_stream_track_metrics_unittest.cc

@@ -20,7 +20,6 @@ using webrtc::AudioTrackSinkInterface;
 using webrtc::MediaStreamInterface;
 using webrtc::ObserverInterface;
 using webrtc::PeerConnectionInterface;
-using webrtc::VideoRendererInterface;
 using webrtc::VideoTrackSourceInterface;
 using webrtc::VideoTrackInterface;
 
@@ -64,8 +63,10 @@ class MockVideoTrackInterface : public VideoTrackInterface {
   MOCK_CONST_METHOD0(state, TrackState());
   MOCK_METHOD1(set_enabled, bool(bool));
   MOCK_METHOD1(set_state, bool(TrackState));
-  MOCK_METHOD1(AddRenderer, void(VideoRendererInterface*));
-  MOCK_METHOD1(RemoveRenderer, void(VideoRendererInterface*));
+  MOCK_METHOD2(AddOrUpdateSink,
+               void(rtc::VideoSinkInterface<cricket::VideoFrame>*,
+                    const rtc::VideoSinkWants&));
+  MOCK_METHOD1(RemoveSink, void(rtc::VideoSinkInterface<cricket::VideoFrame>*));
   MOCK_CONST_METHOD0(GetSource, VideoTrackSourceInterface*());
 
  private:

content/renderer/media/webrtc/mock_peer_connection_dependency_factory.cc

@@ -27,7 +27,6 @@ using webrtc::IceCandidateInterface;
 using webrtc::MediaStreamInterface;
 using webrtc::ObserverInterface;
 using webrtc::SessionDescriptionInterface;
-using webrtc::VideoRendererInterface;
 using webrtc::VideoTrackSourceInterface;
 using webrtc::VideoTrackInterface;
 using webrtc::VideoTrackVector;
@@ -198,18 +197,21 @@ MockWebRtcVideoTrack::MockWebRtcVideoTrack(
       id_(id),
       state_(MediaStreamTrackInterface::kLive),
       source_(source),
-      renderer_(NULL) {}
+      sink_(NULL) {}
 
 MockWebRtcVideoTrack::~MockWebRtcVideoTrack() {}
 
-void MockWebRtcVideoTrack::AddRenderer(VideoRendererInterface* renderer) {
-  DCHECK(!renderer_);
-  renderer_ = renderer;
+void MockWebRtcVideoTrack::AddOrUpdateSink(
+    rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
+    const rtc::VideoSinkWants& wants) {
+  DCHECK(!sink_);
+  sink_ = sink;
 }
 
-void MockWebRtcVideoTrack::RemoveRenderer(VideoRendererInterface* renderer) {
-  DCHECK(renderer_ == renderer);
-  renderer_ = NULL;
+void MockWebRtcVideoTrack::RemoveSink(
+    rtc::VideoSinkInterface<cricket::VideoFrame>* sink) {
+  DCHECK(sink_ == sink);
+  sink_ = NULL;
 }
 
 std::string MockWebRtcVideoTrack::kind() const {

content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h

@@ -60,8 +60,9 @@ class MockWebRtcVideoTrack : public webrtc::VideoTrackInterface {
  public:
   MockWebRtcVideoTrack(const std::string& id,
                        webrtc::VideoTrackSourceInterface* source);
-  void AddRenderer(webrtc::VideoRendererInterface* renderer) override;
-  void RemoveRenderer(webrtc::VideoRendererInterface* renderer) override;
+  void AddOrUpdateSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
+                       const rtc::VideoSinkWants& wants) override;
+  void RemoveSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink) override;
   std::string kind() const override;
   std::string id() const override;
   bool enabled() const override;
@@ -81,7 +82,7 @@ class MockWebRtcVideoTrack : public webrtc::VideoTrackInterface {
   TrackState state_;
   scoped_refptr<webrtc::VideoTrackSourceInterface> source_;
   ObserverSet observers_;
-  webrtc::VideoRendererInterface* renderer_;
+  rtc::VideoSinkInterface<cricket::VideoFrame>* sink_;
 };
 
 class MockMediaStream : public webrtc::MediaStreamInterface {

remoting/protocol/webrtc_video_renderer_adapter.cc

@@ -41,23 +41,23 @@ WebrtcVideoRendererAdapter::WebrtcVideoRendererAdapter(
     LOG(WARNING) << "Received media stream with multiple video tracks.";
   }
 
-  video_tracks[0]->AddRenderer(this);
+  video_tracks[0]->AddOrUpdateSink(this, rtc::VideoSinkWants());
 }
 
 WebrtcVideoRendererAdapter::~WebrtcVideoRendererAdapter() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 }
 
-void WebrtcVideoRendererAdapter::RenderFrame(const cricket::VideoFrame* frame) {
-  // TODO(sergeyu): WebRTC calls RenderFrame on a separate thread it creates.
+void WebrtcVideoRendererAdapter::OnFrame(const cricket::VideoFrame& frame) {
+  // TODO(sergeyu): WebRTC calls OnFrame on a separate thread it creates.
   // FrameConsumer normally expects to be called on the network thread, so we
   // cannot call FrameConsumer::AllocateFrame() here and instead
   // BasicDesktopFrame is created directly. This will not work correctly with
   // all FrameConsumer implementations. Fix this somehow.
   scoped_ptr<webrtc::DesktopFrame> rgb_frame(new webrtc::BasicDesktopFrame(
-      webrtc::DesktopSize(frame->GetWidth(), frame->GetHeight())));
+      webrtc::DesktopSize(frame.GetWidth(), frame.GetHeight())));
 
-  frame->ConvertToRgbBuffer(
+  frame.ConvertToRgbBuffer(
       output_format_fourcc_, rgb_frame->data(),
       std::abs(rgb_frame->stride()) * rgb_frame->size().height(),
       rgb_frame->stride());

remoting/protocol/webrtc_video_renderer_adapter.h

@@ -8,6 +8,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "third_party/webrtc/api/mediastreaminterface.h"
+#include "third_party/webrtc/media/base/videosinkinterface.h"
 
 namespace base {
 class SingleThreadTaskRunner;
@@ -17,12 +18,17 @@ namespace webrtc {
 class DesktopFrame;
 }  // namespace webrtc
 
+namespace cricket {
+class VideoFrame;
+}  // namespace cricket
+
 namespace remoting {
 namespace protocol {
 
 class FrameConsumer;
 
-class WebrtcVideoRendererAdapter : public webrtc::VideoRendererInterface {
+class WebrtcVideoRendererAdapter
+    : public rtc::VideoSinkInterface<cricket::VideoFrame> {
  public:
   WebrtcVideoRendererAdapter(
       scoped_refptr<webrtc::MediaStreamInterface> media_stream,
@@ -31,8 +37,8 @@ class WebrtcVideoRendererAdapter : public webrtc::VideoRendererInterface {
 
   std::string label() const { return media_stream_->label(); }
 
-  // webrtc::VideoRendererInterface implementation.
-  void RenderFrame(const cricket::VideoFrame* frame) override;
+  // rtc::VideoSinkInterface implementation.
+  void OnFrame(const cricket::VideoFrame& frame) override;
 
  private:
   void DrawFrame(scoped_ptr<webrtc::DesktopFrame> frame);