Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/api/webrtcsession.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.
  */
 
@@ skipping 240 matching lines @@
     return false;
   }
 
   *ssrc = stream->first_ssrc();
   return true;
 }
 
 static bool GetTrackIdBySsrc(const SessionDescription* session_description,
                              uint32_t ssrc,
                              std::string* track_id) {
-  ASSERT(track_id != NULL);
+  RTC_DCHECK(track_id != NULL);
 
   const cricket::ContentInfo* audio_info =
       cricket::GetFirstAudioContent(session_description);
   if (audio_info) {
     const cricket::MediaContentDescription* audio_content =
         static_cast<const cricket::MediaContentDescription*>(
             audio_info->description);
 
     const auto* found =
         cricket::GetStreamBySsrc(audio_content->streams(), ssrc);
@@ skipping 223 matching lines @@
       this, &WebRtcSession::OnTransportControllerGatheringState);
   transport_controller_->SignalCandidatesGathered.connect(
       this, &WebRtcSession::OnTransportControllerCandidatesGathered);
   transport_controller_->SignalCandidatesRemoved.connect(
       this, &WebRtcSession::OnTransportControllerCandidatesRemoved);
   transport_controller_->SignalDtlsHandshakeError.connect(
       this, &WebRtcSession::OnTransportControllerDtlsHandshakeError);
 }
 
 WebRtcSession::~WebRtcSession() {
-  ASSERT(signaling_thread()->IsCurrent());
+  RTC_DCHECK(signaling_thread()->IsCurrent());
   // Destroy video_channel_ first since it may have a pointer to the
   // voice_channel_.
   if (video_channel_) {
     SignalVideoChannelDestroyed();
     channel_manager_->DestroyVideoChannel(video_channel_.release());
   }
   if (voice_channel_) {
     SignalVoiceChannelDestroyed();
     channel_manager_->DestroyVoiceChannel(voice_channel_.release());
   }
@@ skipping 175 matching lines @@
 }
 
 void WebRtcSession::CreateAnswer(
     CreateSessionDescriptionObserver* observer,
     const cricket::MediaSessionOptions& session_options) {
   webrtc_session_desc_factory_->CreateAnswer(observer, session_options);
 }
 
 bool WebRtcSession::SetLocalDescription(SessionDescriptionInterface* desc,
                                         std::string* err_desc) {
-  ASSERT(signaling_thread()->IsCurrent());
+  RTC_DCHECK(signaling_thread()->IsCurrent());
 
   // Takes the ownership of |desc| regardless of the result.
   std::unique_ptr<SessionDescriptionInterface> desc_temp(desc);
 
   // Validate SDP.
   if (!ValidateSessionDescription(desc, cricket::CS_LOCAL, err_desc)) {
     return false;
   }
 
   // Update the initial_offerer flag if this session is the initial_offerer.
@@ skipping 33 matching lines @@
   pending_ice_restarts_.clear();
 
   if (error() != ERROR_NONE) {
     return BadLocalSdp(desc->type(), GetSessionErrorMsg(), err_desc);
   }
   return true;
 }
 
 bool WebRtcSession::SetRemoteDescription(SessionDescriptionInterface* desc,
                                          std::string* err_desc) {
-  ASSERT(signaling_thread()->IsCurrent());
+  RTC_DCHECK(signaling_thread()->IsCurrent());
 
   // Takes the ownership of |desc| regardless of the result.
   std::unique_ptr<SessionDescriptionInterface> desc_temp(desc);
 
   // Validate SDP.
   if (!ValidateSessionDescription(desc, cricket::CS_REMOTE, err_desc)) {
     return false;
   }
 
   const SessionDescriptionInterface* old_remote_description =
@@ skipping 80 matching lines @@
   return true;
 }
 
 void WebRtcSession::LogState(State old_state, State new_state) {
   LOG(LS_INFO) << "Session:" << id()
                << " Old state:" << GetStateString(old_state)
                << " New state:" << GetStateString(new_state);
 }
 
 void WebRtcSession::SetState(State state) {
-  ASSERT(signaling_thread_->IsCurrent());
+  RTC_DCHECK(signaling_thread_->IsCurrent());
   if (state != state_) {
     LogState(state_, state);
     state_ = state;
     SignalState(this, state_);
   }
 }
 
 void WebRtcSession::SetError(Error error, const std::string& error_desc) {
-  ASSERT(signaling_thread_->IsCurrent());
+  RTC_DCHECK(signaling_thread_->IsCurrent());
   if (error != error_) {
     error_ = error;
     error_desc_ = error_desc;
   }
 }
 
 bool WebRtcSession::UpdateSessionState(
     Action action, cricket::ContentSource source,
     std::string* err_desc) {
-  ASSERT(signaling_thread()->IsCurrent());
+  RTC_DCHECK(signaling_thread()->IsCurrent());
 
   // If there's already a pending error then no state transition should happen.
   // But all call-sites should be verifying this before calling us!
-  ASSERT(error() == ERROR_NONE);
+  RTC_DCHECK(error() == ERROR_NONE);
   std::string td_err;
   if (action == kOffer) {
     if (!PushdownTransportDescription(source, cricket::CA_OFFER, &td_err)) {
       return BadOfferSdp(source, MakeTdErrorString(td_err), err_desc);
     }
     SetState(source == cricket::CS_LOCAL ? STATE_SENTOFFER
                                          : STATE_RECEIVEDOFFER);
     if (!PushdownMediaDescription(cricket::CA_OFFER, source, err_desc)) {
       SetError(ERROR_CONTENT, *err_desc);
     }
@@ skipping 47 matching lines @@
 }
 
 WebRtcSession::Action WebRtcSession::GetAction(const std::string& type) {
   if (type == SessionDescriptionInterface::kOffer) {
     return WebRtcSession::kOffer;
   } else if (type == SessionDescriptionInterface::kPrAnswer) {
     return WebRtcSession::kPrAnswer;
   } else if (type == SessionDescriptionInterface::kAnswer) {
     return WebRtcSession::kAnswer;
   }
-  ASSERT(false && "unknown action type");
+  RTC_NOTREACHED() << "unknown action type";
   return WebRtcSession::kOffer;
 }
 
 bool WebRtcSession::PushdownMediaDescription(
     cricket::ContentAction action,
     cricket::ContentSource source,
     std::string* err) {
   auto set_content = [this, action, source, err](cricket::BaseChannel* ch) {
     if (!ch) {
       return true;
@@ skipping 275 matching lines @@
                                   track_id);
 }
 
 std::string WebRtcSession::BadStateErrMsg(State state) {
   std::ostringstream desc;
   desc << "Called in wrong state: " << GetStateString(state);
   return desc.str();
 }
 
 bool WebRtcSession::CanInsertDtmf(const std::string& track_id) {
-  ASSERT(signaling_thread()->IsCurrent());
+  RTC_DCHECK(signaling_thread()->IsCurrent());
   if (!voice_channel_) {
     LOG(LS_ERROR) << "CanInsertDtmf: No audio channel exists.";
     return false;
   }
   uint32_t send_ssrc = 0;
   // The Dtmf is negotiated per channel not ssrc, so we only check if the ssrc
   // exists.
   if (!local_description() ||
       !GetAudioSsrcByTrackId(local_description()->description(), track_id,
                              &send_ssrc)) {
     LOG(LS_ERROR) << "CanInsertDtmf: Track does not exist: " << track_id;
     return false;
   }
   return voice_channel_->CanInsertDtmf();
 }
 
 bool WebRtcSession::InsertDtmf(const std::string& track_id,
                                int code, int duration) {
-  ASSERT(signaling_thread()->IsCurrent());
+  RTC_DCHECK(signaling_thread()->IsCurrent());
   if (!voice_channel_) {
     LOG(LS_ERROR) << "InsertDtmf: No audio channel exists.";
     return false;
   }
   uint32_t send_ssrc = 0;
   if (!VERIFY(local_description() &&
               GetAudioSsrcByTrackId(local_description()->description(),
                                     track_id, &send_ssrc))) {
     LOG(LS_ERROR) << "InsertDtmf: Track does not exist: " << track_id;
     return false;
@@ skipping 84 matching lines @@
       RTC_FROM_HERE, rtc::Bind(&cricket::SctpTransportInternal::ResetStream,
                                sctp_transport_.get(), sid));
 }
 
 bool WebRtcSession::ReadyToSendData() const {
   return (rtp_data_channel_ && rtp_data_channel_->ready_to_send_data()) ||
          sctp_ready_to_send_data_;
 }
 
 std::unique_ptr<SessionStats> WebRtcSession::GetStats_s() {
-  ASSERT(signaling_thread()->IsCurrent());
+  RTC_DCHECK(signaling_thread()->IsCurrent());
   ChannelNamePairs channel_name_pairs;
   if (voice_channel()) {
     channel_name_pairs.voice = rtc::Optional<ChannelNamePair>(ChannelNamePair(
         voice_channel()->content_name(), voice_channel()->transport_name()));
   }
   if (video_channel()) {
     channel_name_pairs.video = rtc::Optional<ChannelNamePair>(ChannelNamePair(
         video_channel()->content_name(), video_channel()->transport_name()));
   }
   if (rtp_data_channel()) {
@@ skipping 139 matching lines @@
   }
   ice_connection_receiving_ = receiving;
   if (ice_observer_) {
     ice_observer_->OnIceConnectionReceivingChange(receiving);
   }
 }
 
 void WebRtcSession::OnTransportControllerCandidatesGathered(
     const std::string& transport_name,
     const cricket::Candidates& candidates) {
-  ASSERT(signaling_thread()->IsCurrent());
+  RTC_DCHECK(signaling_thread()->IsCurrent());
   int sdp_mline_index;
   if (!GetLocalCandidateMediaIndex(transport_name, &sdp_mline_index)) {
     LOG(LS_ERROR) << "OnTransportControllerCandidatesGathered: content name "
                   << transport_name << " not found";
     return;
   }
 
   for (cricket::Candidates::const_iterator citer = candidates.begin();
        citer != candidates.end(); ++citer) {
     // Use transport_name as the candidate media id.
     JsepIceCandidate candidate(transport_name, sdp_mline_index, *citer);
     if (ice_observer_) {
       ice_observer_->OnIceCandidate(&candidate);
     }
     if (local_description()) {
       mutable_local_description()->AddCandidate(&candidate);
     }
   }
 }
 
 void WebRtcSession::OnTransportControllerCandidatesRemoved(
     const std::vector<cricket::Candidate>& candidates) {
-  ASSERT(signaling_thread()->IsCurrent());
+  RTC_DCHECK(signaling_thread()->IsCurrent());
   // Sanity check.
   for (const cricket::Candidate& candidate : candidates) {
     if (candidate.transport_name().empty()) {
       LOG(LS_ERROR) << "OnTransportControllerCandidatesRemoved: "
                     << "empty content name in candidate "
                     << candidate.ToString();
       return;
     }
   }
 
@@ skipping 304 matching lines @@
     rtp_data_channel_->SignalSentPacket.connect(this,
                                                 &WebRtcSession::OnSentPacket_w);
   }
 
   SignalDataChannelCreated();
   return true;
 }
 
 std::unique_ptr<SessionStats> WebRtcSession::GetStats_n(
     const ChannelNamePairs& channel_name_pairs) {
-  ASSERT(network_thread()->IsCurrent());
+  RTC_DCHECK(network_thread()->IsCurrent());
   std::unique_ptr<SessionStats> session_stats(new SessionStats());
   for (const auto channel_name_pair : { &channel_name_pairs.voice,
                                         &channel_name_pairs.video,
                                         &channel_name_pairs.data }) {
     if (*channel_name_pair) {
       cricket::TransportStats transport_stats;
       if (!transport_controller_->GetStats((*channel_name_pair)->transport_name,
                                            &transport_stats)) {
         return nullptr;
       }
@@ skipping 108 matching lines @@
 }
 
 // Returns false if bundle is enabled and rtcp_mux is disabled.
 bool WebRtcSession::ValidateBundleSettings(const SessionDescription* desc) {
   bool bundle_enabled = desc->HasGroup(cricket::GROUP_TYPE_BUNDLE);
   if (!bundle_enabled)
     return true;
 
   const cricket::ContentGroup* bundle_group =
       desc->GetGroupByName(cricket::GROUP_TYPE_BUNDLE);
-  ASSERT(bundle_group != NULL);
+  RTC_DCHECK(bundle_group != NULL);
 
   const cricket::ContentInfos& contents = desc->contents();
   for (cricket::ContentInfos::const_iterator citer = contents.begin();
        citer != contents.end(); ++citer) {
     const cricket::ContentInfo* content = (&*citer);
-    ASSERT(content != NULL);
+    RTC_DCHECK(content != NULL);
     if (bundle_group->HasContentName(content->name) &&
         !content->rejected && content->type == cricket::NS_JINGLE_RTP) {
       if (!HasRtcpMuxEnabled(content))
         return false;
     }
   }
   // RTCP-MUX is enabled in all the contents.
   return true;
 }
 
@@ skipping 132 matching lines @@
   return transport_controller_->ReadyForRemoteCandidates(transport_name);
 }
 
 bool WebRtcSession::SrtpRequired() const {
   return dtls_enabled_ ||
          webrtc_session_desc_factory_->SdesPolicy() == cricket::SEC_REQUIRED;
 }
 
 void WebRtcSession::OnTransportControllerGatheringState(
     cricket::IceGatheringState state) {
-  ASSERT(signaling_thread()->IsCurrent());
+  RTC_DCHECK(signaling_thread()->IsCurrent());
   if (state == cricket::kIceGatheringGathering) {
     if (ice_observer_) {
       ice_observer_->OnIceGatheringChange(
           PeerConnectionInterface::kIceGatheringGathering);
     }
   } else if (state == cricket::kIceGatheringComplete) {
     if (ice_observer_) {
       ice_observer_->OnIceGatheringChange(
           PeerConnectionInterface::kIceGatheringComplete);
     }
@@ skipping 138 matching lines @@
         return *sctp_transport_name_;
       }
     }
     // Return an empty string if failed to retrieve the transport name.
     return "";
   }
   return channel->transport_name();
 }
 
 }  // namespace webrtc