Replace NULL with nullptr in all C++ files.

webrtc/pc/mediasession.cc

 /*
  *  Copyright 2004 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 145 matching lines @@
       return false;
     }
   }
   AddMediaCryptos(cryptos, media);
   return true;
 }
 #endif
 
 const CryptoParamsVec* GetCryptos(const MediaContentDescription* media) {
   if (!media) {
-    return NULL;
+    return nullptr;
   }
   return &media->cryptos();
 }
 
 bool FindMatchingCrypto(const CryptoParamsVec& cryptos,
                         const CryptoParams& crypto,
                         CryptoParams* out) {
   for (CryptoParamsVec::const_iterator it = cryptos.begin();
        it != cryptos.end(); ++it) {
     if (crypto.Matches(*it)) {
@@ skipping 394 matching lines @@
   const MediaContentDescription* media_desc =
       static_cast<const MediaContentDescription*>(content->description);
   *cryptos = media_desc->cryptos();
   return true;
 }
 
 // Predicate function used by the remove_if.
 // Returns true if the |crypto|'s cipher_suite is not found in |filter|.
 static bool CryptoNotFound(const CryptoParams crypto,
                            const CryptoParamsVec* filter) {
-  if (filter == NULL) {
+  if (filter == nullptr) {
     return true;
   }
   for (CryptoParamsVec::const_iterator it = filter->begin();
        it != filter->end(); ++it) {
     if (it->cipher_suite == crypto.cipher_suite) {
       return false;
     }
   }
   return true;
 }
@@ skipping 348 matching lines @@
   }
 }
 
 static bool FindByUri(const RtpHeaderExtensions& extensions,
                       const webrtc::RtpExtension& ext_to_match,
                       webrtc::RtpExtension* found_extension) {
   for (RtpHeaderExtensions::const_iterator it = extensions.begin();
        it  != extensions.end(); ++it) {
     // We assume that all URIs are given in a canonical format.
     if (it->uri == ext_to_match.uri) {
-      if (found_extension != NULL) {
+      if (found_extension != nullptr) {
         *found_extension = *it;
       }
       return true;
     }
   }
   return false;
 }
 
 // Iterates through |offered_extensions|, adding each one to |all_extensions|
 // and |used_ids|, and resolving ID conflicts. If an offered extension has the
@@ skipping 14 matching lines @@
 }
 
 // Adds |reference_extensions| to |offered_extensions|, while updating
 // |all_extensions| and |used_ids|.
 static void FindRtpHdrExtsToOffer(
     const RtpHeaderExtensions& reference_extensions,
     RtpHeaderExtensions* offered_extensions,
     RtpHeaderExtensions* all_extensions,
     UsedRtpHeaderExtensionIds* used_ids) {
   for (auto reference_extension : reference_extensions) {
-    if (!FindByUri(*offered_extensions, reference_extension, NULL)) {
+    if (!FindByUri(*offered_extensions, reference_extension, nullptr)) {
       webrtc::RtpExtension existing;
       if (FindByUri(*all_extensions, reference_extension, &existing)) {
         offered_extensions->push_back(existing);
       } else {
         used_ids->FindAndSetIdUsed(&reference_extension);
         all_extensions->push_back(reference_extension);
         offered_extensions->push_back(reference_extension);
       }
     }
   }
@@ skipping 160 matching lines @@
     desc->set_protocol(kMediaProtocolDtlsSavpf);
   else
     desc->set_protocol(kMediaProtocolAvpf);
 }
 
 // Gets the TransportInfo of the given |content_name| from the
 // |current_description|. If doesn't exist, returns a new one.
 static const TransportDescription* GetTransportDescription(
     const std::string& content_name,
     const SessionDescription* current_description) {
-  const TransportDescription* desc = NULL;
+  const TransportDescription* desc = nullptr;
   if (current_description) {
     const TransportInfo* info =
         current_description->GetTransportInfoByName(content_name);
     if (info) {
       desc = &info->description;
     }
   }
   return desc;
 }
 
@@ skipping 174 matching lines @@
 
   // Iterate through the contents of |current_description| to maintain the order
   // of the m-lines in the new offer.
   if (current_description) {
     ContentInfos::const_iterator it = current_description->contents().begin();
     for (; it != current_description->contents().end(); ++it) {
       if (IsMediaContentOfType(&*it, MEDIA_TYPE_AUDIO)) {
         if (!AddAudioContentForOffer(options, current_description,
                                      audio_rtp_extensions, audio_codecs,
                                      &current_streams, offer.get())) {
-          return NULL;
+          return nullptr;
         }
         audio_added = true;
       } else if (IsMediaContentOfType(&*it, MEDIA_TYPE_VIDEO)) {
         if (!AddVideoContentForOffer(options, current_description,
                                      video_rtp_extensions, video_codecs,
                                      &current_streams, offer.get())) {
-          return NULL;
+          return nullptr;
         }
         video_added = true;
       } else if (IsMediaContentOfType(&*it, MEDIA_TYPE_DATA)) {
         MediaSessionOptions options_copy(options);
         if (IsSctp(static_cast<const MediaContentDescription*>(
                 it->description))) {
           options_copy.data_channel_type = DCT_SCTP;
         }
         if (!AddDataContentForOffer(options_copy, current_description,
                                     &data_codecs, &current_streams,
                                     offer.get())) {
-          return NULL;
+          return nullptr;
         }
         data_added = true;
       } else {
         RTC_NOTREACHED();
       }
     }
   }
 
   // Append contents that are not in |current_description|.
   if (!audio_added && options.has_audio() &&
       !AddAudioContentForOffer(options, current_description,
                                audio_rtp_extensions, audio_codecs,
                                &current_streams, offer.get())) {
-    return NULL;
+    return nullptr;
   }
   if (!video_added && options.has_video() &&
       !AddVideoContentForOffer(options, current_description,
                                video_rtp_extensions, video_codecs,
                                &current_streams, offer.get())) {
-    return NULL;
+    return nullptr;
   }
   if (!data_added && options.has_data() &&
       !AddDataContentForOffer(options, current_description, &data_codecs,
                               &current_streams, offer.get())) {
-    return NULL;
+    return nullptr;
   }
 
   // Bundle the contents together, if we've been asked to do so, and update any
   // parameters that need to be tweaked for BUNDLE.
   if (options.bundle_enabled) {
     ContentGroup offer_bundle(GROUP_TYPE_BUNDLE);
     for (ContentInfos::const_iterator content = offer->contents().begin();
        content != offer->contents().end(); ++content) {
       offer_bundle.AddContentName(content->name);
     }
     offer->AddGroup(offer_bundle);
     if (!UpdateTransportInfoForBundle(offer_bundle, offer.get())) {
       LOG(LS_ERROR) << "CreateOffer failed to UpdateTransportInfoForBundle.";
-      return NULL;
+      return nullptr;
     }
     if (!UpdateCryptoParamsForBundle(offer_bundle, offer.get())) {
       LOG(LS_ERROR) << "CreateOffer failed to UpdateCryptoParamsForBundle.";
-      return NULL;
+      return nullptr;
     }
   }
 
   return offer.release();
 }
 
 SessionDescription* MediaSessionDescriptionFactory::CreateAnswer(
     const SessionDescription* offer, const MediaSessionOptions& options,
     const SessionDescription* current_description) const {
   // The answer contains the intersection of the codecs in the offer with the
   // codecs we support. As indicated by XEP-0167, we retain the same payload ids
   // from the offer in the answer.
   std::unique_ptr<SessionDescription> answer(new SessionDescription());
 
   StreamParamsVec current_streams;
   GetCurrentStreamParams(current_description, &current_streams);
 
   if (offer) {
     ContentInfos::const_iterator it = offer->contents().begin();
     for (; it != offer->contents().end(); ++it) {
       if (IsMediaContentOfType(&*it, MEDIA_TYPE_AUDIO)) {
         if (!AddAudioContentForAnswer(offer, options, current_description,
                                   &current_streams, answer.get())) {
-          return NULL;
+          return nullptr;
         }
       } else if (IsMediaContentOfType(&*it, MEDIA_TYPE_VIDEO)) {
         if (!AddVideoContentForAnswer(offer, options, current_description,
                                       &current_streams, answer.get())) {
-          return NULL;
+          return nullptr;
         }
       } else {
         RTC_DCHECK(IsMediaContentOfType(&*it, MEDIA_TYPE_DATA));
         if (!AddDataContentForAnswer(offer, options, current_description,
                                      &current_streams, answer.get())) {
-          return NULL;
+          return nullptr;
         }
       }
     }
   }
 
   // If the offer supports BUNDLE, and we want to use it too, create a BUNDLE
   // group in the answer with the appropriate content names.
   if (offer->HasGroup(GROUP_TYPE_BUNDLE) && options.bundle_enabled) {
     const ContentGroup* offer_bundle = offer->GetGroupByName(GROUP_TYPE_BUNDLE);
     ContentGroup answer_bundle(GROUP_TYPE_BUNDLE);
     for (ContentInfos::const_iterator content = answer->contents().begin();
        content != answer->contents().end(); ++content) {
       if (!content->rejected && offer_bundle->HasContentName(content->name)) {
         answer_bundle.AddContentName(content->name);
       }
     }
     if (answer_bundle.FirstContentName()) {
       answer->AddGroup(answer_bundle);
 
       // Share the same ICE credentials and crypto params across all contents,
       // as BUNDLE requires.
       if (!UpdateTransportInfoForBundle(answer_bundle, answer.get())) {
         LOG(LS_ERROR) << "CreateAnswer failed to UpdateTransportInfoForBundle.";
-        return NULL;
+        return nullptr;
       }
 
       if (!UpdateCryptoParamsForBundle(answer_bundle, answer.get())) {
         LOG(LS_ERROR) << "CreateAnswer failed to UpdateCryptoParamsForBundle.";
-        return NULL;
+        return nullptr;
       }
     }
   }
 
   return answer.release();
 }
 
 const AudioCodecs& MediaSessionDescriptionFactory::GetAudioCodecsForOffer(
     const RtpTransceiverDirection& direction) const {
   // If stream is inactive - generate list as if sendrecv.
@@ skipping 116 matching lines @@
   const std::string& content_name,
   const TransportOptions& transport_options,
   const SessionDescription* current_desc,
   SessionDescription* offer_desc) const {
   if (!transport_desc_factory_)
      return false;
   const TransportDescription* current_tdesc =
       GetTransportDescription(content_name, current_desc);
   std::unique_ptr<TransportDescription> new_tdesc(
       transport_desc_factory_->CreateOffer(transport_options, current_tdesc));
-  bool ret = (new_tdesc.get() != NULL &&
-      offer_desc->AddTransportInfo(TransportInfo(content_name, *new_tdesc)));
+  bool ret =
+      (new_tdesc.get() != nullptr &&
+       offer_desc->AddTransportInfo(TransportInfo(content_name, *new_tdesc)));
   if (!ret) {
     LOG(LS_ERROR)
         << "Failed to AddTransportOffer, content name=" << content_name;
   }
   return ret;
 }
 
 TransportDescription* MediaSessionDescriptionFactory::CreateTransportAnswer(
     const std::string& content_name,
     const SessionDescription* offer_desc,
     const TransportOptions& transport_options,
     const SessionDescription* current_desc) const {
   if (!transport_desc_factory_)
-    return NULL;
+    return nullptr;
   const TransportDescription* offer_tdesc =
       GetTransportDescription(content_name, offer_desc);
   const TransportDescription* current_tdesc =
       GetTransportDescription(content_name, current_desc);
   return
       transport_desc_factory_->CreateAnswer(offer_tdesc, transport_options,
                                             current_tdesc);
 }
 
 bool MediaSessionDescriptionFactory::AddTransportAnswer(
@@ skipping 423 matching lines @@
   return GetFirstMediaContent(sdesc, MEDIA_TYPE_VIDEO);
 }
 
 const ContentInfo* GetFirstDataContent(const SessionDescription* sdesc) {
   return GetFirstMediaContent(sdesc, MEDIA_TYPE_DATA);
 }
 
 const MediaContentDescription* GetFirstMediaContentDescription(
     const SessionDescription* sdesc, MediaType media_type) {
   const ContentInfo* content = GetFirstMediaContent(sdesc, media_type);
-  const ContentDescription* description = content ? content->description : NULL;
+  const ContentDescription* description =
+      content ? content->description : nullptr;
   return static_cast<const MediaContentDescription*>(description);
 }
 
 const AudioContentDescription* GetFirstAudioContentDescription(
     const SessionDescription* sdesc) {
   return static_cast<const AudioContentDescription*>(
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_AUDIO));
 }
 
 const VideoContentDescription* GetFirstVideoContentDescription(
@@ skipping 52 matching lines @@
 }
 
 ContentInfo* GetFirstDataContent(SessionDescription* sdesc) {
   return GetFirstMediaContent(sdesc, MEDIA_TYPE_DATA);
 }
 
 MediaContentDescription* GetFirstMediaContentDescription(
     SessionDescription* sdesc,
     MediaType media_type) {
   ContentInfo* content = GetFirstMediaContent(sdesc, media_type);
-  ContentDescription* description = content ? content->description : NULL;
+  ContentDescription* description = content ? content->description : nullptr;
   return static_cast<MediaContentDescription*>(description);
 }
 
 AudioContentDescription* GetFirstAudioContentDescription(
     SessionDescription* sdesc) {
   return static_cast<AudioContentDescription*>(
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_AUDIO));
 }
 
 VideoContentDescription* GetFirstVideoContentDescription(
     SessionDescription* sdesc) {
   return static_cast<VideoContentDescription*>(
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_VIDEO));
 }
 
 DataContentDescription* GetFirstDataContentDescription(
     SessionDescription* sdesc) {
   return static_cast<DataContentDescription*>(
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_DATA));
 }
 
 }  // namespace cricket