Log current time if we stop logging before stop_time_.

webrtc/call/rtc_event_log_helper_thread.cc

 /*
  *  Copyright (c) 2016 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 206 matching lines @@
     StopLogFile();
   }
   return message_received;
 }
 
 void RtcEventLogHelperThread::StopLogFile() {
   RTC_DCHECK(file_->is_open());
   output_string_.clear();
 
   rtclog::Event end_event;
-  end_event.set_timestamp_us(stop_time_);
+  // This function can be called either because we have reached the stop time,
+  // or because we have reached the log file size limit. Therefore, use the
+  // current time if we have not reached the time limit.
+  end_event.set_timestamp_us(
+      std::min(stop_time_, clock_->TimeInMicroseconds()));

[ivoc, 2016/07/27 09:18:00]

Do you know if the value from TimeInMicroseconds() can wrap?

[pbos-webrtc, 2016/07/27 16:44:20]

This should never wrap. (It calls rtc::TimeMicros() which is ~64-bit sized, all
of our code relies on this not wrapping).

[terelius, 2016/07/27 20:34:40]

When I wrote the code, I assumed that the 64-bit time couldn't wrap. However,
after looking at it earlier today, I am not so sure.

On mac, rtc::TimeMicros() does
ticks = mach_absolute_time() * timebase.numer / timebase.denom;
where mach_absolute_time() measures (roughly) CPU cycles and timebase is a
fraction that scales the CPU cycles to nanoseconds. If the timebase is
1000000000/33333335 then the computation will wrap after about 10 minutes.

https://developer.apple.com/library/mac/qa/qa1398/_index.html also mentions that
there is a danger of overflowing. On the other hand, I've also read that the
timebase is 1/1 on Intel CPU so this would only be an issue on PowerPC.

If it does wrap on some platform, we're going to have bigger problems than just
an incorrect timestamp in a log, though.

   end_event.set_type(rtclog::Event::LOG_END);
   AppendEventToString(&end_event);
 
   if (written_bytes_ + static_cast<int64_t>(output_string_.size()) <=
       max_size_bytes_) {
     if (!file_->Write(output_string_.data(), output_string_.size())) {
       LOG(LS_ERROR) << "FileWrapper failed to write WebRtcEventLog file.";
       // The current FileWrapper implementation closes the file on error.
       RTC_DCHECK(!file_->is_open());
     }
@@ skipping 69 matching lines @@
 
 bool RtcEventLogHelperThread::ThreadOutputFunction(void* obj) {
   RtcEventLogHelperThread* helper = static_cast<RtcEventLogHelperThread*>(obj);
   helper->ProcessEvents();
   return false;
 }
 
 }  // namespace webrtc
 
 #endif  // ENABLE_RTC_EVENT_LOG