Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/api/webrtcsdp.cc

 /*
  *  Copyright 2011 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 563 matching lines @@
       cricket::IsValidRtpPayloadType(*payload_type);
 }
 
 // |msid_stream_id| and |msid_track_id| represent the stream/track ID from the
 // "a=msid" attribute, if it exists. They are empty if the attribute does not
 // exist.
 void CreateTracksFromSsrcInfos(const SsrcInfoVec& ssrc_infos,
                                const std::string& msid_stream_id,
                                const std::string& msid_track_id,
                                StreamParamsVec* tracks) {
-  ASSERT(tracks != NULL);
-  ASSERT(msid_stream_id.empty() == msid_track_id.empty());
+  RTC_DCHECK(tracks != NULL);
+  RTC_DCHECK(msid_stream_id.empty() == msid_track_id.empty());
   for (SsrcInfoVec::const_iterator ssrc_info = ssrc_infos.begin();
        ssrc_info != ssrc_infos.end(); ++ssrc_info) {
     if (ssrc_info->cname.empty()) {
       continue;
     }
 
     std::string stream_id;
     std::string track_id;
     if (ssrc_info->stream_id.empty() && !ssrc_info->mslabel.empty()) {
       // If there's no msid and there's mslabel, we consider this is a sdp from
@@ skipping 228 matching lines @@
   AddLine(kSessionName, &message);
 
   // Time Description.
   AddLine(kTimeDescription, &message);
 
   // Group
   if (desc->HasGroup(cricket::GROUP_TYPE_BUNDLE)) {
     std::string group_line = kAttrGroup;
     const cricket::ContentGroup* group =
         desc->GetGroupByName(cricket::GROUP_TYPE_BUNDLE);
-    ASSERT(group != NULL);
+    RTC_DCHECK(group != NULL);
     const cricket::ContentNames& content_names = group->content_names();
     for (cricket::ContentNames::const_iterator it = content_names.begin();
          it != content_names.end(); ++it) {
       group_line.append(" ");
       group_line.append(*it);
     }
     AddLine(group_line, &message);
   }
 
   // MediaStream semantics
@@ skipping 36 matching lines @@
   return SdpSerializeCandidate(candidate.candidate());
 }
 
 // Serializes a cricket Candidate.
 std::string SdpSerializeCandidate(const cricket::Candidate& candidate) {
   std::string message;
   std::vector<cricket::Candidate> candidates(1, candidate);
   BuildCandidate(candidates, true, &message);
   // From WebRTC draft section 4.8.1.1 candidate-attribute will be
   // just candidate:<candidate> not a=candidate:<blah>CRLF
-  ASSERT(message.find("a=") == 0);
+  RTC_DCHECK(message.find("a=") == 0);
   message.erase(0, 2);
-  ASSERT(message.find(kLineBreak) == message.size() - 2);
+  RTC_DCHECK(message.find(kLineBreak) == message.size() - 2);
   message.resize(message.size() - 2);
   return message;
 }
 
 bool SdpDeserialize(const std::string& message,
                     JsepSessionDescription* jdesc,
                     SdpParseError* error) {
   std::string session_id;
   std::string session_version;
   TransportDescription session_td("", "");
@@ skipping 27 matching lines @@
        it = candidates.begin(); it != candidates.end(); ++it) {
     jdesc->AddCandidate(*it);
     delete *it;
   }
   return true;
 }
 
 bool SdpDeserializeCandidate(const std::string& message,
                              JsepIceCandidate* jcandidate,
                              SdpParseError* error) {
-  ASSERT(jcandidate != NULL);
+  RTC_DCHECK(jcandidate != NULL);
   Candidate candidate;
   if (!ParseCandidate(message, &candidate, error, true)) {
     return false;
   }
   jcandidate->SetCandidate(candidate);
   return true;
 }
 
 bool SdpDeserializeCandidate(const std::string& transport_name,
                              const std::string& message,
                              cricket::Candidate* candidate,
                              SdpParseError* error) {
-  ASSERT(candidate != nullptr);
+  RTC_DCHECK(candidate != nullptr);
   if (!ParseCandidate(message, candidate, error, true)) {
     return false;
   }
   candidate->set_transport_name(transport_name);
   return true;
 }
 
 bool ParseCandidate(const std::string& message, Candidate* candidate,
                     SdpParseError* error, bool is_raw) {
-  ASSERT(candidate != NULL);
+  RTC_DCHECK(candidate != NULL);
 
   // Get the first line from |message|.
   std::string first_line = message;
   size_t pos = 0;
   GetLine(message, &pos, &first_line);
 
   // Makes sure |message| contains only one line.
   if (message.size() > first_line.size()) {
     std::string left, right;
     if (rtc::tokenize_first(message, kNewLine, &left, &right) &&
@@ skipping 233 matching lines @@
   *extmap = RtpExtension(uri, value);
   return true;
 }
 
 void BuildMediaDescription(const ContentInfo* content_info,
                            const TransportInfo* transport_info,
                            const MediaType media_type,
                            const std::vector<Candidate>& candidates,
                            bool unified_plan_sdp,
                            std::string* message) {
-  ASSERT(message != NULL);
+  RTC_DCHECK(message != NULL);
   if (content_info == NULL || message == NULL) {
     return;
   }
   // TODO: Rethink if we should use sprintfn instead of stringstream.
   // According to the style guide, streams should only be used for logging.
   // http://google-styleguide.googlecode.com/svn/
   // trunk/cppguide.xml?showone=Streams#Streams
   std::ostringstream os;
   const MediaContentDescription* media_desc =
       static_cast<const MediaContentDescription*>(
           content_info->description);
-  ASSERT(media_desc != NULL);
+  RTC_DCHECK(media_desc != NULL);
 
   int sctp_port = cricket::kSctpDefaultPort;
 
   // RFC 4566
   // m=<media> <port> <proto> <fmt>
   // fmt is a list of payload type numbers that MAY be used in the session.
   const char* type = NULL;
   if (media_type == cricket::MEDIA_TYPE_AUDIO)
     type = kMediaTypeAudio;
   else if (media_type == cricket::MEDIA_TYPE_VIDEO)
@@ skipping 471 matching lines @@
   }
   if (!rtc::FromString(found->second, value)) {
     return false;
   }
   return true;
 }
 
 void BuildRtpMap(const MediaContentDescription* media_desc,
                  const MediaType media_type,
                  std::string* message) {
-  ASSERT(message != NULL);
-  ASSERT(media_desc != NULL);
+  RTC_DCHECK(message != NULL);
+  RTC_DCHECK(media_desc != NULL);
   std::ostringstream os;
   if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     const VideoContentDescription* video_desc =
         static_cast<const VideoContentDescription*>(media_desc);
     for (std::vector<cricket::VideoCodec>::const_iterator it =
              video_desc->codecs().begin();
          it != video_desc->codecs().end(); ++it) {
       // RFC 4566
       // a=rtpmap:<payload type> <encoding name>/<clock rate>
       // [/<encodingparameters>]
       if (it->id != kWildcardPayloadType) {
         InitAttrLine(kAttributeRtpmap, &os);
         os << kSdpDelimiterColon << it->id << " " << it->name
          << "/" << kDefaultVideoClockrate;
         AddLine(os.str(), message);
       }
       AddRtcpFbLines(*it, message);
       AddFmtpLine(*it, message);
     }
   } else if (media_type == cricket::MEDIA_TYPE_AUDIO) {
     const AudioContentDescription* audio_desc =
         static_cast<const AudioContentDescription*>(media_desc);
     std::vector<int> ptimes;
     std::vector<int> maxptimes;
     int max_minptime = 0;
     for (std::vector<cricket::AudioCodec>::const_iterator it =
              audio_desc->codecs().begin();
          it != audio_desc->codecs().end(); ++it) {
-      ASSERT(!it->name.empty());
+      RTC_DCHECK(!it->name.empty());
       // RFC 4566
       // a=rtpmap:<payload type> <encoding name>/<clock rate>
       // [/<encodingparameters>]
       InitAttrLine(kAttributeRtpmap, &os);
       os << kSdpDelimiterColon << it->id << " ";
       os << it->name << "/" << it->clockrate;
       if (it->channels != 1) {
         os << "/" << it->channels;
       }
       AddLine(os.str(), message);
@@ skipping 11 matching lines @@
       if (GetParameter(kCodecParamMaxPTime, it->params, &maxptime)) {
         maxptimes.push_back(maxptime);
       }
     }
     // Populate the maxptime attribute with the smallest maxptime of all codecs
     // under the same m-line.
     int min_maxptime = INT_MAX;
     if (GetMinValue(maxptimes, &min_maxptime)) {
       AddAttributeLine(kCodecParamMaxPTime, min_maxptime, message);
     }
-    ASSERT(min_maxptime > max_minptime);
+    RTC_DCHECK(min_maxptime > max_minptime);
     // Populate the ptime attribute with the smallest ptime or the largest
     // minptime, whichever is the largest, for all codecs under the same m-line.
     int ptime = INT_MAX;
     if (GetMinValue(ptimes, &ptime)) {
       ptime = std::min(ptime, min_maxptime);
       ptime = std::max(ptime, max_minptime);
       AddAttributeLine(kCodecParamPTime, ptime, message);
     }
   } else if (media_type == cricket::MEDIA_TYPE_DATA) {
     const DataContentDescription* data_desc =
@@ skipping 255 matching lines @@
       session_extmaps->push_back(extmap);
     }
   }
 
   return true;
 }
 
 bool ParseGroupAttribute(const std::string& line,
                          cricket::SessionDescription* desc,
                          SdpParseError* error) {
-  ASSERT(desc != NULL);
+  RTC_DCHECK(desc != NULL);
 
   // RFC 5888 and draft-holmberg-mmusic-sdp-bundle-negotiation-00
   // a=group:BUNDLE video voice
   std::vector<std::string> fields;
   rtc::split(line.substr(kLinePrefixLength),
                    kSdpDelimiterSpace, &fields);
   std::string semantics;
   if (!GetValue(fields[0], kAttributeGroup, &semantics, error)) {
     return false;
   }
@@ skipping 207 matching lines @@
   return media_desc;
 }
 
 bool ParseMediaDescription(const std::string& message,
                            const TransportDescription& session_td,
                            const RtpHeaderExtensions& session_extmaps,
                            size_t* pos,
                            cricket::SessionDescription* desc,
                            std::vector<JsepIceCandidate*>* candidates,
                            SdpParseError* error) {
-  ASSERT(desc != NULL);
+  RTC_DCHECK(desc != NULL);
   std::string line;
   int mline_index = -1;
 
   // Zero or more media descriptions
   // RFC 4566
   // m=<media> <port> <proto> <fmt>
   while (GetLineWithType(message, pos, &line, kLineTypeMedia)) {
     ++mline_index;
 
     std::vector<std::string> fields;
@@ skipping 283 matching lines @@
                   int mline_index,
                   const std::string& protocol,
                   const std::vector<int>& payload_types,
                   size_t* pos,
                   std::string* content_name,
                   bool* bundle_only,
                   MediaContentDescription* media_desc,
                   TransportDescription* transport,
                   std::vector<JsepIceCandidate*>* candidates,
                   SdpParseError* error) {
-  ASSERT(media_desc != NULL);
-  ASSERT(content_name != NULL);
-  ASSERT(transport != NULL);
+  RTC_DCHECK(media_desc != NULL);
+  RTC_DCHECK(content_name != NULL);
+  RTC_DCHECK(transport != NULL);
 
   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
     MaybeCreateStaticPayloadAudioCodecs(
         payload_types, static_cast<AudioContentDescription*>(media_desc));
   }
 
   // The media level "ice-ufrag" and "ice-pwd".
   // The candidates before update the media level "ice-pwd" and "ice-ufrag".
   Candidates candidates_orig;
   std::string line;
@@ skipping 234 matching lines @@
     // only rtcp-fb.
     if (!VerifyVideoCodecs(video_desc)) {
       return ParseFailed("Failed to parse video codecs correctly.", error);
     }
   }
 
   // RFC 5245
   // Update the candidates with the media level "ice-pwd" and "ice-ufrag".
   for (Candidates::iterator it = candidates_orig.begin();
        it != candidates_orig.end(); ++it) {
-    ASSERT((*it).username().empty() ||
-           (*it).username() == transport->ice_ufrag);
+    RTC_DCHECK((*it).username().empty() ||
+               (*it).username() == transport->ice_ufrag);
     (*it).set_username(transport->ice_ufrag);
-    ASSERT((*it).password().empty());
+    RTC_DCHECK((*it).password().empty());
     (*it).set_password(transport->ice_pwd);
     candidates->push_back(
         new JsepIceCandidate(mline_id, mline_index, *it));
   }
   return true;
 }
 
 bool ParseSsrcAttribute(const std::string& line, SsrcInfoVec* ssrc_infos,
                         SdpParseError* error) {
-  ASSERT(ssrc_infos != NULL);
+  RTC_DCHECK(ssrc_infos != NULL);
   // RFC 5576
   // a=ssrc:<ssrc-id> <attribute>
   // a=ssrc:<ssrc-id> <attribute>:<value>
   std::string field1, field2;
   if (!rtc::tokenize_first(line.substr(kLinePrefixLength), kSdpDelimiterSpace,
                            &field1, &field2)) {
     const size_t expected_fields = 2;
     return ParseFailedExpectFieldNum(line, expected_fields, error);
   }
 
@@ skipping 58 matching lines @@
     // The label isn't defined.
     // label:<value>
     ssrc_info->label = value;
   }
   return true;
 }
 
 bool ParseSsrcGroupAttribute(const std::string& line,
                              SsrcGroupVec* ssrc_groups,
                              SdpParseError* error) {
-  ASSERT(ssrc_groups != NULL);
+  RTC_DCHECK(ssrc_groups != NULL);
   // RFC 5576
   // a=ssrc-group:<semantics> <ssrc-id> ...
   std::vector<std::string> fields;
   rtc::split(line.substr(kLinePrefixLength),
                    kSdpDelimiterSpace, &fields);
   const size_t expected_min_fields = 2;
   if (fields.size() < expected_min_fields) {
     return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
   }
   std::string semantics;
@@ skipping 273 matching lines @@
     UpdateCodec<AudioContentDescription, cricket::AudioCodec>(
         media_desc, payload_type, feedback_param);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     UpdateCodec<VideoContentDescription, cricket::VideoCodec>(
         media_desc, payload_type, feedback_param);
   }
   return true;
 }
 
 }  // namespace webrtc