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/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..c6952b4b 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_
