Change default timestamp to 64 bits in all webrtc directories.
BUG=
R=pbos@webrtc.org, pthatcher@webrtc.org, solenberg@webrtc.org
Review URL: https://codereview.webrtc.org/1835053002 .
Cr-Commit-Position: refs/heads/master@{#12646}
diff --git a/webrtc/api/dtmfsender_unittest.cc b/webrtc/api/dtmfsender_unittest.cc
index efe568d..e5fe261 100644
--- a/webrtc/api/dtmfsender_unittest.cc
+++ b/webrtc/api/dtmfsender_unittest.cc
@@ -85,9 +85,9 @@
// TODO(ronghuawu): Make the timer (basically the rtc::TimeNanos)
// mockable and use a fake timer in the unit tests.
if (last_insert_dtmf_call_ > 0) {
- gap = static_cast<int>(rtc::Time() - last_insert_dtmf_call_);
+ gap = static_cast<int>(rtc::TimeMillis() - last_insert_dtmf_call_);
}
- last_insert_dtmf_call_ = rtc::Time();
+ last_insert_dtmf_call_ = rtc::TimeMillis();
LOG(LS_VERBOSE) << "FakeDtmfProvider::InsertDtmf code=" << code
<< " duration=" << duration
diff --git a/webrtc/api/peerconnectionendtoend_unittest.cc b/webrtc/api/peerconnectionendtoend_unittest.cc
index 95369b1..40bb437 100644
--- a/webrtc/api/peerconnectionendtoend_unittest.cc
+++ b/webrtc/api/peerconnectionendtoend_unittest.cc
@@ -38,7 +38,7 @@
namespace {
-const size_t kMaxWait = 10000;
+const int kMaxWait = 10000;
} // namespace
diff --git a/webrtc/api/peerconnectionfactory.cc b/webrtc/api/peerconnectionfactory.cc
index ff8098c..b2a3798 100644
--- a/webrtc/api/peerconnectionfactory.cc
+++ b/webrtc/api/peerconnectionfactory.cc
@@ -153,7 +153,7 @@
bool PeerConnectionFactory::Initialize() {
RTC_DCHECK(signaling_thread_->IsCurrent());
- rtc::InitRandom(rtc::Time());
+ rtc::InitRandom(rtc::Time32());
default_network_manager_.reset(new rtc::BasicNetworkManager());
if (!default_network_manager_) {
diff --git a/webrtc/api/test/fakeaudiocapturemodule.cc b/webrtc/api/test/fakeaudiocapturemodule.cc
index 0ab493d..a32ef64 100644
--- a/webrtc/api/test/fakeaudiocapturemodule.cc
+++ b/webrtc/api/test/fakeaudiocapturemodule.cc
@@ -23,7 +23,7 @@
// Same value as src/modules/audio_device/main/source/audio_device_config.h in
// https://code.google.com/p/webrtc/
-static const uint32_t kAdmMaxIdleTimeProcess = 1000;
+static const int kAdmMaxIdleTimeProcess = 1000;
// Constants here are derived by running VoE using a real ADM.
// The constants correspond to 10ms of mono audio at 44kHz.
@@ -73,12 +73,12 @@
}
int64_t FakeAudioCaptureModule::TimeUntilNextProcess() {
- const uint32_t current_time = rtc::Time();
+ const int64_t current_time = rtc::TimeMillis();
if (current_time < last_process_time_ms_) {
// TODO: wraparound could be handled more gracefully.
return 0;
}
- const uint32_t elapsed_time = current_time - last_process_time_ms_;
+ const int64_t elapsed_time = current_time - last_process_time_ms_;
if (kAdmMaxIdleTimeProcess < elapsed_time) {
return 0;
}
@@ -86,7 +86,7 @@
}
void FakeAudioCaptureModule::Process() {
- last_process_time_ms_ = rtc::Time();
+ last_process_time_ms_ = rtc::TimeMillis();
}
int32_t FakeAudioCaptureModule::ActiveAudioLayer(
@@ -590,7 +590,7 @@
// sent to it. Note that the audio processing pipeline will likely distort the
// original signal.
SetSendBuffer(kHighSampleValue);
- last_process_time_ms_ = rtc::Time();
+ last_process_time_ms_ = rtc::TimeMillis();
return true;
}
@@ -649,7 +649,7 @@
void FakeAudioCaptureModule::ProcessFrameP() {
ASSERT(process_thread_->IsCurrent());
if (!started_) {
- next_frame_time_ = rtc::Time();
+ next_frame_time_ = rtc::TimeMillis();
started_ = true;
}
@@ -665,8 +665,8 @@
}
next_frame_time_ += kTimePerFrameMs;
- const uint32_t current_time = rtc::Time();
- const uint32_t wait_time =
+ const int64_t current_time = rtc::TimeMillis();
+ const int64_t wait_time =
(next_frame_time_ > current_time) ? next_frame_time_ - current_time : 0;
process_thread_->PostDelayed(wait_time, this, MSG_RUN_PROCESS);
}
diff --git a/webrtc/api/test/fakeaudiocapturemodule.h b/webrtc/api/test/fakeaudiocapturemodule.h
index 098243f..ca42c3b 100644
--- a/webrtc/api/test/fakeaudiocapturemodule.h
+++ b/webrtc/api/test/fakeaudiocapturemodule.h
@@ -227,7 +227,7 @@
// The time in milliseconds when Process() was last called or 0 if no call
// has been made.
- uint32_t last_process_time_ms_;
+ int64_t last_process_time_ms_;
// Callback for playout and recording.
webrtc::AudioTransport* audio_callback_;
@@ -247,7 +247,7 @@
// wall clock time the next frame should be generated and received. started_
// ensures that next_frame_time_ can be initialized properly on first call.
bool started_;
- uint32_t next_frame_time_;
+ int64_t next_frame_time_;
std::unique_ptr<rtc::Thread> process_thread_;
diff --git a/webrtc/base/asynctcpsocket.cc b/webrtc/base/asynctcpsocket.cc
index 120bcfb..9ba46d7 100644
--- a/webrtc/base/asynctcpsocket.cc
+++ b/webrtc/base/asynctcpsocket.cc
@@ -296,7 +296,7 @@
return res;
}
- rtc::SentPacket sent_packet(options.packet_id, rtc::Time());
+ rtc::SentPacket sent_packet(options.packet_id, rtc::TimeMillis());
SignalSentPacket(this, sent_packet);
// We claim to have sent the whole thing, even if we only sent partial
diff --git a/webrtc/base/asyncudpsocket.cc b/webrtc/base/asyncudpsocket.cc
index 7eb2a0e..fc7d887 100644
--- a/webrtc/base/asyncudpsocket.cc
+++ b/webrtc/base/asyncudpsocket.cc
@@ -59,7 +59,7 @@
int AsyncUDPSocket::Send(const void *pv, size_t cb,
const rtc::PacketOptions& options) {
- rtc::SentPacket sent_packet(options.packet_id, rtc::Time());
+ rtc::SentPacket sent_packet(options.packet_id, rtc::TimeMillis());
int ret = socket_->Send(pv, cb);
SignalSentPacket(this, sent_packet);
return ret;
@@ -68,7 +68,7 @@
int AsyncUDPSocket::SendTo(const void *pv, size_t cb,
const SocketAddress& addr,
const rtc::PacketOptions& options) {
- rtc::SentPacket sent_packet(options.packet_id, rtc::Time());
+ rtc::SentPacket sent_packet(options.packet_id, rtc::TimeMillis());
int ret = socket_->SendTo(pv, cb, addr);
SignalSentPacket(this, sent_packet);
return ret;
diff --git a/webrtc/base/fileutils.cc b/webrtc/base/fileutils.cc
index cb23153..d354dd8 100644
--- a/webrtc/base/fileutils.cc
+++ b/webrtc/base/fileutils.cc
@@ -133,7 +133,7 @@
#else
file_modify_time = stat_.st_mtime;
#endif
- return TimeDiff(time(NULL), file_modify_time) >= seconds;
+ return time(NULL) - file_modify_time >= seconds;
}
FilesystemInterface* Filesystem::default_filesystem_ = NULL;
diff --git a/webrtc/base/gunit.h b/webrtc/base/gunit.h
index 1a6c363..e705322 100644
--- a/webrtc/base/gunit.h
+++ b/webrtc/base/gunit.h
@@ -20,21 +20,22 @@
#endif
// Wait until "ex" is true, or "timeout" expires.
-#define WAIT(ex, timeout) \
- for (uint32_t start = rtc::Time(); !(ex) && rtc::Time() < start + timeout;) \
+#define WAIT(ex, timeout) \
+ for (int64_t start = rtc::TimeMillis(); \
+ !(ex) && rtc::TimeMillis() < start + timeout;) \
rtc::Thread::Current()->ProcessMessages(1);
// This returns the result of the test in res, so that we don't re-evaluate
// the expression in the XXXX_WAIT macros below, since that causes problems
// when the expression is only true the first time you check it.
-#define WAIT_(ex, timeout, res) \
- do { \
- uint32_t start = rtc::Time(); \
- res = (ex); \
- while (!res && rtc::Time() < start + timeout) { \
- rtc::Thread::Current()->ProcessMessages(1); \
- res = (ex); \
- } \
+#define WAIT_(ex, timeout, res) \
+ do { \
+ int64_t start = rtc::TimeMillis(); \
+ res = (ex); \
+ while (!res && rtc::TimeMillis() < start + timeout) { \
+ rtc::Thread::Current()->ProcessMessages(1); \
+ res = (ex); \
+ } \
} while (0)
// The typical EXPECT_XXXX and ASSERT_XXXXs, but done until true or a timeout.
diff --git a/webrtc/base/logging.cc b/webrtc/base/logging.cc
index 6265668..6060362 100644
--- a/webrtc/base/logging.cc
+++ b/webrtc/base/logging.cc
@@ -124,7 +124,7 @@
const char* module)
: severity_(sev), tag_(kLibjingle) {
if (timestamp_) {
- uint32_t time = TimeSince(LogStartTime());
+ int64_t time = TimeSince(LogStartTime());
// Also ensure WallClockStartTime is initialized, so that it matches
// LogStartTime.
WallClockStartTime();
@@ -209,8 +209,8 @@
}
}
-uint32_t LogMessage::LogStartTime() {
- static const uint32_t g_start = Time();
+int64_t LogMessage::LogStartTime() {
+ static const int64_t g_start = TimeMillis();
return g_start;
}
diff --git a/webrtc/base/logging.h b/webrtc/base/logging.h
index 886b5d8..802dfa7 100644
--- a/webrtc/base/logging.h
+++ b/webrtc/base/logging.h
@@ -156,7 +156,7 @@
// If this is not called externally, the LogMessage ctor also calls it, in
// which case the logging start time will be the time of the first LogMessage
// instance is created.
- static uint32_t LogStartTime();
+ static int64_t LogStartTime();
// Returns the wall clock equivalent of |LogStartTime|, in seconds from the
// epoch.
diff --git a/webrtc/base/logging_unittest.cc b/webrtc/base/logging_unittest.cc
index 6047361..d5bd9d4 100644
--- a/webrtc/base/logging_unittest.cc
+++ b/webrtc/base/logging_unittest.cc
@@ -138,18 +138,18 @@
stream.DisableBuffering();
LogMessage::AddLogToStream(&stream, LS_SENSITIVE);
- uint32_t start = Time(), finish;
+ int64_t start = TimeMillis(), finish;
std::string message('X', 80);
for (int i = 0; i < 1000; ++i) {
LOG(LS_SENSITIVE) << message;
}
- finish = Time();
+ finish = TimeMillis();
LogMessage::RemoveLogToStream(&stream);
stream.Close();
Filesystem::DeleteFile(path);
- LOG(LS_INFO) << "Average log time: " << TimeDiff(finish, start) << " us";
+ LOG(LS_INFO) << "Average log time: " << TimeDiff(finish, start) << " ms";
}
} // namespace rtc
diff --git a/webrtc/base/messagequeue.cc b/webrtc/base/messagequeue.cc
index 1ccee00..e8b5bf5 100644
--- a/webrtc/base/messagequeue.cc
+++ b/webrtc/base/messagequeue.cc
@@ -17,7 +17,7 @@
namespace rtc {
-const uint32_t kMaxMsgLatency = 150; // 150 ms
+const int kMaxMsgLatency = 150; // 150 ms
//------------------------------------------------------------------
// MessageQueueManager
@@ -215,16 +215,16 @@
// Get w/wait + timer scan / dispatch + socket / event multiplexer dispatch
- int cmsTotal = cmsWait;
- int cmsElapsed = 0;
- uint32_t msStart = Time();
- uint32_t msCurrent = msStart;
+ int64_t cmsTotal = cmsWait;
+ int64_t cmsElapsed = 0;
+ int64_t msStart = TimeMillis();
+ int64_t msCurrent = msStart;
while (true) {
// Check for sent messages
ReceiveSends();
// Check for posted events
- int cmsDelayNext = kForever;
+ int64_t cmsDelayNext = kForever;
bool first_pass = true;
while (true) {
// All queue operations need to be locked, but nothing else in this loop
@@ -237,7 +237,7 @@
if (first_pass) {
first_pass = false;
while (!dmsgq_.empty()) {
- if (TimeIsLater(msCurrent, dmsgq_.top().msTrigger_)) {
+ if (msCurrent < dmsgq_.top().msTrigger_) {
cmsDelayNext = TimeDiff(dmsgq_.top().msTrigger_, msCurrent);
break;
}
@@ -256,7 +256,7 @@
// Log a warning for time-sensitive messages that we're late to deliver.
if (pmsg->ts_sensitive) {
- int32_t delay = TimeDiff(msCurrent, pmsg->ts_sensitive);
+ int64_t delay = TimeDiff(msCurrent, pmsg->ts_sensitive);
if (delay > 0) {
LOG_F(LS_WARNING) << "id: " << pmsg->message_id << " delay: "
<< (delay + kMaxMsgLatency) << "ms";
@@ -277,11 +277,11 @@
// Which is shorter, the delay wait or the asked wait?
- int cmsNext;
+ int64_t cmsNext;
if (cmsWait == kForever) {
cmsNext = cmsDelayNext;
} else {
- cmsNext = std::max(0, cmsTotal - cmsElapsed);
+ cmsNext = std::max<int64_t>(0, cmsTotal - cmsElapsed);
if ((cmsDelayNext != kForever) && (cmsDelayNext < cmsNext))
cmsNext = cmsDelayNext;
}
@@ -289,13 +289,13 @@
{
// Wait and multiplex in the meantime
SharedScope ss(&ss_lock_);
- if (!ss_->Wait(cmsNext, process_io))
+ if (!ss_->Wait(static_cast<int>(cmsNext), process_io))
return false;
}
// If the specified timeout expired, return
- msCurrent = Time();
+ msCurrent = TimeMillis();
cmsElapsed = TimeDiff(msCurrent, msStart);
if (cmsWait != kForever) {
if (cmsElapsed >= cmsWait)
@@ -326,7 +326,7 @@
msg.message_id = id;
msg.pdata = pdata;
if (time_sensitive) {
- msg.ts_sensitive = Time() + kMaxMsgLatency;
+ msg.ts_sensitive = TimeMillis() + kMaxMsgLatency;
}
msgq_.push_back(msg);
}
@@ -344,11 +344,20 @@
MessageHandler* phandler,
uint32_t id,
MessageData* pdata) {
+ // This should work even if it is used (unexpectedly).
+ int delay = static_cast<uint32_t>(TimeMillis()) - tstamp;
+ return DoDelayPost(delay, tstamp, phandler, id, pdata);
+}
+
+void MessageQueue::PostAt(int64_t tstamp,
+ MessageHandler* phandler,
+ uint32_t id,
+ MessageData* pdata) {
return DoDelayPost(TimeUntil(tstamp), tstamp, phandler, id, pdata);
}
void MessageQueue::DoDelayPost(int cmsDelay,
- uint32_t tstamp,
+ int64_t tstamp,
MessageHandler* phandler,
uint32_t id,
MessageData* pdata) {
diff --git a/webrtc/base/messagequeue.h b/webrtc/base/messagequeue.h
index 30746f6..4aa96eb 100644
--- a/webrtc/base/messagequeue.h
+++ b/webrtc/base/messagequeue.h
@@ -142,7 +142,7 @@
MessageHandler *phandler;
uint32_t message_id;
MessageData *pdata;
- uint32_t ts_sensitive;
+ int64_t ts_sensitive;
};
typedef std::list<Message> MessageList;
@@ -152,7 +152,7 @@
class DelayedMessage {
public:
- DelayedMessage(int delay, uint32_t trigger, uint32_t num, const Message& msg)
+ DelayedMessage(int delay, int64_t trigger, uint32_t num, const Message& msg)
: cmsDelay_(delay), msTrigger_(trigger), num_(num), msg_(msg) {}
bool operator< (const DelayedMessage& dmsg) const {
@@ -161,7 +161,7 @@
}
int cmsDelay_; // for debugging
- uint32_t msTrigger_;
+ int64_t msTrigger_;
uint32_t num_;
Message msg_;
};
@@ -212,6 +212,11 @@
MessageHandler* phandler,
uint32_t id = 0,
MessageData* pdata = NULL);
+ virtual void PostAt(int64_t tstamp,
+ MessageHandler* phandler,
+ uint32_t id = 0,
+ MessageData* pdata = NULL);
+ // TODO(honghaiz): Remove this when all the dependencies are removed.
virtual void PostAt(uint32_t tstamp,
MessageHandler* phandler,
uint32_t id = 0,
@@ -250,7 +255,7 @@
};
void DoDelayPost(int cmsDelay,
- uint32_t tstamp,
+ int64_t tstamp,
MessageHandler* phandler,
uint32_t id,
MessageData* pdata);
diff --git a/webrtc/base/messagequeue_unittest.cc b/webrtc/base/messagequeue_unittest.cc
index 31fb3bf..50c2ad0 100644
--- a/webrtc/base/messagequeue_unittest.cc
+++ b/webrtc/base/messagequeue_unittest.cc
@@ -54,7 +54,7 @@
static void DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder(
MessageQueue* q) {
EXPECT_TRUE(q != NULL);
- TimeStamp now = Time();
+ int64_t now = TimeMillis();
q->PostAt(now, NULL, 3);
q->PostAt(now - 2, NULL, 0);
q->PostAt(now - 1, NULL, 1);
diff --git a/webrtc/base/nullsocketserver_unittest.cc b/webrtc/base/nullsocketserver_unittest.cc
index 4f22c38..e18afb2 100644
--- a/webrtc/base/nullsocketserver_unittest.cc
+++ b/webrtc/base/nullsocketserver_unittest.cc
@@ -37,7 +37,7 @@
}
TEST_F(NullSocketServerTest, TestWait) {
- uint32_t start = Time();
+ int64_t start = TimeMillis();
ss_.Wait(200, true);
// The actual wait time is dependent on the resolution of the timer used by
// the Event class. Allow for the event to signal ~20ms early.
diff --git a/webrtc/base/physicalsocketserver.cc b/webrtc/base/physicalsocketserver.cc
index e2a0b6f..0230077 100644
--- a/webrtc/base/physicalsocketserver.cc
+++ b/webrtc/base/physicalsocketserver.cc
@@ -1470,9 +1470,9 @@
#if defined(WEBRTC_WIN)
bool PhysicalSocketServer::Wait(int cmsWait, bool process_io) {
- int cmsTotal = cmsWait;
- int cmsElapsed = 0;
- uint32_t msStart = Time();
+ int64_t cmsTotal = cmsWait;
+ int64_t cmsElapsed = 0;
+ int64_t msStart = Time();
fWait_ = true;
while (fWait_) {
@@ -1509,18 +1509,18 @@
// Which is shorter, the delay wait or the asked wait?
- int cmsNext;
+ int64_t cmsNext;
if (cmsWait == kForever) {
cmsNext = cmsWait;
} else {
- cmsNext = std::max(0, cmsTotal - cmsElapsed);
+ cmsNext = std::max<int64_t>(0, cmsTotal - cmsElapsed);
}
// Wait for one of the events to signal
DWORD dw = WSAWaitForMultipleEvents(static_cast<DWORD>(events.size()),
&events[0],
false,
- cmsNext,
+ static_cast<DWORD>(cmsNext),
false);
if (dw == WSA_WAIT_FAILED) {
diff --git a/webrtc/base/ratetracker.cc b/webrtc/base/ratetracker.cc
index c1ad2d5..a59ec2f 100644
--- a/webrtc/base/ratetracker.cc
+++ b/webrtc/base/ratetracker.cc
@@ -19,14 +19,16 @@
namespace rtc {
-RateTracker::RateTracker(uint32_t bucket_milliseconds, size_t bucket_count)
+static const int64_t kTimeUnset = -1;
+
+RateTracker::RateTracker(int64_t bucket_milliseconds, size_t bucket_count)
: bucket_milliseconds_(bucket_milliseconds),
bucket_count_(bucket_count),
sample_buckets_(new size_t[bucket_count + 1]),
total_sample_count_(0u),
- bucket_start_time_milliseconds_(~0u) {
- RTC_CHECK(bucket_milliseconds > 0u);
- RTC_CHECK(bucket_count > 0u);
+ bucket_start_time_milliseconds_(kTimeUnset) {
+ RTC_CHECK(bucket_milliseconds > 0);
+ RTC_CHECK(bucket_count > 0);
}
RateTracker::~RateTracker() {
@@ -34,33 +36,33 @@
}
double RateTracker::ComputeRateForInterval(
- uint32_t interval_milliseconds) const {
- if (bucket_start_time_milliseconds_ == ~0u) {
+ int64_t interval_milliseconds) const {
+ if (bucket_start_time_milliseconds_ == kTimeUnset) {
return 0.0;
}
- uint32_t current_time = Time();
+ int64_t current_time = Time();
// Calculate which buckets to sum up given the current time. If the time
// has passed to a new bucket then we have to skip some of the oldest buckets.
- uint32_t available_interval_milliseconds = std::min<uint32_t>(
- interval_milliseconds,
- bucket_milliseconds_ * static_cast<uint32_t>(bucket_count_));
+ int64_t available_interval_milliseconds =
+ std::min(interval_milliseconds,
+ bucket_milliseconds_ * static_cast<int64_t>(bucket_count_));
// number of old buckets (i.e. after the current bucket in the ring buffer)
// that are expired given our current time interval.
size_t buckets_to_skip;
// Number of milliseconds of the first bucket that are not a portion of the
// current interval.
- uint32_t milliseconds_to_skip;
+ int64_t milliseconds_to_skip;
if (current_time >
initialization_time_milliseconds_ + available_interval_milliseconds) {
- uint32_t time_to_skip =
+ int64_t time_to_skip =
current_time - bucket_start_time_milliseconds_ +
- static_cast<uint32_t>(bucket_count_) * bucket_milliseconds_ -
+ static_cast<int64_t>(bucket_count_) * bucket_milliseconds_ -
available_interval_milliseconds;
buckets_to_skip = time_to_skip / bucket_milliseconds_;
milliseconds_to_skip = time_to_skip % bucket_milliseconds_;
} else {
buckets_to_skip = bucket_count_ - current_bucket_;
- milliseconds_to_skip = 0u;
+ milliseconds_to_skip = 0;
available_interval_milliseconds =
TimeDiff(current_time, initialization_time_milliseconds_);
// Let one bucket interval pass after initialization before reporting.
@@ -70,8 +72,7 @@
}
// If we're skipping all buckets that means that there have been no samples
// within the sampling interval so report 0.
- if (buckets_to_skip > bucket_count_ ||
- available_interval_milliseconds == 0u) {
+ if (buckets_to_skip > bucket_count_ || available_interval_milliseconds == 0) {
return 0.0;
}
size_t start_bucket = NextBucketIndex(current_bucket_ + buckets_to_skip);
@@ -88,21 +89,21 @@
total_samples += sample_buckets_[i];
}
// Convert to samples per second.
- return static_cast<double>(total_samples * 1000u) /
- static_cast<double>(available_interval_milliseconds);
+ return static_cast<double>(total_samples * 1000) /
+ static_cast<double>(available_interval_milliseconds);
}
double RateTracker::ComputeTotalRate() const {
- if (bucket_start_time_milliseconds_ == ~0u) {
+ if (bucket_start_time_milliseconds_ == kTimeUnset) {
return 0.0;
}
- uint32_t current_time = Time();
- if (TimeIsLaterOrEqual(current_time, initialization_time_milliseconds_)) {
+ int64_t current_time = Time();
+ if (current_time <= initialization_time_milliseconds_) {
return 0.0;
}
- return static_cast<double>(total_sample_count_ * 1000u) /
- static_cast<double>(
- TimeDiff(current_time, initialization_time_milliseconds_));
+ return static_cast<double>(total_sample_count_ * 1000) /
+ static_cast<double>(
+ TimeDiff(current_time, initialization_time_milliseconds_));
}
size_t RateTracker::TotalSampleCount() const {
@@ -111,15 +112,16 @@
void RateTracker::AddSamples(size_t sample_count) {
EnsureInitialized();
- uint32_t current_time = Time();
+ int64_t current_time = Time();
// Advance the current bucket as needed for the current time, and reset
// bucket counts as we advance.
- for (size_t i = 0u; i <= bucket_count_ &&
- current_time >= bucket_start_time_milliseconds_ + bucket_milliseconds_;
- ++i) {
+ for (size_t i = 0;
+ i <= bucket_count_ &&
+ current_time >= bucket_start_time_milliseconds_ + bucket_milliseconds_;
+ ++i) {
bucket_start_time_milliseconds_ += bucket_milliseconds_;
current_bucket_ = NextBucketIndex(current_bucket_);
- sample_buckets_[current_bucket_] = 0u;
+ sample_buckets_[current_bucket_] = 0;
}
// Ensure that bucket_start_time_milliseconds_ is updated appropriately if
// the entire buffer of samples has been expired.
@@ -130,18 +132,18 @@
total_sample_count_ += sample_count;
}
-uint32_t RateTracker::Time() const {
- return rtc::Time();
+int64_t RateTracker::Time() const {
+ return rtc::TimeMillis();
}
void RateTracker::EnsureInitialized() {
- if (bucket_start_time_milliseconds_ == ~0u) {
+ if (bucket_start_time_milliseconds_ == kTimeUnset) {
initialization_time_milliseconds_ = Time();
bucket_start_time_milliseconds_ = initialization_time_milliseconds_;
- current_bucket_ = 0u;
+ current_bucket_ = 0;
// We only need to initialize the first bucket because we reset buckets when
// current_bucket_ increments.
- sample_buckets_[current_bucket_] = 0u;
+ sample_buckets_[current_bucket_] = 0;
}
}
diff --git a/webrtc/base/ratetracker.h b/webrtc/base/ratetracker.h
index d49d7ca..6ae9bec 100644
--- a/webrtc/base/ratetracker.h
+++ b/webrtc/base/ratetracker.h
@@ -21,19 +21,19 @@
// that over each bucket the rate was constant.
class RateTracker {
public:
- RateTracker(uint32_t bucket_milliseconds, size_t bucket_count);
+ RateTracker(int64_t bucket_milliseconds, size_t bucket_count);
virtual ~RateTracker();
// Computes the average rate over the most recent interval_milliseconds,
// or if the first sample was added within this period, computes the rate
// since the first sample was added.
- double ComputeRateForInterval(uint32_t interval_milliseconds) const;
+ double ComputeRateForInterval(int64_t interval_milliseconds) const;
// Computes the average rate over the rate tracker's recording interval
// of bucket_milliseconds * bucket_count.
double ComputeRate() const {
return ComputeRateForInterval(bucket_milliseconds_ *
- static_cast<uint32_t>(bucket_count_));
+ static_cast<int64_t>(bucket_count_));
}
// Computes the average rate since the first sample was added to the
@@ -49,19 +49,19 @@
protected:
// overrideable for tests
- virtual uint32_t Time() const;
+ virtual int64_t Time() const;
private:
void EnsureInitialized();
size_t NextBucketIndex(size_t bucket_index) const;
- const uint32_t bucket_milliseconds_;
+ const int64_t bucket_milliseconds_;
const size_t bucket_count_;
size_t* sample_buckets_;
size_t total_sample_count_;
size_t current_bucket_;
- uint32_t bucket_start_time_milliseconds_;
- uint32_t initialization_time_milliseconds_;
+ int64_t bucket_start_time_milliseconds_;
+ int64_t initialization_time_milliseconds_;
};
} // namespace rtc
diff --git a/webrtc/base/ratetracker_unittest.cc b/webrtc/base/ratetracker_unittest.cc
index 75fec55..136934f 100644
--- a/webrtc/base/ratetracker_unittest.cc
+++ b/webrtc/base/ratetracker_unittest.cc
@@ -19,11 +19,11 @@
class RateTrackerForTest : public RateTracker {
public:
RateTrackerForTest() : RateTracker(kBucketIntervalMs, 10u), time_(0) {}
- virtual uint32_t Time() const { return time_; }
- void AdvanceTime(uint32_t delta) { time_ += delta; }
+ virtual int64_t Time() const { return time_; }
+ void AdvanceTime(int delta) { time_ += delta; }
private:
- uint32_t time_;
+ int64_t time_;
};
TEST(RateTrackerTest, Test30FPS) {
@@ -36,7 +36,7 @@
tracker.AdvanceTime(1);
}
}
- EXPECT_DOUBLE_EQ(30.0, tracker.ComputeRateForInterval(50000u));
+ EXPECT_DOUBLE_EQ(30.0, tracker.ComputeRateForInterval(50000));
}
TEST(RateTrackerTest, Test60FPS) {
@@ -49,12 +49,12 @@
tracker.AdvanceTime(1);
}
}
- EXPECT_DOUBLE_EQ(60.0, tracker.ComputeRateForInterval(1000u));
+ EXPECT_DOUBLE_EQ(60.0, tracker.ComputeRateForInterval(1000));
}
TEST(RateTrackerTest, TestRateTrackerBasics) {
RateTrackerForTest tracker;
- EXPECT_DOUBLE_EQ(0.0, tracker.ComputeRateForInterval(1000u));
+ EXPECT_DOUBLE_EQ(0.0, tracker.ComputeRateForInterval(1000));
// Add a sample.
tracker.AddSamples(1234);
@@ -63,7 +63,7 @@
EXPECT_DOUBLE_EQ(0.0, tracker.ComputeRate());
// Advance the clock by 100 ms (one bucket interval).
tracker.AdvanceTime(1);
- EXPECT_DOUBLE_EQ(12340.0, tracker.ComputeRateForInterval(1000u));
+ EXPECT_DOUBLE_EQ(12340.0, tracker.ComputeRateForInterval(1000));
EXPECT_DOUBLE_EQ(12340.0, tracker.ComputeRate());
EXPECT_EQ(1234U, tracker.TotalSampleCount());
EXPECT_DOUBLE_EQ(12340.0, tracker.ComputeTotalRate());
@@ -71,7 +71,7 @@
// Repeat.
tracker.AddSamples(1234);
tracker.AdvanceTime(100);
- EXPECT_DOUBLE_EQ(12340.0, tracker.ComputeRateForInterval(1000u));
+ EXPECT_DOUBLE_EQ(12340.0, tracker.ComputeRateForInterval(1000));
EXPECT_DOUBLE_EQ(12340.0, tracker.ComputeRate());
EXPECT_EQ(1234U * 2, tracker.TotalSampleCount());
EXPECT_DOUBLE_EQ(12340.0, tracker.ComputeTotalRate());
@@ -79,20 +79,20 @@
// Advance the clock by 800 ms, so we've elapsed a full second.
// units_second should now be filled in properly.
tracker.AdvanceTime(800);
- EXPECT_DOUBLE_EQ(1234.0 * 2.0, tracker.ComputeRateForInterval(1000u));
+ EXPECT_DOUBLE_EQ(1234.0 * 2.0, tracker.ComputeRateForInterval(1000));
EXPECT_DOUBLE_EQ(1234.0 * 2.0, tracker.ComputeRate());
EXPECT_EQ(1234U * 2, tracker.TotalSampleCount());
EXPECT_DOUBLE_EQ(1234.0 * 2.0, tracker.ComputeTotalRate());
// Poll the tracker again immediately. The reported rate should stay the same.
- EXPECT_DOUBLE_EQ(1234.0 * 2.0, tracker.ComputeRateForInterval(1000u));
+ EXPECT_DOUBLE_EQ(1234.0 * 2.0, tracker.ComputeRateForInterval(1000));
EXPECT_DOUBLE_EQ(1234.0 * 2.0, tracker.ComputeRate());
EXPECT_EQ(1234U * 2, tracker.TotalSampleCount());
EXPECT_DOUBLE_EQ(1234.0 * 2.0, tracker.ComputeTotalRate());
// Do nothing and advance by a second. We should drop down to zero.
tracker.AdvanceTime(1000);
- EXPECT_DOUBLE_EQ(0.0, tracker.ComputeRateForInterval(1000u));
+ EXPECT_DOUBLE_EQ(0.0, tracker.ComputeRateForInterval(1000));
EXPECT_DOUBLE_EQ(0.0, tracker.ComputeRate());
EXPECT_EQ(1234U * 2, tracker.TotalSampleCount());
EXPECT_DOUBLE_EQ(1234.0, tracker.ComputeTotalRate());
@@ -103,7 +103,7 @@
tracker.AddSamples(9876U);
tracker.AdvanceTime(100);
}
- EXPECT_DOUBLE_EQ(9876.0 * 10.0, tracker.ComputeRateForInterval(1000u));
+ EXPECT_DOUBLE_EQ(9876.0 * 10.0, tracker.ComputeRateForInterval(1000));
EXPECT_DOUBLE_EQ(9876.0 * 10.0, tracker.ComputeRate());
EXPECT_EQ(1234U * 2 + 9876U * 55, tracker.TotalSampleCount());
EXPECT_DOUBLE_EQ((1234.0 * 2.0 + 9876.0 * 55.0) / 7.5,
@@ -112,14 +112,14 @@
// Advance the clock by 500 ms. Since we sent nothing over this half-second,
// the reported rate should be reduced by half.
tracker.AdvanceTime(500);
- EXPECT_DOUBLE_EQ(9876.0 * 5.0, tracker.ComputeRateForInterval(1000u));
+ EXPECT_DOUBLE_EQ(9876.0 * 5.0, tracker.ComputeRateForInterval(1000));
EXPECT_DOUBLE_EQ(9876.0 * 5.0, tracker.ComputeRate());
EXPECT_EQ(1234U * 2 + 9876U * 55, tracker.TotalSampleCount());
EXPECT_DOUBLE_EQ((1234.0 * 2.0 + 9876.0 * 55.0) / 8.0,
tracker.ComputeTotalRate());
// Rate over the last half second should be zero.
- EXPECT_DOUBLE_EQ(0.0, tracker.ComputeRateForInterval(500u));
+ EXPECT_DOUBLE_EQ(0.0, tracker.ComputeRateForInterval(500));
}
TEST(RateTrackerTest, TestLongPeriodBetweenSamples) {
@@ -149,7 +149,7 @@
tracker.AdvanceTime(50);
}
EXPECT_DOUBLE_EQ(15.0, tracker.ComputeRate());
- EXPECT_DOUBLE_EQ(20.0, tracker.ComputeRateForInterval(500u));
+ EXPECT_DOUBLE_EQ(20.0, tracker.ComputeRateForInterval(500));
for (int i = 0; i < 10; ++i) {
tracker.AddSamples(1U);
@@ -162,7 +162,7 @@
RateTrackerForTest tracker;
tracker.AddSamples(1234);
tracker.AdvanceTime(1000);
- EXPECT_DOUBLE_EQ(1234.0, tracker.ComputeRateForInterval(1000u));
+ EXPECT_DOUBLE_EQ(1234.0, tracker.ComputeRateForInterval(1000));
}
} // namespace rtc
diff --git a/webrtc/base/sharedexclusivelock_unittest.cc b/webrtc/base/sharedexclusivelock_unittest.cc
index 585f7ae..45902af 100644
--- a/webrtc/base/sharedexclusivelock_unittest.cc
+++ b/webrtc/base/sharedexclusivelock_unittest.cc
@@ -50,12 +50,12 @@
worker_thread_->Start();
}
- int waiting_time_in_ms() const { return waiting_time_in_ms_; }
+ int64_t waiting_time_in_ms() const { return waiting_time_in_ms_; }
protected:
std::unique_ptr<Thread> worker_thread_;
SharedExclusiveLock* shared_exclusive_lock_;
- int waiting_time_in_ms_;
+ int64_t waiting_time_in_ms_;
int* value_;
bool* done_;
};
@@ -79,10 +79,10 @@
TypedMessageData<int*>* message_data =
static_cast<TypedMessageData<int*>*>(message->pdata);
- uint32_t start_time = Time();
+ int64_t start_time = TimeMillis();
{
SharedScope ss(shared_exclusive_lock_);
- waiting_time_in_ms_ = TimeDiff(Time(), start_time);
+ waiting_time_in_ms_ = TimeDiff(TimeMillis(), start_time);
Thread::SleepMs(kProcessTimeInMs);
*message_data->data() = *value_;
@@ -112,10 +112,10 @@
TypedMessageData<int>* message_data =
static_cast<TypedMessageData<int>*>(message->pdata);
- uint32_t start_time = Time();
+ int64_t start_time = TimeMillis();
{
ExclusiveScope es(shared_exclusive_lock_);
- waiting_time_in_ms_ = TimeDiff(Time(), start_time);
+ waiting_time_in_ms_ = TimeDiff(TimeMillis(), start_time);
Thread::SleepMs(kProcessTimeInMs);
*value_ = message_data->data();
diff --git a/webrtc/base/task_unittest.cc b/webrtc/base/task_unittest.cc
index b09373e..f3ccc24 100644
--- a/webrtc/base/task_unittest.cc
+++ b/webrtc/base/task_unittest.cc
@@ -33,7 +33,7 @@
namespace rtc {
static int64_t GetCurrentTime() {
- return static_cast<int64_t>(Time()) * 10000;
+ return TimeMillis() * 10000;
}
// feel free to change these numbers. Note that '0' won't work, though
diff --git a/webrtc/base/thread.cc b/webrtc/base/thread.cc
index 7cbc972..3971169 100644
--- a/webrtc/base/thread.cc
+++ b/webrtc/base/thread.cc
@@ -482,7 +482,7 @@
}
bool Thread::ProcessMessages(int cmsLoop) {
- uint32_t msEnd = (kForever == cmsLoop) ? 0 : TimeAfter(cmsLoop);
+ int64_t msEnd = (kForever == cmsLoop) ? 0 : TimeAfter(cmsLoop);
int cmsNext = cmsLoop;
while (true) {
diff --git a/webrtc/base/timeutils.cc b/webrtc/base/timeutils.cc
index b222470..a9fe49d 100644
--- a/webrtc/base/timeutils.cc
+++ b/webrtc/base/timeutils.cc
@@ -30,8 +30,6 @@
namespace rtc {
-const uint32_t HALF = 0x80000000;
-
uint64_t TimeNanos() {
int64_t ticks = 0;
#if defined(WEBRTC_MAC)
@@ -90,27 +88,16 @@
return static_cast<uint64_t>(TimeNanos() / kNumNanosecsPerMicrosec);
}
-uint32_t TimeAfter(int32_t elapsed) {
+int64_t TimeAfter(int64_t elapsed) {
RTC_DCHECK_GE(elapsed, 0);
- RTC_DCHECK_LT(static_cast<uint32_t>(elapsed), HALF);
- return Time() + elapsed;
+ return TimeMillis() + elapsed;
}
-bool TimeIsLaterOrEqual(uint32_t earlier, uint32_t later) {
- int32_t diff = later - earlier;
- return (diff >= 0 && static_cast<uint32_t>(diff) < HALF);
-}
-
-bool TimeIsLater(uint32_t earlier, uint32_t later) {
- int32_t diff = later - earlier;
- return (diff > 0 && static_cast<uint32_t>(diff) < HALF);
-}
-
-int32_t TimeDiff(uint32_t later, uint32_t earlier) {
+int32_t TimeDiff32(uint32_t later, uint32_t earlier) {
return later - earlier;
}
-int64_t TimeDiff64(int64_t later, int64_t earlier) {
+int64_t TimeDiff(int64_t later, int64_t earlier) {
return later - earlier;
}
diff --git a/webrtc/base/timeutils.h b/webrtc/base/timeutils.h
index 52edbbf..222d5c2 100644
--- a/webrtc/base/timeutils.h
+++ b/webrtc/base/timeutils.h
@@ -29,58 +29,40 @@
static const int64_t kNumNanosecsPerMicrosec =
kNumNanosecsPerSec / kNumMicrosecsPerSec;
-typedef uint32_t TimeStamp;
+// TODO(honghaiz): Define a type for the time value specifically.
// Returns the current time in milliseconds in 32 bits.
uint32_t Time32();
// Returns the current time in milliseconds in 64 bits.
int64_t TimeMillis();
-
-// Returns the current time in milliseconds.
-// TODO(honghaiz): Change to return TimeMillis() once majority of the webrtc
-// code migrates to 64-bit timestamp.
-inline uint32_t Time() {
- return Time32();
+// Deprecated. Do not use this in any new code.
+inline int64_t Time() {
+ return TimeMillis();
}
// Returns the current time in microseconds.
uint64_t TimeMicros();
+
// Returns the current time in nanoseconds.
uint64_t TimeNanos();
// Returns a future timestamp, 'elapsed' milliseconds from now.
-uint32_t TimeAfter(int32_t elapsed);
-
-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;
-}
+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'.
-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);
+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 int32_t TimeSince(uint32_t earlier) {
- return TimeDiff(Time(), earlier);
+inline int64_t TimeSince(int64_t earlier) {
+ return TimeMillis() - earlier;
}
// The number of milliseconds that will elapse between now and 'later'.
-inline int32_t TimeUntil(uint32_t later) {
- return TimeDiff(later, Time());
+inline int64_t TimeUntil(uint64_t later) {
+ return later - TimeMillis();
}
class TimestampWrapAroundHandler {
diff --git a/webrtc/base/timeutils_unittest.cc b/webrtc/base/timeutils_unittest.cc
index 27784a9..0971c03 100644
--- a/webrtc/base/timeutils_unittest.cc
+++ b/webrtc/base/timeutils_unittest.cc
@@ -17,59 +17,21 @@
namespace rtc {
TEST(TimeTest, TimeInMs) {
- uint32_t ts_earlier = Time();
+ int64_t ts_earlier = TimeMillis();
Thread::SleepMs(100);
- uint32_t ts_now = Time();
+ int64_t ts_now = TimeMillis();
// Allow for the thread to wakeup ~20ms early.
EXPECT_GE(ts_now, ts_earlier + 80);
// Make sure the Time is not returning in smaller unit like microseconds.
EXPECT_LT(ts_now, ts_earlier + 1000);
}
-TEST(TimeTest, Comparison) {
- // Obtain two different times, in known order
- TimeStamp ts_earlier = Time();
- Thread::SleepMs(100);
- TimeStamp ts_now = Time();
- EXPECT_NE(ts_earlier, ts_now);
-
- // Common comparisons
- EXPECT_TRUE( TimeIsLaterOrEqual(ts_earlier, ts_now));
- EXPECT_TRUE( TimeIsLater( ts_earlier, ts_now));
- EXPECT_FALSE(TimeIsLaterOrEqual(ts_now, ts_earlier));
- EXPECT_FALSE(TimeIsLater( ts_now, ts_earlier));
-
- // Edge cases
- EXPECT_TRUE( TimeIsLaterOrEqual(ts_earlier, ts_earlier));
- EXPECT_FALSE(TimeIsLater( ts_earlier, ts_earlier));
-
- // Obtain a third time
- TimeStamp ts_later = TimeAfter(100);
- EXPECT_NE(ts_now, ts_later);
- EXPECT_TRUE( TimeIsLater(ts_now, ts_later));
- EXPECT_TRUE( TimeIsLater(ts_earlier, ts_later));
-
- // Earlier of two times
- EXPECT_EQ(ts_earlier, TimeMin(ts_earlier, ts_earlier));
- EXPECT_EQ(ts_earlier, TimeMin(ts_earlier, ts_now));
- EXPECT_EQ(ts_earlier, TimeMin(ts_earlier, ts_later));
- EXPECT_EQ(ts_earlier, TimeMin(ts_now, ts_earlier));
- EXPECT_EQ(ts_earlier, TimeMin(ts_later, ts_earlier));
-
- // Later of two times
- EXPECT_EQ(ts_earlier, TimeMax(ts_earlier, ts_earlier));
- EXPECT_EQ(ts_now, TimeMax(ts_earlier, ts_now));
- EXPECT_EQ(ts_later, TimeMax(ts_earlier, ts_later));
- EXPECT_EQ(ts_now, TimeMax(ts_now, ts_earlier));
- EXPECT_EQ(ts_later, TimeMax(ts_later, ts_earlier));
-}
-
TEST(TimeTest, Intervals) {
- TimeStamp ts_earlier = Time();
- TimeStamp ts_later = TimeAfter(500);
+ int64_t ts_earlier = TimeMillis();
+ int64_t ts_later = TimeAfter(500);
// We can't depend on ts_later and ts_earlier to be exactly 500 apart
- // since time elapses between the calls to Time() and TimeAfter(500)
+ // since time elapses between the calls to TimeMillis() and TimeAfter(500)
EXPECT_LE(500, TimeDiff(ts_later, ts_earlier));
EXPECT_GE(-500, TimeDiff(ts_earlier, ts_later));
@@ -87,33 +49,6 @@
EXPECT_LE(TimeUntil(ts_later), 500);
}
-TEST(TimeTest, BoundaryComparison) {
- // Obtain two different times, in known order
- TimeStamp ts_earlier = static_cast<TimeStamp>(-50);
- TimeStamp ts_later = ts_earlier + 100;
- EXPECT_NE(ts_earlier, ts_later);
-
- // Common comparisons
- EXPECT_TRUE( TimeIsLaterOrEqual(ts_earlier, ts_later));
- EXPECT_TRUE( TimeIsLater( ts_earlier, ts_later));
- EXPECT_FALSE(TimeIsLaterOrEqual(ts_later, ts_earlier));
- EXPECT_FALSE(TimeIsLater( ts_later, ts_earlier));
-
- // Earlier of two times
- EXPECT_EQ(ts_earlier, TimeMin(ts_earlier, ts_earlier));
- EXPECT_EQ(ts_earlier, TimeMin(ts_earlier, ts_later));
- EXPECT_EQ(ts_earlier, TimeMin(ts_later, ts_earlier));
-
- // Later of two times
- EXPECT_EQ(ts_earlier, TimeMax(ts_earlier, ts_earlier));
- EXPECT_EQ(ts_later, TimeMax(ts_earlier, ts_later));
- EXPECT_EQ(ts_later, TimeMax(ts_later, ts_earlier));
-
- // Interval
- EXPECT_EQ(100, TimeDiff(ts_later, ts_earlier));
- EXPECT_EQ(-100, TimeDiff(ts_earlier, ts_later));
-}
-
TEST(TimeTest, TestTimeDiff64) {
int64_t ts_diff = 100;
int64_t ts_earlier = rtc::TimeMillis();
diff --git a/webrtc/base/virtualsocket_unittest.cc b/webrtc/base/virtualsocket_unittest.cc
index bdbf06a..e633104 100644
--- a/webrtc/base/virtualsocket_unittest.cc
+++ b/webrtc/base/virtualsocket_unittest.cc
@@ -35,7 +35,7 @@
done(false),
rate(rt),
count(0) {
- last_send = rtc::Time();
+ last_send = rtc::TimeMillis();
thread->PostDelayed(NextDelay(), this, 1);
}
@@ -50,9 +50,9 @@
if (done)
return;
- uint32_t cur_time = rtc::Time();
- uint32_t delay = cur_time - last_send;
- uint32_t size = rate * delay / 1000;
+ int64_t cur_time = rtc::TimeMillis();
+ int64_t delay = cur_time - last_send;
+ uint32_t size = static_cast<uint32_t>(rate * delay / 1000);
size = std::min<uint32_t>(size, 4096);
size = std::max<uint32_t>(size, sizeof(uint32_t));
@@ -70,7 +70,7 @@
bool done;
uint32_t rate; // bytes per second
uint32_t count;
- uint32_t last_send;
+ int64_t last_send;
char dummy[4096];
};
@@ -103,7 +103,7 @@
sec_count += size;
uint32_t send_time = *reinterpret_cast<const uint32_t*>(data);
- uint32_t recv_time = rtc::Time();
+ uint32_t recv_time = rtc::TimeMillis();
uint32_t delay = recv_time - send_time;
sum += delay;
sum_sq += delay * delay;
diff --git a/webrtc/base/virtualsocketserver.cc b/webrtc/base/virtualsocketserver.cc
index f5b7db7..c6952b4 100644
--- a/webrtc/base/virtualsocketserver.cc
+++ b/webrtc/base/virtualsocketserver.cc
@@ -501,15 +501,25 @@
}
VirtualSocketServer::VirtualSocketServer(SocketServer* ss)
- : server_(ss), server_owned_(false), msg_queue_(NULL), stop_on_idle_(false),
- network_delay_(Time()), next_ipv4_(kInitialNextIPv4),
- next_ipv6_(kInitialNextIPv6), next_port_(kFirstEphemeralPort),
- bindings_(new AddressMap()), connections_(new ConnectionMap()),
- bandwidth_(0), network_capacity_(kDefaultNetworkCapacity),
+ : server_(ss),
+ server_owned_(false),
+ msg_queue_(NULL),
+ stop_on_idle_(false),
+ network_delay_(TimeMillis()),
+ next_ipv4_(kInitialNextIPv4),
+ next_ipv6_(kInitialNextIPv6),
+ next_port_(kFirstEphemeralPort),
+ bindings_(new AddressMap()),
+ connections_(new ConnectionMap()),
+ bandwidth_(0),
+ network_capacity_(kDefaultNetworkCapacity),
send_buffer_capacity_(kDefaultTcpBufferSize),
recv_buffer_capacity_(kDefaultTcpBufferSize),
- delay_mean_(0), delay_stddev_(0), delay_samples_(NUM_SAMPLES),
- delay_dist_(NULL), drop_prob_(0.0) {
+ delay_mean_(0),
+ delay_stddev_(0),
+ delay_samples_(NUM_SAMPLES),
+ delay_dist_(NULL),
+ drop_prob_(0.0) {
if (!server_) {
server_ = new PhysicalSocketServer();
server_owned_ = true;
@@ -792,7 +802,7 @@
CritScope cs(&socket->crit_);
- uint32_t cur_time = Time();
+ int64_t cur_time = TimeMillis();
PurgeNetworkPackets(socket, cur_time);
// Determine whether we have enough bandwidth to accept this packet. To do
@@ -832,7 +842,7 @@
CritScope cs(&socket->crit_);
- uint32_t cur_time = Time();
+ int64_t cur_time = TimeMillis();
PurgeNetworkPackets(socket, cur_time);
while (true) {
@@ -867,7 +877,7 @@
void VirtualSocketServer::AddPacketToNetwork(VirtualSocket* sender,
VirtualSocket* recipient,
- uint32_t cur_time,
+ int64_t cur_time,
const char* data,
size_t data_size,
size_t header_size,
@@ -895,19 +905,19 @@
// Post the packet as a message to be delivered (on our own thread)
Packet* p = new Packet(data, data_size, sender_addr);
- uint32_t ts = TimeAfter(send_delay + transit_delay);
+ int64_t ts = TimeAfter(send_delay + transit_delay);
if (ordered) {
// Ensure that new packets arrive after previous ones
// TODO: consider ordering on a per-socket basis, since this
- // introduces artifical delay.
- ts = TimeMax(ts, network_delay_);
+ // introduces artificial delay.
+ ts = std::max(ts, network_delay_);
}
msg_queue_->PostAt(ts, recipient, MSG_ID_PACKET, p);
- network_delay_ = TimeMax(ts, network_delay_);
+ network_delay_ = std::max(ts, network_delay_);
}
void VirtualSocketServer::PurgeNetworkPackets(VirtualSocket* socket,
- uint32_t cur_time) {
+ int64_t cur_time) {
while (!socket->network_.empty() &&
(socket->network_.front().done_time <= cur_time)) {
ASSERT(socket->network_size_ >= socket->network_.front().size);
diff --git a/webrtc/base/virtualsocketserver.h b/webrtc/base/virtualsocketserver.h
index c3dc8c8..a83be28 100644
--- a/webrtc/base/virtualsocketserver.h
+++ b/webrtc/base/virtualsocketserver.h
@@ -169,14 +169,14 @@
// Places a packet on the network.
void AddPacketToNetwork(VirtualSocket* socket,
VirtualSocket* recipient,
- uint32_t cur_time,
+ int64_t cur_time,
const char* data,
size_t data_size,
size_t header_size,
bool ordered);
// Removes stale packets from the network
- void PurgeNetworkPackets(VirtualSocket* socket, uint32_t cur_time);
+ void PurgeNetworkPackets(VirtualSocket* socket, int64_t cur_time);
// Computes the number of milliseconds required to send a packet of this size.
uint32_t SendDelay(uint32_t size);
@@ -227,7 +227,7 @@
bool server_owned_;
MessageQueue* msg_queue_;
bool stop_on_idle_;
- uint32_t network_delay_;
+ int64_t network_delay_;
in_addr next_ipv4_;
in6_addr next_ipv6_;
uint16_t next_port_;
@@ -293,7 +293,7 @@
private:
struct NetworkEntry {
size_t size;
- uint32_t done_time;
+ int64_t done_time;
};
typedef std::deque<SocketAddress> ListenQueue;
diff --git a/webrtc/base/win32socketserver.cc b/webrtc/base/win32socketserver.cc
index 72ce4eb..5423eed 100644
--- a/webrtc/base/win32socketserver.cc
+++ b/webrtc/base/win32socketserver.cc
@@ -627,7 +627,7 @@
if (error != ERROR_SUCCESS) {
ReportWSAError("WSAAsync:connect notify", error, addr_);
#if !defined(NDEBUG)
- int32_t duration = TimeSince(connect_time_);
+ int64_t duration = TimeSince(connect_time_);
LOG(LS_INFO) << "WSAAsync:connect error (" << duration
<< " ms), faking close";
#endif
@@ -640,7 +640,7 @@
SignalCloseEvent(this, error);
} else {
#if !defined(NDEBUG)
- int32_t duration = TimeSince(connect_time_);
+ int64_t duration = TimeSince(connect_time_);
LOG(LS_INFO) << "WSAAsync:connect (" << duration << " ms)";
#endif
state_ = CS_CONNECTED;
diff --git a/webrtc/base/win32socketserver.h b/webrtc/base/win32socketserver.h
index b468cfd..f47ed75 100644
--- a/webrtc/base/win32socketserver.h
+++ b/webrtc/base/win32socketserver.h
@@ -159,6 +159,6 @@
} // namespace rtc
-#endif // WEBRTC_WIN
+#endif // WEBRTC_WIN
#endif // WEBRTC_BASE_WIN32SOCKETSERVER_H_
diff --git a/webrtc/libjingle/xmpp/pingtask.cc b/webrtc/libjingle/xmpp/pingtask.cc
index 3df7b85..ad4566a 100644
--- a/webrtc/libjingle/xmpp/pingtask.cc
+++ b/webrtc/libjingle/xmpp/pingtask.cc
@@ -57,7 +57,7 @@
ping_response_deadline_ = 0;
}
- uint32_t now = rtc::Time();
+ int64_t now = rtc::TimeMillis();
// If the ping timed out, signal.
if (ping_response_deadline_ != 0 && now >= ping_response_deadline_) {
diff --git a/webrtc/libjingle/xmpp/pingtask.h b/webrtc/libjingle/xmpp/pingtask.h
index 22fd94d..b070a1c 100644
--- a/webrtc/libjingle/xmpp/pingtask.h
+++ b/webrtc/libjingle/xmpp/pingtask.h
@@ -46,8 +46,8 @@
rtc::MessageQueue* message_queue_;
uint32_t ping_period_millis_;
uint32_t ping_timeout_millis_;
- uint32_t next_ping_time_;
- uint32_t ping_response_deadline_; // 0 if the response has been received
+ int64_t next_ping_time_;
+ int64_t ping_response_deadline_; // 0 if the response has been received
};
} // namespace buzz
diff --git a/webrtc/libjingle/xmpp/xmpppump.cc b/webrtc/libjingle/xmpp/xmpppump.cc
index a428ffa..4412483 100644
--- a/webrtc/libjingle/xmpp/xmpppump.cc
+++ b/webrtc/libjingle/xmpp/xmpppump.cc
@@ -50,7 +50,7 @@
}
int64_t XmppPump::CurrentTime() {
- return (int64_t)rtc::Time();
+ return (int64_t)rtc::TimeMillis();
}
void XmppPump::OnMessage(rtc::Message *pmsg) {
diff --git a/webrtc/media/base/rtpdump.cc b/webrtc/media/base/rtpdump.cc
index a109f2d..2460859 100644
--- a/webrtc/media/base/rtpdump.cc
+++ b/webrtc/media/base/rtpdump.cc
@@ -28,13 +28,12 @@
const char RtpDumpFileHeader::kFirstLine[] = "#!rtpplay1.0 0.0.0.0/0\n";
-RtpDumpFileHeader::RtpDumpFileHeader(uint32_t start_ms, uint32_t s, uint16_t p)
- : start_sec(start_ms / 1000),
- start_usec(start_ms % 1000 * 1000),
+RtpDumpFileHeader::RtpDumpFileHeader(int64_t start_ms, uint32_t s, uint16_t p)
+ : start_sec(static_cast<uint32_t>(start_ms / 1000)),
+ start_usec(static_cast<uint32_t>(start_ms % 1000 * 1000)),
source(s),
port(p),
- padding(0) {
-}
+ padding(0) {}
void RtpDumpFileHeader::WriteToByteBuffer(rtc::ByteBufferWriter* buf) {
buf->WriteUInt32(start_sec);
@@ -44,7 +43,7 @@
buf->WriteUInt16(padding);
}
-static const uint32_t kDefaultTimeIncrease = 30;
+static const int kDefaultTimeIncrease = 30;
bool RtpDumpPacket::IsValidRtpPacket() const {
return original_data_len >= data.size() &&
@@ -162,7 +161,7 @@
uint32_t start_usec;
buf.ReadUInt32(&start_sec);
buf.ReadUInt32(&start_usec);
- start_time_ms_ = start_sec * 1000 + start_usec / 1000;
+ start_time_ms_ = static_cast<int64_t>(start_sec * 1000 + start_usec / 1000);
// Increase the length by 1 since first_line does not contain the ending \n.
first_line_and_file_header_len_ = first_line.size() + 1 + sizeof(header);
}
@@ -305,9 +304,8 @@
: stream_(stream),
packet_filter_(PF_ALL),
file_header_written_(false),
- start_time_ms_(rtc::Time()),
- warn_slow_writes_delay_(kWarnSlowWritesDelayMs) {
-}
+ start_time_ms_(rtc::TimeMillis()),
+ warn_slow_writes_delay_(kWarnSlowWritesDelayMs) {}
void RtpDumpWriter::set_packet_filter(int filter) {
packet_filter_ = filter;
@@ -315,7 +313,7 @@
}
uint32_t RtpDumpWriter::GetElapsedTime() const {
- return rtc::TimeSince(start_time_ms_);
+ return static_cast<uint32_t>(rtc::TimeSince(start_time_ms_));
}
rtc::StreamResult RtpDumpWriter::WriteFileHeader() {
@@ -327,7 +325,7 @@
}
rtc::ByteBufferWriter buf;
- RtpDumpFileHeader file_header(rtc::Time(), 0, 0);
+ RtpDumpFileHeader file_header(rtc::TimeMillis(), 0, 0);
file_header.WriteToByteBuffer(&buf);
return WriteToStream(buf.Data(), buf.Length());
}
@@ -395,10 +393,10 @@
rtc::StreamResult RtpDumpWriter::WriteToStream(
const void* data, size_t data_len) {
- uint32_t before = rtc::Time();
+ int64_t before = rtc::TimeMillis();
rtc::StreamResult result =
stream_->WriteAll(data, data_len, NULL, NULL);
- uint32_t delay = rtc::TimeSince(before);
+ int64_t delay = rtc::TimeSince(before);
if (delay >= warn_slow_writes_delay_) {
LOG(LS_WARNING) << "Slow RtpDump: took " << delay << "ms to write "
<< data_len << " bytes.";
diff --git a/webrtc/media/base/rtpdump.h b/webrtc/media/base/rtpdump.h
index 395408c..8ea7800 100644
--- a/webrtc/media/base/rtpdump.h
+++ b/webrtc/media/base/rtpdump.h
@@ -40,7 +40,7 @@
};
struct RtpDumpFileHeader {
- RtpDumpFileHeader(uint32_t start_ms, uint32_t s, uint16_t p);
+ RtpDumpFileHeader(int64_t start_ms, uint32_t s, uint16_t p);
void WriteToByteBuffer(rtc::ByteBufferWriter* buf);
static const char kFirstLine[];
@@ -113,7 +113,7 @@
rtc::StreamInterface* stream_;
bool file_header_read_;
size_t first_line_and_file_header_len_;
- uint32_t start_time_ms_;
+ int64_t start_time_ms_;
uint32_t ssrc_override_;
RTC_DISALLOW_COPY_AND_ASSIGN(RtpDumpReader);
@@ -159,10 +159,10 @@
// the previous dump packets in the input stream.
uint32_t first_elapsed_time_;
int first_rtp_seq_num_;
- uint32_t first_rtp_timestamp_;
+ int64_t first_rtp_timestamp_;
uint32_t prev_elapsed_time_;
int prev_rtp_seq_num_;
- uint32_t prev_rtp_timestamp_;
+ int64_t prev_rtp_timestamp_;
RTC_DISALLOW_COPY_AND_ASSIGN(RtpDumpLoopReader);
};
@@ -207,9 +207,9 @@
rtc::StreamInterface* stream_;
int packet_filter_;
bool file_header_written_;
- uint32_t start_time_ms_; // Time when the record starts.
+ int64_t start_time_ms_; // Time when the record starts.
// If writing to the stream takes longer than this many ms, log a warning.
- uint32_t warn_slow_writes_delay_;
+ int64_t warn_slow_writes_delay_;
RTC_DISALLOW_COPY_AND_ASSIGN(RtpDumpWriter);
};
diff --git a/webrtc/media/engine/webrtcvideocapturer.cc b/webrtc/media/engine/webrtcvideocapturer.cc
index a540551..71c8841 100644
--- a/webrtc/media/engine/webrtcvideocapturer.cc
+++ b/webrtc/media/engine/webrtcvideocapturer.cc
@@ -278,7 +278,7 @@
return CS_FAILED;
}
- uint32_t start = rtc::Time();
+ int64_t start = rtc::TimeMillis();
module_->RegisterCaptureDataCallback(*this);
if (module_->StartCapture(cap) != 0) {
LOG(LS_ERROR) << "Camera '" << GetId() << "' failed to start";
diff --git a/webrtc/media/engine/webrtcvideoengine2.cc b/webrtc/media/engine/webrtcvideoengine2.cc
index 383f29a..785ec69 100644
--- a/webrtc/media/engine/webrtcvideoengine2.cc
+++ b/webrtc/media/engine/webrtcvideoengine2.cc
@@ -1591,7 +1591,7 @@
// frame->GetTimeStamp() is essentially a delta, align to webrtc time
if (!first_frame_timestamp_ms_) {
first_frame_timestamp_ms_ =
- rtc::Optional<int64_t>(rtc::Time() - frame_delta_ms);
+ rtc::Optional<int64_t>(rtc::TimeMillis() - frame_delta_ms);
}
last_frame_timestamp_ms_ = *first_frame_timestamp_ms_ + frame_delta_ms;
diff --git a/webrtc/p2p/base/port.cc b/webrtc/p2p/base/port.cc
index 46c9d70..a353dc2 100644
--- a/webrtc/p2p/base/port.cc
+++ b/webrtc/p2p/base/port.cc
@@ -789,8 +789,8 @@
last_ping_received_(0),
last_data_received_(0),
last_ping_response_received_(0),
- recv_rate_tracker_(100u, 10u),
- send_rate_tracker_(100u, 10u),
+ recv_rate_tracker_(100, 10u),
+ send_rate_tracker_(100, 10u),
sent_packets_discarded_(0),
sent_packets_total_(0),
reported_(false),
diff --git a/webrtc/p2p/base/pseudotcp.cc b/webrtc/p2p/base/pseudotcp.cc
index 612623b..42f6bad 100644
--- a/webrtc/p2p/base/pseudotcp.cc
+++ b/webrtc/p2p/base/pseudotcp.cc
@@ -203,9 +203,9 @@
uint32_t PseudoTcp::Now() {
#if 0 // Use this to synchronize timers with logging timestamps (easier debug)
- return rtc::TimeSince(StartTime());
+ return static_cast<uint32_t>(rtc::TimeSince(StartTime()));
#else
- return rtc::Time();
+ return rtc::Time32();
#endif
}
@@ -289,7 +289,7 @@
return;
// Check if it's time to retransmit a segment
- if (m_rto_base && (rtc::TimeDiff(m_rto_base + m_rx_rto, now) <= 0)) {
+ if (m_rto_base && (rtc::TimeDiff32(m_rto_base + m_rx_rto, now) <= 0)) {
if (m_slist.empty()) {
ASSERT(false);
} else {
@@ -320,9 +320,8 @@
}
// Check if it's time to probe closed windows
- if ((m_snd_wnd == 0)
- && (rtc::TimeDiff(m_lastsend + m_rx_rto, now) <= 0)) {
- if (rtc::TimeDiff(now, m_lastrecv) >= 15000) {
+ if ((m_snd_wnd == 0) && (rtc::TimeDiff32(m_lastsend + m_rx_rto, now) <= 0)) {
+ if (rtc::TimeDiff32(now, m_lastrecv) >= 15000) {
closedown(ECONNABORTED);
return;
}
@@ -336,19 +335,22 @@
}
// Check if it's time to send delayed acks
- if (m_t_ack && (rtc::TimeDiff(m_t_ack + m_ack_delay, now) <= 0)) {
+ if (m_t_ack && (rtc::TimeDiff32(m_t_ack + m_ack_delay, now) <= 0)) {
packet(m_snd_nxt, 0, 0, 0);
}
#if PSEUDO_KEEPALIVE
// Check for idle timeout
- if ((m_state == TCP_ESTABLISHED) && (TimeDiff(m_lastrecv + IDLE_TIMEOUT, now) <= 0)) {
+ if ((m_state == TCP_ESTABLISHED) &&
+ (TimeDiff32(m_lastrecv + IDLE_TIMEOUT, now) <= 0)) {
closedown(ECONNABORTED);
return;
}
// Check for ping timeout (to keep udp mapping open)
- if ((m_state == TCP_ESTABLISHED) && (TimeDiff(m_lasttraffic + (m_bOutgoing ? IDLE_PING * 3/2 : IDLE_PING), now) <= 0)) {
+ if ((m_state == TCP_ESTABLISHED) &&
+ (TimeDiff32(m_lasttraffic + (m_bOutgoing ? IDLE_PING * 3 / 2 : IDLE_PING),
+ now) <= 0)) {
packet(m_snd_nxt, 0, 0, 0);
}
#endif // PSEUDO_KEEPALIVE
@@ -621,23 +623,24 @@
nTimeout = DEFAULT_TIMEOUT;
if (m_t_ack) {
- nTimeout =
- std::min<int32_t>(nTimeout, rtc::TimeDiff(m_t_ack + m_ack_delay, now));
+ nTimeout = std::min<int32_t>(nTimeout,
+ rtc::TimeDiff32(m_t_ack + m_ack_delay, now));
}
if (m_rto_base) {
- nTimeout =
- std::min<int32_t>(nTimeout, rtc::TimeDiff(m_rto_base + m_rx_rto, now));
+ nTimeout = std::min<int32_t>(nTimeout,
+ rtc::TimeDiff32(m_rto_base + m_rx_rto, now));
}
if (m_snd_wnd == 0) {
- nTimeout =
- std::min<int32_t>(nTimeout, rtc::TimeDiff(m_lastsend + m_rx_rto, now));
+ nTimeout = std::min<int32_t>(nTimeout,
+ rtc::TimeDiff32(m_lastsend + m_rx_rto, now));
}
#if PSEUDO_KEEPALIVE
if (m_state == TCP_ESTABLISHED) {
nTimeout = std::min<int32_t>(
- nTimeout, rtc::TimeDiff(m_lasttraffic + (m_bOutgoing ? IDLE_PING * 3 / 2
- : IDLE_PING),
- now));
+ nTimeout,
+ rtc::TimeDiff32(
+ m_lasttraffic + (m_bOutgoing ? IDLE_PING * 3 / 2 : IDLE_PING),
+ now));
}
#endif // PSEUDO_KEEPALIVE
return true;
@@ -710,7 +713,7 @@
if ((seg.ack > m_snd_una) && (seg.ack <= m_snd_nxt)) {
// Calculate round-trip time
if (seg.tsecr) {
- int32_t rtt = rtc::TimeDiff(now, seg.tsecr);
+ int32_t rtt = rtc::TimeDiff32(now, seg.tsecr);
if (rtt >= 0) {
if (m_rx_srtt == 0) {
m_rx_srtt = rtt;
@@ -1033,7 +1036,7 @@
void PseudoTcp::attemptSend(SendFlags sflags) {
uint32_t now = Now();
- if (rtc::TimeDiff(now, m_lastsend) > static_cast<long>(m_rx_rto)) {
+ if (rtc::TimeDiff32(now, m_lastsend) > static_cast<long>(m_rx_rto)) {
m_cwnd = m_mss;
}
diff --git a/webrtc/p2p/base/pseudotcp_unittest.cc b/webrtc/p2p/base/pseudotcp_unittest.cc
index c9ccbca..a635bce 100644
--- a/webrtc/p2p/base/pseudotcp_unittest.cc
+++ b/webrtc/p2p/base/pseudotcp_unittest.cc
@@ -208,7 +208,8 @@
class PseudoTcpTest : public PseudoTcpTestBase {
public:
void TestTransfer(int size) {
- uint32_t start, elapsed;
+ uint32_t start;
+ int32_t elapsed;
size_t received;
// Create some dummy data to send.
send_stream_.ReserveSize(size);
@@ -220,13 +221,13 @@
// Prepare the receive stream.
recv_stream_.ReserveSize(size);
// Connect and wait until connected.
- start = rtc::Time();
+ start = rtc::Time32();
EXPECT_EQ(0, Connect());
EXPECT_TRUE_WAIT(have_connected_, kConnectTimeoutMs);
// Sending will start from OnTcpWriteable and complete when all data has
// been received.
EXPECT_TRUE_WAIT(have_disconnected_, kTransferTimeoutMs);
- elapsed = rtc::TimeSince(start);
+ elapsed = rtc::Time32() - start;
recv_stream_.GetSize(&received);
// Ensure we closed down OK and we got the right data.
// TODO: Ensure the errors are cleared properly.
@@ -339,7 +340,7 @@
// Prepare the receive stream.
recv_stream_.ReserveSize(size);
// Connect and wait until connected.
- start = rtc::Time();
+ start = rtc::Time32();
EXPECT_EQ(0, Connect());
EXPECT_TRUE_WAIT(have_connected_, kConnectTimeoutMs);
// Sending will start from OnTcpWriteable and stop when the required
diff --git a/webrtc/p2p/base/stunport.cc b/webrtc/p2p/base/stunport.cc
index 078070b..8ed8c44 100644
--- a/webrtc/p2p/base/stunport.cc
+++ b/webrtc/p2p/base/stunport.cc
@@ -87,7 +87,7 @@
int64_t now = rtc::TimeMillis();
if (WithinLifetime(now) &&
- rtc::TimeDiff64(now, start_time_) < RETRY_TIMEOUT) {
+ rtc::TimeDiff(now, start_time_) < RETRY_TIMEOUT) {
port_->requests_.SendDelayed(
new StunBindingRequest(port_, server_addr_, start_time_, lifetime_),
port_->stun_keepalive_delay());
@@ -105,7 +105,7 @@
// Returns true if |now| is within the lifetime of the request (a negative
// lifetime means infinite).
bool WithinLifetime(int64_t now) const {
- return lifetime_ < 0 || rtc::TimeDiff64(now, start_time_) <= lifetime_;
+ return lifetime_ < 0 || rtc::TimeDiff(now, start_time_) <= lifetime_;
}
UDPPort* port_;
const rtc::SocketAddress server_addr_;
diff --git a/webrtc/pc/currentspeakermonitor.cc b/webrtc/pc/currentspeakermonitor.cc
index e84aa82..ce0d579 100644
--- a/webrtc/pc/currentspeakermonitor.cc
+++ b/webrtc/pc/currentspeakermonitor.cc
@@ -63,7 +63,7 @@
}
void CurrentSpeakerMonitor::set_min_time_between_switches(
- uint32_t min_time_between_switches) {
+ int min_time_between_switches) {
min_time_between_switches_ = min_time_between_switches;
}
@@ -165,7 +165,7 @@
// We avoid over-switching by disabling switching for a period of time after
// a switch is done.
- uint32_t now = rtc::Time();
+ int64_t now = rtc::TimeMillis();
if (earliest_permitted_switch_time_ <= now &&
current_speaker_ssrc_ != loudest_speaker_ssrc) {
current_speaker_ssrc_ = loudest_speaker_ssrc;
diff --git a/webrtc/pc/currentspeakermonitor.h b/webrtc/pc/currentspeakermonitor.h
index 19a61f9..730ded0 100644
--- a/webrtc/pc/currentspeakermonitor.h
+++ b/webrtc/pc/currentspeakermonitor.h
@@ -54,7 +54,7 @@
// Used by tests. Note that the actual minimum time between switches
// enforced by the monitor will be the given value plus or minus the
// resolution of the system clock.
- void set_min_time_between_switches(uint32_t min_time_between_switches);
+ void set_min_time_between_switches(int min_time_between_switches);
// This is fired when the current speaker changes, and provides his audio
// SSRC. This only fires after the audio monitor on the underlying
@@ -86,8 +86,8 @@
uint32_t current_speaker_ssrc_;
// To prevent overswitching, switching is disabled for some time after a
// switch is made. This gives us the earliest time a switch is permitted.
- uint32_t earliest_permitted_switch_time_;
- uint32_t min_time_between_switches_;
+ int64_t earliest_permitted_switch_time_;
+ int min_time_between_switches_;
};
} // namespace cricket
diff --git a/webrtc/pc/srtpfilter.cc b/webrtc/pc/srtpfilter.cc
index e8ea289..e4796fd 100644
--- a/webrtc/pc/srtpfilter.cc
+++ b/webrtc/pc/srtpfilter.cc
@@ -259,7 +259,7 @@
return send_session_->GetRtpAuthParams(key, key_len, tag_len);
}
-void SrtpFilter::set_signal_silent_time(uint32_t signal_silent_time_in_ms) {
+void SrtpFilter::set_signal_silent_time(int signal_silent_time_in_ms) {
signal_silent_time_in_ms_ = signal_silent_time_in_ms;
if (IsActive()) {
ASSERT(send_session_ != NULL);
@@ -641,7 +641,7 @@
return true;
}
-void SrtpSession::set_signal_silent_time(uint32_t signal_silent_time_in_ms) {
+void SrtpSession::set_signal_silent_time(int signal_silent_time_in_ms) {
srtp_stat_->set_signal_silent_time(signal_silent_time_in_ms);
}
@@ -891,10 +891,10 @@
if (key.error != SrtpFilter::ERROR_NONE) {
// For errors, signal first time and wait for 1 sec.
FailureStat* stat = &(failures_[key]);
- uint32_t current_time = rtc::Time();
+ int64_t current_time = rtc::TimeMillis();
if (stat->last_signal_time == 0 ||
rtc::TimeDiff(current_time, stat->last_signal_time) >
- static_cast<int>(signal_silent_time_)) {
+ signal_silent_time_) {
SignalSrtpError(key.ssrc, key.mode, key.error);
stat->last_signal_time = current_time;
}
diff --git a/webrtc/pc/srtpfilter.h b/webrtc/pc/srtpfilter.h
index 523ac1d..b54eb8b 100644
--- a/webrtc/pc/srtpfilter.h
+++ b/webrtc/pc/srtpfilter.h
@@ -120,7 +120,7 @@
bool GetRtpAuthParams(uint8_t** key, int* key_len, int* tag_len);
// Update the silent threshold (in ms) for signaling errors.
- void set_signal_silent_time(uint32_t signal_silent_time_in_ms);
+ void set_signal_silent_time(int signal_silent_time_in_ms);
bool ResetParams();
@@ -166,7 +166,7 @@
ST_RECEIVEDPRANSWER
};
State state_;
- uint32_t signal_silent_time_in_ms_;
+ int signal_silent_time_in_ms_;
std::vector<CryptoParams> offer_params_;
std::unique_ptr<SrtpSession> send_session_;
std::unique_ptr<SrtpSession> recv_session_;
@@ -208,7 +208,7 @@
bool GetRtpAuthParams(uint8_t** key, int* key_len, int* tag_len);
// Update the silent threshold (in ms) for signaling errors.
- void set_signal_silent_time(uint32_t signal_silent_time_in_ms);
+ void set_signal_silent_time(int signal_silent_time_in_ms);
// Calls srtp_shutdown if it's initialized.
static void Terminate();
@@ -252,9 +252,9 @@
void AddUnprotectRtcpResult(int result);
// Get silent time (in ms) for SRTP statistics handler.
- uint32_t signal_silent_time() const { return signal_silent_time_; }
+ int signal_silent_time() const { return signal_silent_time_; }
// Set silent time (in ms) for SRTP statistics handler.
- void set_signal_silent_time(uint32_t signal_silent_time) {
+ void set_signal_silent_time(int signal_silent_time) {
signal_silent_time_ = signal_silent_time;
}
@@ -296,7 +296,7 @@
void Reset() {
last_signal_time = 0;
}
- uint32_t last_signal_time;
+ int64_t last_signal_time;
};
// Inspect SRTP result and signal error if needed.
@@ -304,7 +304,7 @@
std::map<FailureKey, FailureStat> failures_;
// Threshold in ms to silent the signaling errors.
- uint32_t signal_silent_time_;
+ int signal_silent_time_;
RTC_DISALLOW_COPY_AND_ASSIGN(SrtpStat);
};
diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc
index f59044c..8b2abc8 100644
--- a/webrtc/video/end_to_end_tests.cc
+++ b/webrtc/video/end_to_end_tests.cc
@@ -19,7 +19,6 @@
#include "webrtc/base/checks.h"
#include "webrtc/base/event.h"
-#include "webrtc/base/timeutils.h"
#include "webrtc/call.h"
#include "webrtc/call/transport_adapter.h"
#include "webrtc/common_video/include/frame_callback.h"
@@ -2934,7 +2933,9 @@
} else {
// Verify timestamps are reasonably close.
uint32_t latest_observed = timestamp_it->second;
- int32_t timestamp_gap = rtc::TimeDiff(timestamp, latest_observed);
+ // Wraparound handling is unnecessary here as long as an int variable
+ // is used to store the result.
+ int32_t timestamp_gap = timestamp - latest_observed;
EXPECT_LE(std::abs(timestamp_gap), kMaxTimestampGap)
<< "Gap in timestamps (" << latest_observed << " -> "
<< timestamp << ") too large for SSRC: " << ssrc << ".";
diff --git a/webrtc/video/receive_statistics_proxy.cc b/webrtc/video/receive_statistics_proxy.cc
index 0b8f12b..4757efa 100644
--- a/webrtc/video/receive_statistics_proxy.cc
+++ b/webrtc/video/receive_statistics_proxy.cc
@@ -27,8 +27,8 @@
// 1000ms window, scale 1000 for ms to s.
decode_fps_estimator_(1000, 1000),
renders_fps_estimator_(1000, 1000),
- render_fps_tracker_(100u, 10u),
- render_pixel_tracker_(100u, 10u) {
+ render_fps_tracker_(100, 10u),
+ render_pixel_tracker_(100, 10u) {
stats_.ssrc = config.rtp.remote_ssrc;
for (auto it : config.rtp.rtx)
rtx_stats_[it.second.ssrc] = StreamDataCounters();
diff --git a/webrtc/video/send_statistics_proxy.cc b/webrtc/video/send_statistics_proxy.cc
index b8fdef2..d8c11a8 100644
--- a/webrtc/video/send_statistics_proxy.cc
+++ b/webrtc/video/send_statistics_proxy.cc
@@ -97,8 +97,8 @@
clock_(clock),
max_sent_width_per_timestamp_(0),
max_sent_height_per_timestamp_(0),
- input_frame_rate_tracker_(100u, 10u),
- sent_frame_rate_tracker_(100u, 10u),
+ input_frame_rate_tracker_(100, 10u),
+ sent_frame_rate_tracker_(100, 10u),
first_rtcp_stats_time_ms_(-1),
first_rtp_stats_time_ms_(-1),
start_stats_(stats) {}
diff --git a/webrtc/voice_engine/test/auto_test/fakes/conference_transport.cc b/webrtc/voice_engine/test/auto_test/fakes/conference_transport.cc
index 086eeab..b15d72f 100644
--- a/webrtc/voice_engine/test/auto_test/fakes/conference_transport.cc
+++ b/webrtc/voice_engine/test/auto_test/fakes/conference_transport.cc
@@ -131,7 +131,7 @@
size_t len) {
{
rtc::CritScope lock(&pq_crit_);
- packet_queue_.push_back(Packet(type, data, len, rtc::Time()));
+ packet_queue_.push_back(Packet(type, data, len, rtc::TimeMillis()));
}
packet_event_->Set();
}
diff --git a/webrtc/voice_engine/test/auto_test/fakes/conference_transport.h b/webrtc/voice_engine/test/auto_test/fakes/conference_transport.h
index 8fd7457..bbdf501 100644
--- a/webrtc/voice_engine/test/auto_test/fakes/conference_transport.h
+++ b/webrtc/voice_engine/test/auto_test/fakes/conference_transport.h
@@ -108,7 +108,7 @@
enum Type { Rtp, Rtcp, } type_;
Packet() : len_(0) {}
- Packet(Type type, const void* data, size_t len, uint32_t time_ms)
+ Packet(Type type, const void* data, size_t len, int64_t time_ms)
: type_(type), len_(len), send_time_ms_(time_ms) {
EXPECT_LE(len_, kMaxPacketSizeByte);
memcpy(data_, data, len_);
@@ -116,7 +116,7 @@
uint8_t data_[kMaxPacketSizeByte];
size_t len_;
- uint32_t send_time_ms_;
+ int64_t send_time_ms_;
};
static bool Run(void* transport) {
diff --git a/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.cc b/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.cc
index d4438a4..1787915 100644
--- a/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.cc
+++ b/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.cc
@@ -14,11 +14,10 @@
namespace voetest {
-void LoudestFilter::RemoveTimeoutStreams(uint32_t time_ms) {
+void LoudestFilter::RemoveTimeoutStreams(int64_t time_ms) {
auto it = stream_levels_.begin();
while (it != stream_levels_.end()) {
- if (rtc::TimeDiff(time_ms, it->second.last_time_ms) >
- kStreamTimeOutMs) {
+ if (rtc::TimeDiff(time_ms, it->second.last_time_ms) > kStreamTimeOutMs) {
stream_levels_.erase(it++);
} else {
++it;
@@ -41,7 +40,7 @@
}
bool LoudestFilter::ForwardThisPacket(const webrtc::RTPHeader& rtp_header) {
- uint32_t time_now_ms = rtc::Time();
+ int64_t time_now_ms = rtc::TimeMillis();
RemoveTimeoutStreams(time_now_ms);
int source_ssrc = rtp_header.ssrc;
diff --git a/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.h b/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.h
index 73b801c..f862c81 100644
--- a/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.h
+++ b/webrtc/voice_engine/test/auto_test/fakes/loudest_filter.h
@@ -29,15 +29,15 @@
private:
struct Status {
- void Set(int audio_level, uint32_t last_time_ms) {
+ void Set(int audio_level, int64_t last_time_ms) {
this->audio_level = audio_level;
this->last_time_ms = last_time_ms;
}
int audio_level;
- uint32_t last_time_ms;
+ int64_t last_time_ms;
};
- void RemoveTimeoutStreams(uint32_t time_ms);
+ void RemoveTimeoutStreams(int64_t time_ms);
unsigned int FindQuietestStream();
// Keeps the streams being forwarded in pair<SSRC, Status>.
diff --git a/webrtc/voice_engine/test/auto_test/voe_conference_test.cc b/webrtc/voice_engine/test/auto_test/voe_conference_test.cc
index c70d92a..946eb4e 100644
--- a/webrtc/voice_engine/test/auto_test/voe_conference_test.cc
+++ b/webrtc/voice_engine/test/auto_test/voe_conference_test.cc
@@ -72,15 +72,15 @@
const int kStatsRequestIntervalMs = 1000;
const int kStatsBufferSize = 3;
- uint32_t deadline = rtc::TimeAfter(kMaxRunTimeMs);
+ int64_t deadline = rtc::TimeAfter(kMaxRunTimeMs);
// Run the following up to |kMaxRunTimeMs| milliseconds.
int successive_pass = 0;
webrtc::CallStatistics stats_1;
webrtc::CallStatistics stats_2;
std::queue<Stats> stats_buffer;
- while (rtc::TimeIsLater(rtc::Time(), deadline) &&
- successive_pass < kNeedSuccessivePass) {
+ while (rtc::TimeMillis() < deadline &&
+ successive_pass < kNeedSuccessivePass) {
webrtc::SleepMs(kStatsRequestIntervalMs);
EXPECT_TRUE(trans.GetReceiverStatistics(id_1, &stats_1));
diff --git a/webrtc/voice_engine/test/auto_test/voe_output_test.cc b/webrtc/voice_engine/test/auto_test/voe_output_test.cc
index d1bcf96..795dac5 100644
--- a/webrtc/voice_engine/test/auto_test/voe_output_test.cc
+++ b/webrtc/voice_engine/test/auto_test/voe_output_test.cc
@@ -183,7 +183,7 @@
OutputTest test(-kDtxBoundForSilence, kDtxBoundForSilence);
Random random(1234ull);
- uint32_t start_time = rtc::Time();
+ int64_t start_time = rtc::TimeMillis();
test.Start();
while (rtc::TimeSince(start_time) < kRuntimeMs) {
webrtc::SleepMs(random.Rand(kUnmuteTimeMs - kUnmuteTimeMs / 10,