Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/api/webrtcsessiondescriptionfactory.cc

 /*
  *  Copyright 2013 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 183 matching lines @@
     : WebRtcSessionDescriptionFactory(signaling_thread,
                                       channel_manager,
                                       session,
                                       session_id,
                                       nullptr,
                                       certificate) {
   RTC_DCHECK(certificate);
 }
 
 WebRtcSessionDescriptionFactory::~WebRtcSessionDescriptionFactory() {
-  ASSERT(signaling_thread_->IsCurrent());
+  RTC_DCHECK(signaling_thread_->IsCurrent());
 
   // Fail any requests that were asked for before identity generation completed.
   FailPendingRequests(kFailedDueToSessionShutdown);
 
   // Process all pending notifications in the message queue.  If we don't do
   // this, requests will linger and not know they succeeded or failed.
   rtc::MessageList list;
   signaling_thread_->Clear(this, rtc::MQID_ANY, &list);
   for (auto& msg : list) {
     if (msg.message_id != MSG_USE_CONSTRUCTOR_CERTIFICATE) {
@@ skipping 27 matching lines @@
     LOG(LS_ERROR) << error;
     PostCreateSessionDescriptionFailed(observer, error);
     return;
   }
 
   CreateSessionDescriptionRequest request(
       CreateSessionDescriptionRequest::kOffer, observer, session_options);
   if (certificate_request_state_ == CERTIFICATE_WAITING) {
     create_session_description_requests_.push(request);
   } else {
-    ASSERT(certificate_request_state_ == CERTIFICATE_SUCCEEDED ||
-           certificate_request_state_ == CERTIFICATE_NOT_NEEDED);
+    RTC_DCHECK(certificate_request_state_ == CERTIFICATE_SUCCEEDED ||
+               certificate_request_state_ == CERTIFICATE_NOT_NEEDED);
     InternalCreateOffer(request);
   }
 }
 
 void WebRtcSessionDescriptionFactory::CreateAnswer(
     CreateSessionDescriptionObserver* observer,
     const cricket::MediaSessionOptions& session_options) {
   std::string error = "CreateAnswer";
   if (certificate_request_state_ == CERTIFICATE_FAILED) {
     error += kFailedDueToIdentityFailed;
@@ skipping 20 matching lines @@
     LOG(LS_ERROR) << error;
     PostCreateSessionDescriptionFailed(observer, error);
     return;
   }
 
   CreateSessionDescriptionRequest request(
       CreateSessionDescriptionRequest::kAnswer, observer, session_options);
   if (certificate_request_state_ == CERTIFICATE_WAITING) {
     create_session_description_requests_.push(request);
   } else {
-    ASSERT(certificate_request_state_ == CERTIFICATE_SUCCEEDED ||
-           certificate_request_state_ == CERTIFICATE_NOT_NEEDED);
+    RTC_DCHECK(certificate_request_state_ == CERTIFICATE_SUCCEEDED ||
+               certificate_request_state_ == CERTIFICATE_NOT_NEEDED);
     InternalCreateAnswer(request);
   }
 }
 
 void WebRtcSessionDescriptionFactory::SetSdesPolicy(
     cricket::SecurePolicy secure_policy) {
   session_desc_factory_.set_secure(secure_policy);
 }
 
 cricket::SecurePolicy WebRtcSessionDescriptionFactory::SdesPolicy() const {
@@ skipping 51 matching lines @@
                            : nullptr));
   // RFC 3264
   // When issuing an offer that modifies the session,
   // the "o=" line of the new SDP MUST be identical to that in the
   // previous SDP, except that the version in the origin field MUST
   // increment by one from the previous SDP.
 
   // Just increase the version number by one each time when a new offer
   // is created regardless if it's identical to the previous one or not.
   // The |session_version_| is a uint64_t, the wrap around should not happen.
-  ASSERT(session_version_ + 1 > session_version_);
+  RTC_DCHECK(session_version_ + 1 > session_version_);
   JsepSessionDescription* offer(new JsepSessionDescription(
       JsepSessionDescription::kOffer));
   if (!offer->Initialize(desc, session_id_,
                          rtc::ToString(session_version_++))) {
     delete offer;
     PostCreateSessionDescriptionFailed(request.observer,
                                        "Failed to initialize the offer.");
     return;
   }
   if (session_->local_description()) {
@@ skipping 37 matching lines @@
       request.options, session_->local_description()
                            ? session_->local_description()->description()
                            : nullptr));
   // RFC 3264
   // If the answer is different from the offer in any way (different IP
   // addresses, ports, etc.), the origin line MUST be different in the answer.
   // In that case, the version number in the "o=" line of the answer is
   // unrelated to the version number in the o line of the offer.
   // Get a new version number by increasing the |session_version_answer_|.
   // The |session_version_| is a uint64_t, the wrap around should not happen.
-  ASSERT(session_version_ + 1 > session_version_);
+  RTC_DCHECK(session_version_ + 1 > session_version_);
   JsepSessionDescription* answer(new JsepSessionDescription(
       JsepSessionDescription::kAnswer));
   if (!answer->Initialize(desc, session_id_,
                           rtc::ToString(session_version_++))) {
     delete answer;
     PostCreateSessionDescriptionFailed(request.observer,
                                        "Failed to initialize the answer.");
     return;
   }
   if (session_->local_description()) {
     for (const cricket::ContentInfo& content :
          session_->local_description()->description()->contents()) {
       // Include all local ICE candidates in the SessionDescription unless
       // the remote peer has requested an ICE restart.
       if (!request.options.transport_options[content.name].ice_restart) {
         CopyCandidatesFromSessionDescription(session_->local_description(),
                                              content.name, answer);
       }
     }
   }
   PostCreateSessionDescriptionSucceeded(request.observer, answer);
 }
 
 void WebRtcSessionDescriptionFactory::FailPendingRequests(
     const std::string& reason) {
-  ASSERT(signaling_thread_->IsCurrent());
+  RTC_DCHECK(signaling_thread_->IsCurrent());
   while (!create_session_description_requests_.empty()) {
     const CreateSessionDescriptionRequest& request =
         create_session_description_requests_.front();
     PostCreateSessionDescriptionFailed(request.observer,
         ((request.type == CreateSessionDescriptionRequest::kOffer) ?
             "CreateOffer" : "CreateAnswer") + reason);
     create_session_description_requests_.pop();
   }
 }
 
 void WebRtcSessionDescriptionFactory::PostCreateSessionDescriptionFailed(
     CreateSessionDescriptionObserver* observer, const std::string& error) {
   CreateSessionDescriptionMsg* msg = new CreateSessionDescriptionMsg(observer);
   msg->error = error;
   signaling_thread_->Post(RTC_FROM_HERE, this,
                           MSG_CREATE_SESSIONDESCRIPTION_FAILED, msg);
   LOG(LS_ERROR) << "Create SDP failed: " << error;
 }
 
 void WebRtcSessionDescriptionFactory::PostCreateSessionDescriptionSucceeded(
     CreateSessionDescriptionObserver* observer,
     SessionDescriptionInterface* description) {
   CreateSessionDescriptionMsg* msg = new CreateSessionDescriptionMsg(observer);
   msg->description.reset(description);
   signaling_thread_->Post(RTC_FROM_HERE, this,
                           MSG_CREATE_SESSIONDESCRIPTION_SUCCESS, msg);
 }
 
 void WebRtcSessionDescriptionFactory::OnCertificateRequestFailed() {
-  ASSERT(signaling_thread_->IsCurrent());
+  RTC_DCHECK(signaling_thread_->IsCurrent());
 
   LOG(LS_ERROR) << "Asynchronous certificate generation request failed.";
   certificate_request_state_ = CERTIFICATE_FAILED;
 
   FailPendingRequests(kFailedDueToIdentityFailed);
 }
 
 void WebRtcSessionDescriptionFactory::SetCertificate(
     const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) {
   RTC_DCHECK(certificate);
   LOG(LS_VERBOSE) << "Setting new certificate.";
 
   certificate_request_state_ = CERTIFICATE_SUCCEEDED;
   SignalCertificateReady(certificate);
 
   transport_desc_factory_.set_certificate(certificate);
   transport_desc_factory_.set_secure(cricket::SEC_ENABLED);
 
   while (!create_session_description_requests_.empty()) {
     if (create_session_description_requests_.front().type ==
         CreateSessionDescriptionRequest::kOffer) {
       InternalCreateOffer(create_session_description_requests_.front());
     } else {
       InternalCreateAnswer(create_session_description_requests_.front());
     }
     create_session_description_requests_.pop();
   }
 }
 }  // namespace webrtc