Replace ASSERT(false) by RTC_NOTREACHED().

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.
  */
 
 #include "webrtc/p2p/base/pseudotcp.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 
 #include <algorithm>
 #include <memory>
 #include <set>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/bytebuffer.h"
 #include "webrtc/base/byteorder.h"
+#include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/socket.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/timeutils.h"
 
 // The following logging is for detailed (packet-level) analysis only.
 #define _DBG_NONE     0
 #define _DBG_NORMAL   1
 #define _DBG_VERBOSE  2
@@ skipping 250 matching lines @@
   }
 }
 
 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::TimeDiff32(m_rto_base + m_rx_rto, now) <= 0)) {
     if (m_slist.empty()) {
-      ASSERT(false);
+      RTC_NOTREACHED();
     } 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)
                    << ")";
 #endif // _DEBUGMSG
@@ skipping 66 matching lines @@
 void PseudoTcp::GetOption(Option opt, int* value) {
   if (opt == OPT_NODELAY) {
     *value = m_use_nagling ? 0 : 1;
   } else if (opt == OPT_ACKDELAY) {
     *value = m_ack_delay;
   } else if (opt == OPT_SNDBUF) {
     *value = m_sbuf_len;
   } else if (opt == OPT_RCVBUF) {
     *value = m_rbuf_len;
   } else {
-    ASSERT(false);
+    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);
     resizeSendBuffer(value);
   } else if (opt == OPT_RCVBUF) {
     ASSERT(m_state == TCP_LISTEN);
     resizeReceiveBuffer(value);
   } else {
-    ASSERT(false);
+    RTC_NOTREACHED();
   }
 }
 
 uint32_t PseudoTcp::GetCongestionWindow() const {
   return m_cwnd;
 }
 
 uint32_t PseudoTcp::GetBytesInFlight() const {
   return m_snd_nxt - m_snd_una;
 }
@@ skipping 321 matching lines @@
         }
         m_rx_rto =
             bound(MIN_RTO, m_rx_srtt + std::max<uint32_t>(1, 4 * m_rx_rttvar),
                   MAX_RTO);
 #if _DEBUGMSG >= _DBG_VERBOSE
         LOG(LS_INFO) << "rtt: " << rtt
                      << "  srtt: " << m_rx_srtt
                      << "  rto: " << m_rx_rto;
 #endif // _DEBUGMSG
       } else {
-        ASSERT(false);
+        RTC_NOTREACHED();
       }
     }
 
     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;
 
@@ skipping 528 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