Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/p2p/base/port.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 166 matching lines @@
       max_port_(max_port),
       component_(ICE_CANDIDATE_COMPONENT_DEFAULT),
       generation_(0),
       ice_username_fragment_(username_fragment),
       password_(password),
       timeout_delay_(kPortTimeoutDelay),
       enable_port_packets_(false),
       ice_role_(ICEROLE_UNKNOWN),
       tiebreaker_(0),
       shared_socket_(false) {
-  ASSERT(factory_ != NULL);
+  RTC_DCHECK(factory_ != NULL);
   Construct();
 }
 
 void Port::Construct() {
   // TODO(pthatcher): Remove this old behavior once we're sure no one
   // relies on it.  If the username_fragment and password are empty,
   // we should just create one.
   if (ice_username_fragment_.empty()) {
-    ASSERT(password_.empty());
+    RTC_DCHECK(password_.empty());
     ice_username_fragment_ = rtc::CreateRandomString(ICE_UFRAG_LENGTH);
     password_ = rtc::CreateRandomString(ICE_PWD_LENGTH);
   }
   network_->SignalTypeChanged.connect(this, &Port::OnNetworkTypeChanged);
   network_cost_ = network_->GetCost();
 
   thread_->PostDelayed(RTC_FROM_HERE, timeout_delay_, this,
                        MSG_DESTROY_IF_DEAD);
   LOG_J(LS_INFO, this) << "Port created with network cost " << network_cost_;
 }
@@ skipping 39 matching lines @@
                       const rtc::SocketAddress& base_address,
                       const rtc::SocketAddress& related_address,
                       const std::string& protocol,
                       const std::string& relay_protocol,
                       const std::string& tcptype,
                       const std::string& type,
                       uint32_t type_preference,
                       uint32_t relay_preference,
                       bool final) {
   if (protocol == TCP_PROTOCOL_NAME && type == LOCAL_PORT_TYPE) {
-    ASSERT(!tcptype.empty());
+    RTC_DCHECK(!tcptype.empty());
   }
 
   std::string foundation =
       ComputeFoundation(type, protocol, relay_protocol, base_address);
   Candidate c(component_, protocol, address, 0U, username_fragment(), password_,
               type, generation_, foundation, network_->id(), network_cost_);
   c.set_priority(
       c.GetPriority(type_preference, network_->preference(), relay_preference));
   c.set_relay_protocol(relay_protocol);
   c.set_tcptype(tcptype);
@@ skipping 81 matching lines @@
 }
 
 bool Port::GetStunMessage(const char* data,
                           size_t size,
                           const rtc::SocketAddress& addr,
                           std::unique_ptr<IceMessage>* out_msg,
                           std::string* out_username) {
   // NOTE: This could clearly be optimized to avoid allocating any memory.
   //       However, at the data rates we'll be looking at on the client side,
   //       this probably isn't worth worrying about.
-  ASSERT(out_msg != NULL);
-  ASSERT(out_username != NULL);
+  RTC_DCHECK(out_msg != NULL);
+  RTC_DCHECK(out_username != NULL);
   out_username->clear();
 
   // Don't bother parsing the packet if we can tell it's not STUN.
   // In ICE mode, all STUN packets will have a valid fingerprint.
   if (!StunMessage::ValidateFingerprint(data, size)) {
     return false;
   }
 
   // Parse the request message.  If the packet is not a complete and correct
   // STUN message, then ignore it.
@@ skipping 177 matching lines @@
 void Port::CreateStunUsername(const std::string& remote_username,
                               std::string* stun_username_attr_str) const {
   stun_username_attr_str->clear();
   *stun_username_attr_str = remote_username;
   stun_username_attr_str->append(":");
   stun_username_attr_str->append(username_fragment());
 }
 
 void Port::SendBindingResponse(StunMessage* request,
                                const rtc::SocketAddress& addr) {
-  ASSERT(request->type() == STUN_BINDING_REQUEST);
+  RTC_DCHECK(request->type() == STUN_BINDING_REQUEST);
 
   // Retrieve the username from the request.
   const StunByteStringAttribute* username_attr =
       request->GetByteString(STUN_ATTR_USERNAME);
-  ASSERT(username_attr != NULL);
+  RTC_DCHECK(username_attr != NULL);
   if (username_attr == NULL) {
     // No valid username, skip the response.
     return;
   }
 
   // Fill in the response message.
   StunMessage response;
   response.SetType(STUN_BINDING_RESPONSE);
   response.SetTransactionID(request->transaction_id());
   const StunUInt32Attribute* retransmit_attr =
@@ skipping 38 matching lines @@
         << ", to=" << addr.ToSensitiveString()
         << ", id=" << rtc::hex_encode(response.transaction_id());
 
     conn->stats_.sent_ping_responses++;
   }
 }
 
 void Port::SendBindingErrorResponse(StunMessage* request,
                                     const rtc::SocketAddress& addr,
                                     int error_code, const std::string& reason) {
-  ASSERT(request->type() == STUN_BINDING_REQUEST);
+  RTC_DCHECK(request->type() == STUN_BINDING_REQUEST);
 
   // Fill in the response message.
   StunMessage response;
   response.SetType(STUN_BINDING_ERROR_RESPONSE);
   response.SetTransactionID(request->transaction_id());
 
   // When doing GICE, we need to write out the error code incorrectly to
   // maintain backwards compatiblility.
   StunErrorCodeAttribute* error_attr = StunAttribute::CreateErrorCode();
   error_attr->SetCode(error_code);
@@ skipping 22 matching lines @@
     state_ = State::KEEP_ALIVE_UNTIL_PRUNED;
   }
 }
 
 void Port::Prune() {
   state_ = State::PRUNED;
   thread_->Post(RTC_FROM_HERE, this, MSG_DESTROY_IF_DEAD);
 }
 
 void Port::OnMessage(rtc::Message *pmsg) {
-  ASSERT(pmsg->message_id == MSG_DESTROY_IF_DEAD);
+  RTC_DCHECK(pmsg->message_id == MSG_DESTROY_IF_DEAD);
   bool dead =
       (state_ == State::INIT || state_ == State::PRUNED) &&
       connections_.empty() &&
       rtc::TimeMillis() - last_time_all_connections_removed_ >= timeout_delay_;
   if (dead) {
     Destroy();
   }
 }
 
 void Port::OnNetworkTypeChanged(const rtc::Network* network) {
-  ASSERT(network == network_);
+  RTC_DCHECK(network == network_);
 
   UpdateNetworkCost();
 }
 
 std::string Port::ToString() const {
   std::stringstream ss;
   ss << "Port[" << std::hex << this << std::dec << ":" << content_name_ << ":"
      << component_ << ":" << generation_ << ":" << type_ << ":"
      << network_->ToString() << "]";
   return ss.str();
@@ skipping 22 matching lines @@
   }
 }
 
 void Port::EnablePortPackets() {
   enable_port_packets_ = true;
 }
 
 void Port::OnConnectionDestroyed(Connection* conn) {
   AddressMap::iterator iter =
       connections_.find(conn->remote_candidate().address());
-  ASSERT(iter != connections_.end());
+  RTC_DCHECK(iter != connections_.end());
   connections_.erase(iter);
   HandleConnectionDestroyed(conn);
 
   // Ports time out after all connections fail if it is not marked as
   // "keep alive until pruned."
   // Note: If a new connection is added after this message is posted, but it
   // fails and is removed before kPortTimeoutDelay, then this message will
   // not cause the Port to be destroyed.
   if (connections_.empty()) {
     last_time_all_connections_removed_ = rtc::TimeMillis();
     thread_->PostDelayed(RTC_FROM_HERE, timeout_delay_, this,
                          MSG_DESTROY_IF_DEAD);
   }
 }
 
 void Port::Destroy() {
-  ASSERT(connections_.empty());
+  RTC_DCHECK(connections_.empty());
   LOG_J(LS_INFO, this) << "Port deleted";
   SignalDestroyed(this);
   delete this;
 }
 
 const std::string Port::username_fragment() const {
   return ice_username_fragment_;
 }
 
 // A ConnectionRequest is a simple STUN ping used to determine writability.
