Change default timestamp to 64 bits in all webrtc directories.

webrtc/base/messagequeue.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #if defined(WEBRTC_POSIX)
 #include <sys/time.h>
 #endif
 
 #include <algorithm>
 
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagequeue.h"
 #if defined(__native_client__)
 #include "webrtc/base/nullsocketserver.h"
 typedef rtc::NullSocketServer DefaultSocketServer;
 #else
 #include "webrtc/base/physicalsocketserver.h"
 typedef rtc::PhysicalSocketServer DefaultSocketServer;
 #endif
 
 namespace rtc {
 
-const uint32_t kMaxMsgLatency = 150;  // 150 ms
+const int kMaxMsgLatency = 150;  // 150 ms

[pthatcher1, 2016/04/11 20:56:59]

Why not uint64_t?

[honghaiz3, 2016/04/18 23:39:03]

According to style guide, we should not use uintXX only because the value does
not take negative values. 
Using uint here will require unnecessary type conversion later. 
For example if using uint64_t here, then kMaxMsgLatency + timestamp will become
uint64_t type, which cannot be directly assigned to another timestamp variable
without a type conversion.  

Using int64_t here is not necessary because the latency value does not need 64
bits. 
Basically for all delta-time, I am using int type except in a few locations
where uint32 is more appropriate for other reasons. 

 
 //------------------------------------------------------------------
 // MessageQueueManager
 
 MessageQueueManager* MessageQueueManager::instance_ = NULL;
 
 MessageQueueManager* MessageQueueManager::Instance() {
   // Note: This is not thread safe, but it is first called before threads are
   // spawned.
   if (!instance_)
@@ skipping 178 matching lines @@
   if (fPeekKeep_) {
     *pmsg = msgPeek_;
     fPeekKeep_ = false;
     return true;
   }
 
   // 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 msStart = Time();
+  int64_t msCurrent = msStart;
   while (true) {
     // Check for sent messages
     ReceiveSends();
 
     // Check for posted events
     int cmsDelayNext = kForever;
     bool first_pass = true;
     while (true) {
       // All queue operations need to be locked, but nothing else in this loop
       // (specifically handling disposed message) can happen inside the crit.
       // Otherwise, disposed MessageHandlers will cause deadlocks.
       {
         CritScope cs(&crit_);
         // On the first pass, check for delayed messages that have been
         // triggered and calculate the next trigger time.
         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;
             }
             msgq_.push_back(dmsgq_.top().msg_);
             dmsgq_.pop();
           }
         }
         // Pull a message off the message queue, if available.
         if (msgq_.empty()) {
           break;
@@ skipping 82 matching lines @@
   WakeUpSocketServer();
 }
 
 void MessageQueue::PostDelayed(int cmsDelay,
                                MessageHandler* phandler,
                                uint32_t id,
                                MessageData* pdata) {
   return DoDelayPost(cmsDelay, TimeAfter(cmsDelay), phandler, id, pdata);
 }
 
-void MessageQueue::PostAt(uint32_t tstamp,
+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) {
   if (fStop_)
     return;
 
   // Keep thread safe
   // Add to the priority queue. Gets sorted soonest first.
   // Signal for the multiplexer to return.
 
@@ skipping 77 matching lines @@
   }
   dmsgq_.container().erase(new_end, dmsgq_.container().end());
   dmsgq_.reheap();
 }
 
 void MessageQueue::Dispatch(Message *pmsg) {
   pmsg->phandler->OnMessage(pmsg);
 }
 
 }  // namespace rtc