Replace ASSERT by RTC_DCHECK in all non-test code.

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 201 matching lines @@
 
 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),
       m_sbuf(m_sbuf_len) {
   // Sanity check on buffer sizes (needed for OnTcpWriteable notification logic)
-  ASSERT(m_rbuf_len + MIN_PACKET < m_sbuf_len);
+  RTC_DCHECK(m_rbuf_len + MIN_PACKET < m_sbuf_len);
 
   uint32_t now = Now();
 
   m_state = TCP_LISTEN;
   m_conv = conv;
   m_rcv_wnd = m_rbuf_len;
   m_rwnd_scale = m_swnd_scale = 0;
   m_snd_nxt = 0;
   m_snd_wnd = 1;
   m_snd_una = m_rcv_nxt = 0;
   m_bReadEnable = true;
   m_bWriteEnable = false;
   m_t_ack = 0;
 
   m_msslevel = 0;
   m_largest = 0;
-  ASSERT(MIN_PACKET > PACKET_OVERHEAD);
+  RTC_DCHECK(MIN_PACKET > PACKET_OVERHEAD);
   m_mss = MIN_PACKET - PACKET_OVERHEAD;
   m_mtu_advise = MAX_PACKET;
 
   m_rto_base = 0;
 
   m_cwnd = 2 * m_mss;
   m_ssthresh = m_rbuf_len;
   m_lastrecv = m_lastsend = m_lasttraffic = now;
   m_bOutgoing = false;
 
@@ skipping 131 matching lines @@
   } else {
     RTC_NOTREACHED();
   }
 }
 void PseudoTcp::SetOption(Option opt, int value) {
   if (opt == OPT_NODELAY) {
     m_use_nagling = value == 0;
   } else if (opt == OPT_ACKDELAY) {
     m_ack_delay = value;
   } else if (opt == OPT_SNDBUF) {
-    ASSERT(m_state == TCP_LISTEN);
+    RTC_DCHECK(m_state == TCP_LISTEN);
     resizeSendBuffer(value);
   } else if (opt == OPT_RCVBUF) {
-    ASSERT(m_state == TCP_LISTEN);
+    RTC_DCHECK(m_state == TCP_LISTEN);
     resizeReceiveBuffer(value);
   } else {
     RTC_NOTREACHED();
   }
 }
 
 uint32_t PseudoTcp::GetCongestionWindow() const {
   return m_cwnd;
 }
 
@@ skipping 23 matching lines @@
 
   size_t read = 0;
   rtc::StreamResult result = m_rbuf.Read(buffer, len, &read, NULL);
 
   // If there's no data in |m_rbuf|.
   if (result == rtc::SR_BLOCK) {
     m_bReadEnable = true;
     m_error = EWOULDBLOCK;
     return SOCKET_ERROR;
   }
