[cleanup] Remove VCMTiming::get_min/max_playout_delay

These methods were only used for testing.

Change-Id: Icbb6a3cc59cbc0b5e1f42efcb86a7203704b92d8
Bug: None
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/256362
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Evan Shrubsole <eshr@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36293}
diff --git a/modules/video_coding/timing.cc b/modules/video_coding/timing.cc
index 390a499..72d1414 100644
--- a/modules/video_coding/timing.cc
+++ b/modules/video_coding/timing.cc
@@ -68,21 +68,11 @@
   min_playout_delay_ = min_playout_delay;
 }
 
-TimeDelta VCMTiming::min_playout_delay() {
-  MutexLock lock(&mutex_);
-  return min_playout_delay_;
-}
-
 void VCMTiming::set_max_playout_delay(TimeDelta max_playout_delay) {
   MutexLock lock(&mutex_);
   max_playout_delay_ = max_playout_delay;
 }
 
-TimeDelta VCMTiming::max_playout_delay() {
-  MutexLock lock(&mutex_);
-  return max_playout_delay_;
-}
-
 void VCMTiming::SetJitterDelay(TimeDelta jitter_delay) {
   MutexLock lock(&mutex_);
   if (jitter_delay != jitter_delay_) {
@@ -245,6 +235,7 @@
                            .target_delay = TargetDelayInternal(),
                            .jitter_buffer_delay = jitter_delay_,
                            .min_playout_delay = min_playout_delay_,
+                           .max_playout_delay = max_playout_delay_,
                            .render_delay = render_delay_,
                            .num_decoded_frames = num_decoded_frames_};
 }
diff --git a/modules/video_coding/timing.h b/modules/video_coding/timing.h
index af3974a..c1f1c3a 100644
--- a/modules/video_coding/timing.h
+++ b/modules/video_coding/timing.h
@@ -47,11 +47,9 @@
 
   // Set/get the minimum playout delay from capture to render.
   void set_min_playout_delay(TimeDelta min_playout_delay);
-  TimeDelta min_playout_delay();
 
   // Set/get the maximum playout delay from capture to render in ms.
   void set_max_playout_delay(TimeDelta max_playout_delay);
-  TimeDelta max_playout_delay();
 
   // Increases or decreases the current delay to get closer to the target delay.
   // Calculates how long it has been since the previous call to this function,
@@ -100,6 +98,7 @@
     TimeDelta target_delay;
     TimeDelta jitter_buffer_delay;
     TimeDelta min_playout_delay;
+    TimeDelta max_playout_delay;
     TimeDelta render_delay;
     size_t num_decoded_frames;
   };
diff --git a/video/video_receive_stream2_unittest.cc b/video/video_receive_stream2_unittest.cc
index 6a719e7..b90deaa 100644
--- a/video/video_receive_stream2_unittest.cc
+++ b/video/video_receive_stream2_unittest.cc
@@ -164,30 +164,36 @@
   test_frame->SetPlayoutDelay(kPlayoutDelayMs);
 
   video_receive_stream_->OnCompleteFrame(std::move(test_frame));
-  EXPECT_EQ(kPlayoutDelayMs.min_ms, timing_->min_playout_delay().ms());
-  EXPECT_EQ(kPlayoutDelayMs.max_ms, timing_->max_playout_delay().ms());
+  auto timings = timing_->GetTimings();
+  EXPECT_EQ(kPlayoutDelayMs.min_ms, timings.min_playout_delay.ms());
+  EXPECT_EQ(kPlayoutDelayMs.max_ms, timings.max_playout_delay.ms());
 
   // Check that the biggest minimum delay is chosen.
   video_receive_stream_->SetMinimumPlayoutDelay(400);
