Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/p2p/client/basicportallocator.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 82 matching lines @@
 
 namespace cricket {
 const uint32_t DISABLE_ALL_PHASES =
     PORTALLOCATOR_DISABLE_UDP | PORTALLOCATOR_DISABLE_TCP |
     PORTALLOCATOR_DISABLE_STUN | PORTALLOCATOR_DISABLE_RELAY;
 
 // BasicPortAllocator
 BasicPortAllocator::BasicPortAllocator(rtc::NetworkManager* network_manager,
                                        rtc::PacketSocketFactory* socket_factory)
     : network_manager_(network_manager), socket_factory_(socket_factory) {
-  ASSERT(network_manager_ != nullptr);
-  ASSERT(socket_factory_ != nullptr);
+  RTC_DCHECK(network_manager_ != nullptr);
+  RTC_DCHECK(socket_factory_ != nullptr);
   Construct();
 }
 
 BasicPortAllocator::BasicPortAllocator(rtc::NetworkManager* network_manager)
     : network_manager_(network_manager), socket_factory_(nullptr) {
-  ASSERT(network_manager_ != nullptr);
+  RTC_DCHECK(network_manager_ != nullptr);
   Construct();
 }
 
 BasicPortAllocator::BasicPortAllocator(rtc::NetworkManager* network_manager,
                                        rtc::PacketSocketFactory* socket_factory,
                                        const ServerAddresses& stun_servers)
     : network_manager_(network_manager), socket_factory_(socket_factory) {
-  ASSERT(socket_factory_ != NULL);
+  RTC_DCHECK(socket_factory_ != NULL);
   SetConfiguration(stun_servers, std::vector<RelayServerConfig>(), 0, false);
   Construct();
 }
 
 BasicPortAllocator::BasicPortAllocator(
     rtc::NetworkManager* network_manager,
     const ServerAddresses& stun_servers,
     const rtc::SocketAddress& relay_address_udp,
     const rtc::SocketAddress& relay_address_tcp,
     const rtc::SocketAddress& relay_address_ssl)
@@ skipping 138 matching lines @@
     socket_factory_ = owned_socket_factory_.get();
   }
 
   network_thread_->Post(RTC_FROM_HERE, this, MSG_CONFIG_START);
 
   LOG(LS_INFO) << "Start getting ports with prune_turn_ports "
                << (prune_turn_ports_ ? "enabled" : "disabled");
 }
 
 void BasicPortAllocatorSession::StopGettingPorts() {
-  ASSERT(rtc::Thread::Current() == network_thread_);
+  RTC_DCHECK(rtc::Thread::Current() == network_thread_);
   ClearGettingPorts();
   // Note: this must be called after ClearGettingPorts because both may set the
   // session state and we should set the state to STOPPED.
   state_ = SessionState::STOPPED;
 }
 
 void BasicPortAllocatorSession::ClearGettingPorts() {
-  ASSERT(rtc::Thread::Current() == network_thread_);
+  RTC_DCHECK(rtc::Thread::Current() == network_thread_);
   network_thread_->Clear(this, MSG_ALLOCATE);
   for (uint32_t i = 0; i < sequences_.size(); ++i) {
     sequences_[i]->Stop();
   }
   network_thread_->Post(RTC_FROM_HERE, this, MSG_CONFIG_STOP);
   state_ = SessionState::CLEARED;
 }
 
 std::vector<rtc::Network*> BasicPortAllocatorSession::GetFailedNetworks() {
   std::vector<rtc::Network*> networks = GetNetworks();
@@ skipping 132 matching lines @@
   // If all allocated ports are no longer gathering, session must have got all
   // expected candidates. Session will trigger candidates allocation complete
   // signal.
   return std::none_of(ports_.begin(), ports_.end(),
                       [](const PortData& port) { return port.inprogress(); });
 }
 
 void BasicPortAllocatorSession::OnMessage(rtc::Message *message) {
   switch (message->message_id) {
   case MSG_CONFIG_START:
-    ASSERT(rtc::Thread::Current() == network_thread_);
+    RTC_DCHECK(rtc::Thread::Current() == network_thread_);
     GetPortConfigurations();
     break;
   case MSG_CONFIG_READY:
-    ASSERT(rtc::Thread::Current() == network_thread_);
+    RTC_DCHECK(rtc::Thread::Current() == network_thread_);
     OnConfigReady(static_cast<PortConfiguration*>(message->pdata));
     break;
   case MSG_ALLOCATE:
-    ASSERT(rtc::Thread::Current() == network_thread_);
+    RTC_DCHECK(rtc::Thread::Current() == network_thread_);
     OnAllocate();
     break;
   case MSG_SEQUENCEOBJECTS_CREATED:
-    ASSERT(rtc::Thread::Current() == network_thread_);
+    RTC_DCHECK(rtc::Thread::Current() == network_thread_);
     OnAllocationSequenceObjectsCreated();
     break;
   case MSG_CONFIG_STOP:
-    ASSERT(rtc::Thread::Current() == network_thread_);
+    RTC_DCHECK(rtc::Thread::Current() == network_thread_);
     OnConfigStop();
     break;
   default:
     RTC_NOTREACHED();
   }
 }
 
 void BasicPortAllocatorSession::UpdateIceParametersInternal() {
   for (PortData& port : ports_) {
     port.port()->set_content_name(content_name());
@@ skipping 19 matching lines @@
 // Adds a configuration to the list.
 void BasicPortAllocatorSession::OnConfigReady(PortConfiguration* config) {
   if (config) {
     configs_.push_back(config);
   }
 
   AllocatePorts();
 }
 
 void BasicPortAllocatorSession::OnConfigStop() {
-  ASSERT(rtc::Thread::Current() == network_thread_);
+  RTC_DCHECK(rtc::Thread::Current() == network_thread_);
 
   // If any of the allocated ports have not completed the candidates allocation,
   // mark those as error. Since session doesn't need any new candidates
   // at this stage of the allocation, it's safe to discard any new candidates.
   bool send_signal = false;
   for (std::vector<PortData>::iterator it = ports_.begin();
        it != ports_.end(); ++it) {
     if (it->inprogress()) {
       // Updating port state to error, which didn't finish allocating candidates
       // yet.
@@ skipping 10 matching lines @@
     }
   }
 
   // If we stopped anything that was running, send a done signal now.
   if (send_signal) {
     MaybeSignalCandidatesAllocationDone();
   }
 }
 
 void BasicPortAllocatorSession::AllocatePorts() {
-  ASSERT(rtc::Thread::Current() == network_thread_);
+  RTC_DCHECK(rtc::Thread::Current() == network_thread_);
   network_thread_->Post(RTC_FROM_HERE, this, MSG_ALLOCATE);
 }
 
 void BasicPortAllocatorSession::OnAllocate() {
   if (network_manager_started_ && !IsStopped())
     DoAllocate();
 
   allocation_started_ = true;
 }
 
 std::vector<rtc::Network*> BasicPortAllocatorSession::GetNetworks() {
   std::vector<rtc::Network*> networks;
   rtc::NetworkManager* network_manager = allocator_->network_manager();
-  ASSERT(network_manager != nullptr);
+  RTC_DCHECK(network_manager != nullptr);
   // If the network permission state is BLOCKED, we just act as if the flag has
   // been passed in.
   if (network_manager->enumeration_permission() ==
       rtc::NetworkManager::ENUMERATION_BLOCKED) {
     set_flags(flags() | PORTALLOCATOR_DISABLE_ADAPTER_ENUMERATION);
   }
   // If the adapter enumeration is disabled, we'll just bind to any address
   // instead of specific NIC. This is to ensure the same routing for http
   // traffic by OS is also used here to avoid any local or public IP leakage
   // during stun process.
@@ skipping 163 matching lines @@
 }
 
 void BasicPortAllocatorSession::OnAllocationSequenceObjectsCreated() {
   allocation_sequences_created_ = true;
   // Send candidate allocation complete signal if we have no sequences.
   MaybeSignalCandidatesAllocationDone();
 }
 
 void BasicPortAllocatorSession::OnCandidateReady(
     Port* port, const Candidate& c) {
-  ASSERT(rtc::Thread::Current() == network_thread_);
+  RTC_DCHECK(rtc::Thread::Current() == network_thread_);
   PortData* data = FindPort(port);
-  ASSERT(data != NULL);
+  RTC_DCHECK(data != NULL);
   LOG_J(LS_INFO, port) << "Gathered candidate: " << c.ToSensitiveString();
   // Discarding any candidate signal if port allocation status is
   // already done with gathering.
   if (!data->inprogress()) {
     LOG(LS_WARNING)
         << "Discarding candidate because port is already done gathering.";
     return;
   }
 
   // Mark that the port has a pairable candidate, either because we have a
@@ skipping 88 matching lines @@
   return pruned;
 }
 
 void BasicPortAllocatorSession::PruneAllPorts() {
   for (PortData& data : ports_) {
     data.Prune();
   }
 }
 
 void BasicPortAllocatorSession::OnPortComplete(Port* port) {
-  ASSERT(rtc::Thread::Current() == network_thread_);
+  RTC_DCHECK(rtc::Thread::Current() == network_thread_);
   LOG_J(LS_INFO, port) << "Port completed gathering candidates.";
   PortData* data = FindPort(port);
-  ASSERT(data != NULL);
+  RTC_DCHECK(data != NULL);
 
   // Ignore any late signals.
   if (!data->inprogress()) {
     return;
   }
 
   // Moving to COMPLETE state.
   data->set_complete();
   // Send candidate allocation complete signal if this was the last port.
   MaybeSignalCandidatesAllocationDone();
 }
 
 void BasicPortAllocatorSession::OnPortError(Port* port) {
-  ASSERT(rtc::Thread::Current() == network_thread_);
+  RTC_DCHECK(rtc::Thread::Current() == network_thread_);
   LOG_J(LS_INFO, port) << "Port encountered error while gathering candidates.";
   PortData* data = FindPort(port);
-  ASSERT(data != NULL);
+  RTC_DCHECK(data != NULL);
   // We might have already given up on this port and stopped it.
   if (!data->inprogress()) {
     return;
   }
 
   // SignalAddressError is currently sent from StunPort/TurnPort.
   // But this signal itself is generic.
   data->set_error();
   // Send candidate allocation complete signal if this was the last port.
   MaybeSignalCandidatesAllocationDone();
@@ skipping 93 matching lines @@
     } else {
       LOG(LS_INFO) << "All candidates gathered for " << content_name() << ":"
                    << component() << ":" << generation();
     }
     SignalCandidatesAllocationDone(this);
   }
 }
 
 void BasicPortAllocatorSession::OnPortDestroyed(
     PortInterface* port) {
-  ASSERT(rtc::Thread::Current() == network_thread_);
+  RTC_DCHECK(rtc::Thread::Current() == network_thread_);
   for (std::vector<PortData>::iterator iter = ports_.begin();
        iter != ports_.end(); ++iter) {
     if (port == iter->port()) {
       ports_.erase(iter);
       LOG_J(LS_INFO, port) << "Removed port from allocator ("
                            << static_cast<int>(ports_.size()) << " remaining)";
       return;
     }
   }
   RTC_NOTREACHED();
@@ skipping 137 matching lines @@
 
 void AllocationSequence::Stop() {
   // If the port is completed, don't set it to stopped.
   if (state_ == kRunning) {
     state_ = kStopped;
     session_->network_thread()->Clear(this, MSG_ALLOCATION_PHASE);
   }
 }
 
 void AllocationSequence::OnMessage(rtc::Message* msg) {
-  ASSERT(rtc::Thread::Current() == session_->network_thread());
-  ASSERT(msg->message_id == MSG_ALLOCATION_PHASE);
+  RTC_DCHECK(rtc::Thread::Current() == session_->network_thread());
+  RTC_DCHECK(msg->message_id == MSG_ALLOCATION_PHASE);
 
   const char* const PHASE_NAMES[kNumPhases] = {
     "Udp", "Relay", "Tcp", "SslTcp"
   };
 
   // Perform all of the phases in the current step.
   LOG_J(LS_INFO, network_) << "Allocation Phase="
                            << PHASE_NAMES[phase_];
 
   switch (phase_) {
@@ skipping 147 matching lines @@
 }
 
 void AllocationSequence::CreateRelayPorts() {
   if (IsFlagSet(PORTALLOCATOR_DISABLE_RELAY)) {
      LOG(LS_VERBOSE) << "AllocationSequence: Relay ports disabled, skipping.";
      return;
   }
 
   // If BasicPortAllocatorSession::OnAllocate left relay ports enabled then we
   // ought to have a relay list for them here.
-  ASSERT(config_ && !config_->relays.empty());
+  RTC_DCHECK(config_ && !config_->relays.empty());
   if (!(config_ && !config_->relays.empty())) {
     LOG(LS_WARNING)
         << "AllocationSequence: No relay server configured, skipping.";
     return;
   }
 
   for (RelayServerConfig& relay : config_->relays) {
     if (relay.type == RELAY_GTURN) {
       CreateGturnPort(relay);
     } else if (relay.type == RELAY_TURN) {
@@ skipping 80 matching lines @@
       port = TurnPort::Create(session_->network_thread(),
                               session_->socket_factory(),
                               network_, ip_,
                               session_->allocator()->min_port(),
                               session_->allocator()->max_port(),
                               session_->username(),
                               session_->password(),
                               *relay_port, config.credentials, config.priority,
                               session_->allocator()->origin());
     }
-    ASSERT(port != NULL);
+    RTC_DCHECK(port != NULL);
     port->SetTlsCertPolicy(config.tls_cert_policy);
     session_->AddAllocatedPort(port, this, true);
   }
 }
 
 void AllocationSequence::OnReadPacket(
     rtc::AsyncPacketSocket* socket, const char* data, size_t size,
     const rtc::SocketAddress& remote_addr,
     const rtc::PacketTime& packet_time) {
-  ASSERT(socket == udp_socket_.get());
+  RTC_DCHECK(socket == udp_socket_.get());
 
   bool turn_port_found = false;
 
   // Try to find the TurnPort that matches the remote address. Note that the
   // message could be a STUN binding response if the TURN server is also used as
   // a STUN server. We don't want to parse every message here to check if it is
   // a STUN binding response, so we pass the message to TurnPort regardless of
   // the message type. The TurnPort will just ignore the message since it will
   // not find any request by transaction ID.
   for (TurnPort* port : turn_ports_) {
@@ skipping 101 matching lines @@
   ServerAddresses servers;
   for (size_t i = 0; i < relays.size(); ++i) {
     if (relays[i].type == turn_type && SupportsProtocol(relays[i], type)) {
       servers.insert(relays[i].ports.front().address);
     }
   }
   return servers;
 }
 
 }  // namespace cricket