diff --git a/talk/app/webrtc/mediastreaminterface.h b/talk/app/webrtc/mediastreaminterface.h
index f2543bb0b7..9b137d9f76 100644
--- a/talk/app/webrtc/mediastreaminterface.h
+++ b/talk/app/webrtc/mediastreaminterface.h
@@ -40,7 +40,6 @@
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/refcount.h"
 #include "webrtc/base/scoped_ref_ptr.h"
-#include "webrtc/media/base/videosinkinterface.h"
 
 namespace cricket {
 
@@ -117,17 +116,12 @@ class MediaStreamTrackInterface : public rtc::RefCountInterface,
 };
 
 // Interface for rendering VideoFrames from a VideoTrack
-class VideoRendererInterface
-    : public rtc::VideoSinkInterface<cricket::VideoFrame> {
+class VideoRendererInterface {
  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.
diff --git a/talk/app/webrtc/rtpsenderreceiver_unittest.cc b/talk/app/webrtc/rtpsenderreceiver_unittest.cc
index 3df9821c9a..a590e1d01f 100644
--- a/talk/app/webrtc/rtpsenderreceiver_unittest.cc
+++ b/talk/app/webrtc/rtpsenderreceiver_unittest.cc
@@ -103,9 +103,8 @@ class FakeVideoSource : public Notifier<VideoSourceInterface> {
   virtual cricket::VideoCapturer* GetVideoCapturer() { return &fake_capturer_; }
   virtual void Stop() {}
   virtual void Restart() {}
-  virtual void AddSink(rtc::VideoSinkInterface<cricket::VideoFrame>* output) {}
-  virtual void RemoveSink(
-      rtc::VideoSinkInterface<cricket::VideoFrame>* output) {}
+  virtual void AddSink(cricket::VideoRenderer* output) {}
+  virtual void RemoveSink(cricket::VideoRenderer* output) {}
   virtual SourceState state() const { return state_; }
   virtual bool remote() const { return remote_; }
   virtual const cricket::VideoOptions* options() const { return &options_; }
diff --git a/talk/app/webrtc/videosource.cc b/talk/app/webrtc/videosource.cc
index 8006c583b6..4b371e3ed5 100644
--- a/talk/app/webrtc/videosource.cc
+++ b/talk/app/webrtc/videosource.cc
@@ -436,21 +436,19 @@ void VideoSource::Restart() {
     SetState(kEnded);
     return;
   }
-  for (auto* sink : sinks_) {
-    channel_manager_->AddVideoSink(video_capturer_.get(), sink);
+  for(cricket::VideoRenderer* sink : sinks_) {
+    channel_manager_->AddVideoRenderer(video_capturer_.get(), sink);
   }
 }
 
-void VideoSource::AddSink(
-    rtc::VideoSinkInterface<cricket::VideoFrame>* output) {
+void VideoSource::AddSink(cricket::VideoRenderer* output) {
   sinks_.push_back(output);
-  channel_manager_->AddVideoSink(video_capturer_.get(), output);
+  channel_manager_->AddVideoRenderer(video_capturer_.get(), output);
 }
 
-void VideoSource::RemoveSink(
-    rtc::VideoSinkInterface<cricket::VideoFrame>* output) {
+void VideoSource::RemoveSink(cricket::VideoRenderer* output) {
   sinks_.remove(output);
-  channel_manager_->RemoveVideoSink(video_capturer_.get(), output);
+  channel_manager_->RemoveVideoRenderer(video_capturer_.get(), output);
 }
 
 // OnStateChange listens to the ChannelManager::SignalVideoCaptureStateChange.
diff --git a/talk/app/webrtc/videosource.h b/talk/app/webrtc/videosource.h
index eaaec41962..98c1e083a3 100644
--- a/talk/app/webrtc/videosource.h
+++ b/talk/app/webrtc/videosource.h
@@ -38,7 +38,6 @@
 #include "talk/media/base/videocommon.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sigslot.h"
-#include "webrtc/media/base/videosinkinterface.h"
 
 // VideoSource implements VideoSourceInterface. It owns a
 // cricket::VideoCapturer and make sure the camera is started at a resolution
@@ -85,8 +84,8 @@ class VideoSource : public Notifier<VideoSourceInterface>,
 
   // |output| will be served video frames as long as the underlying capturer
   // is running video frames.
-  virtual void AddSink(rtc::VideoSinkInterface<cricket::VideoFrame>* output);
-  virtual void RemoveSink(rtc::VideoSinkInterface<cricket::VideoFrame>* output);
+  virtual void AddSink(cricket::VideoRenderer* output);
+  virtual void RemoveSink(cricket::VideoRenderer* output);
 
  protected:
   VideoSource(cricket::ChannelManager* channel_manager,
@@ -104,7 +103,7 @@ class VideoSource : public Notifier<VideoSourceInterface>,
   rtc::scoped_ptr<cricket::VideoCapturer> video_capturer_;
   rtc::scoped_ptr<cricket::VideoRenderer> frame_input_;
 
-  std::list<rtc::VideoSinkInterface<cricket::VideoFrame>*> sinks_;
+  std::list<cricket::VideoRenderer*> sinks_;
 
   cricket::VideoFormat format_;
   cricket::VideoOptions options_;
diff --git a/talk/app/webrtc/videosourceinterface.h b/talk/app/webrtc/videosourceinterface.h
index 4039310016..a90e3d5a48 100644
--- a/talk/app/webrtc/videosourceinterface.h
+++ b/talk/app/webrtc/videosourceinterface.h
@@ -49,10 +49,8 @@ class VideoSourceInterface : public MediaSourceInterface {
   virtual void Restart() = 0;
 
   // Adds |output| to the source to receive frames.
-  virtual void AddSink(
-      rtc::VideoSinkInterface<cricket::VideoFrame>* output) = 0;
-  virtual void RemoveSink(
-      rtc::VideoSinkInterface<cricket::VideoFrame>* output) = 0;
+  virtual void AddSink(cricket::VideoRenderer* output) = 0;
+  virtual void RemoveSink(cricket::VideoRenderer* output) = 0;
   virtual const cricket::VideoOptions* options() const = 0;
   virtual cricket::VideoRenderer* FrameInput() = 0;
 
diff --git a/talk/app/webrtc/videosourceproxy.h b/talk/app/webrtc/videosourceproxy.h
index c847dc6c36..ce96e8e6d1 100644
--- a/talk/app/webrtc/videosourceproxy.h
+++ b/talk/app/webrtc/videosourceproxy.h
@@ -42,8 +42,8 @@ BEGIN_PROXY_MAP(VideoSource)
   PROXY_METHOD0(cricket::VideoCapturer*, GetVideoCapturer)
   PROXY_METHOD0(void, Stop)
   PROXY_METHOD0(void, Restart)
-  PROXY_METHOD1(void, AddSink, rtc::VideoSinkInterface<cricket::VideoFrame>*)
-  PROXY_METHOD1(void, RemoveSink, rtc::VideoSinkInterface<cricket::VideoFrame>*)
+  PROXY_METHOD1(void, AddSink, cricket::VideoRenderer*)
+  PROXY_METHOD1(void, RemoveSink, cricket::VideoRenderer*)
   PROXY_CONSTMETHOD0(const cricket::VideoOptions*, options)
   PROXY_METHOD0(cricket::VideoRenderer*, FrameInput)
   PROXY_METHOD1(void, RegisterObserver, ObserverInterface*)
diff --git a/talk/media/base/capturemanager.cc b/talk/media/base/capturemanager.cc
index 78ca99d39c..dab33fd2bc 100644
--- a/talk/media/base/capturemanager.cc
+++ b/talk/media/base/capturemanager.cc
@@ -30,6 +30,7 @@
 #include <algorithm>
 
 #include "talk/media/base/videocapturer.h"
+#include "talk/media/base/videorenderer.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 
@@ -286,32 +287,32 @@ bool CaptureManager::RestartVideoCapture(
   return true;
 }
 
-void CaptureManager::AddVideoSink(VideoCapturer* video_capturer,
-                                  rtc::VideoSinkInterface<VideoFrame>* sink) {
+bool CaptureManager::AddVideoRenderer(VideoCapturer* video_capturer,
+                                      VideoRenderer* video_renderer) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  // TODO(nisse): Do we really need to tolerate NULL inputs?
-  if (!video_capturer || !sink) {
-    return;
+  if (!video_capturer || !video_renderer) {
+    return false;
   }
   CaptureRenderAdapter* adapter = GetAdapter(video_capturer);
   if (!adapter) {
-    return;
+    return false;
   }
-  adapter->AddSink(sink);
+  adapter->AddRenderer(video_renderer);
+  return true;
 }
 
-void CaptureManager::RemoveVideoSink(
-    VideoCapturer* video_capturer,
-    rtc::VideoSinkInterface<VideoFrame>* sink) {
+bool CaptureManager::RemoveVideoRenderer(VideoCapturer* video_capturer,
+                                         VideoRenderer* video_renderer) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  if (!video_capturer || !sink) {
-    return;
+  if (!video_capturer || !video_renderer) {
+    return false;
   }
   CaptureRenderAdapter* adapter = GetAdapter(video_capturer);
   if (!adapter) {
-    return;
+    return false;
   }
-  adapter->RemoveSink(sink);
+  adapter->RemoveRenderer(video_renderer);
+  return true;
 }
 
 bool CaptureManager::IsCapturerRegistered(VideoCapturer* video_capturer) const {
diff --git a/talk/media/base/capturemanager.h b/talk/media/base/capturemanager.h
index 9f3c2086ff..8cbbf5258c 100644
--- a/talk/media/base/capturemanager.h
+++ b/talk/media/base/capturemanager.h
@@ -79,10 +79,10 @@ class CaptureManager : public sigslot::has_slots<> {
                                    const VideoFormat& desired_format,
                                    RestartOptions options);
 
-  virtual void AddVideoSink(VideoCapturer* video_capturer,
-                            rtc::VideoSinkInterface<VideoFrame>* sink);
-  virtual void RemoveVideoSink(VideoCapturer* video_capturer,
-                               rtc::VideoSinkInterface<VideoFrame>* sink);
+  virtual bool AddVideoRenderer(VideoCapturer* video_capturer,
+                                VideoRenderer* video_renderer);
+  virtual bool RemoveVideoRenderer(VideoCapturer* video_capturer,
+                                   VideoRenderer* video_renderer);
 
   sigslot::repeater2<VideoCapturer*, CaptureState> SignalCapturerStateChange;
 
diff --git a/talk/media/base/capturemanager_unittest.cc b/talk/media/base/capturemanager_unittest.cc
index 4a75fc3682..709ec5bb8d 100644
--- a/talk/media/base/capturemanager_unittest.cc
+++ b/talk/media/base/capturemanager_unittest.cc
@@ -89,6 +89,12 @@ class CaptureManagerTest : public ::testing::Test, public sigslot::has_slots<> {
 };
 
 // Incorrect use cases.
+TEST_F(CaptureManagerTest, InvalidCallOrder) {
+  // Capturer must be registered before any of these calls.
+  EXPECT_FALSE(capture_manager_.AddVideoRenderer(&video_capturer_,
+                                                 &video_renderer_));
+}
+
 TEST_F(CaptureManagerTest, InvalidAddingRemoving) {
   EXPECT_FALSE(capture_manager_.StopVideoCapture(&video_capturer_,
                                                  cricket::VideoFormat()));
@@ -96,8 +102,7 @@ TEST_F(CaptureManagerTest, InvalidAddingRemoving) {
                                                  format_vga_));
   EXPECT_EQ_WAIT(cricket::CS_RUNNING, capture_state(), kMsCallbackWait);
   EXPECT_EQ(1, callback_count());
-  // NULL argument currently allowed, and does nothing.
-  capture_manager_.AddVideoSink(&video_capturer_, NULL);
+  EXPECT_FALSE(capture_manager_.AddVideoRenderer(&video_capturer_, NULL));
   EXPECT_TRUE(capture_manager_.StopVideoCapture(&video_capturer_, format_vga_));
 }
 
@@ -107,7 +112,8 @@ TEST_F(CaptureManagerTest, KeepFirstResolutionHigh) {
                                                  format_vga_));
   EXPECT_EQ_WAIT(cricket::CS_RUNNING, capture_state(), kMsCallbackWait);
   EXPECT_EQ(1, callback_count());
-  capture_manager_.AddVideoSink(&video_capturer_, &video_renderer_);
+  EXPECT_TRUE(capture_manager_.AddVideoRenderer(&video_capturer_,
+                                                &video_renderer_));
   EXPECT_TRUE(video_capturer_.CaptureFrame());
   EXPECT_EQ(1, NumFramesRendered());
   // Renderer should be fed frames with the resolution of format_vga_.
@@ -136,7 +142,8 @@ TEST_F(CaptureManagerTest, KeepFirstResolutionLow) {
                                                  format_qvga_));
   EXPECT_TRUE(capture_manager_.StartVideoCapture(&video_capturer_,
                                                  format_vga_));
-  capture_manager_.AddVideoSink(&video_capturer_, &video_renderer_);
+  EXPECT_TRUE(capture_manager_.AddVideoRenderer(&video_capturer_,
+                                                &video_renderer_));
   EXPECT_EQ_WAIT(1, callback_count(), kMsCallbackWait);
   EXPECT_TRUE(video_capturer_.CaptureFrame());
   EXPECT_EQ(1, NumFramesRendered());
@@ -157,7 +164,8 @@ TEST_F(CaptureManagerTest, MultipleStartStops) {
                                                  format_qvga_));
   EXPECT_EQ_WAIT(cricket::CS_RUNNING, capture_state(), kMsCallbackWait);
   EXPECT_EQ(1, callback_count());
-  capture_manager_.AddVideoSink(&video_capturer_, &video_renderer_);
+  EXPECT_TRUE(capture_manager_.AddVideoRenderer(&video_capturer_,
+                                                &video_renderer_));
   // Ensure that a frame can be captured when two start calls have been made.
   EXPECT_TRUE(video_capturer_.CaptureFrame());
   EXPECT_EQ(1, NumFramesRendered());
@@ -181,7 +189,8 @@ TEST_F(CaptureManagerTest, MultipleStartStops) {
 TEST_F(CaptureManagerTest, TestForceRestart) {
   EXPECT_TRUE(capture_manager_.StartVideoCapture(&video_capturer_,
                                                  format_qvga_));
-  capture_manager_.AddVideoSink(&video_capturer_, &video_renderer_);
+  EXPECT_TRUE(capture_manager_.AddVideoRenderer(&video_capturer_,
+                                                &video_renderer_));
   EXPECT_EQ_WAIT(1, callback_count(), kMsCallbackWait);
   EXPECT_TRUE(video_capturer_.CaptureFrame());
   EXPECT_EQ(1, NumFramesRendered());
@@ -200,7 +209,8 @@ TEST_F(CaptureManagerTest, TestForceRestart) {
 TEST_F(CaptureManagerTest, TestRequestRestart) {
   EXPECT_TRUE(capture_manager_.StartVideoCapture(&video_capturer_,
                                                  format_vga_));
-  capture_manager_.AddVideoSink(&video_capturer_, &video_renderer_);
+  EXPECT_TRUE(capture_manager_.AddVideoRenderer(&video_capturer_,
+                                                &video_renderer_));
   EXPECT_EQ_WAIT(1, callback_count(), kMsCallbackWait);
   EXPECT_TRUE(video_capturer_.CaptureFrame());
   EXPECT_EQ(1, NumFramesRendered());
diff --git a/talk/media/base/capturerenderadapter.cc b/talk/media/base/capturerenderadapter.cc
index 87b3c11d89..e5e8f4c58b 100644
--- a/talk/media/base/capturerenderadapter.cc
+++ b/talk/media/base/capturerenderadapter.cc
@@ -43,7 +43,7 @@ CaptureRenderAdapter::~CaptureRenderAdapter() {
   // outstanding calls to OnVideoFrame will be done when this is done, and no
   // more calls will be serviced by this.
   // We do this explicitly instead of just letting the has_slots<> destructor
-  // take care of it because we need to do this *before* sinks_ is
+  // take care of it because we need to do this *before* video_renderers_ is
   // cleared by the destructor; otherwise we could mess with it while
   // OnVideoFrame is running.
   // We *don't* take capture_crit_ here since it could deadlock with the lock
@@ -61,23 +61,32 @@ CaptureRenderAdapter* CaptureRenderAdapter::Create(
   return return_value;
 }
 
-void CaptureRenderAdapter::AddSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
-  RTC_DCHECK(sink);
+void CaptureRenderAdapter::AddRenderer(VideoRenderer* video_renderer) {
+  RTC_DCHECK(video_renderer);
 
   rtc::CritScope cs(&capture_crit_);
   // This implements set semantics, the same renderer can only be
   // added once.
   // TODO(nisse): Is this really needed?
-  if (std::find(sinks_.begin(), sinks_.end(), sink) == sinks_.end())
-    sinks_.push_back(sink);
+  if (std::find(video_renderers_.begin(), video_renderers_.end(),
+                video_renderer) == video_renderers_.end())
+    video_renderers_.push_back(video_renderer);
 }
 
-void CaptureRenderAdapter::RemoveSink(
-    rtc::VideoSinkInterface<VideoFrame>* sink) {
-  RTC_DCHECK(sink);
+void CaptureRenderAdapter::RemoveRenderer(VideoRenderer* video_renderer) {
+  RTC_DCHECK(video_renderer);
 
   rtc::CritScope cs(&capture_crit_);
-  sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sink), sinks_.end());
+  // TODO(nisse): Switch to using std::list, and use its remove
+  // method. And similarly in VideoTrackRenderers, which this class
+  // mostly duplicates.
+  for (VideoRenderers::iterator iter = video_renderers_.begin();
+       iter != video_renderers_.end(); ++iter) {
+    if (video_renderer == *iter) {
+      video_renderers_.erase(iter);
+      break;
+    }
+  }
 }
 
 void CaptureRenderAdapter::Init() {
@@ -89,12 +98,12 @@ void CaptureRenderAdapter::Init() {
 void CaptureRenderAdapter::OnVideoFrame(VideoCapturer* capturer,
                                         const VideoFrame* video_frame) {
   rtc::CritScope cs(&capture_crit_);
-  if (sinks_.empty()) {
+  if (video_renderers_.empty()) {
     return;
   }
 
-  for (auto* sink : sinks_)
-    sink->OnFrame(*video_frame);
+  for (auto* renderer : video_renderers_)
+    renderer->RenderFrame(video_frame);
 }
 
 }  // namespace cricket
diff --git a/talk/media/base/capturerenderadapter.h b/talk/media/base/capturerenderadapter.h
index f972c983c5..a272952748 100644
--- a/talk/media/base/capturerenderadapter.h
+++ b/talk/media/base/capturerenderadapter.h
@@ -39,32 +39,34 @@
 #include "talk/media/base/videocapturer.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/sigslot.h"
-#include "webrtc/media/base/videosinkinterface.h"
 
 namespace cricket {
 
 class VideoCapturer;
 class VideoProcessor;
+class VideoRenderer;
 
 class CaptureRenderAdapter : public sigslot::has_slots<> {
  public:
   static CaptureRenderAdapter* Create(VideoCapturer* video_capturer);
   ~CaptureRenderAdapter();
 
-  void AddSink(rtc::VideoSinkInterface<VideoFrame>* sink);
-  void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink);
+  void AddRenderer(VideoRenderer* video_renderer);
+  void RemoveRenderer(VideoRenderer* video_renderer);
 
   VideoCapturer* video_capturer() { return video_capturer_; }
  private:
 
+  // Just pointers since ownership is not handed over to this class.
+  typedef std::vector<VideoRenderer*> VideoRenderers;
+
   explicit CaptureRenderAdapter(VideoCapturer* video_capturer);
   void Init();
 
   // Callback for frames received from the capturer.
   void OnVideoFrame(VideoCapturer* capturer, const VideoFrame* video_frame);
 
-  // Just pointers since ownership is not handed over to this class.
-  std::vector<rtc::VideoSinkInterface<VideoFrame>*> sinks_;
+  VideoRenderers video_renderers_;
   VideoCapturer* video_capturer_;
   // Critical section synchronizing the capture thread.
   rtc::CriticalSection capture_crit_;
diff --git a/talk/media/base/fakecapturemanager.h b/talk/media/base/fakecapturemanager.h
index 577a033e99..64c0f521d5 100644
--- a/talk/media/base/fakecapturemanager.h
+++ b/talk/media/base/fakecapturemanager.h
@@ -37,10 +37,14 @@ class FakeCaptureManager : public CaptureManager {
   FakeCaptureManager() {}
   ~FakeCaptureManager() {}
 
-  void AddVideoSink(VideoCapturer* video_capturer,
-                    rtc::VideoSinkInterface<VideoFrame>* sink) override {}
-  void RemoveVideoSink(VideoCapturer* video_capturer,
-                       rtc::VideoSinkInterface<VideoFrame>* sink) override {}
+  virtual bool AddVideoRenderer(VideoCapturer* video_capturer,
+                                VideoRenderer* video_renderer) {
+    return true;
+  }
+  virtual bool RemoveVideoRenderer(VideoCapturer* video_capturer,
+                                   VideoRenderer* video_renderer) {
+    return true;
+  }
 };
 
 }  // namespace cricket
diff --git a/talk/media/base/videorenderer.h b/talk/media/base/videorenderer.h
index 9771c492d6..ac07cc9b61 100644
--- a/talk/media/base/videorenderer.h
+++ b/talk/media/base/videorenderer.h
@@ -28,23 +28,16 @@
 #ifndef TALK_MEDIA_BASE_VIDEORENDERER_H_
 #define TALK_MEDIA_BASE_VIDEORENDERER_H_
 
-#include "webrtc/media/base/videosinkinterface.h"
-
 namespace cricket {
 
 class VideoFrame;
 
 // Abstract interface for rendering VideoFrames.
-class VideoRenderer : public rtc::VideoSinkInterface<VideoFrame> {
+class VideoRenderer {
  public:
   virtual ~VideoRenderer() {}
   // Called when a new frame is available for display.
   virtual bool RenderFrame(const VideoFrame *frame) = 0;
-  // Intended to replace RenderFrame.
-  void OnFrame(const cricket::VideoFrame& frame) override {
-    // Unused return value
-    RenderFrame(&frame);
-  }
 };
 
 }  // namespace cricket
diff --git a/talk/media/webrtc/webrtcvideoengine2.cc b/talk/media/webrtc/webrtcvideoengine2.cc
index df50656a2b..6fbaf1b401 100644
--- a/talk/media/webrtc/webrtcvideoengine2.cc
+++ b/talk/media/webrtc/webrtcvideoengine2.cc
@@ -1185,7 +1185,7 @@ bool WebRtcVideoChannel2::SetRenderer(uint32_t ssrc, VideoRenderer* renderer) {
     return false;
   }
 
-  it->second->SetSink(renderer);
+  it->second->SetRenderer(renderer);
   return true;
 }
 
@@ -2231,7 +2231,7 @@ WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
       config_(config),
       external_decoder_factory_(external_decoder_factory),
       disable_prerenderer_smoothing_(disable_prerenderer_smoothing),
-      sink_(NULL),
+      renderer_(NULL),
       last_width_(-1),
       last_height_(-1),
       first_frame_timestamp_(-1),
@@ -2424,7 +2424,7 @@ void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ClearDecoders(
 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RenderFrame(
     const webrtc::VideoFrame& frame,
     int time_to_render_ms) {
-  rtc::CritScope crit(&sink_lock_);
+  rtc::CritScope crit(&renderer_lock_);
 
   if (first_frame_timestamp_ < 0)
     first_frame_timestamp_ = frame.timestamp();
@@ -2436,8 +2436,8 @@ void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RenderFrame(
   if (frame.ntp_time_ms() > 0)
     estimated_remote_start_ntp_time_ms_ = frame.ntp_time_ms() - elapsed_time_ms;
 
-  if (sink_ == NULL) {
-    LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoSink.";
+  if (renderer_ == NULL) {
+    LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoRenderer.";
     return;
   }
 
@@ -2447,7 +2447,7 @@ void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RenderFrame(
   const WebRtcVideoFrame render_frame(
       frame.video_frame_buffer(),
       frame.render_time_ms() * rtc::kNumNanosecsPerMillisec, frame.rotation());
-  sink_->OnFrame(render_frame);
+  renderer_->RenderFrame(&render_frame);
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsTextureSupported() const {
@@ -2463,10 +2463,10 @@ bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsDefaultStream() const {
   return default_stream_;
 }
 
-void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetSink(
-    rtc::VideoSinkInterface<cricket::VideoFrame>* sink) {
-  rtc::CritScope crit(&sink_lock_);
-  sink_ = sink;
+void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRenderer(
+    cricket::VideoRenderer* renderer) {
+  rtc::CritScope crit(&renderer_lock_);
+  renderer_ = renderer;
 }
 
 std::string
@@ -2500,7 +2500,7 @@ WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetVideoReceiverInfo() {
   info.framerate_output = stats.render_frame_rate;
 
   {
-    rtc::CritScope frame_cs(&sink_lock_);
+    rtc::CritScope frame_cs(&renderer_lock_);
     info.frame_width = last_width_;
     info.frame_height = last_height_;
     info.capture_start_ntp_time_ms = estimated_remote_start_ntp_time_ms_;
diff --git a/talk/media/webrtc/webrtcvideoengine2.h b/talk/media/webrtc/webrtcvideoengine2.h
index b5efa9516d..6bace03c20 100644
--- a/talk/media/webrtc/webrtcvideoengine2.h
+++ b/talk/media/webrtc/webrtcvideoengine2.h
@@ -40,7 +40,6 @@
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/base/thread_checker.h"
-#include "webrtc/media/base/videosinkinterface.h"
 #include "webrtc/call.h"
 #include "webrtc/transport.h"
 #include "webrtc/video_frame.h"
@@ -415,7 +414,7 @@ class WebRtcVideoChannel2 : public rtc::MessageHandler,
     bool SmoothsRenderedFrames() const override;
     bool IsDefaultStream() const;
 
-    void SetSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink);
+    void SetRenderer(cricket::VideoRenderer* renderer);
 
     VideoReceiverInfo GetVideoReceiverInfo();
 
@@ -453,18 +452,18 @@ class WebRtcVideoChannel2 : public rtc::MessageHandler,
 
     const bool disable_prerenderer_smoothing_;
 
-    rtc::CriticalSection sink_lock_;
-    rtc::VideoSinkInterface<cricket::VideoFrame>* sink_ GUARDED_BY(sink_lock_);
-    int last_width_ GUARDED_BY(sink_lock_);
-    int last_height_ GUARDED_BY(sink_lock_);
+    rtc::CriticalSection renderer_lock_;
+    cricket::VideoRenderer* renderer_ GUARDED_BY(renderer_lock_);
+    int last_width_ GUARDED_BY(renderer_lock_);
+    int last_height_ GUARDED_BY(renderer_lock_);
     // Expands remote RTP timestamps to int64_t to be able to estimate how long
     // the stream has been running.
     rtc::TimestampWrapAroundHandler timestamp_wraparound_handler_
-        GUARDED_BY(sink_lock_);
-    int64_t first_frame_timestamp_ GUARDED_BY(sink_lock_);
+        GUARDED_BY(renderer_lock_);
+    int64_t first_frame_timestamp_ GUARDED_BY(renderer_lock_);
     // Start NTP time is estimated as current remote NTP time (estimated from
     // RTCP) minus the elapsed time, as soon as remote NTP time is available.
-    int64_t estimated_remote_start_ntp_time_ms_ GUARDED_BY(sink_lock_);
+    int64_t estimated_remote_start_ntp_time_ms_ GUARDED_BY(renderer_lock_);
   };
 
   void Construct(webrtc::Call* call, WebRtcVideoEngine2* engine);
diff --git a/talk/session/media/channelmanager.cc b/talk/session/media/channelmanager.cc
index 7973f5c2d6..bd89a41328 100644
--- a/talk/session/media/channelmanager.cc
+++ b/talk/session/media/channelmanager.cc
@@ -500,20 +500,18 @@ bool ChannelManager::RestartVideoCapture(
            video_capturer, previous_format, desired_format, options));
 }
 
-void ChannelManager::AddVideoSink(
-    VideoCapturer* capturer, rtc::VideoSinkInterface<VideoFrame>* sink) {
-  if (initialized_)
-    worker_thread_->Invoke<void>(
-        Bind(&CaptureManager::AddVideoSink,
-             capture_manager_.get(), capturer, sink));
+bool ChannelManager::AddVideoRenderer(
+    VideoCapturer* capturer, VideoRenderer* renderer) {
+  return initialized_ && worker_thread_->Invoke<bool>(
+      Bind(&CaptureManager::AddVideoRenderer,
+           capture_manager_.get(), capturer, renderer));
 }
 
-void ChannelManager::RemoveVideoSink(
-    VideoCapturer* capturer, rtc::VideoSinkInterface<VideoFrame>* sink) {
-  if (initialized_)
-    worker_thread_->Invoke<void>(
-        Bind(&CaptureManager::RemoveVideoSink,
-             capture_manager_.get(), capturer, sink));
+bool ChannelManager::RemoveVideoRenderer(
+    VideoCapturer* capturer, VideoRenderer* renderer) {
+  return initialized_ && worker_thread_->Invoke<bool>(
+      Bind(&CaptureManager::RemoveVideoRenderer,
+           capture_manager_.get(), capturer, renderer));
 }
 
 bool ChannelManager::IsScreencastRunning() const {
diff --git a/talk/session/media/channelmanager.h b/talk/session/media/channelmanager.h
index 6f44e4259c..f69bf9a293 100644
--- a/talk/session/media/channelmanager.h
+++ b/talk/session/media/channelmanager.h
@@ -156,10 +156,8 @@ class ChannelManager : public rtc::MessageHandler,
                            const VideoFormat& desired_format,
                            CaptureManager::RestartOptions options);
 
-  virtual void AddVideoSink(VideoCapturer* video_capturer,
-                            rtc::VideoSinkInterface<VideoFrame>* sink);
-  virtual void RemoveVideoSink(VideoCapturer* video_capturer,
-                               rtc::VideoSinkInterface<VideoFrame>* sink);
+  bool AddVideoRenderer(VideoCapturer* capturer, VideoRenderer* renderer);
+  bool RemoveVideoRenderer(VideoCapturer* capturer, VideoRenderer* renderer);
   bool IsScreencastRunning() const;
 
   // The operations below occur on the main thread.
diff --git a/webrtc/media/OWNERS b/webrtc/media/OWNERS
deleted file mode 100644
index eeabb991a6..0000000000
--- a/webrtc/media/OWNERS
+++ /dev/null
@@ -1,4 +0,0 @@
-mflodman@webrtc.org
-pbos@webrtc.org
-pthatcher@webrtc.org
-solenberg@webrtc.org
diff --git a/webrtc/media/base/videosinkinterface.h b/webrtc/media/base/videosinkinterface.h
deleted file mode 100644
index 9b8ba31862..0000000000
--- a/webrtc/media/base/videosinkinterface.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef WEBRTC_MEDIA_BASE_VIDEOSINKINTERFACE_H_
-#define WEBRTC_MEDIA_BASE_VIDEOSINKINTERFACE_H_
-
-namespace rtc {
-
-template <typename VideoFrameT>
-class VideoSinkInterface {
- public:
-  virtual void OnFrame(const VideoFrameT& frame) = 0;
-
- protected:
-  ~VideoSinkInterface() {}
-};
-
-}  // namespace rtc
-
-#endif  // WEBRTC_MEDIA_BASE_VIDEOSINKINTERFACE_H_