-  EXPECT_EQ(400, timing_->min_playout_delay().ms());
+  timings = timing_->GetTimings();
+  EXPECT_EQ(400, timings.min_playout_delay.ms());
 
   // Check base minimum delay validation.
   EXPECT_FALSE(video_receive_stream_->SetBaseMinimumPlayoutDelayMs(12345));
   EXPECT_FALSE(video_receive_stream_->SetBaseMinimumPlayoutDelayMs(-1));
   EXPECT_TRUE(video_receive_stream_->SetBaseMinimumPlayoutDelayMs(500));
-  EXPECT_EQ(500, timing_->min_playout_delay().ms());
+  timings = timing_->GetTimings();
+  EXPECT_EQ(500, timings.min_playout_delay.ms());
 
   // Check that intermidiate values are remembered and the biggest remembered
   // is chosen.
   video_receive_stream_->SetBaseMinimumPlayoutDelayMs(0);
-  EXPECT_EQ(400, timing_->min_playout_delay().ms());
+  timings = timing_->GetTimings();
+  EXPECT_EQ(400, timings.min_playout_delay.ms());
 
   video_receive_stream_->SetMinimumPlayoutDelay(0);
-  EXPECT_EQ(123, timing_->min_playout_delay().ms());
+  timings = timing_->GetTimings();
+  EXPECT_EQ(123, timings.min_playout_delay.ms());
 }
 
 TEST_F(VideoReceiveStream2Test, PlayoutDelayPreservesDefaultMaxValue) {
-  const TimeDelta default_max_playout_latency = timing_->max_playout_delay();
+  const TimeDelta default_max_playout_latency =
+      timing_->GetTimings().max_playout_delay;
   const VideoPlayoutDelay kPlayoutDelayMs = {123, -1};
 
   std::unique_ptr<FrameObjectFake> test_frame(new FrameObjectFake());
@@ -197,13 +203,15 @@
   video_receive_stream_->OnCompleteFrame(std::move(test_frame));
 
   // Ensure that -1 preserves default maximum value from `timing_`.
-  EXPECT_EQ(kPlayoutDelayMs.min_ms, timing_->min_playout_delay().ms());
-  EXPECT_NE(kPlayoutDelayMs.max_ms, timing_->max_playout_delay().ms());
-  EXPECT_EQ(default_max_playout_latency, timing_->max_playout_delay());
+  auto timings = timing_->GetTimings();
+  EXPECT_EQ(kPlayoutDelayMs.min_ms, timings.min_playout_delay.ms());
+  EXPECT_NE(kPlayoutDelayMs.max_ms, timings.max_playout_delay.ms());
+  EXPECT_EQ(default_max_playout_latency, timings.max_playout_delay);
 }
 
 TEST_F(VideoReceiveStream2Test, PlayoutDelayPreservesDefaultMinValue) {
-  const TimeDelta default_min_playout_latency = timing_->min_playout_delay();
+  const TimeDelta default_min_playout_latency =
+      timing_->GetTimings().min_playout_delay;
   const VideoPlayoutDelay kPlayoutDelayMs = {-1, 321};
 
   std::unique_ptr<FrameObjectFake> test_frame(new FrameObjectFake());
@@ -213,9 +221,10 @@
   video_receive_stream_->OnCompleteFrame(std::move(test_frame));
 
   // Ensure that -1 preserves default minimum value from `timing_`.
-  EXPECT_NE(kPlayoutDelayMs.min_ms, timing_->min_playout_delay().ms());
-  EXPECT_EQ(kPlayoutDelayMs.max_ms, timing_->max_playout_delay().ms());
-  EXPECT_EQ(default_min_playout_latency, timing_->min_playout_delay());
+  auto timings = timing_->GetTimings();
+  EXPECT_NE(kPlayoutDelayMs.min_ms, timings.min_playout_delay.ms());
+  EXPECT_EQ(kPlayoutDelayMs.max_ms, timings.max_playout_delay.ms());
+  EXPECT_EQ(default_min_playout_latency, timings.min_playout_delay);
 }
 
 TEST_F(VideoReceiveStream2Test, MaxCompositionDelayNotSetByDefault) {