Replace NULL with nullptr in all C++ files.

webrtc/pc/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 559 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) {
-  RTC_DCHECK(tracks != NULL);
+  RTC_DCHECK(tracks != nullptr);
   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()) {
@@ skipping 233 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);
-    RTC_DCHECK(group != NULL);
+    RTC_DCHECK(group != nullptr);
     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 86 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) {
-  RTC_DCHECK(jcandidate != NULL);
+  RTC_DCHECK(jcandidate != nullptr);
   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) {
   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) {
-  RTC_DCHECK(candidate != NULL);
+  RTC_DCHECK(candidate != nullptr);
 
   // 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 239 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) {
-  RTC_DCHECK(message != NULL);
-  if (content_info == NULL || message == NULL) {
+  RTC_DCHECK(message != nullptr);
+  if (content_info == nullptr || message == nullptr) {
     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);
-  RTC_DCHECK(media_desc != NULL);
+  RTC_DCHECK(media_desc != nullptr);
 
   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;
+  const char* type = nullptr;
   if (media_type == cricket::MEDIA_TYPE_AUDIO)
     type = kMediaTypeAudio;
   else if (media_type == cricket::MEDIA_TYPE_VIDEO)
     type = kMediaTypeVideo;
   else if (media_type == cricket::MEDIA_TYPE_DATA)
     type = kMediaTypeData;
   else
     RTC_NOTREACHED();
 
   std::string fmt;
@@ skipping 53 matching lines @@
   // RFC 3264
   // To reject an offered stream, the port number in the corresponding stream in
   // the answer MUST be set to zero.
   //
   // However, the BUNDLE draft adds a new meaning to port zero, when used along
   // with a=bundle-only.
   const std::string& port =
       (content_info->rejected || content_info->bundle_only) ? kMediaPortRejected
                                                             : kDummyPort;
 
-  rtc::SSLFingerprint* fp = (transport_info) ?
-      transport_info->description.identity_fingerprint.get() : NULL;
+  rtc::SSLFingerprint* fp =
+      (transport_info) ? transport_info->description.identity_fingerprint.get()
+                       : nullptr;
 
   // Add the m and c lines.
   InitLine(kLineTypeMedia, type, &os);
   os << " " << port << " " << media_desc->protocol() << fmt;
   std::string mline = os.str();
   UpdateMediaDefaultDestination(candidates, mline, message);
 
   // RFC 4566
   // b=AS:<bandwidth>
   if (media_desc->bandwidth() >= 1000) {
@@ skipping 328 matching lines @@
       os << " " << iter->param();
     }
     AddLine(os.str(), message);
   }
 }
 
 bool AddSctpDataCodec(DataContentDescription* media_desc,
                       int sctp_port) {
   for (const auto& codec : media_desc->codecs()) {
     if (cricket::CodecNamesEq(codec.name, cricket::kGoogleSctpDataCodecName)) {
-      return ParseFailed("",
-                         "Can't have multiple sctp port attributes.",
-                         NULL);
+      return ParseFailed("", "Can't have multiple sctp port attributes.",
+                         nullptr);
     }
   }
   // Add the SCTP Port number as a pseudo-codec "port" parameter
   cricket::DataCodec codec_port(cricket::kGoogleSctpDataCodecPlType,
                                 cricket::kGoogleSctpDataCodecName);
   codec_port.SetParam(cricket::kCodecParamPort, sctp_port);
   LOG(INFO) << "AddSctpDataCodec: Got SCTP Port Number "
             << sctp_port;
   media_desc->AddCodec(codec_port);
   return true;
@@ skipping 18 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) {
-  RTC_DCHECK(message != NULL);
-  RTC_DCHECK(media_desc != NULL);
+  RTC_DCHECK(message != nullptr);
+  RTC_DCHECK(media_desc != nullptr);
   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>]
