Replace NULL with nullptr in all C++ files.

webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc

 /*
  *  Copyright (c) 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 141 matching lines @@
     // Process RTT if we have received a receiver report and we haven't
     // processed RTT for at least |kRtpRtcpRttProcessTimeMs| milliseconds.
     if (rtcp_receiver_.LastReceivedReceiverReport() >
         last_rtt_process_time_ && process_rtt) {
       std::vector<RTCPReportBlock> receive_blocks;
       rtcp_receiver_.StatisticsReceived(&receive_blocks);
       int64_t max_rtt = 0;
       for (std::vector<RTCPReportBlock>::iterator it = receive_blocks.begin();
            it != receive_blocks.end(); ++it) {
         int64_t rtt = 0;
-        rtcp_receiver_.RTT(it->remoteSSRC, &rtt, NULL, NULL, NULL);
+        rtcp_receiver_.RTT(it->remoteSSRC, &rtt, nullptr, nullptr, nullptr);
         max_rtt = (rtt > max_rtt) ? rtt : max_rtt;
       }
       // Report the rtt.
       if (rtt_stats_ && max_rtt != 0)
         rtt_stats_->OnRttUpdate(max_rtt);
     }
 
     // Verify receiver reports are delivered and the reported sequence number
     // is increasing.
     int64_t rtcp_interval = RtcpReportInterval();
@@ skipping 382 matching lines @@
     StreamDataCounters* rtp_counters,
     StreamDataCounters* rtx_counters) const {
   rtp_sender_.GetDataCounters(rtp_counters, rtx_counters);
 }
 
 void ModuleRtpRtcpImpl::GetRtpPacketLossStats(
     bool outgoing,
     uint32_t ssrc,
     struct RtpPacketLossStats* loss_stats) const {
   if (!loss_stats) return;
-  const PacketLossStats* stats_source = NULL;
+  const PacketLossStats* stats_source = nullptr;
   if (outgoing) {
     if (SSRC() == ssrc) {
       stats_source = &send_loss_stats_;
     }
   } else {
     if (rtcp_receiver_.RemoteSSRC() == ssrc) {
       stats_source = &receive_loss_stats_;
     }
   }
   if (stats_source) {
@@ skipping 116 matching lines @@
 void ModuleRtpRtcpImpl::SendNack(
     const std::vector<uint16_t>& sequence_numbers) {
   rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpNack, sequence_numbers.size(),
                         sequence_numbers.data());
 }
 
 bool ModuleRtpRtcpImpl::TimeToSendFullNackList(int64_t now) const {
   // Use RTT from RtcpRttStats class if provided.
   int64_t rtt = rtt_ms();
   if (rtt == 0) {
-    rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), NULL, &rtt, NULL, NULL);
+    rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), nullptr, &rtt, nullptr,
+                       nullptr);
   }
 
   const int64_t kStartUpRttMs = 100;
   int64_t wait_time = 5 + ((rtt * 3) >> 1);  // 5 + RTT * 1.5.
   if (rtt == 0) {
     wait_time = kStartUpRttMs;
   }
 
   // Send a full NACK list once within every |wait_time|.
   if (rtt_stats_) {
@@ skipping 123 matching lines @@
   for (uint16_t nack_sequence_number : nack_sequence_numbers) {
     send_loss_stats_.AddLostPacket(nack_sequence_number);
   }
   if (!rtp_sender_.StorePackets() ||
       nack_sequence_numbers.size() == 0) {
     return;
   }
   // Use RTT from RtcpRttStats class if provided.
   int64_t rtt = rtt_ms();
   if (rtt == 0) {
-    rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), NULL, &rtt, NULL, NULL);
+    rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), nullptr, &rtt, nullptr,
+                       nullptr);
   }
   rtp_sender_.OnReceivedNack(nack_sequence_numbers, rtt);
 }
 
 void ModuleRtpRtcpImpl::OnReceivedRtcpReportBlocks(
     const ReportBlockList& report_blocks) {
   rtp_sender_.OnReceivedRtcpReportBlocks(report_blocks);
 }
 
 bool ModuleRtpRtcpImpl::LastReceivedNTP(
     uint32_t* rtcp_arrival_time_secs,  // When we got the last report.
     uint32_t* rtcp_arrival_time_frac,
     uint32_t* remote_sr) const {
   // Remote SR: NTP inside the last received (mid 16 bits from sec and frac).
   uint32_t ntp_secs = 0;
   uint32_t ntp_frac = 0;
 
-  if (!rtcp_receiver_.NTP(&ntp_secs,
-                          &ntp_frac,
-                          rtcp_arrival_time_secs,
-                          rtcp_arrival_time_frac,
-                          NULL)) {
+  if (!rtcp_receiver_.NTP(&ntp_secs, &ntp_frac, rtcp_arrival_time_secs,
+                          rtcp_arrival_time_frac, nullptr)) {
     return false;
   }
   *remote_sr =
       ((ntp_secs & 0x0000ffff) << 16) + ((ntp_frac & 0xffff0000) >> 16);
   return true;
 }
 
 // Called from RTCPsender.
 std::vector<rtcp::TmmbItem> ModuleRtpRtcpImpl::BoundingSet(bool* tmmbr_owner) {
   return rtcp_receiver_.BoundingSet(tmmbr_owner);
@@ skipping 32 matching lines @@
 StreamDataCountersCallback*
     ModuleRtpRtcpImpl::GetSendChannelRtpStatisticsCallback() const {
   return rtp_sender_.GetRtpStatisticsCallback();
 }
 
 void ModuleRtpRtcpImpl::SetVideoBitrateAllocation(
     const BitrateAllocation& bitrate) {
   rtcp_sender_.SetVideoBitrateAllocation(bitrate);
 }
 }  // namespace webrtc