Change default timestamp to 64 bits in all webrtc directories.

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 14 matching lines @@
 static const int64_t kNumMicrosecsPerMillisec =
     kNumMicrosecsPerSec / kNumMillisecsPerSec;
 static const int64_t kNumNanosecsPerMillisec =
     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 in 32 bits.
 uint32_t Time32();
 
 // Returns the current time in milliseconds in 64 bits.
+// TODO(honghaiz): remove this and replace the call with Time().
 int64_t Time64();
 
 // Returns the current time in milliseconds.
-// TODO(honghaiz): Returns Time64 once majority of the webrtc code migrates to
-// 64-bit timestamp.
-inline uint32_t Time() {
-  return Time32();
+inline int64_t Time() {
+  return 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);
-
-// Comparisons between time values, which can wrap around.
-bool TimeIsBetween(uint32_t earlier,
-                   uint32_t middle,
-                   uint32_t later);                         // Inclusive
-bool TimeIsLaterOrEqual(uint32_t earlier, uint32_t later);  // Inclusive
-bool TimeIsLater(uint32_t earlier, uint32_t later);         // Exclusive
-
-// Returns the later of two timestamps.
-inline uint32_t TimeMax(uint32_t ts1, uint32_t ts2) {
-  return TimeIsLaterOrEqual(ts1, ts2) ? ts2 : ts1;
-}
-
-// 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);
+int64_t TimeAfter(int elapsed);

[Taylor Brandstetter, 2016/04/05 01:08:14]

Why take an int parameter instead of int64_t? Someone may accidentally try to
use this with an int64_t.

[pthatcher1, 2016/04/11 20:56:59]

I agree.  Using int64_t consistently seems like a good idea.

[honghaiz3, 2016/04/18 23:39:04]

Done.

 
 // 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);
+inline int TimeDiff(int64_t later, int64_t earlier) {
+  return static_cast<int>(TimeDiff64(later, earlier));
+}
 
 // The number of milliseconds that have elapsed since 'earlier'.
-inline int32_t TimeSince(uint32_t earlier) {
-  return TimeDiff(Time(), earlier);
+inline int TimeSince(int64_t earlier) {

[Taylor Brandstetter, 2016/04/05 01:08:14]

Similarly, why do these return ints?

[honghaiz3, 2016/04/18 23:39:04]

For all delta-time (e.g. elapsed time, or time delay), I am using 32-bit values
because it is highly unlikely that any time difference in a call will be more
than 23 days (with int 32 bits). 
Returning an int value simplifies the places where TimeSince is called and the
result value is passed to an int variable. 

[Taylor Brandstetter, 2016/04/19 20:35:27]

See my other comment.

[honghaiz3, 2016/04/22 23:45:20]

Done.

+  return static_cast<int>(Time() - earlier);
 }
 
 // The number of milliseconds that will elapse between now and 'later'.
-inline int32_t TimeUntil(uint32_t later) {
-  return TimeDiff(later, Time());
+inline int TimeUntil(uint64_t later) {
+  return static_cast<int>(later - Time());
 }
 
 // Converts a unix timestamp in nanoseconds to an NTP timestamp in ms.
 inline int64_t UnixTimestampNanosecsToNtpMillisecs(int64_t unix_ts_ns) {
   return unix_ts_ns / kNumNanosecsPerMillisec + kJan1970AsNtpMillisecs;
 }
 
 class TimestampWrapAroundHandler {
  public:
   TimestampWrapAroundHandler();
 
   int64_t Unwrap(uint32_t ts);
 
  private:
   uint32_t last_ts_;
   int64_t num_wrap_;
 };
 
 // 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_