Take ownership and close the platform file even if we fail to start logging.

webrtc/call/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.
  */
 
@@ skipping 31 matching lines @@
 
 // No-op implementation if flag is not set.
 class RtcEventLogNullImpl final : public RtcEventLog {
  public:
   bool StartLogging(const std::string& file_name,
                     int64_t max_size_bytes) override {
     return false;
   }
   bool StartLogging(rtc::PlatformFile platform_file,
                     int64_t max_size_bytes) override {
+    // The platform_file is open and needs to be closed.
+    if (!rtc::ClosePlatformFile(platform_file)) {
+      LOG(LS_ERROR) << "Can't close file.";
+    }
     return false;
   }
   void StopLogging() override {}
   void LogVideoReceiveStreamConfig(
       const VideoReceiveStream::Config& config) override {}
   void LogVideoSendStreamConfig(
       const VideoSendStream::Config& config) override {}
   void LogRtpHeader(PacketDirection direction,
                     MediaType media_type,
                     const uint8_t* header,
@@ skipping 121 matching lines @@
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RtcEventLogHelperThread::ControlMessage message;
   message.message_type = RtcEventLogHelperThread::ControlMessage::START_FILE;
   message.max_size_bytes = max_size_bytes <= 0
                                ? std::numeric_limits<int64_t>::max()
                                : max_size_bytes;
   message.start_time = clock_->TimeInMicroseconds();
   message.stop_time = std::numeric_limits<int64_t>::max();
   message.file.reset(FileWrapper::Create());
   if (message.file->OpenFile(file_name.c_str(), false) != 0) {
+    LOG(LS_ERROR) << "Can't open file. WebRTC event log not started.";
     return false;
   }
   if (!message_queue_.Insert(&message)) {
-    LOG(LS_WARNING) << "Message queue full. Can't start logging.";
+    LOG(LS_ERROR) << "Message queue full. Can't start logging.";
     return false;
   }
+  LOG(LS_INFO) << "Starting WebRTC event log.";
   return true;
 }
 
 bool RtcEventLogImpl::StartLogging(rtc::PlatformFile platform_file,
                                    int64_t max_size_bytes) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RtcEventLogHelperThread::ControlMessage message;
   message.message_type = RtcEventLogHelperThread::ControlMessage::START_FILE;
   message.max_size_bytes = max_size_bytes <= 0
                                ? std::numeric_limits<int64_t>::max()
                                : max_size_bytes;
   message.start_time = clock_->TimeInMicroseconds();
   message.stop_time = std::numeric_limits<int64_t>::max();
   message.file.reset(FileWrapper::Create());
   FILE* file_handle = rtc::FdopenPlatformFileForWriting(platform_file);
   if (!file_handle) {
+    LOG(LS_ERROR) << "Can't open file. WebRTC event log not started.";
+    // Even though we failed to open a FILE*, the platform_file is still open
+    // and needs to be closed.
+    if (!rtc::ClosePlatformFile(platform_file)) {
+      LOG(LS_ERROR) << "Can't close file.";
+    }
     return false;
   }
   if (message.file->OpenFromFileHandle(file_handle, true, false) != 0) {
+    LOG(LS_ERROR) << "Can't open file. WebRTC event log not started.";
     return false;
   }
   if (!message_queue_.Insert(&message)) {

[pbos-webrtc, 2016/05/26 21:22:40]

Side note, should this ever happen? That seems scary.

-    LOG(LS_WARNING) << "Message queue full. Can't start logging.";
+    LOG(LS_ERROR) << "Message queue full. Can't start logging.";
     return false;
   }
+  LOG(LS_INFO) << "Starting WebRTC event log.";
   return true;
 }
 
 void RtcEventLogImpl::StopLogging() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RtcEventLogHelperThread::ControlMessage message;
   message.message_type = RtcEventLogHelperThread::ControlMessage::STOP_FILE;
   message.stop_time = clock_->TimeInMicroseconds();
   while (!message_queue_.Insert(&message)) {
     // TODO(terelius): We would like to have a blocking Insert function in the
     // SwapQueue, but for the time being we will just clear any previous
     // messages.
     // Since StopLogging waits for the thread, it is essential that we don't
     // clear any STOP_FILE messages. To ensure that there is only one call at a
     // time, we require that all calls to StopLogging are made on the same
     // thread.
-    LOG(LS_WARNING) << "Message queue full. Clearing queue to stop logging.";
+    LOG(LS_ERROR) << "Message queue full. Clearing queue to stop logging.";
     message_queue_.Clear();
   }
+  LOG(LS_INFO) << "Stopping WebRTC event log.";
   wake_up_.Set();                       // Request the output thread to wake up.
   stopped_.Wait(rtc::Event::kForever);  // Wait for the log to stop.
 }
 
 void RtcEventLogImpl::LogVideoReceiveStreamConfig(
     const VideoReceiveStream::Config& config) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(clock_->TimeInMicroseconds());
   event->set_type(rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT);
 
