From deb95f32f47ea09e10a8c7c209dca3b9dce7f3d8 Mon Sep 17 00:00:00 2001 From: nisse Date: Mon, 28 Nov 2016 01:54:54 -0800 Subject: [PATCH] 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/api/stats/rtcstatsreport.h | 8 +++---- webrtc/base/fakeclock.cc | 4 ++-- webrtc/base/fakeclock.h | 6 ++--- webrtc/base/opensslstreamadapter.cc | 2 +- webrtc/base/socket_unittest.cc | 4 ++-- webrtc/base/timeutils.cc | 10 ++++---- webrtc/base/timeutils.h | 11 +++++---- webrtc/base/timeutils_unittest.cc | 24 +++++++++---------- .../audio_device/audio_device_buffer.cc | 2 +- .../audio_device/audio_device_buffer.h | 6 ++--- .../test/video_capture_unittest.cc | 4 ++-- .../codecs/test/videoprocessor.cc | 6 ++--- webrtc/stats/rtcstatsreport.cc | 4 ++-- 13 files changed, 46 insertions(+), 45 deletions(-) diff --git a/webrtc/api/stats/rtcstatsreport.h b/webrtc/api/stats/rtcstatsreport.h index 05bc529550..32514e765a 100644 --- a/webrtc/api/stats/rtcstatsreport.h +++ b/webrtc/api/stats/rtcstatsreport.h @@ -52,12 +52,12 @@ class RTCStatsReport : public rtc::RefCountInterface { // TODO(hbos): Remove "= 0" once Chromium unittest has been updated to call // with a parameter. crbug.com/627816 - static rtc::scoped_refptr Create(uint64_t timestamp_us = 0); + static rtc::scoped_refptr Create(int64_t timestamp_us = 0); - explicit RTCStatsReport(uint64_t timestamp_us); + explicit RTCStatsReport(int64_t timestamp_us); RTCStatsReport(const RTCStatsReport& other) = delete; - uint64_t timestamp_us() const { return timestamp_us_; } + int64_t timestamp_us() const { return timestamp_us_; } bool AddStats(std::unique_ptr stats); const RTCStats* Get(const std::string& id) const; size_t size() const { return stats_.size(); } @@ -90,7 +90,7 @@ class RTCStatsReport : public rtc::RefCountInterface { private: ~RTCStatsReport() override; - uint64_t timestamp_us_; + int64_t timestamp_us_; StatsMap stats_; }; diff --git a/webrtc/base/fakeclock.cc b/webrtc/base/fakeclock.cc index bcd720ff74..d95408f6a8 100644 --- a/webrtc/base/fakeclock.cc +++ b/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_); diff --git a/webrtc/base/fakeclock.h b/webrtc/base/fakeclock.h index 4aecc54cc4..7fa101558f 100644 --- a/webrtc/base/fakeclock.h +++ b/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 diff --git a/webrtc/base/opensslstreamadapter.cc b/webrtc/base/opensslstreamadapter.cc index 5a7560e112..6943cd32ff 100644 --- a/webrtc/base/opensslstreamadapter.cc +++ b/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; } diff --git a/webrtc/base/socket_unittest.cc b/webrtc/base/socket_unittest.cc index 5dc52511e4..16edf905e5 100644 --- a/webrtc/base/socket_unittest.cc +++ b/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); diff --git a/webrtc/base/timeutils.cc b/webrtc/base/timeutils.cc index 658d0796ad..c424f701f7 100644 --- a/webrtc/base/timeutils.cc +++ b/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(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(TimeNanos() / kNumNanosecsPerMillisec); + return TimeNanos() / kNumNanosecsPerMillisec; } -uint64_t TimeMicros() { - return static_cast(TimeNanos() / kNumNanosecsPerMicrosec); +int64_t TimeMicros() { + return TimeNanos() / kNumNanosecsPerMicrosec; } int64_t TimeAfter(int64_t elapsed) { diff --git a/webrtc/base/timeutils.h b/webrtc/base/timeutils.h index cc6deb47a9..f41bbb5ad0 100644 --- a/webrtc/base/timeutils.h +++ b/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(); } diff --git a/webrtc/base/timeutils_unittest.cc b/webrtc/base/timeutils_unittest.cc index 6707d8c440..db939cb68b 100644 --- a/webrtc/base/timeutils_unittest.cc +++ b/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 diff --git a/webrtc/modules/audio_device/audio_device_buffer.cc b/webrtc/modules/audio_device/audio_device_buffer.cc index d40b05e70a..83109177c6 100644 --- a/webrtc/modules/audio_device/audio_device_buffer.cc +++ b/webrtc/modules/audio_device/audio_device_buffer.cc @@ -111,7 +111,7 @@ void AudioDeviceBuffer::StartPlayout() { if (!recording_) { StartPeriodicLogging(); } - const uint64_t now_time = rtc::TimeMillis(); + const int64_t now_time = rtc::TimeMillis(); // Clear members that are only touched on the main (creating) thread. play_start_time_ = now_time; playing_ = true; diff --git a/webrtc/modules/audio_device/audio_device_buffer.h b/webrtc/modules/audio_device/audio_device_buffer.h index 167ebd234a..e2c6f2871a 100644 --- a/webrtc/modules/audio_device/audio_device_buffer.h +++ b/webrtc/modules/audio_device/audio_device_buffer.h @@ -220,7 +220,7 @@ class AudioDeviceBuffer { int16_t max_play_level_ ACCESS_ON(task_queue_); // Time stamp of last timer task (drives logging). - uint64_t last_timer_task_time_ ACCESS_ON(task_queue_); + int64_t last_timer_task_time_ ACCESS_ON(task_queue_); // Counts number of audio callbacks modulo 50 to create a signal when // a new storage of audio stats shall be done. @@ -228,8 +228,8 @@ class AudioDeviceBuffer { int16_t play_stat_count_ ACCESS_ON(playout_thread_checker_); // Time stamps of when playout and recording starts. - uint64_t play_start_time_ ACCESS_ON(main_thread_checker_); - uint64_t rec_start_time_ ACCESS_ON(main_thread_checker_); + int64_t play_start_time_ ACCESS_ON(main_thread_checker_); + int64_t rec_start_time_ ACCESS_ON(main_thread_checker_); // Set to true at construction and modified to false as soon as one audio- // level estimate larger than zero is detected. diff --git a/webrtc/modules/video_capture/test/video_capture_unittest.cc b/webrtc/modules/video_capture/test/video_capture_unittest.cc index 0090006fea..0f9f0aea41 100644 --- a/webrtc/modules/video_capture/test/video_capture_unittest.cc +++ b/webrtc/modules/video_capture/test/video_capture_unittest.cc @@ -472,8 +472,8 @@ TEST_F(VideoCaptureExternalTest, TestExternalCapture) { #define MAYBE_FrameRate FrameRate #endif TEST_F(VideoCaptureExternalTest, MAYBE_FrameRate) { - uint64_t testTime = 3 * rtc::kNumNanosecsPerSec; - uint64_t startTime = rtc::TimeNanos(); + int64_t testTime = 3 * rtc::kNumNanosecsPerSec; + int64_t startTime = rtc::TimeNanos(); while ((rtc::TimeNanos() - startTime) < testTime) { size_t length = webrtc::CalcBufferSize(webrtc::kI420, diff --git a/webrtc/modules/video_coding/codecs/test/videoprocessor.cc b/webrtc/modules/video_coding/codecs/test/videoprocessor.cc index aaf29ebb9e..63f0a87150 100644 --- a/webrtc/modules/video_coding/codecs/test/videoprocessor.cc +++ b/webrtc/modules/video_coding/codecs/test/videoprocessor.cc @@ -385,9 +385,9 @@ void VideoProcessorImpl::FrameDecoded(const VideoFrame& image) { int VideoProcessorImpl::GetElapsedTimeMicroseconds(int64_t start, int64_t stop) { - uint64_t encode_time = (stop - start) / rtc::kNumNanosecsPerMicrosec; - RTC_DCHECK_LT(encode_time, - static_cast(std::numeric_limits::max())); + int64_t encode_time = (stop - start) / rtc::kNumNanosecsPerMicrosec; + RTC_DCHECK_GE(encode_time, std::numeric_limits::min()); + RTC_DCHECK_LE(encode_time, std::numeric_limits::max()); return static_cast(encode_time); } diff --git a/webrtc/stats/rtcstatsreport.cc b/webrtc/stats/rtcstatsreport.cc index 9e2244cecf..3dd6eff39f 100644 --- a/webrtc/stats/rtcstatsreport.cc +++ b/webrtc/stats/rtcstatsreport.cc @@ -57,12 +57,12 @@ bool RTCStatsReport::ConstIterator::operator!=( } rtc::scoped_refptr RTCStatsReport::Create( - uint64_t timestamp_us) { + int64_t timestamp_us) { return rtc::scoped_refptr( new rtc::RefCountedObject(timestamp_us)); } -RTCStatsReport::RTCStatsReport(uint64_t timestamp_us) +RTCStatsReport::RTCStatsReport(int64_t timestamp_us) : timestamp_us_(timestamp_us) { }