Reland "Remove dependency of video_replay on TestADM."

This reverts commit f9e3bdd.

Reason for revert: reland with fix

Original change's description:
> Revert "Remove dependency of video_replay on TestADM."
>
> This reverts commit 0171666.
>
> Reason for revert:  breaking CallPerfTest
> https://ci.chromium.org/ui/p/webrtc/builders/perf/Perf%20Android32%20(R%20Pixel5)/967/overview 
>
> Original change's description:
> > Remove dependency of video_replay on TestADM.
> >
> > This should remove requirement to build TestADM in chromium build.
> >
> > Bug: b/272350185, webrtc:15081
> > Change-Id: Iceb8862aa81099c22bd378ae692229f01ab3314c
> > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/302380
> > Reviewed-by: Henrik Andreassson <henrika@webrtc.org>
> > Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
> > Commit-Queue: Artem Titov <titovartem@webrtc.org>
> > Cr-Commit-Position: refs/heads/main@{#39934}
>
> Bug: b/272350185, webrtc:15081
> Change-Id: I73aa0fd3c3d8c244d20e5f29f5792a4c7d7e4165
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/303160
> Bot-Commit: rubber-stamper@appspot.gserviceaccount.com <rubber-stamper@appspot.gserviceaccount.com>
> Owners-Override: Jeremy Leconte <jleconte@google.com>
> Commit-Queue: Jeremy Leconte <jleconte@google.com>
> Cr-Commit-Position: refs/heads/main@{#39939}

Bug: b/272350185, webrtc:15081
Change-Id: I360ef3e140e60fc21d622480d1f3326e40a76f58
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/303400
Commit-Queue: Artem Titov <titovartem@webrtc.org>
Reviewed-by: Henrik Andreassson <henrika@webrtc.org>
Commit-Queue: Henrik Andreassson <henrika@webrtc.org>
Auto-Submit: Artem Titov <titovartem@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#39946}

Author: Artem Titov

audio/BUILD.gn

@@ -139,6 +139,7 @@ if (rtc_include_tests) {
       "../system_wrappers",
       "../test:test_common",
       "../test:test_support",
+      "../test:video_test_constants",
     ]
   }
 
@@ -217,6 +218,7 @@ if (rtc_include_tests) {
       "../test:scoped_key_value_config",
       "../test:test_common",
       "../test:test_support",
+      "../test:video_test_constants",
       "../test/time_controller:time_controller",
       "utility:utility_tests",
       "//testing/gtest",
@@ -278,6 +280,7 @@ if (rtc_include_tests) {
         "../test:test_common",
         "../test:test_main",
         "../test:test_support",
+        "../test:video_test_constants",
         "../test/pc/e2e:network_quality_metrics_reporter",
         "//testing/gtest",
       ]

audio/audio_send_stream_tests.cc

@@ -19,6 +19,7 @@
 #include "test/field_trial.h"
 #include "test/gtest.h"
 #include "test/rtcp_packet_parser.h"
+#include "test/video_test_constants.h"
 
 namespace webrtc {
 namespace test {
@@ -31,7 +32,7 @@ enum : int {  // The first valid value is 1.
 
 class AudioSendTest : public SendTest {
  public:
-  AudioSendTest() : SendTest(CallTest::kDefaultTimeout) {}
+  AudioSendTest() : SendTest(VideoTestConstants::kDefaultTimeout) {}
 
   size_t GetNumVideoStreams() const override { return 0; }
   size_t GetNumAudioStreams() const override { return 1; }

audio/test/audio_end_to_end_test.cc

@@ -19,6 +19,7 @@
 #include "modules/audio_device/include/test_audio_device.h"
 #include "system_wrappers/include/sleep.h"
 #include "test/gtest.h"
+#include "test/video_test_constants.h"
 
 namespace webrtc {
 namespace test {
@@ -29,7 +30,7 @@ constexpr int kSampleRate = 48000;
 }  // namespace
 
 AudioEndToEndTest::AudioEndToEndTest()
-    : EndToEndTest(CallTest::kDefaultTimeout) {}
+    : EndToEndTest(VideoTestConstants::kDefaultTimeout) {}
 
 size_t AudioEndToEndTest::GetNumVideoStreams() const {
   return 0;
@@ -66,7 +67,7 @@ void AudioEndToEndTest::ModifyAudioConfigs(
   const webrtc::SdpAudioFormat kDefaultFormat("opus", 48000, 2,
                                               {{"stereo", "1"}});
   send_config->send_codec_spec = AudioSendStream::Config::SendCodecSpec(
-      test::CallTest::kAudioSendPayloadType, kDefaultFormat);
+      test::VideoTestConstants::kAudioSendPayloadType, kDefaultFormat);
   send_config->min_bitrate_bps = 32000;
   send_config->max_bitrate_bps = 32000;
 }

audio/test/low_bandwidth_audio_test.cc

@@ -14,6 +14,7 @@
 #include "audio/test/audio_end_to_end_test.h"
 #include "system_wrappers/include/sleep.h"
 #include "test/testsupport/file_utils.h"
+#include "test/video_test_constants.h"
 
 ABSL_DECLARE_FLAG(int, sample_rate_hz);
 ABSL_DECLARE_FLAG(bool, quick);
@@ -78,7 +79,7 @@ class Mobile2GNetworkTest : public AudioQualityTest {
                           std::vector<AudioReceiveStreamInterface::Config>*
                               receive_configs) override {
     send_config->send_codec_spec = AudioSendStream::Config::SendCodecSpec(
-        test::CallTest::kAudioSendPayloadType,
+        test::VideoTestConstants::kAudioSendPayloadType,
         {"OPUS",
          48000,
          2,

call/BUILD.gn

@@ -532,6 +532,7 @@ if (rtc_include_tests) {
         "../test:scoped_key_value_config",
         "../test:test_common",
         "../test:test_support",
+        "../test:video_test_constants",
         "../test/scenario",
         "../test/time_controller:time_controller",
         "../video",
@@ -606,6 +607,7 @@ if (rtc_include_tests) {
         "../test:test_common",
         "../test:test_support",
         "../test:video_test_common",
+        "../test:video_test_constants",
         "../video",
         "../video/config:encoder_config",
         "//testing/gtest",

call/bitrate_estimator_tests.cc

@@ -29,6 +29,7 @@
 #include "test/fake_encoder.h"
 #include "test/frame_generator_capturer.h"
 #include "test/gtest.h"
+#include "test/video_test_constants.h"
 
 namespace webrtc {
 namespace {
@@ -80,7 +81,9 @@ class LogObserver {
       }
     }
 
-    bool Wait() { return done_.Wait(test::CallTest::kDefaultTimeout); }
+    bool Wait() {
+      return done_.Wait(test::VideoTestConstants::kDefaultTimeout);
+    }
 
     void PushExpectedLogLine(absl::string_view expected_log_line) {
       MutexLock lock(&mutex_);
@@ -122,13 +125,15 @@ class BitrateEstimatorTest : public test::CallTest {
                              /*observer=*/nullptr);
 
       VideoSendStream::Config video_send_config(send_transport_.get());
-      video_send_config.rtp.ssrcs.push_back(kVideoSendSsrcs[0]);
+      video_send_config.rtp.ssrcs.push_back(
+          test::VideoTestConstants::kVideoSendSsrcs[0]);
       video_send_config.encoder_settings.encoder_factory =
           &fake_encoder_factory_;
       video_send_config.encoder_settings.bitrate_allocator_factory =
           bitrate_allocator_factory_.get();
       video_send_config.rtp.payload_name = "FAKE";
-      video_send_config.rtp.payload_type = kFakeVideoSendPayloadType;
+      video_send_config.rtp.payload_type =
+          test::VideoTestConstants::kFakeVideoSendPayloadType;
       SetVideoSendConfig(video_send_config);
       VideoEncoderConfig video_encoder_config;
       test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
@@ -138,7 +143,8 @@ class BitrateEstimatorTest : public test::CallTest {
           VideoReceiveStreamInterface::Config(receive_transport_.get());
       // receive_config_.decoders will be set by every stream separately.
       receive_config_.rtp.remote_ssrc = GetVideoSendConfig()->rtp.ssrcs[0];
-      receive_config_.rtp.local_ssrc = kReceiverLocalVideoSsrc;
+      receive_config_.rtp.local_ssrc =
+          test::VideoTestConstants::kReceiverLocalVideoSsrc;
     });
   }
 
@@ -173,9 +179,12 @@ class BitrateEstimatorTest : public test::CallTest {
       frame_generator_capturer_ =
           std::make_unique<test::FrameGeneratorCapturer>(
               test->clock_,
-              test::CreateSquareFrameGenerator(kDefaultWidth, kDefaultHeight,
-                                               absl::nullopt, absl::nullopt),
-              kDefaultFramerate, *test->task_queue_factory_);
+              test::CreateSquareFrameGenerator(
+                  test::VideoTestConstants::kDefaultWidth,
+                  test::VideoTestConstants::kDefaultHeight, absl::nullopt,
+                  absl::nullopt),
+              test::VideoTestConstants::kDefaultFramerate,
+              *test->task_queue_factory_);
       frame_generator_capturer_->Init();
       send_stream_->SetSource(frame_generator_capturer_.get(),
                               DegradationPreference::MAINTAIN_FRAMERATE);

call/call_perf_tests.cc

@@ -54,6 +54,7 @@
 #include "test/rtp_rtcp_observer.h"
 #include "test/testsupport/file_utils.h"
 #include "test/video_encoder_proxy_factory.h"
+#include "test/video_test_constants.h"
 #include "video/config/video_encoder_config.h"
 #include "video/transport_adapter.h"
 
@@ -116,7 +117,7 @@ class VideoRtcpAndSyncObserver : public test::RtpRtcpObserver,
   explicit VideoRtcpAndSyncObserver(TaskQueueBase* task_queue,
                                     Clock* clock,
                                     absl::string_view test_label)
-      : test::RtpRtcpObserver(CallPerfTest::kLongTimeout),
+      : test::RtpRtcpObserver(test::VideoTestConstants::kLongTimeout),
         clock_(clock),
         test_label_(test_label),
         creation_time_ms_(clock_->TimeInMilliseconds()),
@@ -274,18 +275,23 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
     audio_send_config.rtp.ssrc = kAudioSendSsrc;
     // TODO(bugs.webrtc.org/14683): Let the tests fail with invalid config.
     audio_send_config.send_codec_spec = AudioSendStream::Config::SendCodecSpec(
-        kAudioSendPayloadType, {"OPUS", 48000, 2});
+        test::VideoTestConstants::kAudioSendPayloadType, {"OPUS", 48000, 2});
     audio_send_config.min_bitrate_bps = 6000;
     audio_send_config.max_bitrate_bps = 510000;
     audio_send_config.encoder_factory = CreateBuiltinAudioEncoderFactory();
     audio_send_stream = sender_call_->CreateAudioSendStream(audio_send_config);
 
-    GetVideoSendConfig()->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+    GetVideoSendConfig()->rtp.nack.rtp_history_ms =
+        test::VideoTestConstants::kNackRtpHistoryMs;
     if (fec == FecMode::kOn) {
-      GetVideoSendConfig()->rtp.ulpfec.red_payload_type = kRedPayloadType;
-      GetVideoSendConfig()->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
-      video_receive_configs_[0].rtp.red_payload_type = kRedPayloadType;
-      video_receive_configs_[0].rtp.ulpfec_payload_type = kUlpfecPayloadType;
+      GetVideoSendConfig()->rtp.ulpfec.red_payload_type =
+          test::VideoTestConstants::kRedPayloadType;
+      GetVideoSendConfig()->rtp.ulpfec.ulpfec_payload_type =
+          test::VideoTestConstants::kUlpfecPayloadType;
+      video_receive_configs_[0].rtp.red_payload_type =
+          test::VideoTestConstants::kRedPayloadType;
+      video_receive_configs_[0].rtp.ulpfec_payload_type =
+          test::VideoTestConstants::kUlpfecPayloadType;
     }
     video_receive_configs_[0].rtp.nack.rtp_history_ms = 1000;
     video_receive_configs_[0].renderer = observer.get();
@@ -298,7 +304,7 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
     audio_recv_config.sync_group = kSyncGroup;
     audio_recv_config.decoder_factory = audio_decoder_factory_;
     audio_recv_config.decoder_map = {
-        {kAudioSendPayloadType, {"OPUS", 48000, 2}}};
+        {test::VideoTestConstants::kAudioSendPayloadType, {"OPUS", 48000, 2}}};
 
     if (create_first == CreateOrder::kAudioFirst) {
       audio_receive_stream =
@@ -312,9 +318,11 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
     EXPECT_EQ(1u, video_receive_streams_.size());
     observer->set_receive_stream(video_receive_streams_[0]);
     drifting_clock = std::make_unique<DriftingClock>(clock_, video_ntp_speed);
-    CreateFrameGeneratorCapturerWithDrift(drifting_clock.get(), video_rtp_speed,
-                                          kDefaultFramerate, kDefaultWidth,
-                                          kDefaultHeight);
+    CreateFrameGeneratorCapturerWithDrift(
+        drifting_clock.get(), video_rtp_speed,
+        test::VideoTestConstants::kDefaultFramerate,
+        test::VideoTestConstants::kDefaultWidth,
+        test::VideoTestConstants::kDefaultHeight);
 
     Start();
 
@@ -405,7 +413,7 @@ void CallPerfTest::TestCaptureNtpTime(
                            int threshold_ms,
                            int start_time_ms,
                            int run_time_ms)
-        : EndToEndTest(kLongTimeout),
+        : EndToEndTest(test::VideoTestConstants::kLongTimeout),
           net_config_(net_config),
           clock_(Clock::GetRealTimeClock()),
           threshold_ms_(threshold_ms),
@@ -558,7 +566,9 @@ TEST_F(CallPerfTest, ReceivesCpuOveruseAndUnderuse) {
   class LoadObserver : public test::SendTest,
                        public test::FrameGeneratorCapturer::SinkWantsObserver {
    public:
-    LoadObserver() : SendTest(kLongTimeout), test_phase_(TestPhase::kInit) {}
+    LoadObserver()
+        : SendTest(test::VideoTestConstants::kLongTimeout),
+          test_phase_(TestPhase::kInit) {}
 
     void OnFrameGeneratorCapturerCreated(
         test::FrameGeneratorCapturer* frame_generator_capturer) override {
@@ -667,7 +677,7 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
    public:
     explicit BitrateObserver(bool using_min_transmit_bitrate,
                              TaskQueueBase* task_queue)
-        : EndToEndTest(kLongTimeout),
+        : EndToEndTest(test::VideoTestConstants::kLongTimeout),
           send_stream_(nullptr),
           converged_(false),
           pad_to_min_bitrate_(using_min_transmit_bitrate),
@@ -794,7 +804,7 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
   class BitrateObserver : public test::EndToEndTest, public test::FakeEncoder {
    public:
     explicit BitrateObserver(TaskQueueBase* task_queue)
-        : EndToEndTest(kDefaultTimeout),
+        : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
           FakeEncoder(Clock::GetRealTimeClock()),
           encoder_inits_(0),
           last_set_bitrate_kbps_(0),
@@ -818,11 +828,11 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
                 : kInitialBitrateKbps - kInitialBitrateOverheadKpbs;
         EXPECT_EQ(expected_bitrate, config->startBitrate)
             << "Encoder not initialized at expected bitrate.";
-        EXPECT_EQ(kDefaultWidth, config->width);
-        EXPECT_EQ(kDefaultHeight, config->height);
+        EXPECT_EQ(test::VideoTestConstants::kDefaultWidth, config->width);
+        EXPECT_EQ(test::VideoTestConstants::kDefaultHeight, config->height);
       } else if (encoder_inits_ == 2) {
-        EXPECT_EQ(2 * kDefaultWidth, config->width);
-        EXPECT_EQ(2 * kDefaultHeight, config->height);
+        EXPECT_EQ(2 * test::VideoTestConstants::kDefaultWidth, config->width);
+        EXPECT_EQ(2 * test::VideoTestConstants::kDefaultHeight, config->height);
         EXPECT_GE(last_set_bitrate_kbps_, kReconfigureThresholdKbps);
         EXPECT_GT(config->startBitrate, kReconfigureThresholdKbps)
             << "Encoder reconfigured with bitrate too far away from last set.";
@@ -871,9 +881,12 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
     }
 
     void PerformTest() override {
-      ASSERT_TRUE(time_to_reconfigure_.Wait(kDefaultTimeout))
+      ASSERT_TRUE(
+          time_to_reconfigure_.Wait(test::VideoTestConstants::kDefaultTimeout))
           << "Timed out before receiving an initial high bitrate.";
-      frame_generator_->ChangeResolution(kDefaultWidth * 2, kDefaultHeight * 2);
+      frame_generator_->ChangeResolution(
+          test::VideoTestConstants::kDefaultWidth * 2,
+          test::VideoTestConstants::kDefaultHeight * 2);
       SendTask(task_queue_, [&]() {
         send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
       });
@@ -1057,7 +1070,7 @@ void CallPerfTest::TestEncodeFramerate(VideoEncoderFactory* encoder_factory,
                       absl::string_view payload_name,
                       const std::vector<int>& max_framerates,
                       TaskQueueBase* task_queue)
-        : EndToEndTest(kDefaultTimeout),
+        : EndToEndTest(test::VideoTestConstants::kDefaultTimeout),
           clock_(Clock::GetRealTimeClock()),
           encoder_factory_(encoder_factory),
           payload_name_(payload_name),
@@ -1096,7 +1109,8 @@ void CallPerfTest::TestEncodeFramerate(VideoEncoderFactory* encoder_factory,
         VideoEncoderConfig* encoder_config) override {
       send_config->encoder_settings.encoder_factory = encoder_factory_;
       send_config->rtp.payload_name = payload_name_;
-      send_config->rtp.payload_type = test::CallTest::kVideoSendPayloadType;
+      send_config->rtp.payload_type =
+          test::VideoTestConstants::kVideoSendPayloadType;
       encoder_config->video_format.name = payload_name_;
       encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
       encoder_config->max_bitrate_bps = kMaxBitrate.bps();