Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/base/network.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 248 matching lines @@
     AddressList& current_list = consolidated_address_list[key];
     for (const InterfaceAddress& address : addresses) {
       current_list.ips.push_back(address);
     }
     if (!might_add_to_merged_list) {
       delete network;
     } else {
       if (current_list.ips[0].family() == AF_INET) {
         stats->ipv4_network_count++;
       } else {
-        ASSERT(current_list.ips[0].family() == AF_INET6);
+        RTC_DCHECK(current_list.ips[0].family() == AF_INET6);
         stats->ipv6_network_count++;
       }
     }
   }
 
   // Next, look for existing network objects to re-use.
   // Result of Network merge. Element in this list should have unique key.
   NetworkList merged_list;
   for (const auto& kv : consolidated_address_list) {
     const std::string& key = kv.first;
@@ skipping 15 matching lines @@
       merged_list.push_back(existing_net);
       if (net->type() != ADAPTER_TYPE_UNKNOWN &&
           net->type() != existing_net->type()) {
         existing_net->set_type(net->type());
         *changed = true;
       }
       // If the existing network was not active, networks have changed.
       if (!existing_net->active()) {
         *changed = true;
       }
-      ASSERT(net->active());
+      RTC_DCHECK(net->active());
       if (existing_net != net) {
         delete net;
       }
     }
   }
   // It may still happen that the merged list is a subset of |networks_|.
   // To detect this change, we compare their sizes.
   if (merged_list.size() != networks_.size()) {
     *changed = true;
   }
@@ skipping 417 matching lines @@
     if (sent_first_update_)
       thread_->Post(RTC_FROM_HERE, this, kSignalNetworksMessage);
   } else {
     thread_->Post(RTC_FROM_HERE, this, kUpdateNetworksMessage);
     StartNetworkMonitor();
   }
   ++start_count_;
 }
 
 void BasicNetworkManager::StopUpdating() {
-  ASSERT(Thread::Current() == thread_);
+  RTC_DCHECK(Thread::Current() == thread_);
   if (!start_count_)
     return;
 
   --start_count_;
   if (!start_count_) {
     thread_->Clear(this);
     sent_first_update_ = false;
     StopNetworkMonitor();
   }
 }
@@ skipping 65 matching lines @@
   }
   if (strncmp(network_name, "wlan", 4) == 0) {
     return ADAPTER_TYPE_WIFI;
   }
 #endif
 
   return ADAPTER_TYPE_UNKNOWN;
 }
 
 IPAddress BasicNetworkManager::QueryDefaultLocalAddress(int family) const {
-  ASSERT(thread_ == Thread::Current());
-  ASSERT(thread_->socketserver() != nullptr);
-  ASSERT(family == AF_INET || family == AF_INET6);
+  RTC_DCHECK(thread_ == Thread::Current());
+  RTC_DCHECK(thread_->socketserver() != nullptr);
+  RTC_DCHECK(family == AF_INET || family == AF_INET6);
 
   std::unique_ptr<AsyncSocket> socket(
       thread_->socketserver()->CreateAsyncSocket(family, SOCK_DGRAM));
   if (!socket) {
     LOG_ERR(LERROR) << "Socket creation failed";
     return IPAddress();
   }
 
   if (socket->Connect(SocketAddress(
           family == AF_INET ? kPublicIPv4Host : kPublicIPv6Host, kPublicPort)) <
       0) {
     if (socket->GetError() != ENETUNREACH
         && socket->GetError() != EHOSTUNREACH) {
       // Ignore the expected case of "host/net unreachable" - which happens if
       // the network is V4- or V6-only.
       LOG(LS_INFO) << "Connect failed with " << socket->GetError();
     }
     return IPAddress();
   }
   return socket->GetLocalAddress().ipaddr();
 }
 
 void BasicNetworkManager::UpdateNetworksOnce() {
   if (!start_count_)
     return;
 
-  ASSERT(Thread::Current() == thread_);
+  RTC_DCHECK(Thread::Current() == thread_);
 
   NetworkList list;
   if (!CreateNetworks(false, &list)) {
     SignalError();
   } else {
     bool changed;
     NetworkManager::Stats stats;
     MergeNetworkList(list, &changed, &stats);
     set_default_local_addresses(QueryDefaultLocalAddress(AF_INET),
                                 QueryDefaultLocalAddress(AF_INET6));
@@ skipping 113 matching lines @@
   std::stringstream ss;
   // Print out the first space-terminated token of the network desc, plus
   // the IP address.
   ss << "Net[" << description_.substr(0, description_.find(' '))
      << ":" << prefix_.ToSensitiveString() << "/" << prefix_length_
      << ":" << AdapterTypeToString(type_) << "]";
   return ss.str();
 }
 
 }  // namespace rtc