Event log cleanup in tests.

webrtc/video/end_to_end_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>
@@ skipping 123 matching lines @@
   void VerifyNewVideoSendStreamsRespectNetworkState(
       MediaType network_to_bring_up,
       VideoEncoder* encoder,
       Transport* transport);
   void VerifyNewVideoReceiveStreamsRespectNetworkState(
       MediaType network_to_bring_up,
       Transport* transport);
 };
 
 TEST_F(EndToEndTest, ReceiverCanBeStartedTwice) {
-  CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
+  CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, 0, &transport);
   CreateMatchingReceiveConfigs(&transport);
 
   CreateVideoStreams();
 
   video_receive_streams_[0]->Start();
   video_receive_streams_[0]->Start();
 
   DestroyStreams();
 }
 
 TEST_F(EndToEndTest, ReceiverCanBeStoppedTwice) {
-  CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
+  CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, 0, &transport);
   CreateMatchingReceiveConfigs(&transport);
 
   CreateVideoStreams();
 
   video_receive_streams_[0]->Stop();
   video_receive_streams_[0]->Stop();
 
   DestroyStreams();
 }
 
 TEST_F(EndToEndTest, ReceiverCanBeStoppedAndRestarted) {
-  CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
+  CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
 
   test::NullTransport transport;
   CreateSendConfig(1, 0, 0, &transport);
   CreateMatchingReceiveConfigs(&transport);
 
   CreateVideoStreams();
 
   video_receive_streams_[0]->Stop();
   video_receive_streams_[0]->Start();
   video_receive_streams_[0]->Stop();
@@ skipping 16 matching lines @@
     void OnFrame(const VideoFrame& video_frame) override {
       SleepMs(kRenderDelayMs);
       event_.Set();
     }
 
     bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
 
     rtc::Event event_;
   } renderer;
 
-  CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
+  CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
 
   test::DirectTransport sender_transport(
       sender_call_.get(), MediaType::VIDEO);
   test::DirectTransport receiver_transport(
       receiver_call_.get(), MediaType::VIDEO);
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, 0, 0, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
@@ skipping 29 matching lines @@
    public:
     Renderer() : event_(false, false) {}
 
     void OnFrame(const VideoFrame& video_frame) override { event_.Set(); }
 
     bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
 
     rtc::Event event_;
   } renderer;
 
-  CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
+  CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
 
   test::DirectTransport sender_transport(
       sender_call_.get(), MediaType::VIDEO);
   test::DirectTransport receiver_transport(
       receiver_call_.get(), MediaType::VIDEO);
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, 0, 0, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
@@ skipping 705 matching lines @@
       FakeNetworkPipe::Config config;
       config.queue_delay_ms = kNetworkDelayMs;
       return new test::PacketTransport(sender_call, this,
                                        test::PacketTransport::kSender,
                                        MediaType::VIDEO, config);
     }
 
     // TODO(holmer): Investigate why we don't send FEC packets when the bitrate
     // is 10 kbps.
     Call::Config GetSenderCallConfig() override {
-      Call::Config config(&event_log_);
+      Call::Config config(event_log_.get());
       const int kMinBitrateBps = 30000;
       config.bitrate_config.min_bitrate_bps = kMinBitrateBps;
       return config;
     }
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       // Configure hybrid NACK/FEC.
@@ skipping 313 matching lines @@
         EXPECT_EQ(DELIVERY_UNKNOWN_SSRC, delivery_status);
         delivered_packet_.Set();
         return delivery_status;
       }
     }
 
     PacketReceiver* receiver_;
     rtc::Event delivered_packet_;
   };
 
-  CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
+  CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
 
   test::DirectTransport send_transport(
       sender_call_.get(), MediaType::VIDEO);
   test::DirectTransport receive_transport(
       receiver_call_.get(), MediaType::VIDEO);
   PacketInputObserver input_observer(receiver_call_->Receiver());
   send_transport.SetReceiver(&input_observer);
   receive_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, 0, 0, &send_transport);
@@ skipping 607 matching lines @@
    private:
     std::unique_ptr<uint8_t[]> buffer_;
     size_t length_;
     FrameType frame_type_;
     rtc::Event called_;
   };
 
   EncodedFrameTestObserver post_encode_observer;
   EncodedFrameTestObserver pre_decode_observer;
 
-  CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
+  CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
 
   test::DirectTransport sender_transport(
       sender_call_.get(), MediaType::VIDEO);
   test::DirectTransport receiver_transport(
       receiver_call_.get(), MediaType::VIDEO);
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   CreateSendConfig(1, 0, 0, &sender_transport);
   CreateMatchingReceiveConfigs(&receiver_transport);
