Video/Screenshare loopback tool.

webrtc/test/call_test.cc

 /*
  *  Copyright (c) 2014 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 14 matching lines @@
 
 namespace webrtc {
 namespace test {
 
 namespace {
 const int kVideoRotationRtpExtensionId = 4;
 }
 
 CallTest::CallTest()
     : clock_(Clock::GetRealTimeClock()),
-      event_log_(RtcEventLog::CreateNull()),
+      event_log_(RtcEventLog::Create()),
       sender_call_transport_controller_(nullptr),
       video_send_config_(nullptr),
       video_send_stream_(nullptr),
       audio_send_config_(nullptr),
       audio_send_stream_(nullptr),
       fake_encoder_(clock_),
       num_video_streams_(1),
       num_audio_streams_(0),
       num_flexfec_streams_(0),
       decoder_factory_(CreateBuiltinAudioDecoderFactory()),
       encoder_factory_(CreateBuiltinAudioEncoderFactory()),
       task_queue_("CallTestTaskQueue"),
       fake_send_audio_device_(nullptr),
-      fake_recv_audio_device_(nullptr) {}
+      fake_recv_audio_device_(nullptr) {
+  int64_t now_ms = clock_->TimeInMilliseconds();
+  std::stringstream ss;
+  ss << "/usr/local/google/home/philipel/temp/vs_stuff/event_logs/" << now_ms
+     << ".log";
+  event_log_->StartLogging(ss.str(), 1000000000);
+}
 
 CallTest::~CallTest() {
   task_queue_.SendTask([this]() {
     fake_send_audio_device_.reset();
     fake_recv_audio_device_.reset();
     frame_generator_capturer_.reset();
   });
 }
 
 void CallTest::RunBaseTest(BaseTest* test) {
-  task_queue_.SendTask([this, test]() {
-    num_video_streams_ = test->GetNumVideoStreams();
-    num_audio_streams_ = test->GetNumAudioStreams();
-    num_flexfec_streams_ = test->GetNumFlexfecStreams();
-    RTC_DCHECK(num_video_streams_ > 0 || num_audio_streams_ > 0);
-    Call::Config send_config(test->GetSenderCallConfig());
-    if (num_audio_streams_ > 0) {
-      CreateFakeAudioDevices(test->CreateCapturer(), test->CreateRenderer());
-      test->OnFakeAudioDevicesCreated(fake_send_audio_device_.get(),
-                                      fake_recv_audio_device_.get());
-      apm_send_ = AudioProcessing::Create();
-      apm_recv_ = AudioProcessing::Create();
-      CreateVoiceEngines();
-      AudioState::Config audio_state_config;
-      audio_state_config.voice_engine = voe_send_.voice_engine;
-      audio_state_config.audio_mixer = AudioMixerImpl::Create();
-      audio_state_config.audio_processing = apm_send_;
-      send_config.audio_state = AudioState::Create(audio_state_config);
-    }
-    CreateSenderCall(send_config);
-    if (sender_call_transport_controller_ != nullptr) {
-      test->OnRtpTransportControllerSendCreated(
-          sender_call_transport_controller_);
-    }
-    if (test->ShouldCreateReceivers()) {
-      Call::Config recv_config(test->GetReceiverCallConfig());
-      if (num_audio_streams_ > 0) {
-        AudioState::Config audio_state_config;
-        audio_state_config.voice_engine = voe_recv_.voice_engine;
-        audio_state_config.audio_mixer = AudioMixerImpl::Create();
-        audio_state_config.audio_processing = apm_recv_;
-        recv_config.audio_state = AudioState::Create(audio_state_config);
-      }
-      CreateReceiverCall(recv_config);
-    }
-    test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
-    receive_transport_.reset(test->CreateReceiveTransport(&task_queue_));
-    send_transport_.reset(
-        test->CreateSendTransport(&task_queue_, sender_call_.get()));
+  // num_video_streams_ = test->GetNumVideoStreams();
+  // num_audio_streams_ = test->GetNumAudioStreams();
+  // num_flexfec_streams_ = test->GetNumFlexfecStreams();
+  // RTC_DCHECK(num_video_streams_ > 0 || num_audio_streams_ > 0);
+  // Call::Config send_config(test->GetSenderCallConfig());
+  // if (num_audio_streams_ > 0) {
+  //   CreateFakeAudioDevices(test->CreateCapturer(), test->CreateRenderer());
+  //   test->OnFakeAudioDevicesCreated(fake_send_audio_device_.get(),
+  //                                   fake_recv_audio_device_.get());
+  //   apm_send_ = AudioProcessing::Create();
+  //   apm_recv_ = AudioProcessing::Create();
+  //   CreateVoiceEngines();
+  //   AudioState::Config audio_state_config;
+  //   audio_state_config.voice_engine = voe_send_.voice_engine;
+  //   audio_state_config.audio_mixer = AudioMixerImpl::Create();
+  //   audio_state_config.audio_processing = apm_send_;
+  //   send_config.audio_state = AudioState::Create(audio_state_config);
+  // }
+  // CreateSenderCall(send_config);
+  // if (sender_call_transport_controller_ != nullptr) {
+  //   test->OnRtpTransportControllerSendCreated(
+  //       sender_call_transport_controller_);
+  // }
+  // if (test->ShouldCreateReceivers()) {
+  //   Call::Config recv_config(test->GetReceiverCallConfig());
+  //   if (num_audio_streams_ > 0) {
+  //     AudioState::Config audio_state_config;
+  //     audio_state_config.voice_engine = voe_recv_.voice_engine;
+  //     audio_state_config.audio_mixer = AudioMixerImpl::Create();
+  //     audio_state_config.audio_processing = apm_recv_;
+  //     recv_config.audio_state = AudioState::Create(audio_state_config);
+  //   }
+  //   CreateReceiverCall(recv_config);
+  // }
+  // test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
+  // receive_transport_.reset(test->CreateReceiveTransport());
+  // send_transport_.reset(test->CreateSendTransport(sender_call_.get()));
 
-    if (test->ShouldCreateReceivers()) {
-      send_transport_->SetReceiver(receiver_call_->Receiver());
-      receive_transport_->SetReceiver(sender_call_->Receiver());
-      if (num_video_streams_ > 0)
-        receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
-      if (num_audio_streams_ > 0)
-        receiver_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp);
-    } else {
-      // Sender-only call delivers to itself.
-      send_transport_->SetReceiver(sender_call_->Receiver());
-      receive_transport_->SetReceiver(nullptr);
-    }
+  // if (test->ShouldCreateReceivers()) {
+  //   send_transport_->SetReceiver(receiver_call_->Receiver());
+  //   receive_transport_->SetReceiver(sender_call_->Receiver());
+  //   if (num_video_streams_ > 0)
+  //     receiver_call_->SignalChannelNetworkState(MediaType::VIDEO,
+  //     kNetworkUp);
+  //   if (num_audio_streams_ > 0)
+  //     receiver_call_->SignalChannelNetworkState(MediaType::AUDIO,
+  //     kNetworkUp);
+  // } else {
+  //   // Sender-only call delivers to itself.
+  //   send_transport_->SetReceiver(sender_call_->Receiver());
+  //   receive_transport_->SetReceiver(nullptr);
+  // }
 
-    CreateSendConfig(num_video_streams_, num_audio_streams_,
-                     num_flexfec_streams_, send_transport_.get());
-    if (test->ShouldCreateReceivers()) {
-      CreateMatchingReceiveConfigs(receive_transport_.get());
-    }
-    if (num_video_streams_ > 0) {
-      test->ModifyVideoConfigs(&video_send_config_, &video_receive_configs_,
-                               &video_encoder_config_);
-    }
-    if (num_audio_streams_ > 0) {
-      test->ModifyAudioConfigs(&audio_send_config_, &audio_receive_configs_);
-    }
-    if (num_flexfec_streams_ > 0) {
-      test->ModifyFlexfecConfigs(&flexfec_receive_configs_);
-    }
+  // CreateSendConfig();
+  // if (test->ShouldCreateReceivers()) {
+  //   CreateMatchingReceiveConfigs(
+  //       receive_transport_.get(),
+  //       &video_receive_configs_,
+  //       &allocated_decoders_,
+  //       &video_send_config_);
+  // }
+  // if (num_video_streams_ > 0) {
+  //   test->ModifyVideoConfigs(&video_send_config_, &video_receive_configs_,
+  //                            &video_encoder_config_);
+  // }
+  // if (num_audio_streams_ > 0) {
+  //   test->ModifyAudioConfigs(&audio_send_config_, &audio_receive_configs_);
+  // }
+  // if (num_flexfec_streams_ > 0) {
+  //   test->ModifyFlexfecConfigs(&flexfec_receive_configs_);
+  // }
 
-    if (num_flexfec_streams_ > 0) {
-      CreateFlexfecStreams();
-      test->OnFlexfecStreamsCreated(flexfec_receive_streams_);
-    }
-    if (num_video_streams_ > 0) {
-      CreateVideoStreams();
-      test->OnVideoStreamsCreated(video_send_stream_, video_receive_streams_);
-    }
-    if (num_audio_streams_ > 0) {
-      CreateAudioStreams();
-      test->OnAudioStreamsCreated(audio_send_stream_, audio_receive_streams_);
-    }
+  // if (num_flexfec_streams_ > 0) {
+  //   CreateFlexfecStreams();
+  //   test->OnFlexfecStreamsCreated(flexfec_receive_streams_);
+  // }
+  // if (num_video_streams_ > 0) {
+  //   video_send_stream_ = CreateVideoStreams(sender_call_.get(),
+  //                                           receiver_call_.get(),
+  //                                           &video_send_config_,
+  //                                           &video_receive_configs_,
+  //                                           &video_receive_streams_,
+  //                                           &video_encoder_config_);
+  //   test->OnVideoStreamsCreated(video_send_stream_, video_receive_streams_);
+  // }
+  // if (num_audio_streams_ > 0) {
+  //   CreateAudioStreams();
+  //   test->OnAudioStreamsCreated(audio_send_stream_, audio_receive_streams_);
+  // }
 
-    if (num_video_streams_ > 0) {
-      int width = kDefaultWidth;
-      int height = kDefaultHeight;
-      int frame_rate = kDefaultFramerate;
-      test->ModifyVideoCaptureStartResolution(&width, &height, &frame_rate);
-      CreateFrameGeneratorCapturer(frame_rate, width, height);
-      test->OnFrameGeneratorCapturerCreated(frame_generator_capturer_.get());
-    }
+  // if (num_video_streams_ > 0) {
+  //   int width = kDefaultWidth;
+  //   int height = kDefaultHeight;
+  //   int frame_rate = kDefaultFramerate;
+  //   test->ModifyVideoCaptureStartResolution(&width, &height, &frame_rate);
+  //   CreateFrameGeneratorCapturer(frame_rate, width, height);
+  //   test->OnFrameGeneratorCapturerCreated(frame_generator_capturer_.get());
+  // }
 
-    Start();
-  });
+  // Start();
+  // test->PerformTest();
+  // send_transport_->StopSending();
+  // receive_transport_->StopSending();
+  // Stop();
 
-  test->PerformTest();
+  // DestroyStreams();
+  // DestroyCalls();
+  // if (num_audio_streams_ > 0)
+  //   DestroyVoiceEngines();
 
-  task_queue_.SendTask([this]() {
-    Stop();
-    DestroyStreams();
-    send_transport_.reset();
-    receive_transport_.reset();
-    DestroyCalls();
-    if (num_audio_streams_ > 0)
-      DestroyVoiceEngines();
-  });
-
-  test->OnTestFinished();
+  // test->OnTestFinished();
 }
 
 void CallTest::CreateCalls(const Call::Config& sender_config,
                            const Call::Config& receiver_config) {
   CreateSenderCall(sender_config);
   CreateReceiverCall(receiver_config);
 }
 
 void CallTest::CreateSenderCall(const Call::Config& config) {
   sender_call_transport_controller_ = new RtpTransportControllerSend(
       Clock::GetRealTimeClock(), config.event_log);
 
   sender_call_.reset(
       Call::Create(config, std::unique_ptr<RtpTransportControllerSend>(
                                sender_call_transport_controller_)));
+  sender_call_->PrintDebugStuff();
 }
 
 void CallTest::CreateReceiverCall(const Call::Config& config) {
   receiver_call_.reset(Call::Create(config));
 }
 
 void CallTest::DestroyCalls() {
   sender_call_.reset();
   receiver_call_.reset();
 }
 
 void CallTest::CreateSendConfig(size_t num_video_streams,
                                 size_t num_audio_streams,
                                 size_t num_flexfec_streams,
-                                Transport* send_transport) {
+                                Transport* send_transport,
+                                VideoSendStream::Config* video_send_config,
+                                VideoEncoderConfig* video_encoder_config,
+                                std::vector<uint32_t>* send_ssrcs) {
   RTC_DCHECK(num_video_streams <= kNumSsrcs);
   RTC_DCHECK_LE(num_audio_streams, 1);
   RTC_DCHECK_LE(num_flexfec_streams, 1);
-  RTC_DCHECK(num_audio_streams == 0 || voe_send_.channel_id >= 0);
+  RTC_DCHECK(num_audio_streams == 0);
   if (num_video_streams > 0) {
-    video_send_config_ = VideoSendStream::Config(send_transport);
-    video_send_config_.encoder_settings.encoder = &fake_encoder_;
-    video_send_config_.encoder_settings.payload_name = "FAKE";
-    video_send_config_.encoder_settings.payload_type =
+    *video_send_config = VideoSendStream::Config(send_transport);
+    video_send_config->encoder_settings.encoder = &fake_encoder_;
+    video_send_config->encoder_settings.payload_name = "FAKE";
+    video_send_config->encoder_settings.payload_type =
         kFakeVideoSendPayloadType;
-    video_send_config_.rtp.extensions.push_back(
+    video_send_config->rtp.extensions.push_back(
         RtpExtension(RtpExtension::kTransportSequenceNumberUri,
                      kTransportSequenceNumberExtensionId));
-    video_send_config_.rtp.extensions.push_back(RtpExtension(
+    video_send_config->rtp.extensions.push_back(RtpExtension(
         RtpExtension::kVideoContentTypeUri, kVideoContentTypeExtensionId));
-    FillEncoderConfiguration(num_video_streams, &video_encoder_config_);
+    FillEncoderConfiguration(num_video_streams, video_encoder_config);
 
     for (size_t i = 0; i < num_video_streams; ++i)
-      video_send_config_.rtp.ssrcs.push_back(kVideoSendSsrcs[i]);
-    video_send_config_.rtp.extensions.push_back(RtpExtension(
+      video_send_config->rtp.ssrcs.push_back(send_ssrcs->at(i));
+    video_send_config->rtp.extensions.push_back(RtpExtension(
         RtpExtension::kVideoRotationUri, kVideoRotationRtpExtensionId));
   }
 
-  if (num_audio_streams > 0) {
-    audio_send_config_ = AudioSendStream::Config(send_transport);
-    audio_send_config_.voe_channel_id = voe_send_.channel_id;
-    audio_send_config_.rtp.ssrc = kAudioSendSsrc;
-    audio_send_config_.send_codec_spec =
-        rtc::Optional<AudioSendStream::Config::SendCodecSpec>(
-            {kAudioSendPayloadType, {"OPUS", 48000, 2, {{"stereo", "1"}}}});
-    audio_send_config_.encoder_factory = encoder_factory_;
-  }
-
   // TODO(brandtr): Update this when we support multistream protection.
-  if (num_flexfec_streams > 0) {
-    video_send_config_.rtp.flexfec.payload_type = kFlexfecPayloadType;
-    video_send_config_.rtp.flexfec.ssrc = kFlexfecSendSsrc;
-    video_send_config_.rtp.flexfec.protected_media_ssrcs = {kVideoSendSsrcs[0]};
-  }
+  RTC_DCHECK(num_flexfec_streams == 0);
+  // if (num_flexfec_streams > 0) {
+  //   video_send_config->rtp.flexfec.payload_type = kFlexfecPayloadType;
+  //   video_send_config->rtp.flexfec.ssrc = kFlexfecSendSsrc;
+  //   video_send_config->rtp.flexfec.protected_media_ssrcs =
+  //   {kVideoSendSsrcs[0]};
+  // }
 }
 
-void CallTest::CreateMatchingReceiveConfigs(Transport* rtcp_send_transport) {
-  video_receive_configs_.clear();
-  allocated_decoders_.clear();
+void CallTest::CreateMatchingReceiveConfigs(
+    Transport* rtcp_send_transport,
+    std::vector<VideoReceiveStream::Config>* video_receive_configs,
+    std::vector<std::unique_ptr<VideoDecoder>>* allocated_decoders,
+    VideoSendStream::Config* video_send_config) {
+  video_receive_configs->clear();
+  allocated_decoders->clear();
   if (num_video_streams_ > 0) {
-    RTC_DCHECK(!video_send_config_.rtp.ssrcs.empty());
+    RTC_DCHECK(!video_send_config->rtp.ssrcs.empty());
     VideoReceiveStream::Config video_config(rtcp_send_transport);
     video_config.rtp.remb = false;
     video_config.rtp.transport_cc = true;
     video_config.rtp.local_ssrc = kReceiverLocalVideoSsrc;
-    for (const RtpExtension& extension : video_send_config_.rtp.extensions)
+    for (const RtpExtension& extension : video_send_config->rtp.extensions)
       video_config.rtp.extensions.push_back(extension);
     video_config.renderer = &fake_renderer_;
-    for (size_t i = 0; i < video_send_config_.rtp.ssrcs.size(); ++i) {
+    for (size_t i = 0; i < video_send_config->rtp.ssrcs.size(); ++i) {
       VideoReceiveStream::Decoder decoder =
-          test::CreateMatchingDecoder(video_send_config_.encoder_settings);
-      allocated_decoders_.push_back(
+          test::CreateMatchingDecoder(video_send_config->encoder_settings);
+      allocated_decoders->push_back(
           std::unique_ptr<VideoDecoder>(decoder.decoder));
       video_config.decoders.clear();
       video_config.decoders.push_back(decoder);
-      video_config.rtp.remote_ssrc = video_send_config_.rtp.ssrcs[i];
-      video_receive_configs_.push_back(video_config.Copy());
+      video_config.rtp.remote_ssrc = video_send_config->rtp.ssrcs[i];
+      video_receive_configs->push_back(video_config.Copy());
     }
   }
 
-  RTC_DCHECK_GE(1, num_audio_streams_);
-  if (num_audio_streams_ == 1) {
-    RTC_DCHECK_LE(0, voe_send_.channel_id);
-    AudioReceiveStream::Config audio_config;
-    audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc;
-    audio_config.rtcp_send_transport = rtcp_send_transport;
-    audio_config.voe_channel_id = voe_recv_.channel_id;
-    audio_config.rtp.remote_ssrc = audio_send_config_.rtp.ssrc;
-    audio_config.decoder_factory = decoder_factory_;
-    audio_config.decoder_map = {{kAudioSendPayloadType, {"opus", 48000, 2}}};
-    audio_receive_configs_.push_back(audio_config);
-  }
-
-  // TODO(brandtr): Update this when we support multistream protection.
-  RTC_DCHECK(num_flexfec_streams_ <= 1);
-  if (num_flexfec_streams_ == 1) {
-    FlexfecReceiveStream::Config config(rtcp_send_transport);
-    config.payload_type = kFlexfecPayloadType;
-    config.remote_ssrc = kFlexfecSendSsrc;
-    config.protected_media_ssrcs = {kVideoSendSsrcs[0]};
-    config.local_ssrc = kReceiverLocalVideoSsrc;
-    for (const RtpExtension& extension : video_send_config_.rtp.extensions)
-      config.rtp_header_extensions.push_back(extension);
-    flexfec_receive_configs_.push_back(config);
-  }
+  RTC_DCHECK_EQ(0, num_audio_streams_);
+  RTC_DCHECK(num_flexfec_streams_ <= 0);
 }
 
 void CallTest::CreateFrameGeneratorCapturerWithDrift(Clock* clock,
                                                      float speed,
                                                      int framerate,
                                                      int width,
                                                      int height) {
   frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create(
       width, height, framerate * speed, clock));
   video_send_stream_->SetSource(
@@ skipping 13 matching lines @@
 
 void CallTest::CreateFakeAudioDevices(
     std::unique_ptr<FakeAudioDevice::Capturer> capturer,
     std::unique_ptr<FakeAudioDevice::Renderer> renderer) {
   fake_send_audio_device_.reset(new FakeAudioDevice(
       std::move(capturer), nullptr, 1.f));
   fake_recv_audio_device_.reset(new FakeAudioDevice(
       nullptr, std::move(renderer), 1.f));
 }
 
-void CallTest::CreateVideoStreams() {
-  RTC_DCHECK(video_send_stream_ == nullptr);
-  RTC_DCHECK(video_receive_streams_.empty());
-  RTC_DCHECK(audio_send_stream_ == nullptr);
-  RTC_DCHECK(audio_receive_streams_.empty());
-
-  video_send_stream_ = sender_call_->CreateVideoSendStream(
-      video_send_config_.Copy(), video_encoder_config_.Copy());
-  for (size_t i = 0; i < video_receive_configs_.size(); ++i) {
-    video_receive_streams_.push_back(receiver_call_->CreateVideoReceiveStream(
-        video_receive_configs_[i].Copy()));
+VideoSendStream* CallTest::CreateVideoStreams(
+    Call* sender_call,
+    Call* receiver_call,
+    VideoSendStream::Config* video_send_config,
+    std::vector<VideoReceiveStream::Config>* video_receive_configs,
+    std::vector<VideoReceiveStream*>* video_receive_streams,
+    VideoEncoderConfig* video_encoder_config) {
+  for (size_t i = 0; i < video_receive_configs->size(); ++i) {
+    video_receive_streams->push_back(receiver_call->CreateVideoReceiveStream(
+        video_receive_configs->at(i).Copy()));
   }
 
-  AssociateFlexfecStreamsWithVideoStreams();
+  return sender_call->CreateVideoSendStream(video_send_config->Copy(),
+                                            video_encoder_config->Copy());
 }
 
 void CallTest::CreateAudioStreams() {
   audio_send_stream_ = sender_call_->CreateAudioSendStream(audio_send_config_);
   for (size_t i = 0; i < audio_receive_configs_.size(); ++i) {
     audio_receive_streams_.push_back(
         receiver_call_->CreateAudioReceiveStream(audio_receive_configs_[i]));
   }
 }
 
@@ skipping 123 matching lines @@
 const uint8_t CallTest::kFakeVideoSendPayloadType = 125;
 const uint8_t CallTest::kSendRtxPayloadType = 98;
 const uint8_t CallTest::kRedPayloadType = 118;
 const uint8_t CallTest::kRtxRedPayloadType = 99;
 const uint8_t CallTest::kUlpfecPayloadType = 119;
 const uint8_t CallTest::kFlexfecPayloadType = 120;
 const uint8_t CallTest::kAudioSendPayloadType = 103;
 const uint8_t CallTest::kPayloadTypeH264 = 122;
 const uint8_t CallTest::kPayloadTypeVP8 = 123;
 const uint8_t CallTest::kPayloadTypeVP9 = 124;
-const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = {0xBADCAFD, 0xBADCAFE,
-                                                     0xBADCAFF};
-const uint32_t CallTest::kVideoSendSsrcs[kNumSsrcs] = {0xC0FFED, 0xC0FFEE,
-                                                       0xC0FFEF};
+// const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = {0xBADCAFD, 0xBADCAFE,
+//                                                      0xBADCAFF};
+// const uint32_t CallTest::kVideoSendSsrcs[kNumSsrcs] = {0xC0FFED, 0xC0FFEE,
+//                                                        0xC0FFEF};
 const uint32_t CallTest::kAudioSendSsrc = 0xDEADBEEF;
 const uint32_t CallTest::kFlexfecSendSsrc = 0xBADBEEF;
 const uint32_t CallTest::kReceiverLocalVideoSsrc = 0x123456;
 const uint32_t CallTest::kReceiverLocalAudioSsrc = 0x1234567;
 const int CallTest::kNackRtpHistoryMs = 1000;
 
 const uint8_t CallTest::kDefaultKeepalivePayloadType =
     RtpKeepAliveConfig().payload_type;
 
 const std::map<uint8_t, MediaType> CallTest::payload_type_map_ = {
@@ skipping 113 matching lines @@
 
 EndToEndTest::EndToEndTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
 }
 
 bool EndToEndTest::ShouldCreateReceivers() const {
   return true;
 }
 
 }  // namespace test
 }  // namespace webrtc