@@ skipping 130 matching lines @@
   // TODO(mallinath) - Start connections from STATE_FROZEN.
   // Wire up to send stun packets
   requests_.SignalSendPacket.connect(this, &Connection::OnSendStunPacket);
   LOG_J(LS_INFO, this) << "Connection created";
 }
 
 Connection::~Connection() {
 }
 
 const Candidate& Connection::local_candidate() const {
-  ASSERT(local_candidate_index_ < port_->Candidates().size());
+  RTC_DCHECK(local_candidate_index_ < port_->Candidates().size());
   return port_->Candidates()[local_candidate_index_];
 }
 
 const Candidate& Connection::remote_candidate() const {
   return remote_candidate_;
 }
 
 uint64_t Connection::priority() const {
   uint64_t priority = 0;
   // RFC 5245 - 5.7.2.  Computing Pair Priority and Ordering Pairs
@@ skipping 551 matching lines @@
       remote_candidate_.protocol() == new_candidate.protocol() &&
       remote_candidate_.address() == new_candidate.address() &&
       remote_candidate_.username() == new_candidate.username() &&
       remote_candidate_.password() == new_candidate.password() &&
       remote_candidate_.generation() == new_candidate.generation()) {
     remote_candidate_ = new_candidate;
   }
 }
 
 void Connection::OnMessage(rtc::Message *pmsg) {
-  ASSERT(pmsg->message_id == MSG_DELETE);
+  RTC_DCHECK(pmsg->message_id == MSG_DELETE);
   LOG(LS_INFO) << "Connection deleted with number of pings sent: "
                << num_pings_sent_;
   SignalDestroyed(this);
   delete this;
 }
 
 int64_t Connection::last_received() const {
   return std::max(last_data_received_,
              std::max(last_ping_received_, last_ping_response_received_));
 }
@@ skipping 104 matching lines @@
                                  size_t index,
                                  const Candidate& remote_candidate)
     : Connection(port, index, remote_candidate) {}
 
 int ProxyConnection::Send(const void* data, size_t size,
                           const rtc::PacketOptions& options) {
   stats_.sent_total_packets++;
   int sent = port_->SendTo(data, size, remote_candidate_.address(),
                            options, true);
   if (sent <= 0) {
-    ASSERT(sent < 0);
+    RTC_DCHECK(sent < 0);
     error_ = port_->GetError();
     stats_.sent_discarded_packets++;
   } else {
     send_rate_tracker_.AddSamples(sent);
   }
   return sent;
 }
 
 }  // namespace cricket