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.
  */
 #include <algorithm>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagequeue.h"
 #include "webrtc/base/trace_event.h"
 
 namespace rtc {
 
-const uint32_t kMaxMsgLatency = 150;  // 150 ms
+const int kMaxMsgLatency = 150;  // 150 ms
 
 //------------------------------------------------------------------
 // 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 177 matching lines @@
   // Always return the peek if it exists so there is Peek/Get symmetry
 
   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 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
       // (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;
         } else {
           *pmsg = msgq_.front();
           msgq_.pop_front();
         }
       }  // crit_ is released here.
 
       // 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";
         }
       }
       // If this was a dispose message, delete it and skip it.
       if (MQID_DISPOSE == pmsg->message_id) {
         ASSERT(NULL == pmsg->phandler);
         delete pmsg->pdata;
         *pmsg = Message();
         continue;
       }
       return true;
     }
 
     if (fStop_)
       break;
 
     // 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;
     }
 
     {
       // 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)
         return false;
     }
   }
   return false;
 }
 
 void MessageQueue::ReceiveSends() {
@@ skipping 10 matching lines @@
   // Add the message to the end of the queue
   // Signal for the multiplexer to return
 
   {
     CritScope cs(&crit_);
     Message msg;
     msg.phandler = phandler;
     msg.message_id = id;
     msg.pdata = pdata;
     if (time_sensitive) {
-      msg.ts_sensitive = Time() + kMaxMsgLatency;
+      msg.ts_sensitive = TimeMillis() + kMaxMsgLatency;
     }
     msgq_.push_back(msg);
   }
   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,
                           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) {
   if (fStop_)
     return;
 
   // Keep thread safe
   // Add to the priority queue. Gets sorted soonest first.
   // Signal for the multiplexer to return.
 
@@ skipping 78 matching lines @@
   dmsgq_.container().erase(new_end, dmsgq_.container().end());
   dmsgq_.reheap();
 }
 
 void MessageQueue::Dispatch(Message *pmsg) {
   TRACE_EVENT0("webrtc", "MessageQueue::Dispatch");
   pmsg->phandler->OnMessage(pmsg);
 }
 
 }  // namespace rtc