Cleanup of webrtc::VideoRenderer

webrtc/call/call_perf_tests.cc

 /*
  *  Copyright (c) 2013 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.
  */
 
@@ skipping 70 matching lines @@
   static const int kMinRunTimeMs = 30000;
 
  public:
   explicit VideoRtcpAndSyncObserver(Clock* clock)
       : test::RtpRtcpObserver(CallPerfTest::kLongTimeoutMs),
         clock_(clock),
         creation_time_ms_(clock_->TimeInMilliseconds()),
         first_time_in_sync_(-1),
         receive_stream_(nullptr) {}
 
-  void RenderFrame(const VideoFrame& video_frame,
-                   int time_to_render_ms) override {
+  void OnFrame(const VideoFrame& video_frame) override {
     VideoReceiveStream::Stats stats;
     {
       rtc::CritScope lock(&crit_);
       if (receive_stream_)
         stats = receive_stream_->GetStats();
     }
     if (stats.sync_offset_ms == std::numeric_limits<int>::max())
       return;
 
     int64_t now_ms = clock_->TimeInMilliseconds();
@@ skipping 19 matching lines @@
                                   "synchronization",
                                   time_since_creation,
                                   "ms",
                                   false);
       }
       if (time_since_creation > kMinRunTimeMs)
         observation_complete_.Set();
     }
   }
 
-  bool IsTextureSupported() const override { return false; }
-
   void set_receive_stream(VideoReceiveStream* receive_stream) {
     rtc::CritScope lock(&crit_);
     receive_stream_ = receive_stream;
   }
 
  private:
   Clock* const clock_;
   const int64_t creation_time_ms_;
   int64_t first_time_in_sync_;
   rtc::CriticalSection crit_;
@@ skipping 226 matching lines @@
     test::PacketTransport* CreateSendTransport(Call* sender_call) override {
       return new test::PacketTransport(
           sender_call, this, test::PacketTransport::kSender, net_config_);
     }
 
     test::PacketTransport* CreateReceiveTransport() override {
       return new test::PacketTransport(
           nullptr, this, test::PacketTransport::kReceiver, net_config_);
     }
 
-    void RenderFrame(const VideoFrame& video_frame,
-                     int time_to_render_ms) override {
+    void OnFrame(const VideoFrame& video_frame) override {
       rtc::CritScope lock(&crit_);
       if (video_frame.ntp_time_ms() <= 0) {
         // Haven't got enough RTCP SR in order to calculate the capture ntp
         // time.
         return;
       }
 
       int64_t now_ms = clock_->TimeInMilliseconds();
       int64_t time_since_creation = now_ms - creation_time_ms_;
       if (time_since_creation < start_time_ms_) {
@@ skipping 18 matching lines @@
       int time_offset_ms = real_capture_timestamp - estimated_capture_timestamp;
       time_offset_ms = time_offset_ms / 90;
       std::stringstream ss;
       ss << time_offset_ms;
 
       webrtc::test::PrintResult(
           "capture_ntp_time", "", "real - estimated", ss.str(), "ms", true);
       EXPECT_TRUE(std::abs(time_offset_ms) < threshold_ms_);
     }
 
-    bool IsTextureSupported() const override { return false; }
-
     virtual Action OnSendRtp(const uint8_t* packet, size_t length) {
       rtc::CritScope lock(&crit_);
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
 
       if (!rtp_start_timestamp_set_) {
         // Calculate the rtp timestamp offset in order to calculate the real
         // capture time.
         uint32_t first_capture_timestamp =
             90 * static_cast<uint32_t>(capturer_->first_frame_capture_time());
@@ skipping 285 matching lines @@
     int encoder_inits_;
     uint32_t last_set_bitrate_;
     VideoSendStream* send_stream_;
     VideoEncoderConfig encoder_config_;
   } test;
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc