Refactoring: move ownership of RtcEventLog from Call to PeerConnection

webrtc/video/video_send_stream_tests.cc

 /*
  *  Copyright (c) 2013 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.
  */
 #include <algorithm>  // max
@@ skipping 42 matching lines @@
  protected:
   void TestNackRetransmission(uint32_t retransmit_ssrc,
                               uint8_t retransmit_payload_type);
   void TestPacketFragmentationSize(VideoFormat format, bool with_fec);
 
   void TestVp9NonFlexMode(uint8_t num_temporal_layers,
                           uint8_t num_spatial_layers);
 };
 
 TEST_F(VideoSendStreamTest, CanStartStartedStream) {
+  webrtc::RtcEventLogNullImpl event_log;
   Call::Config call_config;
+  call_config.event_log = &event_log;
   CreateSenderCall(call_config);
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, &transport);
   CreateVideoStreams();
   video_send_stream_->Start();
   video_send_stream_->Start();
   DestroyStreams();
 }
 
 TEST_F(VideoSendStreamTest, CanStopStoppedStream) {
+  webrtc::RtcEventLogNullImpl event_log;
   Call::Config call_config;
+  call_config.event_log = &event_log;
   CreateSenderCall(call_config);
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, &transport);
   CreateVideoStreams();
   video_send_stream_->Stop();
   video_send_stream_->Stop();
   DestroyStreams();
 }
 
@@ skipping 645 matching lines @@
           current_size_frame_.Value() < static_cast<int32_t>(stop_size_)) {
         ++current_size_frame_;
       }
       encoder_.SetFrameSize(static_cast<size_t>(current_size_frame_.Value()));
     }
 
     Call::Config GetSenderCallConfig() override {
       Call::Config config;
       const int kMinBitrateBps = 30000;
       config.bitrate_config.min_bitrate_bps = kMinBitrateBps;
+      config.event_log = &event_log_;
       return config;
     }
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       transport_adapter_.reset(
           new internal::TransportAdapter(send_config->send_transport));
       transport_adapter_->Enable();
@@ skipping 11 matching lines @@
 
       // Make sure there is at least one extension header, to make the RTP
       // header larger than the base length of 12 bytes.
       EXPECT_FALSE(send_config->rtp.extensions.empty());
     }
 
     void PerformTest() override {
       EXPECT_TRUE(Wait()) << "Timed out while observing incoming RTP packets.";
     }
 
+    webrtc::RtcEventLogNullImpl event_log_;
     std::unique_ptr<internal::TransportAdapter> transport_adapter_;
     test::ConfigurableFrameSizeEncoder encoder_;
 
     const size_t max_packet_size_;
     const size_t stop_size_;
     const bool test_generic_packetization_;
     const bool use_fec_;
 
     uint32_t packet_count_;
     size_t accumulated_size_;
@@ skipping 649 matching lines @@
       return 0;
     }
 
     rtc::CriticalSection crit_;
     rtc::Event init_encode_called_;
     size_t number_of_initializations_ GUARDED_BY(&crit_);
     int last_initialized_frame_width_ GUARDED_BY(&crit_);
     int last_initialized_frame_height_ GUARDED_BY(&crit_);
   };
 
-  CreateSenderCall(Call::Config());
+  webrtc::RtcEventLogNullImpl event_log;
+  Call::Config call_config;
+  call_config.event_log = &event_log;
+  CreateSenderCall(call_config);
   test::NullTransport transport;
   CreateSendConfig(1, 0, &transport);
   EncoderObserver encoder;
   video_send_config_.encoder_settings.encoder = &encoder;
   CreateVideoStreams();
   CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
                                kDefaultHeight);
   frame_generator_capturer_->Start();
 
   encoder.WaitForResolution(kDefaultWidth, kDefaultHeight);
@@ skipping 35 matching lines @@
       return start_bitrate_changed_.Wait(
           VideoSendStreamTest::kDefaultTimeoutMs);
     }
 
    private:
     rtc::CriticalSection crit_;
     rtc::Event start_bitrate_changed_;
     int start_bitrate_kbps_ GUARDED_BY(crit_);
   };
 
