Change rtc::TimeNanos and rtc::TimeMicros return value from uint64_t to int64_t.

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 16 matching lines @@
 static const int64_t kNumNanosecsPerMillisec =
     kNumNanosecsPerSec / kNumMillisecsPerSec;
 static const int64_t kNumNanosecsPerMicrosec =
     kNumNanosecsPerSec / kNumMicrosecsPerSec;
 
 // TODO(honghaiz): Define a type for the time value specifically.
 
 class ClockInterface {
  public:
   virtual ~ClockInterface() {}
-  virtual uint64_t TimeNanos() const = 0;
+  virtual int64_t TimeNanos() const = 0;

[kwiberg-webrtc, 2016/11/21 12:12:34]

With this (and the other changes to this file), you're changing the public API,
right? If so, shouldn't you (1) introduce new stuff, (2) announce that people
have X weeks to stop using the old stuff, (3) wait X weeks, (4) remove the old
stuff?

[nisse-webrtc, 2016/11/21 12:39:12]

What's "public" in base/ is a fuzzy line. This ClockInterface is intended for
testing only. I've found two uses outside of webrtc (which I think I was
involved in adding), and I think they are under control; they're there mainly
because ScopedFakeClock isn't imported into the projects in question.

TimeMicros and TimeNanos are potentially more of a problem. We could introduce
new names for them, but that would also add some confusion. My opionion is that
in the long run, it's more hassle to update all applications to use a new name,
than to update them to accept a different return type; if for no other reason, a
lot fewer of the call sites will require any changes. (In practice, I think we
can almost promise that the returned values will be representable in both
int64_t and uint64_t).

 };
 
 // Sets the global source of time. This is useful mainly for unit tests.
 //
 // Returns the previously set ClockInterface, or nullptr if none is set.
 //
 // Does not transfer ownership of the clock. SetClockForTesting(nullptr)
 // should be called before the ClockInterface is deleted.
 //
 // This method is not thread-safe; it should only be used when no other thread
 // is running (for example, at the start/end of a unit test, or start/end of
 // main()).
 //
 // TODO(deadbeef): Instead of having functions that access this global
 // ClockInterface, we may want to pass the ClockInterface into everything
 // that uses it, eliminating the need for a global variable and this function.
 ClockInterface* SetClockForTesting(ClockInterface* clock);
 
 // Returns the actual system time, even if a clock is set for testing.
 // Useful for timeouts while using a test clock, or for logging.
-uint64_t SystemTimeNanos();
+int64_t SystemTimeNanos();
 int64_t SystemTimeMillis();
 
 // Returns the current time in milliseconds in 32 bits.
 uint32_t Time32();
 
 // Returns the current time in milliseconds in 64 bits.
 int64_t TimeMillis();
 // Deprecated. Do not use this in any new code.
 inline int64_t Time() {
   return TimeMillis();
 }
 
 // Returns the current time in microseconds.
-uint64_t TimeMicros();
+int64_t TimeMicros();
 
 // Returns the current time in nanoseconds.
-uint64_t TimeNanos();
+int64_t TimeNanos();
+
 
 // Returns a future timestamp, 'elapsed' milliseconds from now.
 int64_t TimeAfter(int64_t elapsed);
 
 // Number of milliseconds that would elapse between 'earlier' and 'later'
 // timestamps.  The value is negative if 'later' occurs before 'earlier'.
 int64_t TimeDiff(int64_t later, int64_t earlier);
 int32_t TimeDiff32(uint32_t later, uint32_t earlier);
 
 // The number of milliseconds that have elapsed since 'earlier'.
 inline int64_t TimeSince(int64_t earlier) {
   return TimeMillis() - earlier;
 }
 
 // The number of milliseconds that will elapse between now and 'later'.
-inline int64_t TimeUntil(uint64_t later) {
+inline int64_t TimeUntil(int64_t later) {
   return later - TimeMillis();
 }
 
 class TimestampWrapAroundHandler {
  public:
   TimestampWrapAroundHandler();
 
   int64_t Unwrap(uint32_t ts);
 
  private:
@@ skipping 14 matching lines @@
 // Note that this function obeys the system's idea about what the time
 // is. It is not guaranteed to be monotonic; it will jump in case the
 // system time is changed, e.g., by some other process calling
 // settimeofday. Always use rtc::TimeMicros(), not this function, for
 // measuring time intervals and timeouts.
 int64_t TimeUTCMicros();
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_TIMEUTILS_H_