Replace RTC_DCHECK(false) with RTC_NOTREACHED().

webrtc/api/peerconnection.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 309 matching lines @@
           PeerConnectionInterface::kTlsCertPolicyInsecureNoCheck) {
         config.tls_cert_policy =
             cricket::TlsCertPolicy::TLS_CERT_POLICY_INSECURE_NO_CHECK;
       }
       turn_servers->push_back(config);
       break;
     }
     default:
       // We shouldn't get to this point with an invalid service_type, we should
       // have returned an error already.
-      RTC_DCHECK(false) << "Unexpected service type";
+      RTC_NOTREACHED() << "Unexpected service type";
       return RTCErrorType::INTERNAL_ERROR;
   }
   return RTCErrorType::NONE;
 }
 
 // Check if we can send |new_stream| on a PeerConnection.
 bool CanAddLocalMediaStream(webrtc::StreamCollectionInterface* current_streams,
                             webrtc::MediaStreamInterface* new_stream) {
   if (!new_stream || !current_streams) {
     return false;
@@ skipping 200 matching lines @@
 bool PeerConnectionInterface::RTCConfiguration::operator!=(
     const PeerConnectionInterface::RTCConfiguration& o) const {
   return !(*this == o);
 }
 
 // Generate a RTCP CNAME when a PeerConnection is created.
 std::string GenerateRtcpCname() {
   std::string cname;
   if (!rtc::CreateRandomString(kRtcpCnameLength, &cname)) {
     LOG(LS_ERROR) << "Failed to generate CNAME.";
-    RTC_DCHECK(false);
+    RTC_NOTREACHED();
   }
   return cname;
 }
 
 bool ExtractMediaSessionOptions(
     const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
     bool is_offer,
     cricket::MediaSessionOptions* session_options) {
   typedef PeerConnectionInterface::RTCOfferAnswerOptions RTCOfferAnswerOptions;
   if (!IsValidOfferToReceiveMedia(rtc_options.offer_to_receive_audio) ||
@@ skipping 1048 matching lines @@
       stats_->GetStats(param->track, reports.get());
       param->observer->OnCompleteReports(std::move(reports));
       delete param;
       break;
     }
     case MSG_FREE_DATACHANNELS: {
       sctp_data_channels_to_free_.clear();
       break;
     }
     default:
-      RTC_DCHECK(false && "Not implemented");
+      RTC_NOTREACHED() << "Not implemented";
       break;
   }
 }
 
 void PeerConnection::CreateAudioReceiver(MediaStreamInterface* stream,
                                          const std::string& track_id,
                                          uint32_t ssrc) {
   rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
       receiver = RtpReceiverProxyWithInternal<RtpReceiverInternal>::Create(
           signaling_thread(), new AudioRtpReceiver(stream, track_id, ssrc,
@@ skipping 404 matching lines @@
                                        const std::string& track_id,
                                        uint32_t ssrc,
                                        cricket::MediaType media_type) {
   MediaStreamInterface* stream = remote_streams_->find(stream_label);
 
   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
     CreateAudioReceiver(stream, track_id, ssrc);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     CreateVideoReceiver(stream, track_id, ssrc);
   } else {
-    RTC_DCHECK(false && "Invalid media type");
+    RTC_NOTREACHED() << "Invalid media type";
   }
 }
 
 void PeerConnection::OnRemoteTrackRemoved(const std::string& stream_label,
                                           const std::string& track_id,
                                           cricket::MediaType media_type) {
   MediaStreamInterface* stream = remote_streams_->find(stream_label);
 
   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
     // When the MediaEngine audio channel is destroyed, the RemoteAudioSource
@@ skipping 508 matching lines @@
 
 bool PeerConnection::StartRtcEventLog_w(rtc::PlatformFile file,
                                         int64_t max_size_bytes) {
   return event_log_->StartLogging(file, max_size_bytes);
 }
 
 void PeerConnection::StopRtcEventLog_w() {
   event_log_->StopLogging();
 }
 }  // namespace webrtc