Separates send and receive event log in CallTest.

This makes it possible to use them in VideoQualityTest and prepares for
allowing saving logs in other tests as well.

Bug: webrtc:9510
Change-Id: I3b1cc187d88e4f17745414433c2f96efd836a302
Reviewed-on: https://webrtc-review.googlesource.com/88561
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23964}

call/bitrate_estimator_tests.cc

@@ -103,9 +103,7 @@ class BitrateEstimatorTest : public test::CallTest {
 
   virtual void SetUp() {
     task_queue_.SendTask([this]() {
-      Call::Config config(event_log_.get());
-      receiver_call_.reset(Call::Create(config));
-      sender_call_.reset(Call::Create(config));
+      CreateCalls();
 
       send_transport_.reset(new test::DirectTransport(
           &task_queue_, sender_call_.get(), payload_type_map_));
@@ -145,8 +143,7 @@ class BitrateEstimatorTest : public test::CallTest {
       send_transport_.reset();
       receive_transport_.reset();
 
-      receiver_call_.reset();
-      sender_call_.reset();
+      DestroyCalls();
     });
   }
 
@@ -224,8 +221,6 @@ class BitrateEstimatorTest : public test::CallTest {
   LogObserver receiver_log_;
   std::unique_ptr<test::DirectTransport> send_transport_;
   std::unique_ptr<test::DirectTransport> receive_transport_;
-  std::unique_ptr<Call> sender_call_;
-  std::unique_ptr<Call> receiver_call_;
   VideoReceiveStream::Config receive_config_;
   std::vector<Stream*> streams_;
 };

call/call_perf_tests.cc

@@ -179,12 +179,12 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
     send_audio_state_config.audio_processing =
         AudioProcessingBuilder().Create();
     send_audio_state_config.audio_device_module = fake_audio_device;
-    Call::Config sender_config(event_log_.get());
+    Call::Config sender_config(send_event_log_.get());
 
     auto audio_state = AudioState::Create(send_audio_state_config);
     fake_audio_device->RegisterAudioCallback(audio_state->audio_transport());
     sender_config.audio_state = audio_state;
-    Call::Config receiver_config(event_log_.get());
+    Call::Config receiver_config(recv_event_log_.get());
     receiver_config.audio_state = audio_state;
     CreateCalls(sender_config, receiver_config);
 

test/call_test.cc

@@ -32,7 +32,8 @@ const int kVideoRotationRtpExtensionId = 4;
 
 CallTest::CallTest()
     : clock_(Clock::GetRealTimeClock()),
-      event_log_(RtcEventLog::CreateNull()),
+      send_event_log_(RtcEventLog::CreateNull()),
+      recv_event_log_(RtcEventLog::CreateNull()),
       sender_call_transport_controller_(nullptr),
       video_send_config_(nullptr),
       video_send_stream_(nullptr),
@@ -170,12 +171,21 @@ void CallTest::RunBaseTest(BaseTest* test) {
   });
 }
 
+void CallTest::CreateCalls() {
+  CreateCalls(Call::Config(send_event_log_.get()),
+              Call::Config(recv_event_log_.get()));
+}
+
 void CallTest::CreateCalls(const Call::Config& sender_config,
                            const Call::Config& receiver_config) {
   CreateSenderCall(sender_config);
   CreateReceiverCall(receiver_config);
 }
 
+void CallTest::CreateSenderCall() {
+  CreateSenderCall(Call::Config(send_event_log_.get()));
+}
+
 void CallTest::CreateSenderCall(const Call::Config& config) {
   std::unique_ptr<RtpTransportControllerSend> controller_send =
       absl::make_unique<RtpTransportControllerSend>(

test/call_test.h

@@ -70,8 +70,10 @@ class CallTest : public ::testing::Test {
   // to simplify test code.
   void RunBaseTest(BaseTest* test);
 
+  void CreateCalls();
   void CreateCalls(const Call::Config& sender_config,
                    const Call::Config& receiver_config);
+  void CreateSenderCall();
   void CreateSenderCall(const Call::Config& config);
   void CreateReceiverCall(const Call::Config& config);
   void DestroyCalls();
@@ -118,7 +120,8 @@ class CallTest : public ::testing::Test {
 
   Clock* const clock_;
 
-  std::unique_ptr<webrtc::RtcEventLog> event_log_;
+  std::unique_ptr<webrtc::RtcEventLog> send_event_log_;
+  std::unique_ptr<webrtc::RtcEventLog> recv_event_log_;
   std::unique_ptr<Call> sender_call_;
   RtpTransportControllerSend* sender_call_transport_controller_;
   std::unique_ptr<PacketTransport> send_transport_;

video/end_to_end_tests/call_operation_tests.cc

@@ -35,7 +35,7 @@ INSTANTIATE_TEST_CASE_P(
                       "WebRTC-TaskQueueCongestionControl/Enabled/"));
 
 TEST_P(CallOperationEndToEndTest, ReceiverCanBeStartedTwice) {
-  CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
+  CreateCalls();
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, 0, &transport);
@@ -50,7 +50,7 @@ TEST_P(CallOperationEndToEndTest, ReceiverCanBeStartedTwice) {
 }
 
 TEST_P(CallOperationEndToEndTest, ReceiverCanBeStoppedTwice) {
-  CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
+  CreateCalls();
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, 0, &transport);
@@ -65,7 +65,7 @@ TEST_P(CallOperationEndToEndTest, ReceiverCanBeStoppedTwice) {
 }
 
 TEST_P(CallOperationEndToEndTest, ReceiverCanBeStoppedAndRestarted) {
-  CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
+  CreateCalls();
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, 0, &transport);
@@ -108,7 +108,7 @@ TEST_P(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
 
   task_queue_.SendTask([this, &renderer, &frame_forwarder, &sender_transport,
                         &receiver_transport]() {
-    CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
+    CreateCalls();
 
     sender_transport = absl::make_unique<test::DirectTransport>(
         &task_queue_, sender_call_.get(), payload_type_map_);
@@ -168,7 +168,7 @@ TEST_P(CallOperationEndToEndTest, TransmitsFirstFrame) {
 
   task_queue_.SendTask([this, &renderer, &frame_generator, &frame_forwarder,
                         &sender_transport, &receiver_transport]() {
-    CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
+    CreateCalls();
 
     sender_transport = absl::make_unique<test::DirectTransport>(
         &task_queue_, sender_call_.get(), payload_type_map_);
@@ -235,7 +235,7 @@ TEST_P(CallOperationEndToEndTest, ObserversEncodedFrames) {
   std::unique_ptr<test::DirectTransport> receiver_transport;
 
   task_queue_.SendTask([&]() {
-    CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
+    CreateCalls();
 
     sender_transport = absl::make_unique<test::DirectTransport>(
         &task_queue_, sender_call_.get(), payload_type_map_);

video/end_to_end_tests/multi_codec_receive_tests.cc

@@ -144,8 +144,7 @@ class MultiCodecReceiveTest : public test::CallTest {
  public:
   MultiCodecReceiveTest() {
     task_queue_.SendTask([this]() {
-      Call::Config config(event_log_.get());
-      CreateCalls(config, config);
+      CreateCalls();
 
       send_transport_.reset(new test::PacketTransport(
           &task_queue_, sender_call_.get(), &observer_,

video/end_to_end_tests/network_state_tests.cc

@@ -83,7 +83,7 @@ void NetworkStateEndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState(
 
   task_queue_.SendTask([this, network_to_bring_up, &encoder_factory,
                         transport]() {
-    CreateSenderCall(Call::Config(event_log_.get()));
+    CreateSenderCall(Call::Config(send_event_log_.get()));
     sender_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
 
     CreateSendConfig(1, 0, 0, transport);
@@ -111,8 +111,7 @@ void NetworkStateEndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState(
 
   task_queue_.SendTask([this, &sender_transport, network_to_bring_up,
                         transport]() {
-    Call::Config config(event_log_.get());
-    CreateCalls(config, config);
+    CreateCalls();
     receiver_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
     sender_transport = absl::make_unique<test::DirectTransport>(
         &task_queue_, sender_call_.get(), payload_type_map_);

video/end_to_end_tests/rtp_rtcp_tests.cc

@@ -268,12 +268,11 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation(
   std::unique_ptr<test::PacketTransport> send_transport;
   std::unique_ptr<test::PacketTransport> receive_transport;
 
-  Call::Config config(event_log_.get());
   VideoEncoderConfig one_stream;
 
   task_queue_.SendTask([this, &observer, &send_transport, &receive_transport,
-                        &config, &one_stream, use_rtx]() {
-    CreateCalls(config, config);
+                        &one_stream, use_rtx]() {
+    CreateCalls();
 
     send_transport = absl::make_unique<test::PacketTransport>(
         &task_queue_, sender_call_.get(), &observer,
@@ -464,15 +463,13 @@ TEST_F(RtpRtcpEndToEndTest, TestFlexfecRtpStatePreservation) {
   static constexpr int kFrameMaxHeight = 180;
   static constexpr int kFrameRate = 15;
 
-  Call::Config config(event_log_.get());
-
   std::unique_ptr<test::PacketTransport> send_transport;
   std::unique_ptr<test::PacketTransport> receive_transport;
   test::FunctionVideoEncoderFactory encoder_factory(
       []() { return VP8Encoder::Create(); });
 
   task_queue_.SendTask([&]() {
-    CreateCalls(config, config);
+    CreateCalls();
 
     FakeNetworkPipe::Config lossy_delayed_link;
     lossy_delayed_link.loss_percent = 2;

video/end_to_end_tests/ssrc_tests.cc

@@ -75,7 +75,7 @@ TEST_F(SsrcEndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
 
   task_queue_.SendTask([this, &send_transport, &receive_transport,
                         &input_observer]() {
-    CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
+    CreateCalls();
 
     send_transport = absl::make_unique<test::DirectTransport>(
         &task_queue_, sender_call_.get(), payload_type_map_);

video/end_to_end_tests/stats_tests.cc

@@ -711,7 +711,7 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
   task_queue_.SendTask([this, &sender_transport, &receiver_transport]() {
     FakeNetworkPipe::Config config;
     config.queue_delay_ms = kSendDelayMs;
-    CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
+    CreateCalls();
     sender_transport = absl::make_unique<test::DirectTransport>(
         &task_queue_, config, sender_call_.get(), payload_type_map_);
     config.queue_delay_ms = kReceiveDelayMs;

video/picture_id_tests.cc

@@ -282,8 +282,7 @@ void PictureIdTest::SetupEncoder(VideoEncoderFactory* encoder_factory,
       new PictureIdObserver(PayloadStringToCodecType(payload_name)));
 
   task_queue_.SendTask([this, encoder_factory, payload_name]() {
-    Call::Config config(event_log_.get());
-    CreateCalls(config, config);
+    CreateCalls();
 
     send_transport_.reset(new test::PacketTransport(
         &task_queue_, sender_call_.get(), observer_.get(),

video/video_quality_test.cc

@@ -1048,8 +1048,6 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
 
   analyzer->Wait();
 
-  event_log_->StopLogging();
-
   task_queue_.SendTask([&]() {
     for (std::unique_ptr<test::VideoCapturer>& video_caputurer :
          thumbnail_capturers_)
@@ -1128,6 +1126,7 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
   std::unique_ptr<test::VideoRenderer> local_preview;
   std::vector<std::unique_ptr<test::VideoRenderer>> loopback_renderers;
   AudioReceiveStream* audio_receive_stream = nullptr;
+  RtcEventLogNullImpl null_event_log;
 
   task_queue_.SendTask([&]() {
     params_ = params;
@@ -1135,7 +1134,7 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
 
     // TODO(ivica): Remove bitrate_config and use the default Call::Config(), to
     // match the full stack tests.
-    Call::Config call_config(event_log_.get());
+    Call::Config call_config(&null_event_log);
     call_config.bitrate_config = params_.call.call_bitrate_config;
 
     rtc::scoped_refptr<TestAudioDeviceModule> fake_audio_device =

video/video_quality_test.h

@@ -119,9 +119,6 @@ class VideoQualityTest :
       DegradationPreference::MAINTAIN_FRAMERATE;
   Params params_;
 
-  std::unique_ptr<webrtc::RtcEventLog> recv_event_log_;
-  std::unique_ptr<webrtc::RtcEventLog> send_event_log_;
-
   size_t num_video_streams_;
 };
 

video/video_send_stream_tests.cc

@@ -90,7 +90,7 @@ class VideoSendStreamTest : public test::CallTest {
 
 TEST_F(VideoSendStreamTest, CanStartStartedStream) {
   task_queue_.SendTask([this]() {
-    CreateSenderCall(Call::Config(event_log_.get()));
+    CreateSenderCall();
 
     test::NullTransport transport;
     CreateSendConfig(1, 0, 0, &transport);
@@ -104,7 +104,7 @@ TEST_F(VideoSendStreamTest, CanStartStartedStream) {
 
 TEST_F(VideoSendStreamTest, CanStopStoppedStream) {
   task_queue_.SendTask([this]() {
-    CreateSenderCall(Call::Config(event_log_.get()));
+    CreateSenderCall();
 
     test::NullTransport transport;
     CreateSendConfig(1, 0, 0, &transport);
@@ -1937,7 +1937,7 @@ TEST_F(VideoSendStreamTest,
   test::EncoderProxyFactory encoder_factory(&encoder);
 
   task_queue_.SendTask([this, &transport, &encoder_factory]() {
-    CreateSenderCall(Call::Config(event_log_.get()));
+    CreateSenderCall();
     CreateSendConfig(1, 0, 0, &transport);
     video_send_config_.encoder_settings.encoder_factory = &encoder_factory;
     CreateVideoStreams();
@@ -2000,7 +2000,7 @@ TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
     int start_bitrate_kbps_ RTC_GUARDED_BY(crit_);
   };
 
-  CreateSenderCall(Call::Config(event_log_.get()));
+  CreateSenderCall();
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, 0, &transport);
@@ -2099,7 +2099,7 @@ TEST_F(VideoSendStreamTest, VideoSendStreamStopSetEncoderRateToZero) {
   test::FrameForwarder forwarder;
 
   task_queue_.SendTask([this, &transport, &encoder_factory, &forwarder]() {
-    CreateSenderCall(Call::Config(event_log_.get()));
+    CreateSenderCall();
     CreateSendConfig(1, 0, 0, &transport);
 
     sender_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
@@ -2141,7 +2141,7 @@ TEST_F(VideoSendStreamTest, VideoSendStreamUpdateActiveSimulcastLayers) {
   test::FrameForwarder forwarder;
 
   task_queue_.SendTask([this, &transport, &encoder_factory, &forwarder]() {
-    CreateSenderCall(Call::Config(event_log_.get()));
+    CreateSenderCall();
     // Create two simulcast streams.
     CreateSendConfig(2, 0, 0, &transport);
 
@@ -2228,7 +2228,7 @@ TEST_F(VideoSendStreamTest, CapturesTextureAndVideoFrames) {
 
   task_queue_.SendTask([this, &transport, &observer, &input_frames]() {
     // Initialize send stream.
-    CreateSenderCall(Call::Config(event_log_.get()));
+    CreateSenderCall();
 
     CreateSendConfig(1, 0, 0, &transport);
     video_send_config_.pre_encode_callback = &observer;
@@ -3600,7 +3600,7 @@ TEST_F(VideoSendStreamTest, MAYBE_Vp9FlexModeRefCount) {
 
 void VideoSendStreamTest::TestRequestSourceRotateVideo(
     bool support_orientation_ext) {
-  CreateSenderCall(Call::Config(event_log_.get()));
+  CreateSenderCall();
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, 0, &transport);