Make CreateRtcLogStreamConfig() return a std::unique_ptr

webrtc/call/call.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.
  */
 
@@ skipping 75 matching lines @@
 }
 
 const int* FindKeyByValue(const std::map<int, int>& m, int v) {
   for (const auto& kv : m) {
     if (kv.second == v)
       return &kv.first;
   }
   return nullptr;
 }
 
-rtclog::StreamConfig CreateRtcLogStreamConfig(
+std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig(
     const VideoReceiveStream::Config& config) {
-  rtclog::StreamConfig rtclog_config;
-  rtclog_config.remote_ssrc = config.rtp.remote_ssrc;
-  rtclog_config.local_ssrc = config.rtp.local_ssrc;
-  rtclog_config.rtx_ssrc = config.rtp.rtx_ssrc;
-  rtclog_config.rtcp_mode = config.rtp.rtcp_mode;
-  rtclog_config.remb = config.rtp.remb;
-  rtclog_config.rtp_extensions = config.rtp.extensions;
+  auto rtclog_config = rtc::MakeUnique<rtclog::StreamConfig>();
+  rtclog_config->remote_ssrc = config.rtp.remote_ssrc;
+  rtclog_config->local_ssrc = config.rtp.local_ssrc;
+  rtclog_config->rtx_ssrc = config.rtp.rtx_ssrc;
+  rtclog_config->rtcp_mode = config.rtp.rtcp_mode;
+  rtclog_config->remb = config.rtp.remb;
+  rtclog_config->rtp_extensions = config.rtp.extensions;
 
   for (const auto& d : config.decoders) {
     const int* search =
         FindKeyByValue(config.rtp.rtx_associated_payload_types, d.payload_type);
-    rtclog_config.codecs.emplace_back(d.payload_name, d.payload_type,
+    rtclog_config->codecs.emplace_back(d.payload_name, d.payload_type,
                                       search ? *search : 0);
   }
   return rtclog_config;
 }
 
-rtclog::StreamConfig CreateRtcLogStreamConfig(
+std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig(
     const VideoSendStream::Config& config,
     size_t ssrc_index) {
-  rtclog::StreamConfig rtclog_config;
-  rtclog_config.local_ssrc = config.rtp.ssrcs[ssrc_index];
+  auto rtclog_config = rtc::MakeUnique<rtclog::StreamConfig>();
+  rtclog_config->local_ssrc = config.rtp.ssrcs[ssrc_index];
   if (ssrc_index < config.rtp.rtx.ssrcs.size()) {
-    rtclog_config.rtx_ssrc = config.rtp.rtx.ssrcs[ssrc_index];
+    rtclog_config->rtx_ssrc = config.rtp.rtx.ssrcs[ssrc_index];
   }
-  rtclog_config.rtcp_mode = config.rtp.rtcp_mode;
-  rtclog_config.rtp_extensions = config.rtp.extensions;
+  rtclog_config->rtcp_mode = config.rtp.rtcp_mode;
+  rtclog_config->rtp_extensions = config.rtp.extensions;
 
-  rtclog_config.codecs.emplace_back(config.encoder_settings.payload_name,
-                                    config.encoder_settings.payload_type,
-                                    config.rtp.rtx.payload_type);
+  rtclog_config->codecs.emplace_back(config.encoder_settings.payload_name,
+                                     config.encoder_settings.payload_type,
+                                     config.rtp.rtx.payload_type);
   return rtclog_config;
 }
 
-rtclog::StreamConfig CreateRtcLogStreamConfig(
+std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig(
     const AudioReceiveStream::Config& config) {
-  rtclog::StreamConfig rtclog_config;
-  rtclog_config.remote_ssrc = config.rtp.remote_ssrc;
-  rtclog_config.local_ssrc = config.rtp.local_ssrc;
-  rtclog_config.rtp_extensions = config.rtp.extensions;
+  auto rtclog_config = rtc::MakeUnique<rtclog::StreamConfig>();
+  rtclog_config->remote_ssrc = config.rtp.remote_ssrc;
+  rtclog_config->local_ssrc = config.rtp.local_ssrc;
+  rtclog_config->rtp_extensions = config.rtp.extensions;
   return rtclog_config;
 }
 
-rtclog::StreamConfig CreateRtcLogStreamConfig(
+std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig(
     const AudioSendStream::Config& config) {
-  rtclog::StreamConfig rtclog_config;
-  rtclog_config.local_ssrc = config.rtp.ssrc;
-  rtclog_config.rtp_extensions = config.rtp.extensions;
+  auto rtclog_config = rtc::MakeUnique<rtclog::StreamConfig>();
+  rtclog_config->local_ssrc = config.rtp.ssrc;
+  rtclog_config->rtp_extensions = config.rtp.extensions;
   if (config.send_codec_spec) {
-    rtclog_config.codecs.emplace_back(config.send_codec_spec->format.name,
-                                      config.send_codec_spec->payload_type, 0);
+    rtclog_config->codecs.emplace_back(config.send_codec_spec->format.name,
+                                       config.send_codec_spec->payload_type, 0);
   }
   return rtclog_config;
 }
 
 }  // namespace
 
 namespace internal {
 
 class Call : public webrtc::Call,
              public PacketReceiver,
@@ skipping 439 matching lines @@
 
 PacketReceiver* Call::Receiver() {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
   return this;
 }
 
 webrtc::AudioSendStream* Call::CreateAudioSendStream(
     const webrtc::AudioSendStream::Config& config) {
   TRACE_EVENT0("webrtc", "Call::CreateAudioSendStream");
   RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
-  event_log_->LogAudioSendStreamConfig(CreateRtcLogStreamConfig(config));
+  event_log_->LogAudioSendStreamConfig(*CreateRtcLogStreamConfig(config));
 
   rtc::Optional<RtpState> suspended_rtp_state;
   {
     const auto& iter = suspended_audio_send_ssrcs_.find(config.rtp.ssrc);
     if (iter != suspended_audio_send_ssrcs_.end()) {
       suspended_rtp_state.emplace(iter->second);
     }
   }
 
   AudioSendStream* send_stream = new AudioSendStream(
@@ skipping 45 matching lines @@
   }
   UpdateAggregateNetworkState();
   sent_rtp_audio_timer_ms_.Extend(audio_send_stream->GetActiveLifetime());
   delete send_stream;
 }
 
 webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream(
     const webrtc::AudioReceiveStream::Config& config) {
   TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream");
   RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
-  event_log_->LogAudioReceiveStreamConfig(CreateRtcLogStreamConfig(config));
+  event_log_->LogAudioReceiveStreamConfig(*CreateRtcLogStreamConfig(config));
   AudioReceiveStream* receive_stream = new AudioReceiveStream(
       &audio_receiver_controller_, transport_send_->packet_router(), config,
       config_.audio_state, event_log_);
   {
     WriteLockScoped write_lock(*receive_crit_);
     receive_rtp_config_[config.rtp.remote_ssrc] =
         ReceiveRtpConfig(config.rtp.extensions, UseSendSideBwe(config));
     audio_receive_streams_.insert(receive_stream);
 
     ConfigureSync(config.sync_group);
@@ skipping 40 matching lines @@
 webrtc::VideoSendStream* Call::CreateVideoSendStream(
     webrtc::VideoSendStream::Config config,
     VideoEncoderConfig encoder_config) {
   TRACE_EVENT0("webrtc", "Call::CreateVideoSendStream");
   RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
 
   video_send_delay_stats_->AddSsrcs(config);
   for (size_t ssrc_index = 0; ssrc_index < config.rtp.ssrcs.size();
        ++ssrc_index) {
     event_log_->LogVideoSendStreamConfig(
-        CreateRtcLogStreamConfig(config, ssrc_index));
+        *CreateRtcLogStreamConfig(config, ssrc_index));
   }
 
   // TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if
   // the call has already started.
   // Copy ssrcs from |config| since |config| is moved.
   std::vector<uint32_t> ssrcs = config.rtp.ssrcs;
   VideoSendStream* send_stream = new VideoSendStream(
       num_cpu_cores_, module_process_thread_.get(), &worker_queue_,
       call_stats_.get(), transport_send_.get(), bitrate_allocator_.get(),
       video_send_delay_stats_.get(), event_log_, std::move(config),
@@ skipping 69 matching lines @@
       // type, we may get an incorrect value for the rtx stream, but
       // that is unlikely to matter in practice.
       receive_rtp_config_[config.rtp.rtx_ssrc] = receive_config;
     }
     receive_rtp_config_[config.rtp.remote_ssrc] = receive_config;
     video_receive_streams_.insert(receive_stream);
     ConfigureSync(config.sync_group);
   }
   receive_stream->SignalNetworkState(video_network_state_);
   UpdateAggregateNetworkState();
-  event_log_->LogVideoReceiveStreamConfig(CreateRtcLogStreamConfig(config));
+  event_log_->LogVideoReceiveStreamConfig(*CreateRtcLogStreamConfig(config));
   return receive_stream;
 }
 
 void Call::DestroyVideoReceiveStream(
     webrtc::VideoReceiveStream* receive_stream) {
   TRACE_EVENT0("webrtc", "Call::DestroyVideoReceiveStream");
   RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
   RTC_DCHECK(receive_stream != nullptr);
   VideoReceiveStream* receive_stream_impl =
       static_cast<VideoReceiveStream*>(receive_stream);
@@ skipping 599 matching lines @@
       (use_send_side_bwe && header.extension.hasTransportSequenceNumber)) {
     receive_side_cc_.OnReceivedPacket(
         packet.arrival_time_ms(), packet.payload_size() + packet.padding_size(),
         header);
   }
 }
 
 }  // namespace internal
 
 }  // namespace webrtc