Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/api/datachannel.cc

 /*
  *  Copyright 2012 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/api/datachannel.h"
 
 #include <memory>
 #include <string>
 
 #include "webrtc/api/sctputils.h"
+#include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/refcount.h"
 #include "webrtc/media/sctp/sctptransportinternal.h"
 
 namespace webrtc {
 
 static size_t kMaxQueuedReceivedDataBytes = 16 * 1024 * 1024;
 static size_t kMaxQueuedSendDataBytes = 16 * 1024 * 1024;
 
 enum {
@@ skipping 214 matching lines @@
   // code accordingly.
   if (buffer.size() == 0) {
     return true;
   }
 
   // If the queue is non-empty, we're waiting for SignalReadyToSend,
   // so just add to the end of the queue and keep waiting.
   if (!queued_send_data_.Empty()) {
     // Only SCTP DataChannel queues the outgoing data when the transport is
     // blocked.
-    ASSERT(data_channel_type_ == cricket::DCT_SCTP);
+    RTC_DCHECK(data_channel_type_ == cricket::DCT_SCTP);
     if (!QueueSendDataMessage(buffer)) {
       Close();
     }
     return true;
   }
 
   bool success = SendDataMessage(buffer, true);
   if (data_channel_type_ == cricket::DCT_RTP) {
     return success;
   }
 
   // Always return true for SCTP DataChannel per the spec.
   return true;
 }
 
 void DataChannel::SetReceiveSsrc(uint32_t receive_ssrc) {
-  ASSERT(data_channel_type_ == cricket::DCT_RTP);
+  RTC_DCHECK(data_channel_type_ == cricket::DCT_RTP);
 
   if (receive_ssrc_set_) {
     return;
   }
   receive_ssrc_ = receive_ssrc;
   receive_ssrc_set_ = true;
   UpdateState();
 }
 
 // The remote peer request that this channel shall be closed.
 void DataChannel::RemotePeerRequestClose() {
   DoClose();
 }
 
 void DataChannel::SetSctpSid(int sid) {
-  ASSERT(config_.id < 0 && sid >= 0 && data_channel_type_ == cricket::DCT_SCTP);
+  RTC_DCHECK(config_.id < 0 && sid >= 0 &&
+             data_channel_type_ == cricket::DCT_SCTP);
   if (config_.id == sid) {
     return;
   }
 
   config_.id = sid;
   provider_->AddSctpDataStream(sid);
 }
 
 void DataChannel::OnTransportChannelCreated() {
-  ASSERT(data_channel_type_ == cricket::DCT_SCTP);
+  RTC_DCHECK(data_channel_type_ == cricket::DCT_SCTP);
   if (!connected_to_provider_) {
     connected_to_provider_ = provider_->ConnectDataChannel(this);
   }
   // The sid may have been unassigned when provider_->ConnectDataChannel was
   // done. So always add the streams even if connected_to_provider_ is true.
   if (config_.id >= 0) {
     provider_->AddSctpDataStream(config_.id);
   }
 }
 
 void DataChannel::OnTransportChannelDestroyed() {
   // This method needs to synchronously close the data channel, which means any
   // queued data needs to be discarded.
   queued_send_data_.Clear();
   queued_control_data_.Clear();
   DoClose();
 }
 
 void DataChannel::SetSendSsrc(uint32_t send_ssrc) {
-  ASSERT(data_channel_type_ == cricket::DCT_RTP);
+  RTC_DCHECK(data_channel_type_ == cricket::DCT_RTP);
   if (send_ssrc_set_) {
     return;
   }
   send_ssrc_ = send_ssrc;
   send_ssrc_set_ = true;
   UpdateState();
 }
 
 void DataChannel::OnMessage(rtc::Message* msg) {
   switch (msg->message_id) {
     case MSG_CHANNELREADY:
       OnChannelReady(true);
       break;
   }
 }
 
 void DataChannel::OnDataReceived(const cricket::ReceiveDataParams& params,
                                  const rtc::CopyOnWriteBuffer& payload) {
   if (data_channel_type_ == cricket::DCT_RTP && params.ssrc != receive_ssrc_) {
     return;
   }
   if (data_channel_type_ == cricket::DCT_SCTP && params.sid != config_.id) {
     return;
   }
 
   if (params.type == cricket::DMT_CONTROL) {
-    ASSERT(data_channel_type_ == cricket::DCT_SCTP);
+    RTC_DCHECK(data_channel_type_ == cricket::DCT_SCTP);
     if (handshake_state_ != kHandshakeWaitingForAck) {
       // Ignore it if we are not expecting an ACK message.
       LOG(LS_WARNING) << "DataChannel received unexpected CONTROL message, "
                       << "sid = " << params.sid;
       return;
     }
     if (ParseDataChannelOpenAckMessage(payload)) {
       // We can send unordered as soon as we receive the ACK message.
       handshake_state_ = kHandshakeReady;
       LOG(LS_INFO) << "DataChannel received OPEN_ACK message, sid = "
                    << params.sid;
     } else {
       LOG(LS_WARNING) << "DataChannel failed to parse OPEN_ACK message, sid = "
                       << params.sid;
     }
     return;
   }
 
-  ASSERT(params.type == cricket::DMT_BINARY ||
-         params.type == cricket::DMT_TEXT);
+  RTC_DCHECK(params.type == cricket::DMT_BINARY ||
+             params.type == cricket::DMT_TEXT);
 
   LOG(LS_VERBOSE) << "DataChannel received DATA message, sid = " << params.sid;
   // We can send unordered as soon as we receive any DATA message since the
   // remote side must have received the OPEN (and old clients do not send
   // OPEN_ACK).
   if (handshake_state_ == kHandshakeWaitingForAck) {
     handshake_state_ = kHandshakeReady;
   }
 
   bool binary = (params.type == cricket::DMT_BINARY);
@@ skipping 138 matching lines @@
     observer_->OnMessage(*buffer);
     queued_received_data_.Pop();
   }
 }
 
 void DataChannel::SendQueuedDataMessages() {
   if (queued_send_data_.Empty()) {
     return;
   }
 
-  ASSERT(state_ == kOpen || state_ == kClosing);
+  RTC_DCHECK(state_ == kOpen || state_ == kClosing);
 
   uint64_t start_buffered_amount = buffered_amount();
   while (!queued_send_data_.Empty()) {
     DataBuffer* buffer = queued_send_data_.Front();
     if (!SendDataMessage(*buffer, false)) {
       // Leave the message in the queue if sending is aborted.
       break;
     }
     queued_send_data_.Pop();
     delete buffer;
@@ skipping 78 matching lines @@
   }
 }
 
 void DataChannel::QueueControlMessage(const rtc::CopyOnWriteBuffer& buffer) {
   queued_control_data_.Push(new DataBuffer(buffer, true));
 }
 
 bool DataChannel::SendControlMessage(const rtc::CopyOnWriteBuffer& buffer) {
   bool is_open_message = handshake_state_ == kHandshakeShouldSendOpen;
 
-  ASSERT(data_channel_type_ == cricket::DCT_SCTP &&
-         writable_ &&
-         config_.id >= 0 &&
-         (!is_open_message || !config_.negotiated));
+  RTC_DCHECK(data_channel_type_ == cricket::DCT_SCTP && writable_ &&
+             config_.id >= 0 && (!is_open_message || !config_.negotiated));
 
   cricket::SendDataParams send_params;
   send_params.sid = config_.id;
   // Send data as ordered before we receive any message from the remote peer to
   // make sure the remote peer will not receive any data before it receives the
   // OPEN message.
   send_params.ordered = config_.ordered || is_open_message;
   send_params.type = cricket::DMT_CONTROL;
 
   cricket::SendDataResult send_result = cricket::SDR_SUCCESS;
@@ skipping 10 matching lines @@
     QueueControlMessage(buffer);
   } else {
     LOG(LS_ERROR) << "Closing the DataChannel due to a failure to send"
                   << " the CONTROL message, send_result = " << send_result;
     Close();
   }
   return retval;
 }
 
 }  // namespace webrtc