Change default timestamp to 64 bits in all webrtc directories.

webrtc/p2p/base/pseudotcp.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.
  */
 
@@ skipping 185 matching lines @@
 }
 
 #endif
 
 //////////////////////////////////////////////////////////////////////
 // PseudoTcp
 //////////////////////////////////////////////////////////////////////
 
 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
 }
 
 PseudoTcp::PseudoTcp(IPseudoTcpNotify* notify, uint32_t conv)
     : m_notify(notify),
       m_shutdown(SD_NONE),
       m_error(0),
       m_rbuf_len(DEFAULT_RCV_BUF_SIZE),
       m_rbuf(m_rbuf_len),
       m_sbuf_len(DEFAULT_SND_BUF_SIZE),
@@ skipping 63 matching lines @@
   if (m_state == TCP_ESTABLISHED) {
     adjustMTU();
   }
 }
 
 void PseudoTcp::NotifyClock(uint32_t now) {
   if (m_state == TCP_CLOSED)
     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 {
       // Note: (m_slist.front().xmit == 0)) {
       // retransmit segments
 #if _DEBUGMSG >= _DBG_NORMAL
       LOG(LS_INFO) << "timeout retransmit (rto: " << m_rx_rto
                    << ") (rto_base: " << m_rto_base
                    << ") (now: " << now
                    << ") (dup_acks: " << static_cast<unsigned>(m_dup_acks)
@@ skipping 10 matching lines @@
       m_cwnd = m_mss;
 
       // Back off retransmit timer.  Note: the limit is lower when connecting.
       uint32_t rto_limit = (m_state < TCP_ESTABLISHED) ? DEF_RTO : MAX_RTO;
       m_rx_rto = std::min(rto_limit, m_rx_rto * 2);
       m_rto_base = now;
     }
   }
 
   // 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;
     }
 
     // probe the window
     packet(m_snd_nxt - 1, 0, 0, 0);
     m_lastsend = now;
 
     // back off retransmit timer
     m_rx_rto = std::min(MAX_RTO, m_rx_rto * 2);
   }
 
   // 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
 }
 
 bool PseudoTcp::NotifyPacket(const char* buffer, size_t len) {
   if (len > MAX_PACKET) {
     LOG_F(WARNING) << "packet too large";
     return false;
   }
@@ skipping 252 matching lines @@
   }
 
   if (m_state == TCP_CLOSED) {
     nTimeout = CLOSED_TIMEOUT;
     return true;
   }
 
   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;
 }
 
 bool PseudoTcp::process(Segment& seg) {
   // If this is the wrong conversation, send a reset!?! (with the correct conversation?)
   if (seg.conv != m_conv) {
     //if ((seg.flags & FLAG_RST) == 0) {
     //  packet(tcb, seg.ack, 0, FLAG_RST, 0, 0);
@@ skipping 52 matching lines @@
 
   // Update timestamp
   if ((seg.seq <= m_ts_lastack) && (m_ts_lastack < seg.seq + seg.len)) {
     m_ts_recent = seg.tsval;
   }
 
   // Check if this is a valuable ack
   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;
           m_rx_rttvar = rtt / 2;
         } else {
           uint32_t unsigned_rtt = static_cast<uint32_t>(rtt);
           uint32_t abs_err = unsigned_rtt > m_rx_srtt
                                  ? unsigned_rtt - m_rx_srtt
                                  : m_rx_srtt - unsigned_rtt;
           m_rx_rttvar = (3 * m_rx_rttvar + abs_err) / 4;
@@ skipping 302 matching lines @@
   if (m_rto_base == 0) {
     m_rto_base = now;
   }
 
   return true;
 }
 
 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;
   }
 
 #if _DEBUGMSG
   bool bFirst = true;
   RTC_UNUSED(bFirst);
 #endif // _DEBUGMSG
 
   while (true) {
     uint32_t cwnd = m_cwnd;
@@ skipping 227 matching lines @@
   m_rbuf_len = new_size;
   m_rwnd_scale = scale_factor;
   m_ssthresh = new_size;
 
   size_t available_space = 0;
   m_rbuf.GetWriteRemaining(&available_space);
   m_rcv_wnd = static_cast<uint32_t>(available_space);
 }
 
 }  // namespace cricket