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

Also updated types close to call sites.

BUG=webrtc:6733

Review-Url: https://codereview.webrtc.org/2514553003
Cr-Commit-Position: refs/heads/master@{#15255}

webrtc/base/fakeclock.cc

@@ -15,12 +15,12 @@
 
 namespace rtc {
 
-uint64_t FakeClock::TimeNanos() const {
+int64_t FakeClock::TimeNanos() const {
   CritScope cs(&lock_);
   return time_;
 }
 
-void FakeClock::SetTimeNanos(uint64_t nanos) {
+void FakeClock::SetTimeNanos(int64_t nanos) {
   {
     CritScope cs(&lock_);
     RTC_DCHECK(nanos >= time_);

webrtc/base/fakeclock.h

@@ -26,18 +26,18 @@ class FakeClock : public ClockInterface {
   ~FakeClock() override {}
 
   // ClockInterface implementation.
-  uint64_t TimeNanos() const override;
+  int64_t TimeNanos() const override;
 
   // Methods that can be used by the test to control the time.
 
   // Should only be used to set a time in the future.
-  void SetTimeNanos(uint64_t nanos);
+  void SetTimeNanos(int64_t nanos);
 
   void AdvanceTime(TimeDelta delta);
 
  private:
   CriticalSection lock_;
-  uint64_t time_ GUARDED_BY(lock_) = 0u;
+  int64_t time_ GUARDED_BY(lock_) = 0;
 };
 
 // Helper class that sets itself as the global clock in its constructor and

webrtc/base/opensslstreamadapter.cc

@@ -64,7 +64,7 @@ static SrtpCipherMapEntry SrtpCipherMap[] = {
 
 #ifdef OPENSSL_IS_BORINGSSL
 static void TimeCallback(const SSL* ssl, struct timeval* out_clock) {
-  uint64_t time = TimeNanos();
+  int64_t time = TimeNanos();
   out_clock->tv_sec = time / kNumNanosecsPerSec;
   out_clock->tv_usec = (time % kNumNanosecsPerSec) / kNumNanosecsPerMicrosec;
 }

webrtc/base/socket_unittest.cc

@@ -1038,7 +1038,7 @@ void SocketTest::SocketRecvTimestamp(const IPAddress& loopback) {
   EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
   SocketAddress address = socket->GetLocalAddress();
 
-  uint64_t send_time_1 = TimeMicros();
+  int64_t send_time_1 = TimeMicros();
   socket->SendTo("foo", 3, address);
   int64_t recv_timestamp_1;
   char buffer[3];
@@ -1048,7 +1048,7 @@ void SocketTest::SocketRecvTimestamp(const IPAddress& loopback) {
   const int64_t kTimeBetweenPacketsMs = 100;
   Thread::SleepMs(kTimeBetweenPacketsMs);
 
-  uint64_t send_time_2 = TimeMicros();
+  int64_t send_time_2 = TimeMicros();
   socket->SendTo("bar", 3, address);
   int64_t recv_timestamp_2;
   socket->RecvFrom(buffer, 3, nullptr, &recv_timestamp_2);

webrtc/base/timeutils.cc

@@ -39,7 +39,7 @@ ClockInterface* SetClockForTesting(ClockInterface* clock) {
   return prev;
 }
 
-uint64_t SystemTimeNanos() {
+int64_t SystemTimeNanos() {
   int64_t ticks;
 #if defined(WEBRTC_MAC)
   static mach_timebase_info_data_t timebase;
@@ -88,7 +88,7 @@ int64_t SystemTimeMillis() {
   return static_cast<int64_t>(SystemTimeNanos() / kNumNanosecsPerMillisec);
 }
 
-uint64_t TimeNanos() {
+int64_t TimeNanos() {
   if (g_clock) {
     return g_clock->TimeNanos();
   }
@@ -100,11 +100,11 @@ uint32_t Time32() {
 }
 
 int64_t TimeMillis() {
-  return static_cast<int64_t>(TimeNanos() / kNumNanosecsPerMillisec);
+  return TimeNanos() / kNumNanosecsPerMillisec;
 }
 
-uint64_t TimeMicros() {
-  return static_cast<uint64_t>(TimeNanos() / kNumNanosecsPerMicrosec);
+int64_t TimeMicros() {
+  return TimeNanos() / kNumNanosecsPerMicrosec;
 }
 
 int64_t TimeAfter(int64_t elapsed) {

webrtc/base/timeutils.h

@@ -34,7 +34,7 @@ static const int64_t kNumNanosecsPerMicrosec =
 class ClockInterface {
  public:
   virtual ~ClockInterface() {}
-  virtual uint64_t TimeNanos() const = 0;
+  virtual int64_t TimeNanos() const = 0;
 };
 
 // Sets the global source of time. This is useful mainly for unit tests.
@@ -55,7 +55,7 @@ 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.
@@ -69,10 +69,11 @@ inline int64_t Time() {
 }
 
 // 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);
@@ -88,7 +89,7 @@ inline int64_t TimeSince(int64_t 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();
 }
 

webrtc/base/timeutils_unittest.cc

@@ -303,11 +303,11 @@ TEST(FakeClock, TimeFunctionsUseFakeClock) {
   FakeClock clock;
   SetClockForTesting(&clock);
 
-  clock.SetTimeNanos(987654321u);
+  clock.SetTimeNanos(987654321);
   EXPECT_EQ(987u, Time32());
   EXPECT_EQ(987, TimeMillis());
-  EXPECT_EQ(987654u, TimeMicros());
-  EXPECT_EQ(987654321u, TimeNanos());
+  EXPECT_EQ(987654, TimeMicros());
+  EXPECT_EQ(987654321, TimeNanos());
   EXPECT_EQ(1000u, TimeAfter(13));
 
   SetClockForTesting(nullptr);
@@ -317,27 +317,27 @@ TEST(FakeClock, TimeFunctionsUseFakeClock) {
 
 TEST(FakeClock, InitialTime) {
   FakeClock clock;
-  EXPECT_EQ(0u, clock.TimeNanos());
+  EXPECT_EQ(0, clock.TimeNanos());
 }
 
 TEST(FakeClock, SetTimeNanos) {
   FakeClock clock;
-  clock.SetTimeNanos(123u);
-  EXPECT_EQ(123u, clock.TimeNanos());
-  clock.SetTimeNanos(456u);
-  EXPECT_EQ(456u, clock.TimeNanos());
+  clock.SetTimeNanos(123);
+  EXPECT_EQ(123, clock.TimeNanos());
+  clock.SetTimeNanos(456);
+  EXPECT_EQ(456, clock.TimeNanos());
 }
 
 TEST(FakeClock, AdvanceTime) {
   FakeClock clock;
   clock.AdvanceTime(TimeDelta::FromNanoseconds(1111u));
-  EXPECT_EQ(1111u, clock.TimeNanos());
+  EXPECT_EQ(1111, clock.TimeNanos());
   clock.AdvanceTime(TimeDelta::FromMicroseconds(2222u));
-  EXPECT_EQ(2223111u, clock.TimeNanos());
+  EXPECT_EQ(2223111, clock.TimeNanos());
   clock.AdvanceTime(TimeDelta::FromMilliseconds(3333u));
-  EXPECT_EQ(3335223111u, clock.TimeNanos());
+  EXPECT_EQ(3335223111, clock.TimeNanos());
   clock.AdvanceTime(TimeDelta::FromSeconds(4444u));
-  EXPECT_EQ(4447335223111u, clock.TimeNanos());
+  EXPECT_EQ(4447335223111, clock.TimeNanos());
 }
 
 // When the clock is advanced, threads that are waiting in a socket select