@@ skipping 285 matching lines @@
       if (!ParseIceOptions(line, &(session_td->transport_options), error)) {
         return false;
       }
     } else if (HasAttribute(line, kAttributeFingerprint)) {
       if (session_td->identity_fingerprint.get()) {
         return ParseFailed(
             line,
             "Can't have multiple fingerprint attributes at the same level.",
             error);
       }
-      rtc::SSLFingerprint* fingerprint = NULL;
+      rtc::SSLFingerprint* fingerprint = nullptr;
       if (!ParseFingerprintAttribute(line, &fingerprint, error)) {
         return false;
       }
       session_td->identity_fingerprint.reset(fingerprint);
     } else if (HasAttribute(line, kAttributeSetup)) {
       if (!ParseDtlsSetup(line, &(session_td->connection_role), error)) {
         return false;
       }
     } else if (HasAttribute(line, kAttributeMsidSemantics)) {
       std::string semantics;
@@ skipping 10 matching lines @@
       session_extmaps->push_back(extmap);
     }
   }
 
   return true;
 }
 
 bool ParseGroupAttribute(const std::string& line,
                          cricket::SessionDescription* desc,
                          SdpParseError* error) {
-  RTC_DCHECK(desc != NULL);
+  RTC_DCHECK(desc != nullptr);
 
   // 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 186 matching lines @@
       *content_name = cricket::CN_DATA;
       break;
     default:
       RTC_NOTREACHED();
       break;
   }
   if (!ParseContent(message, media_type, mline_index, protocol, payload_types,
                     pos, content_name, bundle_only, media_desc, transport,
                     candidates, error)) {
     delete media_desc;
-    return NULL;
+    return nullptr;
   }
   // Sort the codecs according to the m-line fmt list.
   std::unordered_map<int, int> payload_type_preferences;
   // "size + 1" so that the lowest preference payload type has a preference of
   // 1, which is greater than the default (0) for payload types not in the fmt
   // list.
   int preference = static_cast<int>(payload_types.size() + 1);
   for (int pt : payload_types) {
     payload_type_preferences[pt] = preference--;
   }
   std::vector<typename C::CodecType> codecs = media_desc->codecs();
   std::sort(codecs.begin(), codecs.end(), [&payload_type_preferences](
                                               const typename C::CodecType& a,
                                               const typename C::CodecType& b) {
     return payload_type_preferences[a.id] > payload_type_preferences[b.id];
   });
   media_desc->set_codecs(codecs);
   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) {
-  RTC_DCHECK(desc != NULL);
+  RTC_DCHECK(desc != nullptr);
   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 62 matching lines @@
       int p;
       if (data_desc && IsDtlsSctp(protocol) && rtc::FromString(fields[3], &p)) {
         if (!AddSctpDataCodec(data_desc, p))
           return false;
       }
     } else {
       LOG(LS_WARNING) << "Unsupported media type: " << line;
       continue;
     }
     if (!content.get()) {
-      // ParseContentDescription returns NULL if failed.
+      // ParseContentDescription returns null if failed.
       return false;
     }
 
     bool content_rejected = false;
     // A port of 0 is not interpreted as a rejected m= section when it's
     // used along with a=bundle-only.
     if (bundle_only) {
       if (!port_rejected) {
         // Usage of bundle-only with a nonzero port is unspecified. So just
         // ignore bundle-only if we see this.
@@ skipping 200 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) {
-  RTC_DCHECK(media_desc != NULL);
-  RTC_DCHECK(content_name != NULL);
-  RTC_DCHECK(transport != NULL);
+  RTC_DCHECK(media_desc != nullptr);
+  RTC_DCHECK(content_name != nullptr);
+  RTC_DCHECK(transport != nullptr);
 
   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 88 matching lines @@
       }
     } else if (HasAttribute(line, kAttributeIceOption)) {
       if (!ParseIceOptions(line, &transport->transport_options, error)) {
         return false;
       }
     } else if (HasAttribute(line, kAttributeFmtp)) {
       if (!ParseFmtpAttributes(line, media_type, media_desc, error)) {
         return false;
       }
     } else if (HasAttribute(line, kAttributeFingerprint)) {
-      rtc::SSLFingerprint* fingerprint = NULL;
+      rtc::SSLFingerprint* fingerprint = nullptr;
 
       if (!ParseFingerprintAttribute(line, &fingerprint, error)) {
         return false;
       }
       transport->identity_fingerprint.reset(fingerprint);
     } else if (HasAttribute(line, kAttributeSetup)) {
       if (!ParseDtlsSetup(line, &(transport->connection_role), error)) {
         return false;
       }
     } else if (IsDtlsSctp(protocol) && HasAttribute(line, kAttributeSctpPort)) {
@@ skipping 144 matching lines @@
     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) {
-  RTC_DCHECK(ssrc_infos != NULL);
+  RTC_DCHECK(ssrc_infos != nullptr);
   // 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) {
-  RTC_DCHECK(ssrc_groups != NULL);
+  RTC_DCHECK(ssrc_groups != nullptr);
   // 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 261 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