@@ skipping 154 matching lines @@
 
     test::PacketTransport* CreateReceiveTransport() override {
       receive_transport_ = new test::PacketTransport(
           nullptr, this, test::PacketTransport::kReceiver,
           MediaType::VIDEO,
           FakeNetworkPipe::Config());
       return receive_transport_;
     }
 
     Call::Config GetSenderCallConfig() override {
-      Call::Config config(&event_log_);
+      Call::Config config(event_log_.get());
       // Set a high start bitrate to reduce the test completion time.
       config.bitrate_config.start_bitrate_bps = remb_bitrate_bps_;
       return config;
     }
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       ASSERT_EQ(1u, send_config->rtp.ssrcs.size());
@@ skipping 89 matching lines @@
  public:
   explicit ProbingTest(int start_bitrate_bps)
       : clock_(Clock::GetRealTimeClock()),
         start_bitrate_bps_(start_bitrate_bps),
         state_(0),
         sender_call_(nullptr) {}
 
   ~ProbingTest() {}
 
   Call::Config GetSenderCallConfig() override {
-    Call::Config config(&event_log_);
+    Call::Config config(event_log_.get());
     config.bitrate_config.start_bitrate_bps = start_bitrate_bps_;
     return config;
   }
 
   void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
     sender_call_ = sender_call;
   }
 
  protected:
   Clock* const clock_;
@@ skipping 1406 matching lines @@
     SequenceNumberUnwrapper seq_numbers_unwrapper_;
     std::map<uint32_t, std::list<int64_t>> last_observed_seq_numbers_;
     std::map<uint32_t, uint32_t> last_observed_timestamp_;
     std::map<uint32_t, bool> ssrc_is_rtx_;
 
     rtc::CriticalSection crit_;
     size_t ssrcs_to_observe_ GUARDED_BY(crit_);
     std::map<uint32_t, bool> ssrc_observed_ GUARDED_BY(crit_);
   } observer(use_rtx);
 
-  Call::Config config(&event_log_);
+  Call::Config config(event_log_.get());
   CreateCalls(config, config);
 
   test::PacketTransport send_transport(sender_call_.get(), &observer,
                                        test::PacketTransport::kSender,
                                        MediaType::VIDEO,
                                        FakeNetworkPipe::Config());
   test::PacketTransport receive_transport(nullptr, &observer,
                                           test::PacketTransport::kReceiver,
                                           MediaType::VIDEO,
                                           FakeNetworkPipe::Config());
@@ skipping 277 matching lines @@
     int receiver_rtcp_ GUARDED_BY(test_crit_);
     int down_frames_ GUARDED_BY(test_crit_);
   } test;
 
   RunBaseTest(&test);
 }
 
 TEST_F(EndToEndTest, CallReportsRttForSender) {
   static const int kSendDelayMs = 30;
   static const int kReceiveDelayMs = 70;
-  CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
+  CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
 
   FakeNetworkPipe::Config config;
   config.queue_delay_ms = kSendDelayMs;
   test::DirectTransport sender_transport(
       config, sender_call_.get(), MediaType::VIDEO);
   config.queue_delay_ms = kReceiveDelayMs;
   test::DirectTransport receiver_transport(
       config, receiver_call_.get(), MediaType::VIDEO);
   sender_transport.SetReceiver(receiver_call_->Receiver());
   receiver_transport.SetReceiver(sender_call_->Receiver());
@@ skipping 26 matching lines @@
   receiver_transport.StopSending();
   Stop();
   DestroyStreams();
   DestroyCalls();
 }
 
 void EndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState(
     MediaType network_to_bring_up,
     VideoEncoder* encoder,
     Transport* transport) {
-  CreateSenderCall(Call::Config(&event_log_));
+  CreateSenderCall(Call::Config(event_log_.get()));
   sender_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
 
   CreateSendConfig(1, 0, 0, transport);
   video_send_config_.encoder_settings.encoder = encoder;
   CreateVideoStreams();
   CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
                                kDefaultHeight);
 
   Start();
   SleepMs(kSilenceTimeoutMs);
   Stop();
 
   DestroyStreams();
 }
 
 void EndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState(
     MediaType network_to_bring_up,
     Transport* transport) {
-  Call::Config config(&event_log_);
+  Call::Config config(event_log_.get());
   CreateCalls(config, config);
   receiver_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
 
   test::DirectTransport sender_transport(sender_call_.get(), MediaType::VIDEO);
   sender_transport.SetReceiver(receiver_call_->Receiver());
   CreateSendConfig(1, 0, 0, &sender_transport);
   CreateMatchingReceiveConfigs(transport);
   CreateVideoStreams();
   CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
                                kDefaultHeight);
@@ skipping 307 matching lines @@
     std::unique_ptr<VideoEncoder> encoder_;
     std::unique_ptr<VideoDecoder> decoder_;
     rtc::CriticalSection crit_;
     int recorded_frames_ GUARDED_BY(crit_);
   } test(this);
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc