Change default timestamp to 64 bits in all webrtc directories.

webrtc/base/messagequeue.h

 /*
  *  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.
  */
 
@@ skipping 123 matching lines @@
   Message() {
     memset(this, 0, sizeof(*this));
   }
   inline bool Match(MessageHandler* handler, uint32_t id) const {
     return (handler == NULL || handler == phandler)
            && (id == MQID_ANY || id == message_id);
   }
   MessageHandler *phandler;
   uint32_t message_id;
   MessageData *pdata;
-  uint32_t ts_sensitive;
+  int64_t ts_sensitive;
 };
 
 typedef std::list<Message> MessageList;
 
 // DelayedMessage goes into a priority queue, sorted by trigger time.  Messages
 // with the same trigger time are processed in num_ (FIFO) order.
 
 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 {
     return (dmsg.msTrigger_ < msTrigger_)
            || ((dmsg.msTrigger_ == msTrigger_) && (dmsg.num_ < num_));
   }
 
   int cmsDelay_;  // for debugging
-  uint32_t msTrigger_;
+  int64_t msTrigger_;
   uint32_t num_;
   Message msg_;
 };
 
 class MessageQueue {
  public:
   static const int kForever = -1;
 
   // Create a new MessageQueue and optionally assign it to the passed
   // SocketServer. Subclasses that override Clear should pass false for
@@ skipping 30 matching lines @@
                    bool process_io = true);
   virtual bool Peek(Message *pmsg, int cmsWait = 0);
   virtual void Post(MessageHandler* phandler,
                     uint32_t id = 0,
                     MessageData* pdata = NULL,
                     bool time_sensitive = false);
   virtual void PostDelayed(int cmsDelay,
                            MessageHandler* phandler,
                            uint32_t id = 0,
                            MessageData* pdata = NULL);
-  virtual void PostAt(uint32_t tstamp,
+  virtual void PostAt(int64_t tstamp,
                       MessageHandler* phandler,
                       uint32_t id = 0,
                       MessageData* pdata = NULL);
   virtual void Clear(MessageHandler* phandler,
                      uint32_t id = MQID_ANY,
                      MessageList* removed = NULL);
   virtual void Dispatch(Message *pmsg);
   virtual void ReceiveSends();
 
   // Amount of time until the next message can be retrieved
@@ skipping 17 matching lines @@
   sigslot::signal0<> SignalQueueDestroyed;
 
  protected:
   class PriorityQueue : public std::priority_queue<DelayedMessage> {
    public:
     container_type& container() { return c; }
     void reheap() { make_heap(c.begin(), c.end(), comp); }
   };
 
   void DoDelayPost(int cmsDelay,
-                   uint32_t tstamp,
+                   int64_t tstamp,
                    MessageHandler* phandler,
                    uint32_t id,
                    MessageData* pdata);
 
   // Perform initialization, subclasses must call this from their constructor
   // if false was passed as init_queue to the MessageQueue constructor.
   void DoInit();
 
   // Perform cleanup, subclasses that override Clear must call this from the
   // destructor.
@@ skipping 17 matching lines @@
   // If a server isn't supplied in the constructor, use this one.
   scoped_ptr<SocketServer> default_ss_;
   SharedExclusiveLock ss_lock_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(MessageQueue);
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_MESSAGEQUEUE_H_