nit: Avoid pointer-to-unique_ptr in RtcEventLogImpl

webrtc/logging/rtc_event_log/rtc_event_log.cc

 /*
  *  Copyright (c) 2015 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 "webrtc/logging/rtc_event_log/rtc_event_log.h"
 
 #include <limits>
+#include <utility>
 #include <vector>
 
 #include "webrtc/logging/rtc_event_log/rtc_event_log_helper_thread.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/common_header.h"
@@ skipping 66 matching lines @@
                               int min_probes,
                               int min_bytes) override;
   void LogProbeResultSuccess(int id, int bitrate_bps) override;
   void LogProbeResultFailure(int id,
                              ProbeFailureReason failure_reason) override;
 
  private:
   // Private constructor to ensure that creation is done by RtcEventLog::Create.
   RtcEventLogImpl();
 
-  void StoreEvent(std::unique_ptr<rtclog::Event>* event);
+  void StoreEvent(std::unique_ptr<rtclog::Event> event);
   void LogProbeResult(int id,
                       rtclog::BweProbeResult::ResultType result,
                       int bitrate_bps);
 
   static volatile int log_count_;
 
   // Message queue for passing control messages to the logging thread.
   SwapQueue<RtcEventLogHelperThread::ControlMessage> message_queue_;
 
   // Message queue for passing events to the logging thread.
@@ skipping 181 matching lines @@
     rtclog::DecoderConfig* decoder = receiver_config->add_decoders();
     decoder->set_name(d.payload_name);
     decoder->set_payload_type(d.payload_type);
     if (d.rtx_payload_type != 0) {
       rtclog::RtxMap* rtx = receiver_config->add_rtx_map();
       rtx->set_payload_type(d.payload_type);
       rtx->mutable_config()->set_rtx_ssrc(config.rtx_ssrc);
       rtx->mutable_config()->set_rtx_payload_type(d.rtx_payload_type);
     }
   }
-  StoreEvent(&event);
+  StoreEvent(std::move(event));
 }
 
 void RtcEventLogImpl::LogVideoSendStreamConfig(
     const rtclog::StreamConfig& config) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(rtc::TimeMicros());
   event->set_type(rtclog::Event::VIDEO_SENDER_CONFIG_EVENT);
 
   rtclog::VideoSendConfig* sender_config = event->mutable_video_sender_config();
 
@@ skipping 18 matching lines @@
     encoder->set_name(codec.payload_name);
     encoder->set_payload_type(codec.payload_type);
 
     if (config.codecs.size() > 1) {
       LOG(WARNING) << "LogVideoSendStreamConfig currently only supports one "
                    << "codec. Logging codec :" << codec.payload_name;
       break;
     }
   }
 
-  StoreEvent(&event);
+  StoreEvent(std::move(event));
 }
 
 void RtcEventLogImpl::LogAudioReceiveStreamConfig(
     const rtclog::StreamConfig& config) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(rtc::TimeMicros());
   event->set_type(rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT);
 
   rtclog::AudioReceiveConfig* receiver_config =
       event->mutable_audio_receiver_config();
   receiver_config->set_remote_ssrc(config.remote_ssrc);
   receiver_config->set_local_ssrc(config.local_ssrc);
 
   for (const auto& e : config.rtp_extensions) {
     rtclog::RtpHeaderExtension* extension =
         receiver_config->add_header_extensions();
     extension->set_name(e.uri);
     extension->set_id(e.id);
   }
-  StoreEvent(&event);
+  StoreEvent(std::move(event));
 }
 
 void RtcEventLogImpl::LogAudioSendStreamConfig(
     const rtclog::StreamConfig& config) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(rtc::TimeMicros());
   event->set_type(rtclog::Event::AUDIO_SENDER_CONFIG_EVENT);
 
   rtclog::AudioSendConfig* sender_config = event->mutable_audio_sender_config();
 
   sender_config->set_ssrc(config.local_ssrc);
 
   for (const auto& e : config.rtp_extensions) {
     rtclog::RtpHeaderExtension* extension =
         sender_config->add_header_extensions();
     extension->set_name(e.uri);
     extension->set_id(e.id);
   }
 
-  StoreEvent(&event);
+  StoreEvent(std::move(event));
 }
 
 void RtcEventLogImpl::LogRtpHeader(PacketDirection direction,
                                    const uint8_t* header,
                                    size_t packet_length) {
   LogRtpHeader(direction, header, packet_length, PacedPacketInfo::kNotAProbe);
 }
 
 void RtcEventLogImpl::LogRtpHeader(PacketDirection direction,
                                    const uint8_t* header,
@@ skipping 16 matching lines @@
   }
 
   std::unique_ptr<rtclog::Event> rtp_event(new rtclog::Event());
   rtp_event->set_timestamp_us(rtc::TimeMicros());
   rtp_event->set_type(rtclog::Event::RTP_EVENT);
   rtp_event->mutable_rtp_packet()->set_incoming(direction == kIncomingPacket);
   rtp_event->mutable_rtp_packet()->set_packet_length(packet_length);
   rtp_event->mutable_rtp_packet()->set_header(header, header_length);
   if (probe_cluster_id != PacedPacketInfo::kNotAProbe)
     rtp_event->mutable_rtp_packet()->set_probe_cluster_id(probe_cluster_id);
-  StoreEvent(&rtp_event);
+  StoreEvent(std::move(rtp_event));
 }
 
 void RtcEventLogImpl::LogRtcpPacket(PacketDirection direction,
                                     const uint8_t* packet,
                                     size_t length) {
   std::unique_ptr<rtclog::Event> rtcp_event(new rtclog::Event());
   rtcp_event->set_timestamp_us(rtc::TimeMicros());
   rtcp_event->set_type(rtclog::Event::RTCP_EVENT);
   rtcp_event->mutable_rtcp_packet()->set_incoming(direction == kIncomingPacket);
 
@@ skipping 27 matching lines @@
       case rtcp::App::kPacketType:
       default:
         // We don't log sender descriptions, application defined messages
         // or message blocks of unknown type.
         break;
     }
 
     block_begin += block_size;
   }
   rtcp_event->mutable_rtcp_packet()->set_packet_data(buffer, buffer_length);
-  StoreEvent(&rtcp_event);
+  StoreEvent(std::move(rtcp_event));
 }
 
 void RtcEventLogImpl::LogAudioPlayout(uint32_t ssrc) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(rtc::TimeMicros());
   event->set_type(rtclog::Event::AUDIO_PLAYOUT_EVENT);
   auto playout_event = event->mutable_audio_playout_event();
   playout_event->set_local_ssrc(ssrc);
-  StoreEvent(&event);
+  StoreEvent(std::move(event));
 }
 
 void RtcEventLogImpl::LogLossBasedBweUpdate(int32_t bitrate_bps,
                                             uint8_t fraction_loss,
                                             int32_t total_packets) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(rtc::TimeMicros());
   event->set_type(rtclog::Event::LOSS_BASED_BWE_UPDATE);
   auto bwe_event = event->mutable_loss_based_bwe_update();
   bwe_event->set_bitrate_bps(bitrate_bps);
   bwe_event->set_fraction_loss(fraction_loss);
   bwe_event->set_total_packets(total_packets);
-  StoreEvent(&event);
+  StoreEvent(std::move(event));
 }
 
 void RtcEventLogImpl::LogDelayBasedBweUpdate(int32_t bitrate_bps,
                                              BandwidthUsage detector_state) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(rtc::TimeMicros());
   event->set_type(rtclog::Event::DELAY_BASED_BWE_UPDATE);
   auto bwe_event = event->mutable_delay_based_bwe_update();
   bwe_event->set_bitrate_bps(bitrate_bps);
   bwe_event->set_detector_state(ConvertDetectorState(detector_state));
-  StoreEvent(&event);
+  StoreEvent(std::move(event));
 }
 
 void RtcEventLogImpl::LogAudioNetworkAdaptation(
     const AudioEncoderRuntimeConfig& config) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(rtc::TimeMicros());
   event->set_type(rtclog::Event::AUDIO_NETWORK_ADAPTATION_EVENT);
   auto audio_network_adaptation = event->mutable_audio_network_adaptation();
   if (config.bitrate_bps)
     audio_network_adaptation->set_bitrate_bps(*config.bitrate_bps);
   if (config.frame_length_ms)
     audio_network_adaptation->set_frame_length_ms(*config.frame_length_ms);
   if (config.uplink_packet_loss_fraction) {
     audio_network_adaptation->set_uplink_packet_loss_fraction(
         *config.uplink_packet_loss_fraction);
   }
   if (config.enable_fec)
     audio_network_adaptation->set_enable_fec(*config.enable_fec);
   if (config.enable_dtx)
     audio_network_adaptation->set_enable_dtx(*config.enable_dtx);
   if (config.num_channels)
     audio_network_adaptation->set_num_channels(*config.num_channels);
-  StoreEvent(&event);
+  StoreEvent(std::move(event));
 }
 
 void RtcEventLogImpl::LogProbeClusterCreated(int id,
                                              int bitrate_bps,
                                              int min_probes,
                                              int min_bytes) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(rtc::TimeMicros());
   event->set_type(rtclog::Event::BWE_PROBE_CLUSTER_CREATED_EVENT);
 
   auto probe_cluster = event->mutable_probe_cluster();
   probe_cluster->set_id(id);
   probe_cluster->set_bitrate_bps(bitrate_bps);
   probe_cluster->set_min_packets(min_probes);
   probe_cluster->set_min_bytes(min_bytes);
-  StoreEvent(&event);
+  StoreEvent(std::move(event));
 }
 
 void RtcEventLogImpl::LogProbeResultSuccess(int id, int bitrate_bps) {
   LogProbeResult(id, rtclog::BweProbeResult::SUCCESS, bitrate_bps);
 }
 
 void RtcEventLogImpl::LogProbeResultFailure(int id,
                                             ProbeFailureReason failure_reason) {
   rtclog::BweProbeResult::ResultType result =
       ConvertProbeResultType(failure_reason);
   LogProbeResult(id, result, -1);
 }
 
 void RtcEventLogImpl::LogProbeResult(int id,
                                      rtclog::BweProbeResult::ResultType result,
                                      int bitrate_bps) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(rtc::TimeMicros());
   event->set_type(rtclog::Event::BWE_PROBE_RESULT_EVENT);
 
   auto probe_result = event->mutable_probe_result();
   probe_result->set_id(id);
   probe_result->set_result(result);
   if (result == rtclog::BweProbeResult::SUCCESS)
     probe_result->set_bitrate_bps(bitrate_bps);
-  StoreEvent(&event);
+  StoreEvent(std::move(event));
 }
 
-void RtcEventLogImpl::StoreEvent(std::unique_ptr<rtclog::Event>* event) {
-  RTC_DCHECK(event != nullptr);
-  RTC_DCHECK(event->get() != nullptr);
-  if (!event_queue_.Insert(event)) {
+void RtcEventLogImpl::StoreEvent(std::unique_ptr<rtclog::Event> event) {
+  RTC_DCHECK(event.get() != nullptr);
+  if (!event_queue_.Insert(&event)) {
     LOG(LS_ERROR) << "WebRTC event log queue full. Dropping event.";
   }
   helper_thread_.SignalNewEvent();
 }
 
 bool RtcEventLog::ParseRtcEventLog(const std::string& file_name,
                                    rtclog::EventStream* result) {
   char tmp_buffer[1024];
   int bytes_read = 0;
   std::unique_ptr<FileWrapper> dump_file(FileWrapper::Create());
@@ skipping 25 matching lines @@
 #else
   return std::unique_ptr<RtcEventLog>(new RtcEventLogNullImpl());
 #endif  // ENABLE_RTC_EVENT_LOG
 }
 
 std::unique_ptr<RtcEventLog> RtcEventLog::CreateNull() {
   return std::unique_ptr<RtcEventLog>(new RtcEventLogNullImpl());
 }
 
 }  // namespace webrtc