Delete VideoRendererInterface.

Use in chromium was deleted a few days ago.

BUG=webrtc:5426
R=magjed@webrtc.org, pbos@webrtc.org, perkj@webrtc.org, pthatcher@webrtc.org, tkchin@webrtc.org

Review URL: https://codereview.webrtc.org/1817473002 .

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

talk/app/webrtc/objc/RTCVideoRendererAdapter.h

@@ -33,7 +33,7 @@
 
 @property(nonatomic, readonly) id<RTCVideoRenderer> videoRenderer;
 @property(nonatomic, readonly)
-    webrtc::VideoRendererInterface* nativeVideoRenderer;
+    rtc::VideoSinkInterface<cricket::VideoFrame> *nativeVideoRenderer;
 
 - (instancetype)initWithVideoRenderer:(id<RTCVideoRenderer>)videoRenderer;
 

talk/app/webrtc/objc/RTCVideoRendererAdapter.mm

@@ -36,15 +36,16 @@
 
 namespace webrtc {
 
-class RTCVideoRendererNativeAdapter : public VideoRendererInterface {
+class RTCVideoRendererNativeAdapter
+    : public rtc::VideoSinkInterface<cricket::VideoFrame> {
  public:
   RTCVideoRendererNativeAdapter(RTCVideoRendererAdapter* adapter) {
     _adapter = adapter;
     _size = CGSizeZero;
   }
 
-  void RenderFrame(const cricket::VideoFrame* videoFrame) override {
-    const cricket::VideoFrame* frame = videoFrame->GetCopyWithRotationApplied();
+  void OnFrame(const cricket::VideoFrame& videoFrame) override {
+    const cricket::VideoFrame* frame = videoFrame.GetCopyWithRotationApplied();
     CGSize currentSize = CGSizeMake(frame->GetWidth(), frame->GetHeight());
     if (!CGSizeEqualToSize(_size, currentSize)) {
       _size = currentSize;
@@ -74,7 +75,7 @@ class RTCVideoRendererNativeAdapter : public VideoRendererInterface {
   return self;
 }
 
-- (webrtc::VideoRendererInterface*)nativeVideoRenderer {
+- (rtc::VideoSinkInterface<cricket::VideoFrame> *)nativeVideoRenderer {
   return _adapter.get();
 }
 

talk/app/webrtc/objc/RTCVideoTrack.mm

@@ -78,7 +78,7 @@
 
 - (void)dealloc {
   for (RTCVideoRendererAdapter *adapter in _adapters) {
-    self.nativeVideoTrack->RemoveRenderer(adapter.nativeVideoRenderer);
+    self.nativeVideoTrack->RemoveSink(adapter.nativeVideoRenderer);
   }
 }
 
@@ -91,7 +91,8 @@
   RTCVideoRendererAdapter* adapter =
       [[RTCVideoRendererAdapter alloc] initWithVideoRenderer:renderer];
   [_adapters addObject:adapter];
-  self.nativeVideoTrack->AddRenderer(adapter.nativeVideoRenderer);
+  self.nativeVideoTrack->AddOrUpdateSink(adapter.nativeVideoRenderer,
+                                         rtc::VideoSinkWants());
 }
 
 - (void)removeRenderer:(id<RTCVideoRenderer>)renderer {
@@ -107,7 +108,7 @@
   if (indexToRemove == NSNotFound) {
     return;
   }
-  self.nativeVideoTrack->RemoveRenderer(adapter.nativeVideoRenderer);
+  self.nativeVideoTrack->RemoveSink(adapter.nativeVideoRenderer);
   [_adapters removeObjectAtIndex:indexToRemove];
 }
 

webrtc/api/java/android/org/webrtc/SurfaceViewRenderer.java

@@ -31,7 +31,7 @@ import javax.microedition.khronos.egl.EGLContext;
  * renderFrame() is asynchronous to avoid blocking the calling thread.
  * This class is thread safe and handles access from potentially four different threads:
  * Interaction from the main app in init, release, setMirror, and setScalingtype.
- * Interaction from C++ webrtc::VideoRendererInterface in renderFrame and canApplyRotation.
+ * Interaction from C++ rtc::VideoSinkInterface in renderFrame.
  * Interaction from the Activity lifecycle in surfaceCreated, surfaceChanged, and surfaceDestroyed.
  * Interaction with the layout framework in onMeasure and onSizeChanged.
  */

webrtc/api/java/jni/peerconnection_jni.cc

@@ -106,7 +106,6 @@ using webrtc::SetSessionDescriptionObserver;
 using webrtc::StatsObserver;
 using webrtc::StatsReport;
 using webrtc::StatsReports;
-using webrtc::VideoRendererInterface;
 using webrtc::VideoTrackSourceInterface;
 using webrtc::VideoTrackInterface;
 using webrtc::VideoTrackVector;
@@ -731,32 +730,10 @@ class StatsObserverWrapper : public StatsObserver {
   const jmethodID j_value_ctor_;
 };
 
-// Adapter presenting a cricket::VideoRenderer as a
-// webrtc::VideoRendererInterface.
-class VideoRendererWrapper : public VideoRendererInterface {
- public:
-  static VideoRendererWrapper* Create(cricket::VideoRenderer* renderer) {
-    if (renderer)
-      return new VideoRendererWrapper(renderer);
-    return NULL;
-  }
-
-  virtual ~VideoRendererWrapper() {}
-
-  void RenderFrame(const cricket::VideoFrame* video_frame) override {
-    ScopedLocalRefFrame local_ref_frame(AttachCurrentThreadIfNeeded());
-    renderer_->RenderFrame(video_frame->GetCopyWithRotationApplied());
-  }
-
- private:
-  explicit VideoRendererWrapper(cricket::VideoRenderer* renderer)
-      : renderer_(renderer) {}
-  scoped_ptr<cricket::VideoRenderer> renderer_;
-};
-
-// Wrapper dispatching webrtc::VideoRendererInterface to a Java VideoRenderer
+// Wrapper dispatching rtc::VideoSinkInterface to a Java VideoRenderer
 // instance.
-class JavaVideoRendererWrapper : public VideoRendererInterface {
+class JavaVideoRendererWrapper
+    : public rtc::VideoSinkInterface<cricket::VideoFrame> {
  public:
   JavaVideoRendererWrapper(JNIEnv* jni, jobject j_callbacks)
       : j_callbacks_(jni, j_callbacks),
@@ -776,11 +753,11 @@ class JavaVideoRendererWrapper : public VideoRendererInterface {
 
   virtual ~JavaVideoRendererWrapper() {}
 
-  void RenderFrame(const cricket::VideoFrame* video_frame) override {
+  void OnFrame(const cricket::VideoFrame& video_frame) override {
     ScopedLocalRefFrame local_ref_frame(jni());
-    jobject j_frame = (video_frame->GetNativeHandle() != nullptr)
-                          ? CricketToJavaTextureFrame(video_frame)
-                          : CricketToJavaI420Frame(video_frame);
+    jobject j_frame = (video_frame.GetNativeHandle() != nullptr)
+                          ? CricketToJavaTextureFrame(&video_frame)
+                          : CricketToJavaI420Frame(&video_frame);
     // |j_callbacks_| is responsible for releasing |j_frame| with
     // VideoRenderer.renderFrameDone().
     jni()->CallVoidMethod(*j_callbacks_, j_render_frame_id_, j_frame);
@@ -1997,15 +1974,20 @@ JOW(jboolean, MediaStreamTrack_nativeSetEnabled)(
 JOW(void, VideoTrack_nativeAddRenderer)(
     JNIEnv* jni, jclass,
     jlong j_video_track_pointer, jlong j_renderer_pointer) {
-  reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)->AddRenderer(
-      reinterpret_cast<VideoRendererInterface*>(j_renderer_pointer));
+  reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)
+      ->AddOrUpdateSink(
+          reinterpret_cast<rtc::VideoSinkInterface<cricket::VideoFrame>*>(
+              j_renderer_pointer),
+          rtc::VideoSinkWants());
 }
 
 JOW(void, VideoTrack_nativeRemoveRenderer)(
     JNIEnv* jni, jclass,
     jlong j_video_track_pointer, jlong j_renderer_pointer) {
-  reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)->RemoveRenderer(
-      reinterpret_cast<VideoRendererInterface*>(j_renderer_pointer));
+  reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)
+      ->RemoveSink(
+          reinterpret_cast<rtc::VideoSinkInterface<cricket::VideoFrame>*>(
+              j_renderer_pointer));
 }
 
 JOW(jlong, CallSessionFileRotatingLogSink_nativeAddSink)(

webrtc/api/java/src/org/webrtc/VideoRenderer.java

@@ -13,7 +13,7 @@ package org.webrtc;
 import java.nio.ByteBuffer;
 
 /**
- * Java version of VideoRendererInterface.  In addition to allowing clients to
+ * Java version of VideoSinkInterface.  In addition to allowing clients to
  * define their own rendering behavior (by passing in a Callbacks object), this
  * class also provides a createGui() method for creating a GUI-rendering window
  * on various platforms.
@@ -106,7 +106,7 @@ public class VideoRenderer {
   public static native void nativeCopyPlane(ByteBuffer src, int width,
       int height, int srcStride, ByteBuffer dst, int dstStride);
 
-  /** The real meat of VideoRendererInterface. */
+  /** The real meat of VideoSinkInterface. */
   public static interface Callbacks {
     // |frame| might have pending rotation and implementation of Callbacks
     // should handle that by applying rotation during rendering. The callee

webrtc/api/mediastreaminterface.h

@@ -99,26 +99,6 @@ class MediaStreamTrackInterface : public rtc::RefCountInterface,
   virtual ~MediaStreamTrackInterface() {}
 };
 
-// Interface for rendering VideoFrames from a VideoTrack
-class VideoRendererInterface
-    : public rtc::VideoSinkInterface<cricket::VideoFrame> {
- public:
-  // |frame| may have pending rotation. For clients which can't apply rotation,
-  // |frame|->GetCopyWithRotationApplied() will return a frame that has the
-  // rotation applied.
-  virtual void RenderFrame(const cricket::VideoFrame* frame) = 0;
-  // Intended to replace RenderFrame.
-  void OnFrame(const cricket::VideoFrame& frame) override {
-    RenderFrame(&frame);
-  }
-
- protected:
-  // The destructor is protected to prevent deletion via the interface.
-  // This is so that we allow reference counted classes, where the destructor
-  // should never be public, to implement the interface.
-  virtual ~VideoRendererInterface() {}
-};
-
 // VideoTrackSourceInterface is a reference counted source used for VideoTracks.
 // The same source can be used in multiple VideoTracks.
 class VideoTrackSourceInterface
@@ -157,16 +137,6 @@ class VideoTrackInterface
     : public MediaStreamTrackInterface,
       public rtc::VideoSourceInterface<cricket::VideoFrame> {
  public:
-  // AddRenderer and RemoveRenderer are for backwards compatibility
-  // only. They are obsoleted by the methods of
-  // rtc::VideoSourceInterface.
-  virtual void AddRenderer(VideoRendererInterface* renderer) {
-    AddOrUpdateSink(renderer, rtc::VideoSinkWants());
-  }
-  virtual void RemoveRenderer(VideoRendererInterface* renderer) {
-    RemoveSink(renderer);
-  }
-
   // Register a video sink for this track.
   void AddOrUpdateSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
                        const rtc::VideoSinkWants& wants) override{};

webrtc/api/mediastreamtrackproxy.h

@@ -46,8 +46,6 @@ BEGIN_PROXY_MAP(VideoTrack)
   PROXY_METHOD1(bool, set_enabled, bool)
   PROXY_METHOD1(bool, set_state, TrackState)
 
-  PROXY_METHOD1(void, AddRenderer, VideoRendererInterface*)
-  PROXY_METHOD1(void, RemoveRenderer, VideoRendererInterface*)
   PROXY_METHOD2(void,
                 AddOrUpdateSink,
                 rtc::VideoSinkInterface<cricket::VideoFrame>*,

webrtc/api/objc/RTCVideoRendererAdapter+Private.h

@@ -26,12 +26,12 @@ NS_ASSUME_NONNULL_BEGIN
 @property(nonatomic, readonly) id<RTCVideoRenderer> videoRenderer;
 
 /**
- * The native VideoRendererInterface surface exposed by this adapter. Calls made
+ * The native VideoSinkInterface surface exposed by this adapter. Calls made
  * to this interface will be adapted and passed to the RTCVideoRenderer supplied
  * during construction. This pointer is unsafe and owned by this class.
  */
 @property(nonatomic, readonly)
-    webrtc::VideoRendererInterface *nativeVideoRenderer;
+    rtc::VideoSinkInterface<cricket::VideoFrame> *nativeVideoRenderer;
 
 /** Initialize an RTCVideoRendererAdapter with an RTCVideoRenderer. */
 - (instancetype)initWithNativeRenderer:(id<RTCVideoRenderer>)videoRenderer

webrtc/api/objc/RTCVideoRendererAdapter.h

@@ -13,8 +13,8 @@
 NS_ASSUME_NONNULL_BEGIN
 
 /*
- * Creates a webrtc::VideoRendererInterface surface for an RTCVideoRenderer. The
- * webrtc::VideoRendererInterface is used by WebRTC rendering code - this
+ * Creates a rtc::VideoSinkInterface surface for an RTCVideoRenderer. The
+ * rtc::VideoSinkInterface is used by WebRTC rendering code - this
  * adapter adapts calls made to that interface to the RTCVideoRenderer supplied
  * during construction.
  */

webrtc/api/objc/RTCVideoRendererAdapter.mm

@@ -15,16 +15,17 @@
 
 namespace webrtc {
 
-class VideoRendererAdapter : public VideoRendererInterface {
+class VideoRendererAdapter
+    : public rtc::VideoSinkInterface<cricket::VideoFrame> {
  public:
   VideoRendererAdapter(RTCVideoRendererAdapter* adapter) {
     adapter_ = adapter;
     size_ = CGSizeZero;
   }
 
-  void RenderFrame(const cricket::VideoFrame *nativeVideoFrame) override {
+  void OnFrame(const cricket::VideoFrame& nativeVideoFrame) override {
     const cricket::VideoFrame *frame =
-        nativeVideoFrame->GetCopyWithRotationApplied();
+        nativeVideoFrame.GetCopyWithRotationApplied();
     CGSize current_size = CGSizeMake(frame->GetWidth(), frame->GetHeight());
     if (!CGSizeEqualToSize(size_, current_size)) {
       size_ = current_size;
@@ -56,7 +57,7 @@ class VideoRendererAdapter : public VideoRendererInterface {
   return self;
 }
 
-- (webrtc::VideoRendererInterface *)nativeVideoRenderer {
+- (rtc::VideoSinkInterface<cricket::VideoFrame> *)nativeVideoRenderer {
   return _adapter.get();
 }
 

webrtc/api/objc/RTCVideoTrack.mm

@@ -52,7 +52,7 @@
 
 - (void)dealloc {
   for (RTCVideoRendererAdapter *adapter in _adapters) {
-    self.nativeVideoTrack->RemoveRenderer(adapter.nativeVideoRenderer);
+    self.nativeVideoTrack->RemoveSink(adapter.nativeVideoRenderer);
   }
 }
 
@@ -79,7 +79,8 @@
   RTCVideoRendererAdapter* adapter =
       [[RTCVideoRendererAdapter alloc] initWithNativeRenderer:renderer];
   [_adapters addObject:adapter];
-  self.nativeVideoTrack->AddRenderer(adapter.nativeVideoRenderer);
+  self.nativeVideoTrack->AddOrUpdateSink(adapter.nativeVideoRenderer,
+                                         rtc::VideoSinkWants());
 }
 
 - (void)removeRenderer:(id<RTCVideoRenderer>)renderer {
@@ -97,7 +98,7 @@
   }
   RTCVideoRendererAdapter *adapterToRemove =
       [_adapters objectAtIndex:indexToRemove];
-  self.nativeVideoTrack->RemoveRenderer(adapterToRemove.nativeVideoRenderer);
+  self.nativeVideoTrack->RemoveSink(adapterToRemove.nativeVideoRenderer);
   [_adapters removeObjectAtIndex:indexToRemove];
 }
 

webrtc/api/test/fakevideotrackrenderer.h

@@ -44,33 +44,6 @@ class FakeVideoTrackRenderer
   rtc::scoped_refptr<VideoTrackInterface> video_track_;
 };
 
-// Similar class, testing the deprecated AddRenderer/RemoveRenderer methods.
-class FakeVideoTrackRendererOld : public VideoRendererInterface {
- public:
-  FakeVideoTrackRendererOld(VideoTrackInterface* video_track)
-      : video_track_(video_track) {
-    video_track_->AddRenderer(this);
-  }
-  ~FakeVideoTrackRendererOld() { video_track_->RemoveRenderer(this); }
-
-  virtual void RenderFrame(const cricket::VideoFrame* video_frame) override {
-    fake_renderer_.RenderFrame(video_frame);
-  }
-
-  int errors() const { return fake_renderer_.errors(); }
-  int width() const { return fake_renderer_.width(); }
-  int height() const { return fake_renderer_.height(); }
-  bool black_frame() const { return fake_renderer_.black_frame(); }
-
-  int num_rendered_frames() const {
-    return fake_renderer_.num_rendered_frames();
-  }
-
- private:
-  cricket::FakeVideoRenderer fake_renderer_;
-  rtc::scoped_refptr<VideoTrackInterface> video_track_;
-};
-
 }  // namespace webrtc
 
 #endif  // WEBRTC_API_TEST_FAKEVIDEOTRACKRENDERER_H_

webrtc/api/videotrack_unittest.cc

@@ -20,7 +20,6 @@
 #include "webrtc/media/engine/webrtcvideoframe.h"
 
 using webrtc::FakeVideoTrackRenderer;
-using webrtc::FakeVideoTrackRendererOld;
 using webrtc::MediaSourceInterface;
 using webrtc::MediaStreamTrackInterface;
 using webrtc::VideoTrackSource;
@@ -74,30 +73,6 @@ TEST_F(VideoTrackTest, RenderVideo) {
   EXPECT_EQ(2, renderer_2->num_rendered_frames());
 }
 
-// Test adding renderers to a video track and render to them by
-// providing frames to the source. Uses the old VideoTrack interface
-// with AddRenderer and RemoveRenderer.
-TEST_F(VideoTrackTest, RenderVideoOld) {
-  // FakeVideoTrackRenderer register itself to |video_track_|
-  rtc::scoped_ptr<FakeVideoTrackRendererOld> renderer_1(
-      new FakeVideoTrackRendererOld(video_track_.get()));
-
-  capturer_.CaptureFrame();
-  EXPECT_EQ(1, renderer_1->num_rendered_frames());
-
-  // FakeVideoTrackRenderer register itself to |video_track_|
-  rtc::scoped_ptr<FakeVideoTrackRenderer> renderer_2(
-      new FakeVideoTrackRenderer(video_track_.get()));
-
-  capturer_.CaptureFrame();
-  EXPECT_EQ(2, renderer_1->num_rendered_frames());
-  EXPECT_EQ(1, renderer_2->num_rendered_frames());
-
-  renderer_1.reset(nullptr);
-  capturer_.CaptureFrame();
-  EXPECT_EQ(2, renderer_2->num_rendered_frames());
-}
-
 // Test that disabling the track results in blacked out frames.
 TEST_F(VideoTrackTest, DisableTrackBlackout) {
   rtc::scoped_ptr<FakeVideoTrackRenderer> renderer(

webrtc/examples/peerconnection/client/linux/main_wnd.h

@@ -77,9 +77,8 @@ class GtkMainWnd : public MainWindow {
                   webrtc::VideoTrackInterface* track_to_render);
     virtual ~VideoRenderer();
 
-    // VideoRendererInterface implementation
-    virtual void SetSize(int width, int height);
-    virtual void OnFrame(const cricket::VideoFrame& frame);
+    // VideoSinkInterface implementation
+    void OnFrame(const cricket::VideoFrame& frame) override;
 
     const uint8_t* image() const { return image_.get(); }
 
@@ -92,6 +91,7 @@ class GtkMainWnd : public MainWindow {
     }
 
    protected:
+    void SetSize(int width, int height);
     rtc::scoped_ptr<uint8_t[]> image_;
     int width_;
     int height_;

webrtc/examples/peerconnection/client/main_wnd.cc

@@ -576,11 +576,11 @@ MainWnd::VideoRenderer::VideoRenderer(
   bmi_.bmiHeader.biHeight = -height;
   bmi_.bmiHeader.biSizeImage = width * height *
                               (bmi_.bmiHeader.biBitCount >> 3);
-  rendered_track_->AddRenderer(this);
+  rendered_track_->AddOrUpdateSink(this, rtc::VideoSinkWants());
 }
 
 MainWnd::VideoRenderer::~VideoRenderer() {
-  rendered_track_->RemoveRenderer(this);
+  rendered_track_->RemoveSink(this);
   ::DeleteCriticalSection(&buffer_lock_);
 }
 
@@ -598,16 +598,14 @@ void MainWnd::VideoRenderer::SetSize(int width, int height) {
   image_.reset(new uint8_t[bmi_.bmiHeader.biSizeImage]);
 }
 
-void MainWnd::VideoRenderer::RenderFrame(
-    const cricket::VideoFrame* video_frame) {
-  if (!video_frame)
-    return;
+void MainWnd::VideoRenderer::OnFrame(
+    const cricket::VideoFrame& video_frame) {
 
   {
     AutoLock<VideoRenderer> lock(this);
 
     const cricket::VideoFrame* frame =
-        video_frame->GetCopyWithRotationApplied();
+        video_frame.GetCopyWithRotationApplied();
 
     SetSize(static_cast<int>(frame->GetWidth()),
             static_cast<int>(frame->GetHeight()));

webrtc/examples/peerconnection/client/main_wnd.h

@@ -102,7 +102,7 @@ class MainWnd : public MainWindow {
 
   HWND handle() const { return wnd_; }
 
-  class VideoRenderer : public webrtc::VideoRendererInterface {
+  class VideoRenderer : public rtc::VideoSinkInterface<cricket::VideoFrame> {
    public:
     VideoRenderer(HWND wnd, int width, int height,
                   webrtc::VideoTrackInterface* track_to_render);
@@ -116,14 +116,15 @@ class MainWnd : public MainWindow {
       ::LeaveCriticalSection(&buffer_lock_);
     }
 
-    // VideoRendererInterface implementation
-    virtual void SetSize(int width, int height);
-    virtual void RenderFrame(const cricket::VideoFrame* frame);
+    // VideoSinkInterface implementation
+    void OnFrame(const cricket::VideoFrame& frame) override;
 
     const BITMAPINFO& bmi() const { return bmi_; }
     const uint8_t* image() const { return image_.get(); }
 
    protected:
+    void SetSize(int width, int height);
+
     enum {
       SET_SIZE,
       RENDER_FRAME,