Revert of New rtc::VideoSinkInterface.

talk/media/webrtc/webrtcvideoengine2.cc

 /*
  * libjingle
  * Copyright 2014 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 1167 matching lines @@
     return true;
   }
 
   rtc::CritScope stream_lock(&stream_crit_);
   std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
       receive_streams_.find(ssrc);
   if (it == receive_streams_.end()) {
     return false;
   }
 
-  it->second->SetSink(renderer);
+  it->second->SetRenderer(renderer);
   return true;
 }
 
 bool WebRtcVideoChannel2::GetStats(VideoMediaInfo* info) {
   info->Clear();
   FillSenderStats(info);
   FillReceiverStats(info);
   webrtc::Call::Stats stats = call_->GetStats();
   FillBandwidthEstimationStats(stats, info);
   if (stats.rtt_ms != -1) {
@@ skipping 1025 matching lines @@
     const std::vector<VideoCodecSettings>& recv_codecs,
     bool disable_prerenderer_smoothing)
     : call_(call),
       ssrcs_(sp.ssrcs),
       ssrc_groups_(sp.ssrc_groups),
       stream_(NULL),
       default_stream_(default_stream),
       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),
       estimated_remote_start_ntp_time_ms_(0) {
   config_.renderer = this;
   // SetRecvCodecs will also reset (start) the VideoReceiveStream.
   LOG(LS_INFO) << "SetRecvCodecs (recv) because we are creating the receive "
                   "stream for the first time: "
                << CodecSettingsVectorToString(recv_codecs);
   SetRecvCodecs(recv_codecs);
@@ skipping 172 matching lines @@
           (*allocated_decoders)[i].external_decoder);
     }
     delete (*allocated_decoders)[i].decoder;
   }
   allocated_decoders->clear();
 }
 
 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();
   int64_t rtp_time_elapsed_since_first_frame =
       (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) -
        first_frame_timestamp_);
   int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame /
                             (cricket::kVideoCodecClockrate / 1000);
   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;
   }
 
   last_width_ = frame.width();
   last_height_ = frame.height();
 
   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 {
   return true;
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::SmoothsRenderedFrames()
     const {
   return disable_prerenderer_smoothing_;
 }
 
 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
 WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetCodecNameFromPayloadType(
     int payload_type) {
   for (const webrtc::VideoReceiveStream::Decoder& decoder : config_.decoders) {
     if (decoder.payload_type == payload_type) {
       return decoder.payload_name;
     }
   }
@@ skipping 13 matching lines @@
   info.packets_rcvd = stats.rtp_stats.transmitted.packets;
   info.packets_lost = stats.rtcp_stats.cumulative_lost;
   info.fraction_lost =
       static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8);
 
   info.framerate_rcvd = stats.network_frame_rate;
   info.framerate_decoded = stats.decode_frame_rate;
   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_;
   }
 
   info.decode_ms = stats.decode_ms;
   info.max_decode_ms = stats.max_decode_ms;
   info.current_delay_ms = stats.current_delay_ms;
   info.target_delay_ms = stats.target_delay_ms;
   info.jitter_buffer_ms = stats.jitter_buffer_ms;
@@ skipping 117 matching lines @@
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VIDEO