-  CreateSenderCall(Call::Config());
+  webrtc::RtcEventLogNullImpl event_log;
+  Call::Config call_config;
+  call_config.event_log = &event_log;
+  CreateSenderCall(call_config);
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, &transport);
 
   Call::Config::BitrateConfig bitrate_config;
   bitrate_config.start_bitrate_bps = 2 * video_encoder_config_.max_bitrate_bps;
   sender_call_->SetBitrateConfig(bitrate_config);
 
   StartBitrateObserver encoder;
   video_send_config_.encoder_settings.encoder = &encoder;
@@ skipping 60 matching lines @@
       return bitrate_changed_.Wait(VideoSendStreamTest::kDefaultTimeoutMs);
     }
 
    private:
     rtc::CriticalSection crit_;
     rtc::Event encoder_init_;
     rtc::Event bitrate_changed_;
     int bitrate_kbps_ GUARDED_BY(crit_);
   };
 
-  CreateSenderCall(Call::Config());
+  webrtc::RtcEventLogNullImpl event_log;
+  Call::Config call_config;
+  call_config.event_log = &event_log;
+  CreateSenderCall(call_config);
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, &transport);
 
   StartStopBitrateObserver encoder;
   video_send_config_.encoder_settings.encoder = &encoder;
   video_send_config_.encoder_settings.internal_source = true;
 
   CreateVideoStreams();
 
@@ skipping 34 matching lines @@
 
    private:
     // Delivered output frames.
     std::vector<VideoFrame> output_frames_;
 
     // Indicate an output frame has arrived.
     rtc::Event output_frame_event_;
   };
 
   // Initialize send stream.
-  CreateSenderCall(Call::Config());
+  webrtc::RtcEventLogNullImpl event_log;
+  Call::Config call_config;
+  call_config.event_log = &event_log;
+  CreateSenderCall(call_config);
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, &transport);
   FrameObserver observer;
   video_send_config_.pre_encode_callback = &observer;
   CreateVideoStreams();
 
   // Prepare five input frames. Send ordinary VideoFrame and texture frames
   // alternatively.
   std::vector<VideoFrame> input_frames;
@@ skipping 619 matching lines @@
     void WaitForSetRates(uint32_t expected_bitrate) {
       EXPECT_TRUE(
           bitrate_changed_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs))
           << "Timed out while waiting encoder rate to be set.";
       rtc::CritScope lock(&crit_);
       EXPECT_EQ(expected_bitrate, target_bitrate_);
     }
 
     Call::Config GetSenderCallConfig() override {
       Call::Config config;
+      config.event_log = &event_log_;
       config.bitrate_config.min_bitrate_bps = kMinBitrateKbps * 1000;
       config.bitrate_config.start_bitrate_bps = kStartBitrateKbps * 1000;
       config.bitrate_config.max_bitrate_bps = kMaxBitrateKbps * 1000;
       return config;
     }
 
     class VideoStreamFactory
         : public VideoEncoderConfig::VideoStreamFactoryInterface {
      public:
       explicit VideoStreamFactory(int min_bitrate_bps)
@@ skipping 61 matching lines @@
       send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());
       ASSERT_TRUE(
           init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));
       EXPECT_EQ(4, num_initializations_)
           << "Encoder should have been reconfigured with the new value.";
       // Expected target bitrate is the start bitrate set in the call to
       // call_->SetBitrateConfig.
       WaitForSetRates(kIncreasedStartBitrateKbps);
     }
 
+    webrtc::RtcEventLogNullImpl event_log_;
     rtc::Event init_encode_event_;
     rtc::Event bitrate_changed_event_;
     rtc::CriticalSection crit_;
     uint32_t target_bitrate_ GUARDED_BY(&crit_);
 
     int num_initializations_;
     webrtc::Call* call_;
     webrtc::VideoSendStream* send_stream_;
     webrtc::VideoEncoderConfig encoder_config_;
   } test;
@@ skipping 526 matching lines @@
         observation_complete_.Set();
       }
     }
   } test;
 
   RunBaseTest(&test);
 }
 #endif  // !defined(RTC_DISABLE_VP9)
 
 }  // namespace webrtc