Replace NULL with nullptr in all C++ files.

webrtc/test/rtp_file_reader.cc

 /*
  *  Copyright (c) 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 51 matching lines @@
 
 class RtpFileReaderImpl : public RtpFileReader {
  public:
   virtual bool Init(const std::string& filename,
                     const std::set<uint32_t>& ssrc_filter) = 0;
 };
 
 class InterleavedRtpFileReader : public RtpFileReaderImpl {
  public:
   virtual ~InterleavedRtpFileReader() {
-    if (file_ != NULL) {
+    if (file_ != nullptr) {
       fclose(file_);
-      file_ = NULL;
+      file_ = nullptr;
     }
   }
 
   virtual bool Init(const std::string& filename,
                     const std::set<uint32_t>& ssrc_filter) {
     file_ = fopen(filename.c_str(), "rb");
-    if (file_ == NULL) {
+    if (file_ == nullptr) {
       printf("ERROR: Can't open file: %s\n", filename.c_str());
       return false;
     }
     return true;
   }
   virtual bool NextPacket(RtpPacket* packet) {
-    assert(file_ != NULL);
+    assert(file_ != nullptr);
     packet->length = RtpPacket::kMaxPacketBufferSize;
     uint32_t len = 0;
     TRY(ReadUint32(&len, file_));
     if (packet->length < len) {
       FATAL() << "Packet is too large to fit: " << len << " bytes vs "
               << packet->length
               << " bytes allocated. Consider increasing the buffer "
                  "size";
     }
     if (fread(packet->data, 1, len, file_) != len)
       return false;
 
     packet->length = len;
     packet->original_length = len;
     packet->time_ms = time_ms_;
     time_ms_ += 5;
     return true;
   }
 
  private:
-  FILE* file_ = NULL;
+  FILE* file_ = nullptr;
   int64_t time_ms_ = 0;
 };
 
 // Read RTP packets from file in rtpdump format, as documented at:
 // http://www.cs.columbia.edu/irt/software/rtptools/
 class RtpDumpReader : public RtpFileReaderImpl {
  public:
-  RtpDumpReader() : file_(NULL) {}
+  RtpDumpReader() : file_(nullptr) {}
   virtual ~RtpDumpReader() {
-    if (file_ != NULL) {
+    if (file_ != nullptr) {
       fclose(file_);
-      file_ = NULL;
+      file_ = nullptr;
     }
   }
 
   bool Init(const std::string& filename,
             const std::set<uint32_t>& ssrc_filter) override {
     file_ = fopen(filename.c_str(), "rb");
-    if (file_ == NULL) {
+    if (file_ == nullptr) {
       printf("ERROR: Can't open file: %s\n", filename.c_str());
       return false;
     }
 
     char firstline[kFirstLineLength + 1] = {0};
-    if (fgets(firstline, kFirstLineLength, file_) == NULL) {
+    if (fgets(firstline, kFirstLineLength, file_) == nullptr) {
       LOG(LS_INFO) << "Can't read from file";
       return false;
     }
     if (strncmp(firstline, "#!rtpplay", 9) == 0) {
       if (strncmp(firstline, "#!rtpplay1.0", 12) != 0) {
         LOG(LS_INFO) <<  "Wrong rtpplay version, must be 1.0";
         return false;
       }
     } else if (strncmp(firstline, "#!RTPencode", 11) == 0) {
       if (strncmp(firstline, "#!RTPencode1.0", 14) != 0) {
@@ skipping 89 matching lines @@
     } else if (r == kResultSkip) {                     \
       return kResultSkip;                              \
     }                                                  \
   } while (0)
 
 // Read RTP packets from file in tcpdump/libpcap format, as documented at:
 // http://wiki.wireshark.org/Development/LibpcapFileFormat
 class PcapReader : public RtpFileReaderImpl {
  public:
   PcapReader()
-    : file_(NULL),
-      swap_pcap_byte_order_(false),
+      : file_(nullptr),
+        swap_pcap_byte_order_(false),
 #ifdef WEBRTC_ARCH_BIG_ENDIAN
-      swap_network_byte_order_(false),
+        swap_network_byte_order_(false),
 #else
-      swap_network_byte_order_(true),
+        swap_network_byte_order_(true),
 #endif
-      read_buffer_(),
-      packets_by_ssrc_(),
-      packets_(),
-      next_packet_it_() {
+        read_buffer_(),
+        packets_by_ssrc_(),
+        packets_(),
+        next_packet_it_() {
   }
 
   virtual ~PcapReader() {
-    if (file_ != NULL) {
+    if (file_ != nullptr) {
       fclose(file_);
-      file_ = NULL;
+      file_ = nullptr;
     }
   }
 
   bool Init(const std::string& filename,
             const std::set<uint32_t>& ssrc_filter) override {
     return Initialize(filename, ssrc_filter) == kResultSuccess;
   }
 
   int Initialize(const std::string& filename,
                  const std::set<uint32_t>& ssrc_filter) {
     file_ = fopen(filename.c_str(), "rb");
-    if (file_ == NULL) {
+    if (file_ == nullptr) {
       printf("ERROR: Can't open file: %s\n", filename.c_str());
       return kResultFail;
     }
 
     if (ReadGlobalHeader() < 0) {
       return kResultFail;
     }
 
     int total_packet_count = 0;
     uint32_t stream_start_ms = 0;
@@ skipping 118 matching lines @@
 
     int32_t this_zone;  // GMT to local correction.
     uint32_t sigfigs;   // Accuracy of timestamps.
     uint32_t snaplen;   // Max length of captured packets, in octets.
     uint32_t network;   // Data link type.
     TRY_PCAP(Read(&this_zone, false));
     TRY_PCAP(Read(&sigfigs, false));
     TRY_PCAP(Read(&snaplen, false));
     TRY_PCAP(Read(&network, false));
 
-    // Accept only LINKTYPE_NULL and LINKTYPE_ETHERNET.
+    // Accept only LINKTYPE_null and LINKTYPE_ETHERNET.
     // See: http://www.tcpdump.org/linktypes.html
     if (network != kLinktypeNull && network != kLinktypeEthernet) {
       return kResultFail;
     }
 
     return kResultSuccess;
   }
 
   int ReadPacket(int32_t* next_packet_pos,
                  uint32_t stream_start_ms,
@@ skipping 210 matching lines @@
   SsrcMap packets_by_ssrc_;
   std::vector<RtpPacketMarker> packets_;
   PacketIterator next_packet_it_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(PcapReader);
 };
 
 RtpFileReader* RtpFileReader::Create(FileFormat format,
                                      const std::string& filename,
                                      const std::set<uint32_t>& ssrc_filter) {
-  RtpFileReaderImpl* reader = NULL;
+  RtpFileReaderImpl* reader = nullptr;
   switch (format) {
     case kPcap:
       reader = new PcapReader();
       break;
     case kRtpDump:
       reader = new RtpDumpReader();
       break;
     case kLengthPacketInterleaved:
       reader = new InterleavedRtpFileReader();
       break;
   }
   if (!reader->Init(filename, ssrc_filter)) {
     delete reader;
-    return NULL;
+    return nullptr;
   }
   return reader;
 }
 
 RtpFileReader* RtpFileReader::Create(FileFormat format,
                                      const std::string& filename) {
   return RtpFileReader::Create(format, filename, std::set<uint32_t>());
 }
 
 }  // namespace test
 }  // namespace webrtc