Using 64-bit timestamp in webrtc/p2p

webrtc/base/timeutils.h

 /*
  *  Copyright 2005 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 17 matching lines @@
     kNumNanosecsPerSec / kNumMillisecsPerSec;
 static const int64_t kNumNanosecsPerMicrosec =
     kNumNanosecsPerSec / kNumMicrosecsPerSec;
 
 // January 1970, in NTP milliseconds.
 static const int64_t kJan1970AsNtpMillisecs = INT64_C(2208988800000);
 
 typedef uint32_t TimeStamp;
 
 // Returns the current time in milliseconds.
 uint32_t Time();

[pthatcher1, 2016/03/15 04:10:50]

Can you make a Time32() that chooses 32-bit time, and then make Time() call
Time32() for now, but then later change the remaining callers of Time() to be
Time32(), and then change Time() to call Time64()?

And can you also put a TODO here saying that's what you are going to do?  That
way, we'll eventually be in a state where everything can call Time() with the
right size, and only get 32-bit if it asks for it with Time32().

In fact, we should probably go back and rename all the calls to Time64() to be
Time() as well. 

[honghaiz3, 2016/03/15 17:35:33]

Done. The last item will be done in the next CL when we switch the default from
32bit to 64bit time. 

+
+// Returns the current time in milliseconds.
+int64_t Time64();
+
 // Returns the current time in microseconds.
 uint64_t TimeMicros();
 // Returns the current time in nanoseconds.
 uint64_t TimeNanos();
 
 // Stores current time in *tm and microseconds in *microseconds.
 void CurrentTmTime(struct tm *tm, int *microseconds);
 
 // Returns a future timestamp, 'elapsed' milliseconds from now.
 uint32_t TimeAfter(int32_t elapsed);
@@ skipping 12 matching lines @@
 
 // Returns the earlier of two timestamps.
 inline uint32_t TimeMin(uint32_t ts1, uint32_t ts2) {
   return TimeIsLaterOrEqual(ts1, ts2) ? ts1 : ts2;
 }
 
 // Number of milliseconds that would elapse between 'earlier' and 'later'
 // timestamps.  The value is negative if 'later' occurs before 'earlier'.
 int32_t TimeDiff(uint32_t later, uint32_t earlier);
 
+// Number of milliseconds that would elapse between 'earlier' and 'later'
+// timestamps.  The value is negative if 'later' occurs before 'earlier'.
+int64_t TimeDiff64(int64_t later, int64_t earlier);

[pthatcher1, 2016/03/15 04:10:50]

Same here with the names: make TimeDiff64 the default and 32 the strange one.

[honghaiz3, 2016/03/15 17:35:33]

Will do this in the next CL because many of the 32-bit methods including
TimeDiff may be removed at all (The implementation is extremely simple. The only
reason to keep them is to support the legacy call).

+
 // The number of milliseconds that have elapsed since 'earlier'.
 inline int32_t TimeSince(uint32_t earlier) {
   return TimeDiff(Time(), earlier);
 }
 
 // The number of milliseconds that will elapse between now and 'later'.
 inline int32_t TimeUntil(uint32_t later) {
   return TimeDiff(later, Time());
 }
 
@@ skipping 14 matching lines @@
 };
 
 // Convert from std::tm, which is relative to 1900-01-01 00:00 to number of
 // seconds from 1970-01-01 00:00 ("epoch").  Don't return time_t since that
 // is still 32 bits on many systems.
 int64_t TmToSeconds(const std::tm& tm);
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_TIMEUTILS_H_