Replace NULL with nullptr in all C++ files.

webrtc/modules/video_coding/test/rtp_player.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 70 matching lines @@
         loss_count_(0),
         packets_(),
         clock_(clock),
         rtt_ms_(rtt_ms) {
     assert(clock);
   }
 
   ~LostPackets() {
     if (debug_file_) {
       fclose(debug_file_);
-      debug_file_ = NULL;
+      debug_file_ = nullptr;
     }
     while (!packets_.empty()) {
       delete packets_.back();
       packets_.pop_back();
     }
   }
 
   void AddPacket(RawRtpPacket* packet) {
     assert(packet);
     printf("Throw:  %08x:%u\n", packet->ssrc(), packet->seq_num());
@@ skipping 28 matching lines @@
   RawRtpPacket* NextPacketToResend(int64_t time_now) {
     CriticalSectionScoped cs(crit_sect_.get());
     for (RtpPacketIterator it = packets_.begin(); it != packets_.end(); ++it) {
       RawRtpPacket* packet = *it;
       if (time_now >= packet->resend_time_ms() &&
           packet->resend_time_ms() != -1) {
         packets_.erase(it);
         return packet;
       }
     }
-    return NULL;
+    return nullptr;
   }
 
   int NumberOfPacketsToResend() const {
     CriticalSectionScoped cs(crit_sect_.get());
     int count = 0;
     for (ConstRtpPacketIterator it = packets_.begin(); it != packets_.end();
          ++it) {
       if ((*it)->resend_time_ms() >= 0) {
         count++;
       }
@@ skipping 57 matching lines @@
 
   int RegisterSsrc(uint32_t ssrc, LostPackets* lost_packets, Clock* clock) {
     if (handlers_.count(ssrc) > 0) {
       return 0;
     }
     DEBUG_LOG1("Registering handler for ssrc=%08x", ssrc);
 
     std::unique_ptr<Handler> handler(
         new Handler(ssrc, payload_types_, lost_packets));
     handler->payload_sink_.reset(payload_sink_factory_->Create(handler.get()));
-    if (handler->payload_sink_.get() == NULL) {
+    if (handler->payload_sink_.get() == nullptr) {
       return -1;
     }
 
     RtpRtcp::Configuration configuration;
     configuration.clock = clock;
     configuration.audio = false;
     handler->rtp_module_.reset(RtpReceiver::CreateVideoReceiver(
-        configuration.clock, handler->payload_sink_.get(), NULL,
+        configuration.clock, handler->payload_sink_.get(), nullptr,
         handler->rtp_payload_registry_.get()));
-    if (handler->rtp_module_.get() == NULL) {
+    if (handler->rtp_module_.get() == nullptr) {
       return -1;
     }
 
     handler->rtp_header_parser_->RegisterRtpHeaderExtension(
         kRtpExtensionTransmissionTimeOffset,
         kDefaultTransmissionTimeOffsetExtensionId);
 
     for (PayloadTypesIterator it = payload_types_.begin();
          it != payload_types_.end(); ++it) {
       VideoCodec codec;
@@ skipping 103 matching lines @@
     assert(packet_source->get());
     packet_source_.swap(*packet_source);
     std::srand(321);
   }
 
   virtual ~RtpPlayerImpl() {}
 
   virtual int NextPacket(int64_t time_now) {
     // Send any packets ready to be resent.
     for (RawRtpPacket* packet = lost_packets_.NextPacketToResend(time_now);
-         packet != NULL; packet = lost_packets_.NextPacketToResend(time_now)) {
+         packet != nullptr;
+         packet = lost_packets_.NextPacketToResend(time_now)) {
       int ret = SendPacket(packet->data(), packet->length());
       if (ret > 0) {
         printf("Resend: %08x:%u\n", packet->ssrc(), packet->seq_num());
         lost_packets_.LogPacketResent(packet);
         resend_packet_count_++;
       }
       delete packet;
       if (ret < 0) {
         return ret;
       }
     }
 
     // Send any packets from packet source.
     if (!end_of_file_ && (TimeUntilNextPacket() == 0 || first_packet_)) {
       if (first_packet_) {
         if (!packet_source_->NextPacket(&next_packet_))
           return 0;
         first_packet_rtp_time_ = next_packet_.time_ms;
         first_packet_time_ms_ = clock_->TimeInMilliseconds();
         first_packet_ = false;
       }
 
-      if (reordering_ && reorder_buffer_.get() == NULL) {
+      if (reordering_ && reorder_buffer_.get() == nullptr) {
         reorder_buffer_.reset(
             new RawRtpPacket(next_packet_.data, next_packet_.length, 0, 0));
         return 0;
       }
       int ret = SendPacket(next_packet_.data, next_packet_.length);
       if (reorder_buffer_.get()) {
         SendPacket(reorder_buffer_->data(), reorder_buffer_->length());
-        reorder_buffer_.reset(NULL);
+        reorder_buffer_.reset(nullptr);
       }
       if (ret < 0) {
         return ret;
       }
 
       if (!packet_source_->NextPacket(&next_packet_)) {
         end_of_file_ = true;
         return 0;
       } else if (next_packet_.length == 0) {
         return 0;
@@ skipping 75 matching lines @@
 RtpPlayerInterface* Create(const std::string& input_filename,
                            PayloadSinkFactoryInterface* payload_sink_factory,
                            Clock* clock,
                            const PayloadTypes& payload_types,
                            float loss_rate,
                            int64_t rtt_ms,
                            bool reordering) {
   std::unique_ptr<test::RtpFileReader> packet_source(
       test::RtpFileReader::Create(test::RtpFileReader::kRtpDump,
                                   input_filename));
-  if (packet_source.get() == NULL) {
+  if (packet_source.get() == nullptr) {
     packet_source.reset(test::RtpFileReader::Create(test::RtpFileReader::kPcap,
                                                     input_filename));
-    if (packet_source.get() == NULL) {
-      return NULL;
+    if (packet_source.get() == nullptr) {
+      return nullptr;
     }
   }
 
   std::unique_ptr<RtpPlayerImpl> impl(
       new RtpPlayerImpl(payload_sink_factory, payload_types, clock,
                         &packet_source, loss_rate, rtt_ms, reordering));
   return impl.release();
 }
 }  // namespace rtpplayer
 }  // namespace webrtc