Revert of New rtc::VideoSinkInterface.

talk/media/base/capturerenderadapter.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 25 matching lines @@
 CaptureRenderAdapter::CaptureRenderAdapter(VideoCapturer* video_capturer)
     : video_capturer_(video_capturer) {
 }
 
 CaptureRenderAdapter::~CaptureRenderAdapter() {
   // Since the signal we're connecting to is multi-threaded,
   // disconnect_all() will block until all calls are serviced, meaning any
   // 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
   // taken by the video frame signal.
   disconnect_all();
 }
 
 CaptureRenderAdapter* CaptureRenderAdapter::Create(
     VideoCapturer* video_capturer) {
   if (!video_capturer) {
     return NULL;
   }
   CaptureRenderAdapter* return_value = new CaptureRenderAdapter(video_capturer);
   return_value->Init();  // Can't fail.
   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() {
   video_capturer_->SignalVideoFrame.connect(
       this,
       &CaptureRenderAdapter::OnVideoFrame);
 }
 
 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