Remove VCMRenderBufferSizeCallback.

Unused/dead code.

BUG=
R=stefan@webrtc.org

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

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

webrtc/modules/video_coding/include/video_coding.h

@@ -392,10 +392,6 @@ class VideoCodingModule : public Module {
   //                     < 0,    on error.
   virtual int32_t Decode(uint16_t maxWaitTimeMs = 200) = 0;
 
-  // Registers a callback which conveys the size of the render buffer.
-  virtual int RegisterRenderBufferSizeCallback(
-      VCMRenderBufferSizeCallback* callback) = 0;
-
   // API to get the codec which is currently used for decoding by the module.
   //
   // Input:

webrtc/modules/video_coding/include/video_coding_defines.h

@@ -199,16 +199,6 @@ class VCMQMSettingsCallback {
   virtual ~VCMQMSettingsCallback() {}
 };
 
-// Callback class used for telling the user about the size (in time) of the
-// render buffer, that is the size in time of the complete continuous frames.
-class VCMRenderBufferSizeCallback {
- public:
-  virtual void RenderBufferSizeMs(int buffer_size_ms) = 0;
-
- protected:
-  virtual ~VCMRenderBufferSizeCallback() {}
-};
-
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_INCLUDE_VIDEO_CODING_DEFINES_H_

webrtc/modules/video_coding/jitter_buffer.cc

@@ -1194,19 +1194,6 @@ int64_t VCMJitterBuffer::LastDecodedTimestamp() const {
   return last_decoded_state_.time_stamp();
 }
 
-void VCMJitterBuffer::RenderBufferSize(uint32_t* timestamp_start,
-                                       uint32_t* timestamp_end) {
-  CriticalSectionScoped cs(crit_sect_);
-  CleanUpOldOrEmptyFrames();
-  *timestamp_start = 0;
-  *timestamp_end = 0;
-  if (decodable_frames_.empty()) {
-    return;
-  }
-  *timestamp_start = decodable_frames_.Front()->TimeStamp();
-  *timestamp_end = decodable_frames_.Back()->TimeStamp();
-}
-
 void VCMJitterBuffer::RegisterStatsCallback(
     VCMReceiveStatisticsCallback* callback) {
   CriticalSectionScoped cs(crit_sect_);

webrtc/modules/video_coding/jitter_buffer.h

@@ -212,10 +212,6 @@ class VCMJitterBuffer {
   int64_t LastDecodedTimestamp() const;
   VCMDecodeErrorMode decode_error_mode() const { return decode_error_mode_; }
 
-  // Used to compute time of complete continuous frames. Returns the timestamps
-  // corresponding to the start and end of the continuous complete buffer.
-  void RenderBufferSize(uint32_t* timestamp_start, uint32_t* timestamp_end);
-
   void RegisterStatsCallback(VCMReceiveStatisticsCallback* callback);
 
   int64_t TimeUntilNextProcess();

webrtc/modules/video_coding/receiver.cc

@@ -286,24 +286,6 @@ int VCMReceiver::SetMinReceiverDelay(int desired_delay_ms) {
   return 0;
 }
 
-int VCMReceiver::RenderBufferSizeMs() {
-  uint32_t timestamp_start = 0u;
-  uint32_t timestamp_end = 0u;
-  // Render timestamps are computed just prior to decoding. Therefore this is
-  // only an estimate based on frames' timestamps and current timing state.
-  jitter_buffer_.RenderBufferSize(&timestamp_start, &timestamp_end);
-  if (timestamp_start == timestamp_end) {
-    return 0;
-  }
-  // Update timing.
-  const int64_t now_ms = clock_->TimeInMilliseconds();
-  timing_->SetJitterDelay(jitter_buffer_.EstimatedJitterMs());
-  // Get render timestamps.
-  uint32_t render_start = timing_->RenderTimeMs(timestamp_start, now_ms);
-  uint32_t render_end = timing_->RenderTimeMs(timestamp_end, now_ms);
-  return render_end - render_start;
-}
-
 void VCMReceiver::RegisterStatsCallback(
     VCMReceiveStatisticsCallback* callback) {
   jitter_buffer_.RegisterStatsCallback(callback);

webrtc/modules/video_coding/receiver.h

@@ -90,11 +90,6 @@ class VCMReceiver {
   void SetDecodeErrorMode(VCMDecodeErrorMode decode_error_mode);
   VCMDecodeErrorMode DecodeErrorMode() const;
 
-  // Returns size in time (milliseconds) of complete continuous frames in the
-  // jitter buffer. The render time is estimated based on the render delay at
-  // the time this function is called.
-  int RenderBufferSizeMs();
-
   void RegisterStatsCallback(VCMReceiveStatisticsCallback* callback);
 
   void TriggerDecoderShutdown();

webrtc/modules/video_coding/receiver_unittest.cc

@@ -92,66 +92,6 @@ class TestVCMReceiver : public ::testing::Test {
   std::unique_ptr<StreamGenerator> stream_generator_;
 };
 
-TEST_F(TestVCMReceiver, RenderBufferSize_AllComplete) {
-  EXPECT_EQ(0, receiver_.RenderBufferSizeMs());
-  EXPECT_GE(InsertFrame(kVideoFrameKey, true), kNoError);
-  int num_of_frames = 10;
-  for (int i = 0; i < num_of_frames; ++i) {
-    EXPECT_GE(InsertFrame(kVideoFrameDelta, true), kNoError);
-  }
-  EXPECT_EQ(num_of_frames * kDefaultFramePeriodMs,
-            receiver_.RenderBufferSizeMs());
-}
-
-TEST_F(TestVCMReceiver, RenderBufferSize_SkipToKeyFrame) {
-  EXPECT_EQ(0, receiver_.RenderBufferSizeMs());
-  const int kNumOfNonDecodableFrames = 2;
-  for (int i = 0; i < kNumOfNonDecodableFrames; ++i) {
-    EXPECT_GE(InsertFrame(kVideoFrameDelta, true), kNoError);
-  }
-  const int kNumOfFrames = 10;
-  EXPECT_GE(InsertFrame(kVideoFrameKey, true), kNoError);
-  for (int i = 0; i < kNumOfFrames - 1; ++i) {
-    EXPECT_GE(InsertFrame(kVideoFrameDelta, true), kNoError);
-  }
-  EXPECT_EQ((kNumOfFrames - 1) * kDefaultFramePeriodMs,
-            receiver_.RenderBufferSizeMs());
-}
-
-TEST_F(TestVCMReceiver, RenderBufferSize_NotAllComplete) {
-  EXPECT_EQ(0, receiver_.RenderBufferSizeMs());
-  EXPECT_GE(InsertFrame(kVideoFrameKey, true), kNoError);
-  int num_of_frames = 10;
-  for (int i = 0; i < num_of_frames; ++i) {
-    EXPECT_GE(InsertFrame(kVideoFrameDelta, true), kNoError);
-  }
-  num_of_frames++;
-  EXPECT_GE(InsertFrame(kVideoFrameDelta, false), kNoError);
-  for (int i = 0; i < num_of_frames; ++i) {
-    EXPECT_GE(InsertFrame(kVideoFrameDelta, true), kNoError);
-  }
-  EXPECT_EQ((num_of_frames - 1) * kDefaultFramePeriodMs,
-            receiver_.RenderBufferSizeMs());
-}
-
-TEST_F(TestVCMReceiver, RenderBufferSize_NoKeyFrame) {
-  EXPECT_EQ(0, receiver_.RenderBufferSizeMs());
-  int num_of_frames = 10;
-  for (int i = 0; i < num_of_frames; ++i) {
-    EXPECT_GE(InsertFrame(kVideoFrameDelta, true), kNoError);
-  }
-  int64_t next_render_time_ms = 0;
-  VCMEncodedFrame* frame =
-      receiver_.FrameForDecoding(10, &next_render_time_ms, false);
-  EXPECT_TRUE(frame == NULL);
-  receiver_.ReleaseFrame(frame);
-  EXPECT_GE(InsertFrame(kVideoFrameDelta, false), kNoError);
-  for (int i = 0; i < num_of_frames; ++i) {
-    EXPECT_GE(InsertFrame(kVideoFrameDelta, true), kNoError);
-  }
-  EXPECT_EQ(0, receiver_.RenderBufferSizeMs());
-}
-
 TEST_F(TestVCMReceiver, NonDecodableDuration_Empty) {
   // Enable NACK and with no RTT thresholds for disabling retransmission delay.
   receiver_.SetNackMode(kNack, -1, -1);

webrtc/modules/video_coding/video_coding_impl.cc

@@ -212,11 +212,6 @@ class VideoCodingModuleImpl : public VideoCodingModule {
     return receiver_.RegisterPacketRequestCallback(callback);
   }
 
-  int RegisterRenderBufferSizeCallback(
-      VCMRenderBufferSizeCallback* callback) override {
-    return receiver_.RegisterRenderBufferSizeCallback(callback);
-  }
-
   int32_t Decode(uint16_t maxWaitTimeMs) override {
     return receiver_.Decode(maxWaitTimeMs);
   }

webrtc/modules/video_coding/video_coding_impl.h

@@ -152,7 +152,6 @@ class VideoReceiver : public Module {
       VCMDecoderTimingCallback* decoderTiming);
   int32_t RegisterFrameTypeCallback(VCMFrameTypeCallback* frameTypeCallback);
   int32_t RegisterPacketRequestCallback(VCMPacketRequestCallback* callback);
-  int RegisterRenderBufferSizeCallback(VCMRenderBufferSizeCallback* callback);
 
   int32_t Decode(uint16_t maxWaitTimeMs);
 
@@ -201,8 +200,6 @@ class VideoReceiver : public Module {
   VCMReceiveStatisticsCallback* _receiveStatsCallback GUARDED_BY(process_crit_);
   VCMDecoderTimingCallback* _decoderTimingCallback GUARDED_BY(process_crit_);
   VCMPacketRequestCallback* _packetRequestCallback GUARDED_BY(process_crit_);
-  VCMRenderBufferSizeCallback* render_buffer_callback_
-      GUARDED_BY(process_crit_);
   VCMGenericDecoder* _decoder;
 
   VCMFrameBuffer _frameFromFile;

webrtc/modules/video_coding/video_receiver.cc

@@ -40,7 +40,6 @@ VideoReceiver::VideoReceiver(Clock* clock,
       _receiveStatsCallback(nullptr),
       _decoderTimingCallback(nullptr),
       _packetRequestCallback(nullptr),
-      render_buffer_callback_(nullptr),
       _decoder(nullptr),
       _frameFromFile(),
       _scheduleKeyRequest(false),
@@ -81,12 +80,6 @@ void VideoReceiver::Process() {
           decode_ms, max_decode_ms, current_delay_ms, target_delay_ms,
           jitter_buffer_ms, min_playout_delay_ms, render_delay_ms);
     }
-
-    // Size of render buffer.
-    if (render_buffer_callback_) {
-      int buffer_size_ms = _receiver.RenderBufferSizeMs();
-      render_buffer_callback_->RenderBufferSizeMs(buffer_size_ms);
-    }
   }
 
   // Key frame requests
@@ -242,13 +235,6 @@ int32_t VideoReceiver::RegisterPacketRequestCallback(
   return VCM_OK;
 }
 
-int VideoReceiver::RegisterRenderBufferSizeCallback(
-    VCMRenderBufferSizeCallback* callback) {
-  rtc::CritScope cs(&process_crit_);
-  render_buffer_callback_ = callback;
-  return VCM_OK;
-}
-
 void VideoReceiver::TriggerDecoderShutdown() {
   _receiver.TriggerDecoderShutdown();
 }