@@ skipping 18 matching lines @@
     extension->set_name(e.name);
     extension->set_id(e.id);
   }
 
   for (const auto& d : config.decoders) {
     rtclog::DecoderConfig* decoder = receiver_config->add_decoders();
     decoder->set_name(d.payload_name);
     decoder->set_payload_type(d.payload_type);
   }
   if (!event_queue_.Insert(&event)) {
-    LOG(LS_WARNING) << "Config queue full. Not logging config event.";
+    LOG(LS_ERROR) << "Config queue full. Not logging config event.";
   }
 }
 
 void RtcEventLogImpl::LogVideoSendStreamConfig(
     const VideoSendStream::Config& config) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(clock_->TimeInMicroseconds());
   event->set_type(rtclog::Event::VIDEO_SENDER_CONFIG_EVENT);
 
   rtclog::VideoSendConfig* sender_config = event->mutable_video_sender_config();
@@ skipping 11 matching lines @@
 
   for (const auto& rtx_ssrc : config.rtp.rtx.ssrcs) {
     sender_config->add_rtx_ssrcs(rtx_ssrc);
   }
   sender_config->set_rtx_payload_type(config.rtp.rtx.payload_type);
 
   rtclog::EncoderConfig* encoder = sender_config->mutable_encoder();
   encoder->set_name(config.encoder_settings.payload_name);
   encoder->set_payload_type(config.encoder_settings.payload_type);
   if (!event_queue_.Insert(&event)) {
-    LOG(LS_WARNING) << "Config queue full. Not logging config event.";
+    LOG(LS_ERROR) << "Config queue full. Not logging config event.";
   }
 }
 
 void RtcEventLogImpl::LogRtpHeader(PacketDirection direction,
                                    MediaType media_type,
                                    const uint8_t* header,
                                    size_t packet_length) {
   // Read header length (in bytes) from packet data.
   if (packet_length < 12u) {
     return;  // Don't read outside the packet.
@@ skipping 11 matching lines @@
   }
 
   std::unique_ptr<rtclog::Event> rtp_event(new rtclog::Event());
   rtp_event->set_timestamp_us(clock_->TimeInMicroseconds());
   rtp_event->set_type(rtclog::Event::RTP_EVENT);
   rtp_event->mutable_rtp_packet()->set_incoming(direction == kIncomingPacket);
   rtp_event->mutable_rtp_packet()->set_type(ConvertMediaType(media_type));
   rtp_event->mutable_rtp_packet()->set_packet_length(packet_length);
   rtp_event->mutable_rtp_packet()->set_header(header, header_length);
   if (!event_queue_.Insert(&rtp_event)) {
-    LOG(LS_WARNING) << "RTP queue full. Not logging RTP packet.";
+    LOG(LS_ERROR) << "RTP queue full. Not logging RTP packet.";
   }
 }
 
 void RtcEventLogImpl::LogRtcpPacket(PacketDirection direction,
                                     MediaType media_type,
                                     const uint8_t* packet,
                                     size_t length) {
   std::unique_ptr<rtclog::Event> rtcp_event(new rtclog::Event());
   rtcp_event->set_timestamp_us(clock_->TimeInMicroseconds());
   rtcp_event->set_type(rtclog::Event::RTCP_EVENT);
@@ skipping 39 matching lines @@
       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);
   if (!event_queue_.Insert(&rtcp_event)) {
-    LOG(LS_WARNING) << "RTCP queue full. Not logging RTCP packet.";
+    LOG(LS_ERROR) << "RTCP queue full. Not logging RTCP packet.";
   }
 }
 
 void RtcEventLogImpl::LogAudioPlayout(uint32_t ssrc) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(clock_->TimeInMicroseconds());
   event->set_type(rtclog::Event::AUDIO_PLAYOUT_EVENT);
   auto playout_event = event->mutable_audio_playout_event();
   playout_event->set_local_ssrc(ssrc);
   if (!event_queue_.Insert(&event)) {
-    LOG(LS_WARNING) << "Playout queue full. Not logging ACM playout.";
+    LOG(LS_ERROR) << "Playout queue full. Not logging ACM playout.";
   }
 }
 
 void RtcEventLogImpl::LogBwePacketLossEvent(int32_t bitrate,
                                             uint8_t fraction_loss,
                                             int32_t total_packets) {
   std::unique_ptr<rtclog::Event> event(new rtclog::Event());
   event->set_timestamp_us(clock_->TimeInMicroseconds());
   event->set_type(rtclog::Event::BWE_PACKET_LOSS_EVENT);
   auto bwe_event = event->mutable_bwe_packet_loss_event();
   bwe_event->set_bitrate(bitrate);
   bwe_event->set_fraction_loss(fraction_loss);
   bwe_event->set_total_packets(total_packets);
   if (!event_queue_.Insert(&event)) {
-    LOG(LS_WARNING) << "BWE loss queue full. Not logging BWE update.";
+    LOG(LS_ERROR) << "BWE loss queue full. Not logging BWE update.";
   }
 }
 
 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());
   if (dump_file->OpenFile(file_name.c_str(), true) != 0) {
     return false;
@@ skipping 11 matching lines @@
 // RtcEventLog member functions.
 std::unique_ptr<RtcEventLog> RtcEventLog::Create(const Clock* clock) {
 #ifdef ENABLE_RTC_EVENT_LOG
   return std::unique_ptr<RtcEventLog>(new RtcEventLogImpl(clock));
 #else
   return std::unique_ptr<RtcEventLog>(new RtcEventLogNullImpl());
 #endif  // ENABLE_RTC_EVENT_LOG
 }
 
 }  // namespace webrtc