Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/p2p/quic/quictransportchannel.cc

 /*
  *  Copyright 2016 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 255 matching lines @@
   LOG(LS_ERROR) << "Failed to send an invalid SRTP bypass packet using QUIC.";
   return -1;
 }
 
 // The state transition logic here is as follows:
 //     - Before the QUIC handshake is complete, the QUIC channel is unwritable.
 //     - When |channel_| goes writable we start the QUIC handshake.
 //     - Once the QUIC handshake completes, the state is that of the
 //       |channel_| again.
 void QuicTransportChannel::OnWritableState(TransportChannel* channel) {
-  ASSERT(rtc::Thread::Current() == network_thread_);
-  ASSERT(channel == channel_.get());
+  RTC_DCHECK(rtc::Thread::Current() == network_thread_);
+  RTC_DCHECK(channel == channel_.get());
   LOG_J(LS_VERBOSE, this)
       << "QuicTransportChannel: channel writable state changed to "
       << channel_->writable();
   switch (quic_state_) {
     case QUIC_TRANSPORT_NEW:
       // Start the QUIC handshake when |channel_| is writable.
       // This will fail if the SSL role or remote fingerprint are not set.
       // Otherwise failure could result from network or QUIC errors.
       MaybeStartQuic();
       break;
@@ skipping 12 matching lines @@
       }
       break;
     case QUIC_TRANSPORT_CLOSED:
       // TODO(mikescarlett): Allow the QUIC connection to be reset if it drops
       // due to a non-failure.
       break;
   }
 }
 
 void QuicTransportChannel::OnReceivingState(TransportChannel* channel) {
-  ASSERT(rtc::Thread::Current() == network_thread_);
-  ASSERT(channel == channel_.get());
+  RTC_DCHECK(rtc::Thread::Current() == network_thread_);
+  RTC_DCHECK(channel == channel_.get());
   LOG_J(LS_VERBOSE, this)
       << "QuicTransportChannel: channel receiving state changed to "
       << channel_->receiving();
   if (quic_state_ == QUIC_TRANSPORT_CONNECTED) {
     // Note: SignalReceivingState fired by set_receiving.
     set_receiving(channel_->receiving());
   }
 }
 
 void QuicTransportChannel::OnReadPacket(TransportChannel* channel,
                                         const char* data,
                                         size_t size,
                                         const rtc::PacketTime& packet_time,
                                         int flags) {
-  ASSERT(rtc::Thread::Current() == network_thread_);
-  ASSERT(channel == channel_.get());
-  ASSERT(flags == 0);
+  RTC_DCHECK(rtc::Thread::Current() == network_thread_);
+  RTC_DCHECK(channel == channel_.get());
+  RTC_DCHECK(flags == 0);
 
   switch (quic_state_) {
     case QUIC_TRANSPORT_NEW:
       // This would occur if other peer is ready to start QUIC but this peer
       // hasn't started QUIC.
       LOG_J(LS_INFO, this) << "Dropping packet received before QUIC started.";
       break;
     case QUIC_TRANSPORT_CONNECTING:
     case QUIC_TRANSPORT_CONNECTED:
       // We should only get QUIC or SRTP packets; STUN's already been demuxed.
@@ skipping 14 matching lines @@
       }
       break;
     case QUIC_TRANSPORT_CLOSED:
       // This shouldn't be happening. Drop the packet.
       break;
   }
 }
 
 void QuicTransportChannel::OnSentPacket(TransportChannel* channel,
                                         const rtc::SentPacket& sent_packet) {
-  ASSERT(rtc::Thread::Current() == network_thread_);
+  RTC_DCHECK(rtc::Thread::Current() == network_thread_);
   SignalSentPacket(this, sent_packet);
 }
 
 void QuicTransportChannel::OnReadyToSend(TransportChannel* channel) {
   if (writable()) {
     SignalReadyToSend(this);
   }
 }
 
 void QuicTransportChannel::OnGatheringState(TransportChannelImpl* channel) {
-  ASSERT(channel == channel_.get());
+  RTC_DCHECK(channel == channel_.get());
   SignalGatheringState(this);
 }
 
 void QuicTransportChannel::OnCandidateGathered(TransportChannelImpl* channel,
                                                const Candidate& c) {
-  ASSERT(channel == channel_.get());
+  RTC_DCHECK(channel == channel_.get());
   SignalCandidateGathered(this, c);
 }
 
 void QuicTransportChannel::OnRoleConflict(TransportChannelImpl* channel) {
-  ASSERT(channel == channel_.get());
+  RTC_DCHECK(channel == channel_.get());
   SignalRoleConflict(this);
 }
 
 void QuicTransportChannel::OnRouteChange(TransportChannel* channel,
                                          const Candidate& candidate) {
-  ASSERT(channel == channel_.get());
+  RTC_DCHECK(channel == channel_.get());
   SignalRouteChange(this, candidate);
 }
 
 void QuicTransportChannel::OnSelectedCandidatePairChanged(
     TransportChannel* channel,
     CandidatePairInterface* selected_candidate_pair,
     int last_sent_packet_id,
     bool ready_to_send) {
-  ASSERT(channel == channel_.get());
+  RTC_DCHECK(channel == channel_.get());
   SignalSelectedCandidatePairChanged(this, selected_candidate_pair,
                                      last_sent_packet_id, ready_to_send);
 }
 
 void QuicTransportChannel::OnChannelStateChanged(
     TransportChannelImpl* channel) {
-  ASSERT(channel == channel_.get());
+  RTC_DCHECK(channel == channel_.get());
   SignalStateChanged(this);
 }
 
 bool QuicTransportChannel::MaybeStartQuic() {
   if (!channel_->writable()) {
     LOG_J(LS_ERROR, this) << "Couldn't start QUIC handshake.";
     return false;
   }
   if (!CreateQuicSession() || !StartQuicHandshake()) {
     LOG_J(LS_WARNING, this)
@@ skipping 81 matching lines @@
                                         quic_compressed_certs_cache_.get(),
                                         use_stateless_rejects_if_peer_supported,
                                         quic_.get());
     quic_->StartServerHandshake(crypto_stream);
     LOG_J(LS_INFO, this) << "QuicTransportChannel: Started server handshake.";
   }
   return true;
 }
 
 bool QuicTransportChannel::HandleQuicPacket(const char* data, size_t size) {
-  ASSERT(rtc::Thread::Current() == network_thread_);
+  RTC_DCHECK(rtc::Thread::Current() == network_thread_);
   return quic_->OnReadPacket(data, size);
 }
 
 net::WriteResult QuicTransportChannel::WritePacket(
     const char* buffer,
     size_t buf_len,
     const net::IPAddress& self_address,
     const net::IPEndPoint& peer_address,
     net::PerPacketOptions* options) {
   // QUIC should never call this if IsWriteBlocked, but just in case...
@@ skipping 69 matching lines @@
     return quic_->CreateOutgoingDynamicStream(priority);
   }
   return nullptr;
 }
 
 void QuicTransportChannel::OnIncomingStream(ReliableQuicStream* stream) {
   SignalIncomingStream(stream);
 }
 
 }  // namespace cricket