-  ASSERT(result == rtc::SR_SUCCESS);
+  RTC_DCHECK(result == rtc::SR_SUCCESS);
 
   size_t available_space = 0;
   m_rbuf.GetWriteRemaining(&available_space);
 
   if (uint32_t(available_space) - m_rcv_wnd >=
       std::min<uint32_t>(m_rbuf_len / 2, m_mss)) {
     // TODO(jbeda): !?! Not sure about this was closed business
     bool bWasClosed = (m_rcv_wnd == 0);
     m_rcv_wnd = static_cast<uint32_t>(available_space);
 
@@ skipping 36 matching lines @@
 
 //
 // Internal Implementation
 //
 
 uint32_t PseudoTcp::queue(const char* data, uint32_t len, bool bCtrl) {
   size_t available_space = 0;
   m_sbuf.GetWriteRemaining(&available_space);
 
   if (len > static_cast<uint32_t>(available_space)) {
-    ASSERT(!bCtrl);
+    RTC_DCHECK(!bCtrl);
     len = static_cast<uint32_t>(available_space);
   }
 
   // We can concatenate data if the last segment is the same type
   // (control v. regular data), and has not been transmitted yet
   if (!m_slist.empty() && (m_slist.back().bCtrl == bCtrl) &&
       (m_slist.back().xmit == 0)) {
     m_slist.back().len += len;
   } else {
     size_t snd_buffered = 0;
     m_sbuf.GetBuffered(&snd_buffered);
     SSegment sseg(static_cast<uint32_t>(m_snd_una + snd_buffered), len, bCtrl);
     m_slist.push_back(sseg);
   }
 
   size_t written = 0;
   m_sbuf.Write(data, len, &written, NULL);
   return static_cast<uint32_t>(written);
 }
 
 IPseudoTcpNotify::WriteResult PseudoTcp::packet(uint32_t seq,
                                                 uint8_t flags,
                                                 uint32_t offset,
                                                 uint32_t len) {
-  ASSERT(HEADER_SIZE + len <= MAX_PACKET);
+  RTC_DCHECK(HEADER_SIZE + len <= MAX_PACKET);
 
   uint32_t now = Now();
 
   std::unique_ptr<uint8_t[]> buffer(new uint8_t[MAX_PACKET]);
   long_to_bytes(m_conv, buffer.get());
   long_to_bytes(seq, buffer.get() + 4);
   long_to_bytes(m_rcv_nxt, buffer.get() + 8);
   buffer[12] = 0;
   buffer[13] = flags;
   short_to_bytes(static_cast<uint16_t>(m_rcv_wnd >> m_rwnd_scale),
                  buffer.get() + 14);
 
   // Timestamp computations
   long_to_bytes(now, buffer.get() + 16);
   long_to_bytes(m_ts_recent, buffer.get() + 20);
   m_ts_lastack = m_rcv_nxt;
 
   if (len) {
     size_t bytes_read = 0;
     rtc::StreamResult result = m_sbuf.ReadOffset(
         buffer.get() + HEADER_SIZE, len, offset, &bytes_read);
     RTC_UNUSED(result);
-    ASSERT(result == rtc::SR_SUCCESS);
-    ASSERT(static_cast<uint32_t>(bytes_read) == len);
+    RTC_DCHECK(result == rtc::SR_SUCCESS);
+    RTC_DCHECK(static_cast<uint32_t>(bytes_read) == len);
   }
 
 #if _DEBUGMSG >= _DBG_VERBOSE
   LOG(LS_INFO) << "<-- <CONV=" << m_conv
                << "><FLG=" << static_cast<unsigned>(flags)
                << "><SEQ=" << seq << ":" << seq + len
                << "><ACK=" << m_rcv_nxt
                << "><WND=" << m_rcv_wnd
                << "><TS="  << (now % 10000)
                << "><TSR=" << (m_ts_recent % 10000)
@@ skipping 188 matching lines @@
     m_snd_wnd = static_cast<uint32_t>(seg.wnd) << m_swnd_scale;
 
     uint32_t nAcked = seg.ack - m_snd_una;
     m_snd_una = seg.ack;
 
     m_rto_base = (m_snd_una == m_snd_nxt) ? 0 : now;
 
     m_sbuf.ConsumeReadData(nAcked);
 
     for (uint32_t nFree = nAcked; nFree > 0;) {
-      ASSERT(!m_slist.empty());
+      RTC_DCHECK(!m_slist.empty());
       if (nFree < m_slist.front().len) {
         m_slist.front().len -= nFree;
         nFree = 0;
       } else {
         if (m_slist.front().len > m_largest) {
           m_largest = m_slist.front().len;
         }
         nFree -= m_slist.front().len;
         m_slist.pop_front();
       }
@@ skipping 141 matching lines @@
   if (seg.len > 0) {
     if (bIgnoreData) {
       if (seg.seq == m_rcv_nxt) {
         m_rcv_nxt += seg.len;
       }
     } else {
       uint32_t nOffset = seg.seq - m_rcv_nxt;
 
       rtc::StreamResult result = m_rbuf.WriteOffset(seg.data, seg.len,
                                                           nOffset, NULL);
-      ASSERT(result == rtc::SR_SUCCESS);
+      RTC_DCHECK(result == rtc::SR_SUCCESS);
       RTC_UNUSED(result);
 
       if (seg.seq == m_rcv_nxt) {
         m_rbuf.ConsumeWriteBuffer(seg.len);
         m_rcv_nxt += seg.len;
         m_rcv_wnd -= seg.len;
         bNewData = true;
 
         RList::iterator it = m_rlist.begin();
         while ((it != m_rlist.end()) && (it->seq <= m_rcv_nxt)) {
@@ skipping 56 matching lines @@
                                                 nTransmit);
 
     if (wres == IPseudoTcpNotify::WR_SUCCESS)
       break;
 
     if (wres == IPseudoTcpNotify::WR_FAIL) {
       LOG_F(LS_VERBOSE) << "packet failed";
       return false;
     }
 
-    ASSERT(wres == IPseudoTcpNotify::WR_TOO_LARGE);
+    RTC_DCHECK(wres == IPseudoTcpNotify::WR_TOO_LARGE);
 
     while (true) {
       if (PACKET_MAXIMUMS[m_msslevel + 1] == 0) {
         LOG_F(LS_VERBOSE) << "MTU too small";
         return false;
       }
       // !?! We need to break up all outstanding and pending packets and then retransmit!?!
 
       m_mss = PACKET_MAXIMUMS[++m_msslevel] - PACKET_OVERHEAD;
       m_cwnd = 2 * m_mss; // I added this... haven't researched actual formula
@@ skipping 100 matching lines @@
     // data ready to send then hold off until we get more to send, or the
     // in-flight data is acknowledged.
     if (m_use_nagling && (m_snd_nxt > m_snd_una) && (nAvailable < m_mss))  {
       return;
     }
 
     // Find the next segment to transmit
     SList::iterator it = m_slist.begin();
     while (it->xmit > 0) {
       ++it;
-      ASSERT(it != m_slist.end());
+      RTC_DCHECK(it != m_slist.end());
     }
     SList::iterator seg = it;
 
     // If the segment is too large, break it into two
     if (seg->len > nAvailable) {
       SSegment subseg(seg->seq + nAvailable, seg->len - nAvailable, seg->bCtrl);
       seg->len = nAvailable;
       m_slist.insert(++it, subseg);
     }
 
@@ skipping 72 matching lines @@
 
     if (kind == TCP_OPT_EOL) {
       // End of option list.
       break;
     } else if (kind == TCP_OPT_NOOP) {
       // No op.
       continue;
     }
 
     // Length of this option.
-    ASSERT(len != 0);
+    RTC_DCHECK(len != 0);
     RTC_UNUSED(len);
     uint8_t opt_len = 0;
     buf.ReadUInt8(&opt_len);
 
     // Content of this option.
     if (opt_len <= buf.Length()) {
       applyOption(kind, buf.Data(), opt_len);
       buf.Consume(opt_len);
     } else {
       LOG(LS_ERROR) << "Invalid option length received.";
@@ skipping 49 matching lines @@
   }
 
   // Determine the proper size of the buffer.
   new_size <<= scale_factor;
   bool result = m_rbuf.SetCapacity(new_size);
 
   // Make sure the new buffer is large enough to contain data in the old
   // buffer. This should always be true because this method is called either
   // before connection is established or when peers are exchanging connect
   // messages.
-  ASSERT(result);
+  RTC_DCHECK(result);
   RTC_UNUSED(result);
   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