Replace NULL with nullptr in all C++ files.

webrtc/pc/statscollector.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 385 matching lines @@
 // Wallclock time in ms.
 double StatsCollector::GetTimeNow() {
   return rtc::TimeUTCMicros() /
          static_cast<double>(rtc::kNumMicrosecsPerMillisec);
 }
 
 // Adds a MediaStream with tracks that can be used as a |selector| in a call
 // to GetStats.
 void StatsCollector::AddStream(MediaStreamInterface* stream) {
   RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
-  RTC_DCHECK(stream != NULL);
+  RTC_DCHECK(stream != nullptr);
 
   CreateTrackReports<AudioTrackVector>(stream->GetAudioTracks(),
                                        &reports_, track_ids_);
   CreateTrackReports<VideoTrackVector>(stream->GetVideoTracks(),
                                        &reports_, track_ids_);
 }
 
 void StatsCollector::AddLocalAudioTrack(AudioTrackInterface* audio_track,
                                         uint32_t ssrc) {
   RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
-  RTC_DCHECK(audio_track != NULL);
+  RTC_DCHECK(audio_track != nullptr);
 #if RTC_DCHECK_IS_ON
   for (const auto& track : local_audio_tracks_)
     RTC_DCHECK(track.first != audio_track || track.second != ssrc);
 #endif
 
   local_audio_tracks_.push_back(std::make_pair(audio_track, ssrc));
 
   // Create the kStatsReportTypeTrack report for the new track if there is no
   // report yet.
   StatsReport::Id id(StatsReport::NewTypedId(StatsReport::kStatsReportTypeTrack,
                                              audio_track->id()));
   StatsReport* report = reports_.Find(id);
   if (!report) {
     report = reports_.InsertNew(id);
     report->AddString(StatsReport::kStatsValueNameTrackId, audio_track->id());
   }
 }
 
 void StatsCollector::RemoveLocalAudioTrack(AudioTrackInterface* audio_track,
                                            uint32_t ssrc) {
-  RTC_DCHECK(audio_track != NULL);
+  RTC_DCHECK(audio_track != nullptr);
   local_audio_tracks_.erase(std::remove_if(local_audio_tracks_.begin(),
       local_audio_tracks_.end(),
       [audio_track, ssrc](const LocalAudioTrackVector::value_type& track) {
         return track.first == audio_track && track.second == ssrc;
       }));
 }
 
 void StatsCollector::GetStats(MediaStreamTrackInterface* track,
                               StatsReports* reports) {
   RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
-  RTC_DCHECK(reports != NULL);
+  RTC_DCHECK(reports != nullptr);
   RTC_DCHECK(reports->empty());
 
   rtc::Thread::ScopedDisallowBlockingCalls no_blocking_calls;
 
   if (!track) {
     reports->reserve(reports_.size());
     for (auto* r : reports_)
       reports->push_back(r);
     return;
   }
@@ skipping 63 matching lines @@
   StatsReport::Id id(StatsReport::NewIdWithDirection(
       local ? StatsReport::kStatsReportTypeSsrc
             : StatsReport::kStatsReportTypeRemoteSsrc,
       rtc::ToString<uint32_t>(ssrc), direction));
   StatsReport* report = reports_.Find(id);
 
   // Use the ID of the track that is currently mapped to the SSRC, if any.
   std::string track_id;
   if (!GetTrackIdBySsrc(ssrc, &track_id, direction)) {
     if (!report) {
-      // The ssrc is not used by any track or existing report, return NULL
+      // The ssrc is not used by any track or existing report, return null
       // in such case to indicate no report is prepared for the ssrc.
-      return NULL;
+      return nullptr;
     }
 
     // The ssrc is not used by any existing track. Keeps the old track id
     // since we want to report the stats for inactive ssrc.
     const StatsReport::Value* v =
         report->FindValue(StatsReport::kStatsValueNameTrackId);
     if (v)
       track_id = v->string_val();
   }
 
@@ skipping 11 matching lines @@
 }
 
 bool StatsCollector::IsValidTrack(const std::string& track_id) {
   return reports_.Find(StatsReport::NewTypedId(
              StatsReport::kStatsReportTypeTrack, track_id)) != nullptr;
 }
 
 StatsReport* StatsCollector::AddCertificateReports(
     const rtc::SSLCertificate* cert) {
   RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
-  RTC_DCHECK(cert != NULL);
+  RTC_DCHECK(cert != nullptr);
 
   std::unique_ptr<rtc::SSLCertificateStats> first_stats = cert->GetStats();
   StatsReport* first_report = nullptr;
   StatsReport* prev_report = nullptr;
   for (rtc::SSLCertificateStats* stats = first_stats.get(); stats;
        stats = stats->issuer.get()) {
     StatsReport::Id id(StatsReport::NewTypedId(
         StatsReport::kStatsReportTypeCertificate, stats->fingerprint));
 
     StatsReport* report = reports_.ReplaceOrAddNew(id);
@@ skipping 324 matching lines @@
 
 void StatsCollector::UpdateStatsFromExistingLocalAudioTracks() {
   RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
   // Loop through the existing local audio tracks.
   for (const auto& it : local_audio_tracks_) {
     AudioTrackInterface* track = it.first;
     uint32_t ssrc = it.second;
     StatsReport* report =
         GetReport(StatsReport::kStatsReportTypeSsrc,
                   rtc::ToString<uint32_t>(ssrc), StatsReport::kSend);
-    if (report == NULL) {
+    if (report == nullptr) {
       // This can happen if a local audio track is added to a stream on the
       // fly and the report has not been set up yet. Do nothing in this case.
       LOG(LS_ERROR) << "Stats report does not exist for ssrc " << ssrc;
       continue;
     }
 
     // The same ssrc can be used by both local and remote audio tracks.
     const StatsReport::Value* v =
         report->FindValue(StatsReport::kStatsValueNameTrackId);
     if (!v || v->string_val() != track->id())
       continue;
 
     report->set_timestamp(stats_gathering_started_);
     UpdateReportFromAudioTrack(track, report);
   }
 }
 
 void StatsCollector::UpdateReportFromAudioTrack(AudioTrackInterface* track,
                                                 StatsReport* report) {
   RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
-  RTC_DCHECK(track != NULL);
+  RTC_DCHECK(track != nullptr);
 
   // Don't overwrite report values if they're not available.
   int signal_level;
   if (track->GetSignalLevel(&signal_level)) {
     RTC_DCHECK_GE(signal_level, 0);
     report->AddInt(StatsReport::kStatsValueNameAudioInputLevel, signal_level);
   }
 
   auto audio_processor(track->GetAudioProcessor());
 
@@ skipping 44 matching lines @@
     StatsReport* report = entry.second;
     report->set_timestamp(stats_gathering_started_);
   }
 }
 
 void StatsCollector::ClearUpdateStatsCacheForTest() {
   stats_gathering_started_ = 0;
 }
 
 }  // namespace webrtc