Replace NULL with nullptr in all C++ files.

webrtc/pc/statscollector_unittest.cc

 /*
  *  Copyright 2014 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 80 matching lines @@
   }
 };
 
 class FakeAudioTrack
     : public webrtc::MediaStreamTrack<webrtc::AudioTrackInterface> {
  public:
   explicit FakeAudioTrack(const std::string& id)
       : webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>(id),
         processor_(new rtc::RefCountedObject<FakeAudioProcessor>()) {}
   std::string kind() const override { return "audio"; }
-  webrtc::AudioSourceInterface* GetSource() const override { return NULL; }
+  webrtc::AudioSourceInterface* GetSource() const override { return nullptr; }
   void AddSink(webrtc::AudioTrackSinkInterface* sink) override {}
   void RemoveSink(webrtc::AudioTrackSinkInterface* sink) override {}
   bool GetSignalLevel(int* level) override {
     *level = 1;
     return true;
   }
   rtc::scoped_refptr<webrtc::AudioProcessorInterface> GetAudioProcessor()
       override {
     return processor_;
   }
@@ skipping 21 matching lines @@
 };
 
 class FakeAudioTrackWithInitValue
     : public webrtc::MediaStreamTrack<webrtc::AudioTrackInterface> {
  public:
   explicit FakeAudioTrackWithInitValue(const std::string& id)
       : webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>(id),
         processor_(
             new rtc::RefCountedObject<FakeAudioProcessorWithInitValue>()) {}
   std::string kind() const override { return "audio"; }
-  webrtc::AudioSourceInterface* GetSource() const override { return NULL; }
+  webrtc::AudioSourceInterface* GetSource() const override { return nullptr; }
   void AddSink(webrtc::AudioTrackSinkInterface* sink) override {}
   void RemoveSink(webrtc::AudioTrackSinkInterface* sink) override {}
   bool GetSignalLevel(int* level) override {
     *level = 1;
     return true;
   }
   rtc::scoped_refptr<webrtc::AudioProcessorInterface> GetAudioProcessor()
       override {
     return processor_;
   }
@@ skipping 97 matching lines @@
 }
 
 void CheckCertChainReports(const StatsReports& reports,
                            const std::vector<std::string>& ders,
                            const StatsReport::Id& start_id) {
   StatsReport::Id cert_id;
   const StatsReport::Id* certificate_id = &start_id;
   size_t i = 0;
   while (true) {
     const StatsReport* report = FindReportById(reports, *certificate_id);
-    ASSERT_TRUE(report != NULL);
+    ASSERT_TRUE(report != nullptr);
 
     std::string der_base64;
     EXPECT_TRUE(GetValue(
         report, StatsReport::kStatsValueNameDer, &der_base64));
     std::string der = rtc::Base64::Decode(der_base64, rtc::Base64::DO_STRICT);
     EXPECT_EQ(ders[i], der);
 
     std::string fingerprint_algorithm;
     EXPECT_TRUE(GetValue(
         report,
@@ skipping 287 matching lines @@
     stream_ = webrtc::MediaStream::Create("streamlabel");
     track_ = webrtc::VideoTrack::Create(kRemoteTrackId,
                                         webrtc::FakeVideoTrackSource::Create());
     stream_->AddTrack(track_);
     EXPECT_CALL(session_, GetRemoteTrackIdBySsrc(kSsrcOfTrack, _))
         .WillRepeatedly(DoAll(SetArgPointee<1>(kRemoteTrackId), Return(true)));
     }
 
   // Adds a outgoing audio track with a given SSRC into the stats.
   void AddOutgoingAudioTrackStats() {
-    if (stream_ == NULL)
+    if (stream_ == nullptr)
       stream_ = webrtc::MediaStream::Create("streamlabel");
 
     audio_track_ = new rtc::RefCountedObject<FakeAudioTrack>(
         kLocalTrackId);
     stream_->AddTrack(audio_track_);
     EXPECT_CALL(session_, GetLocalTrackIdBySsrc(kSsrcOfTrack, _))
         .WillOnce(DoAll(SetArgPointee<1>(kLocalTrackId), Return(true)));
   }
 
   // Adds a incoming audio track with a given SSRC into the stats.
   void AddIncomingAudioTrackStats() {
-    if (stream_ == NULL)
+    if (stream_ == nullptr)
       stream_ = webrtc::MediaStream::Create("streamlabel");
 
     audio_track_ = new rtc::RefCountedObject<FakeAudioTrack>(
         kRemoteTrackId);
     stream_->AddTrack(audio_track_);
     EXPECT_CALL(session_, GetRemoteTrackIdBySsrc(kSsrcOfTrack, _))
         .WillOnce(DoAll(SetArgPointee<1>(kRemoteTrackId), Return(true)));
   }
 
   void AddDataChannel(cricket::DataChannelType type,
@@ skipping 18 matching lines @@
       webrtc::StatsCollector* stats,
       cricket::VoiceChannel* voice_channel,
       const std::string& vc_name,
       MockVoiceMediaChannel* media_channel,
       cricket::VoiceSenderInfo* voice_sender_info,
       cricket::VoiceReceiverInfo* voice_receiver_info,
       cricket::VoiceMediaInfo* stats_read,
       StatsReports* reports) {
     // A track can't have both sender report and recv report at the same time
     // for now, this might change in the future though.
-    EXPECT_TRUE((voice_sender_info == NULL) ^ (voice_receiver_info == NULL));
+    EXPECT_TRUE((voice_sender_info == nullptr) ^
+                (voice_receiver_info == nullptr));
 
     // Instruct the session to return stats containing the transport channel.
     InitSessionStats(vc_name);
     EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(Invoke(
         [this](const ChannelNamePairs&) {
           return std::unique_ptr<SessionStats>(
               new SessionStats(session_stats_));
         }));
 
     // Constructs an ssrc stats update.
     if (voice_sender_info)
       stats_read->senders.push_back(*voice_sender_info);
     if (voice_receiver_info)
       stats_read->receivers.push_back(*voice_receiver_info);
 
     EXPECT_CALL(session_, voice_channel()).WillRepeatedly(
         Return(voice_channel));
     EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
     EXPECT_CALL(*media_channel, GetStats(_))
         .WillOnce(DoAll(SetArgPointee<0>(*stats_read), Return(true)));
 
     stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
     stats->ClearUpdateStatsCacheForTest();
-    stats->GetStats(NULL, reports);
+    stats->GetStats(nullptr, reports);
 
     // Verify the existence of the track report.
     const StatsReport* report = FindNthReportByType(
         *reports, StatsReport::kStatsReportTypeSsrc, 1);
-    EXPECT_FALSE(report == NULL);
+    EXPECT_FALSE(report == nullptr);
     EXPECT_EQ(stats->GetTimeNow(), report->timestamp());
     std::string track_id = ExtractSsrcStatsValue(
         *reports, StatsReport::kStatsValueNameTrackId);
     EXPECT_EQ(audio_track->id(), track_id);
     std::string ssrc_id = ExtractSsrcStatsValue(
         *reports, StatsReport::kStatsValueNameSsrc);
     EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
 
     std::string media_type = ExtractSsrcStatsValue(*reports,
         StatsReport::kStatsValueNameMediaType);
@@ skipping 64 matching lines @@
                               transport_stats.transport_name))
         .WillOnce(Return(remote_cert.release()));
     EXPECT_CALL(session_, GetStats(_)).WillOnce(Invoke(
         [&session_stats](const ChannelNamePairs&) {
           return std::unique_ptr<SessionStats>(
               new SessionStats(session_stats));
         }));
 
     stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
 
-    stats.GetStats(NULL, &reports);
+    stats.GetStats(nullptr, &reports);
 
     const StatsReport* channel_report = FindNthReportByType(
         reports, StatsReport::kStatsReportTypeComponent, 1);
-    EXPECT_TRUE(channel_report != NULL);
+    EXPECT_TRUE(channel_report != nullptr);
 
     // Check local certificate chain.
     std::string local_certificate_id = ExtractStatsValue(
         StatsReport::kStatsReportTypeComponent,
         reports,
         StatsReport::kStatsValueNameLocalCertificateId);
     if (local_ders.size() > 0) {
       EXPECT_NE(kNotFound, local_certificate_id);
       StatsReport::Id id(IdFromCertIdString(local_certificate_id));
       CheckCertChainReports(reports, local_ders, id);
@@ skipping 50 matching lines @@
   const int id = -1;
   const std::string state = DataChannelInterface::DataStateString(
       DataChannelInterface::DataState::kConnecting);
 
   AddDataChannel(cricket::DCT_SCTP, label, id);
   StatsCollectorForTest stats(&pc_);
 
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
 
   StatsReports reports;
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
 
   const StatsReport* report =
       FindNthReportByType(reports, StatsReport::kStatsReportTypeDataChannel, 1);
 
   std::string value_in_report;
   EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameDataChannelId,
                         &value_in_report));
 }
 
 // Verify that ExtractDataInfo populates reports.
 TEST_F(StatsCollectorTest, ExtractDataInfo) {
   const std::string label = "hacks";
   const int id = 31337;
   const std::string state = DataChannelInterface::DataStateString(
       DataChannelInterface::DataState::kConnecting);
 
   AddDataChannel(cricket::DCT_SCTP, label, id);
   StatsCollectorForTest stats(&pc_);
 
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
 
   StatsReports reports;
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
 
   const StatsReport* report =
       FindNthReportByType(reports, StatsReport::kStatsReportTypeDataChannel, 1);
 
   StatsReport::Id reportId = StatsReport::NewTypedIntId(
       StatsReport::kStatsReportTypeDataChannel, id);
 
   EXPECT_TRUE(reportId->Equals(report->id()));
 
   EXPECT_EQ(stats.GetTimeNow(), report->timestamp());
@@ skipping 47 matching lines @@
   video_sender_info.add_ssrc(1234);
   video_sender_info.bytes_sent = kBytesSent;
   stats_read.senders.push_back(video_sender_info);
 
   EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
   EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
   EXPECT_CALL(*media_channel, GetStats(_))
       .WillOnce(DoAll(SetArgPointee<0>(stats_read),
                       Return(true)));
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
   std::string result = ExtractSsrcStatsValue(reports,
       StatsReport::kStatsValueNameBytesSent);
   EXPECT_EQ(kBytesSentString, result);
 }
 
 // Test that BWE information is reported via stats.
 TEST_F(StatsCollectorTest, BandwidthEstimationInfoIsReported) {
   StatsCollectorForTest stats(&pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
@@ skipping 35 matching lines @@
   const std::string kTargetEncBitrateString("123456");
   bwe.target_enc_bitrate = kTargetEncBitrate;
   stats_read.bw_estimations.push_back(bwe);
 
   EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
   EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
   EXPECT_CALL(*media_channel, GetStats(_))
       .WillOnce(DoAll(SetArgPointee<0>(stats_read), Return(true)));
 
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
   std::string result = ExtractSsrcStatsValue(reports,
       StatsReport::kStatsValueNameBytesSent);
   EXPECT_EQ(kBytesSentString, result);
   result = ExtractBweStatsValue(reports,
       StatsReport::kStatsValueNameTargetEncBitrate);
   EXPECT_EQ(kTargetEncBitrateString, result);
 }
 
 // This test verifies that an object of type "googSession" always
 // exists in the returned stats.
 TEST_F(StatsCollectorTest, SessionObjectExists) {
   StatsCollectorForTest stats(&pc_);
 
   StatsReports reports;  // returned values.
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
   const StatsReport* session_report = FindNthReportByType(
       reports, StatsReport::kStatsReportTypeSession, 1);
-  EXPECT_FALSE(session_report == NULL);
+  EXPECT_FALSE(session_report == nullptr);
 }
 
 // This test verifies that only one object of type "googSession" exists
 // in the returned stats.
 TEST_F(StatsCollectorTest, OnlyOneSessionObjectExists) {
   StatsCollectorForTest stats(&pc_);
 
   StatsReports reports;  // returned values.
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
   const StatsReport* session_report = FindNthReportByType(
       reports, StatsReport::kStatsReportTypeSession, 1);
-  EXPECT_FALSE(session_report == NULL);
+  EXPECT_FALSE(session_report == nullptr);
   session_report = FindNthReportByType(
       reports, StatsReport::kStatsReportTypeSession, 2);
-  EXPECT_EQ(NULL, session_report);
+  EXPECT_EQ(nullptr, session_report);
 }
 
 // This test verifies that the empty track report exists in the returned stats
 // without calling StatsCollector::UpdateStats.
 TEST_F(StatsCollectorTest, TrackObjectExistsWithoutUpdateStats) {
   StatsCollectorForTest stats(&pc_);
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   cricket::VideoChannel video_channel(
       worker_thread_, network_thread_, nullptr, media_channel, "video",
       kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
 
   // Verfies the existence of the track report.
   StatsReports reports;
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
   EXPECT_EQ((size_t)1, reports.size());
   EXPECT_EQ(StatsReport::kStatsReportTypeTrack, reports[0]->type());
   EXPECT_EQ(0, reports[0]->timestamp());
 
   std::string trackValue =
       ExtractStatsValue(StatsReport::kStatsReportTypeTrack,
                         reports,
                         StatsReport::kStatsValueNameTrackId);
   EXPECT_EQ(kLocalTrackId, trackValue);
 }
@@ skipping 34 matching lines @@
   stats_read.senders.push_back(video_sender_info);
 
   EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
   EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
   EXPECT_CALL(*media_channel, GetStats(_))
     .WillOnce(DoAll(SetArgPointee<0>(stats_read),
                     Return(true)));
 
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   StatsReports reports;
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
   // |reports| should contain at least one session report, one track report,
   // and one ssrc report.
   EXPECT_LE((size_t)3, reports.size());
   const StatsReport* track_report = FindNthReportByType(
       reports, StatsReport::kStatsReportTypeTrack, 1);
   EXPECT_TRUE(track_report);
 
   // Get report for the specific |track|.
   reports.clear();
   stats.GetStats(track_, &reports);
@@ skipping 55 matching lines @@
 
   InitSessionStats(kVcName);
   EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(Invoke(
       [this](const ChannelNamePairs&) {
         return std::unique_ptr<SessionStats>(
             new SessionStats(session_stats_));
       }));
 
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   StatsReports reports;
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
   std::string transport_id = ExtractStatsValue(
       StatsReport::kStatsReportTypeSsrc,
       reports,
       StatsReport::kStatsValueNameTransportId);
   ASSERT_NE(kNotFound, transport_id);
   // Transport id component ID will always be 1.
   // This has assumptions about how the ID is constructed.  As is, this is
   // OK since this is for testing purposes only, but if we ever need this
   // in production, we should add a generic method that does this.
   size_t index = transport_id.find('-');
   ASSERT_NE(std::string::npos, index);
   std::string content = transport_id.substr(index + 1);
   index = content.rfind('-');
   ASSERT_NE(std::string::npos, index);
   content = content.substr(0, index);
   StatsReport::Id id(StatsReport::NewComponentId(content, 1));
   ASSERT_EQ(transport_id, id->ToString());
   const StatsReport* transport_report = FindReportById(reports, id);
-  ASSERT_FALSE(transport_report == NULL);
+  ASSERT_FALSE(transport_report == nullptr);
 }
 
 // This test verifies that a remote stats object will not be created for
 // an outgoing SSRC where remote stats are not returned.
 TEST_F(StatsCollectorTest, RemoteSsrcInfoIsAbsent) {
   StatsCollectorForTest stats(&pc_);
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   // The transport_name known by the video channel.
   const std::string kVcName("vcname");
   cricket::VideoChannel video_channel(
       worker_thread_, network_thread_, nullptr, media_channel, kVcName,
       kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
 
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   StatsReports reports;
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
   const StatsReport* remote_report = FindNthReportByType(reports,
       StatsReport::kStatsReportTypeRemoteSsrc, 1);
-  EXPECT_TRUE(remote_report == NULL);
+  EXPECT_TRUE(remote_report == nullptr);
 }
 
 // This test verifies that a remote stats object will be created for
 // an outgoing SSRC where stats are returned.
 TEST_F(StatsCollectorTest, RemoteSsrcInfoIsPresent) {
   StatsCollectorForTest stats(&pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
@@ skipping 28 matching lines @@
   stats_read.senders.push_back(video_sender_info);
 
   EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
   EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
   EXPECT_CALL(*media_channel, GetStats(_))
     .WillRepeatedly(DoAll(SetArgPointee<0>(stats_read),
                           Return(true)));
 
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   StatsReports reports;
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
 
   const StatsReport* remote_report = FindNthReportByType(reports,
       StatsReport::kStatsReportTypeRemoteSsrc, 1);
-  EXPECT_FALSE(remote_report == NULL);
+  EXPECT_FALSE(remote_report == nullptr);
   EXPECT_EQ(12345.678, remote_report->timestamp());
 }
 
 // This test verifies that the empty track report exists in the returned stats
 // when StatsCollector::UpdateStats is called with ssrc stats.
 TEST_F(StatsCollectorTest, ReportsFromRemoteTrack) {
   StatsCollectorForTest stats(&pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
@@ skipping 26 matching lines @@
   stats_read.receivers.push_back(video_receiver_info);
 
   EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
   EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
   EXPECT_CALL(*media_channel, GetStats(_))
       .WillOnce(DoAll(SetArgPointee<0>(stats_read),
                       Return(true)));
 
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   StatsReports reports;
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
   // |reports| should contain at least one session report, one track report,
   // and one ssrc report.
   EXPECT_LE(static_cast<size_t>(3), reports.size());
   const StatsReport* track_report = FindNthReportByType(
       reports, StatsReport::kStatsReportTypeTrack, 1);
   EXPECT_TRUE(track_report);
   EXPECT_EQ(stats.GetTimeNow(), track_report->timestamp());
 
   std::string ssrc_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameSsrc);
@@ skipping 34 matching lines @@
   c = cricket::Candidate();
   EXPECT_GT(c.id().length(), 0u);
   c.set_type(cricket::PRFLX_PORT_TYPE);
   c.set_protocol(cricket::UDP_PROTOCOL_NAME);
   c.set_address(remote_address);
   c.set_priority(priority);
   c.set_network_type(network_type);
   report_id = AddCandidateReport(&stats, c, false)->id()->ToString();
   EXPECT_EQ("Cand-" + c.id(), report_id);
 
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
 
   // Verify the local candidate report is populated correctly.
   EXPECT_EQ(
       local_ip,
       ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
                         StatsReport::kStatsValueNameCandidateIPAddress));
   EXPECT_EQ(
       rtc::ToString<int>(local_port),
       ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
                         StatsReport::kStatsValueNameCandidatePortNumber));
@@ skipping 108 matching lines @@
       transport_stats;
 
   // Configure MockWebRtcSession
   EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(Invoke(
       [&session_stats](const ChannelNamePairs&) {
         return std::unique_ptr<SessionStats>(
             new SessionStats(session_stats));
       }));
 
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
 
   // Check that the local certificate is absent.
   std::string local_certificate_id = ExtractStatsValue(
       StatsReport::kStatsReportTypeComponent,
       reports,
       StatsReport::kStatsValueNameLocalCertificateId);
   ASSERT_EQ(kNotFound, local_certificate_id);
 
   // Check that the remote certificate is absent.
   std::string remote_certificate_id = ExtractStatsValue(
@@ skipping 37 matching lines @@
   session_stats.transport_stats[transport_stats.transport_name] =
       transport_stats;
 
   // Configure MockWebRtcSession
   EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(Invoke(
       [&session_stats](const ChannelNamePairs&) {
         return std::unique_ptr<SessionStats>(
             new SessionStats(session_stats));
       }));
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
 
   // Check that the local certificate is absent.
   std::string local_certificate_id = ExtractStatsValue(
       StatsReport::kStatsReportTypeComponent,
       reports,
       StatsReport::kStatsValueNameLocalCertificateId);
   ASSERT_EQ(kNotFound, local_certificate_id);
 
   // Check that the remote certificate is absent.
   std::string remote_certificate_id = ExtractStatsValue(
@@ skipping 31 matching lines @@
       .WillRepeatedly(Return(nullptr));
 
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(
       worker_thread_, network_thread_, nullptr, media_engine_, media_channel,
       kVcName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
 
   // Create a local stream with a local audio track and adds it to the stats.
-  if (stream_ == NULL)
+  if (stream_ == nullptr)
     stream_ = webrtc::MediaStream::Create("streamlabel");
 
   rtc::scoped_refptr<FakeAudioTrackWithInitValue> local_track(
       new rtc::RefCountedObject<FakeAudioTrackWithInitValue>(kLocalTrackId));
   stream_->AddTrack(local_track);
   EXPECT_CALL(session_, GetLocalTrackIdBySsrc(kSsrcOfTrack, _))
       .WillOnce(DoAll(SetArgPointee<1>(kLocalTrackId), Return(true)));
   stats.AddStream(stream_);
   stats.AddLocalAudioTrack(local_track.get(), kSsrcOfTrack);
 
@@ skipping 98 matching lines @@
   stats.AddStream(stream_);
   stats.AddLocalAudioTrack(audio_track_, kSsrcOfTrack);
 
   cricket::VoiceSenderInfo voice_sender_info;
   InitVoiceSenderInfo(&voice_sender_info);
 
   cricket::VoiceMediaInfo stats_read;
   StatsReports reports;  // returned values.
   SetupAndVerifyAudioTrackStats(
       audio_track_.get(), stream_.get(), &stats, &voice_channel, kVcName,
-      media_channel, &voice_sender_info, NULL, &stats_read, &reports);
+      media_channel, &voice_sender_info, nullptr, &stats_read, &reports);
 
   // Verify that there is no remote report for the local audio track because
   // we did not set it up.
   const StatsReport* remote_report = FindNthReportByType(reports,
       StatsReport::kStatsReportTypeRemoteSsrc, 1);
-  EXPECT_TRUE(remote_report == NULL);
+  EXPECT_TRUE(remote_report == nullptr);
 }
 
 // This test verifies that audio receive streams populate stats reports
 // correctly.
 TEST_F(StatsCollectorTest, GetStatsFromRemoteStream) {
   StatsCollectorForTest stats(&pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(
       worker_thread_, network_thread_, nullptr, media_engine_, media_channel,
       kVcName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
   AddIncomingAudioTrackStats();
   stats.AddStream(stream_);
 
   cricket::VoiceReceiverInfo voice_receiver_info;
   InitVoiceReceiverInfo(&voice_receiver_info);
   voice_receiver_info.codec_name = "fake_codec";
 
   cricket::VoiceMediaInfo stats_read;
   StatsReports reports;  // returned values.
-  SetupAndVerifyAudioTrackStats(
-      audio_track_.get(), stream_.get(), &stats, &voice_channel, kVcName,
-      media_channel, NULL, &voice_receiver_info, &stats_read, &reports);
+  SetupAndVerifyAudioTrackStats(audio_track_.get(), stream_.get(), &stats,
+                                &voice_channel, kVcName, media_channel, nullptr,
+                                &voice_receiver_info, &stats_read, &reports);
 }
 
 // This test verifies that a local stats object won't update its statistics
 // after a RemoveLocalAudioTrack() call.
 TEST_F(StatsCollectorTest, GetStatsAfterRemoveAudioStream) {
   StatsCollectorForTest stats(&pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
@@ skipping 26 matching lines @@
   stats_read.senders.push_back(voice_sender_info);
 
   EXPECT_CALL(session_, voice_channel()).WillRepeatedly(Return(&voice_channel));
   EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
   EXPECT_CALL(*media_channel, GetStats(_))
       .WillRepeatedly(DoAll(SetArgPointee<0>(stats_read),
                             Return(true)));
 
   StatsReports reports;  // returned values.
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
 
   // The report will exist since we don't remove them in RemoveStream().
   const StatsReport* report = FindNthReportByType(
       reports, StatsReport::kStatsReportTypeSsrc, 1);
-  EXPECT_FALSE(report == NULL);
+  EXPECT_FALSE(report == nullptr);
   EXPECT_EQ(stats.GetTimeNow(), report->timestamp());
   std::string track_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameTrackId);
   EXPECT_EQ(kLocalTrackId, track_id);
   std::string ssrc_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameSsrc);
   EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
 
   // Verifies the values in the track report, no value will be changed by the
   // AudioTrackInterface::GetSignalValue() and
@@ skipping 113 matching lines @@
   stats.AddStream(stream_);
   stats.AddLocalAudioTrack(audio_track_, kSsrcOfTrack);
 
   cricket::VoiceSenderInfo voice_sender_info;
   voice_sender_info.add_ssrc(kSsrcOfTrack);
 
   cricket::VoiceMediaInfo stats_read;
   StatsReports reports;  // returned values.
   SetupAndVerifyAudioTrackStats(
       audio_track_.get(), stream_.get(), &stats, &voice_channel, kVcName,
-      media_channel, &voice_sender_info, NULL, &stats_read, &reports);
+      media_channel, &voice_sender_info, nullptr, &stats_read, &reports);
 
   // Remove the previous audio track from the stream.
   stream_->RemoveTrack(audio_track_.get());
   stats.RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
 
   // Create a new audio track and adds it to the stream and stats.
   static const std::string kNewTrackId = "new_track_id";
   rtc::scoped_refptr<FakeAudioTrack> new_audio_track(
       new rtc::RefCountedObject<FakeAudioTrack>(kNewTrackId));
   EXPECT_CALL(session_, GetLocalTrackIdBySsrc(kSsrcOfTrack, _))
       .WillOnce(DoAll(SetArgPointee<1>(kNewTrackId), Return(true)));
   stream_->AddTrack(new_audio_track);
 
   stats.AddLocalAudioTrack(new_audio_track, kSsrcOfTrack);
   stats.ClearUpdateStatsCacheForTest();
   cricket::VoiceSenderInfo new_voice_sender_info;
   InitVoiceSenderInfo(&new_voice_sender_info);
   cricket::VoiceMediaInfo new_stats_read;
   reports.clear();
-  SetupAndVerifyAudioTrackStats(
-      new_audio_track.get(), stream_.get(), &stats, &voice_channel, kVcName,
-      media_channel, &new_voice_sender_info, NULL, &new_stats_read, &reports);
+  SetupAndVerifyAudioTrackStats(new_audio_track.get(), stream_.get(), &stats,
+                                &voice_channel, kVcName, media_channel,
+                                &new_voice_sender_info, nullptr,
+                                &new_stats_read, &reports);
 }
 
 // This test verifies that stats are correctly set in video send ssrc stats.
 TEST_F(StatsCollectorTest, VerifyVideoSendSsrcStats) {
   StatsCollectorForTest stats(&pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
@@ skipping 22 matching lines @@
   video_sender_info.add_ssrc(1234);
   video_sender_info.frames_encoded = 10;
   video_sender_info.qp_sum = rtc::Optional<uint64_t>(11);
   stats_read.senders.push_back(video_sender_info);
 
   EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
   EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
   EXPECT_CALL(*media_channel, GetStats(_))
       .WillOnce(DoAll(SetArgPointee<0>(stats_read), Return(true)));
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
   EXPECT_EQ(rtc::ToString(video_sender_info.frames_encoded),
             ExtractSsrcStatsValue(reports,
                                   StatsReport::kStatsValueNameFramesEncoded));
   EXPECT_EQ(rtc::ToString(*video_sender_info.qp_sum),
             ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameQpSum));
 }
 
 // This test verifies that stats are correctly set in video receive ssrc stats.
 TEST_F(StatsCollectorTest, VerifyVideoReceiveSsrcStats) {
   StatsCollectorForTest stats(&pc_);
@@ skipping 27 matching lines @@
   video_receiver_info.add_ssrc(1234);
   video_receiver_info.frames_decoded = 10;
   video_receiver_info.qp_sum = rtc::Optional<uint64_t>(11);
   stats_read.receivers.push_back(video_receiver_info);
 
   EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
   EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
   EXPECT_CALL(*media_channel, GetStats(_))
       .WillOnce(DoAll(SetArgPointee<0>(stats_read), Return(true)));
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
-  stats.GetStats(NULL, &reports);
+  stats.GetStats(nullptr, &reports);
   EXPECT_EQ(rtc::ToString(video_receiver_info.frames_decoded),
             ExtractSsrcStatsValue(reports,
                                   StatsReport::kStatsValueNameFramesDecoded));
   EXPECT_EQ(rtc::ToString(*video_receiver_info.qp_sum),
             ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameQpSum));
 }
 
 }  // namespace webrtc