Replace NULL with nullptr in all C++ files.

webrtc/modules/rtp_rtcp/source/rtp_format_vp8_unittest.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 42 matching lines @@
 //      +-+-+-+-+-+-+-+-+
 //      | Bytes 4..N of |
 //      | VP8 payload   |
 //      :               :
 //      +-+-+-+-+-+-+-+-+
 //      | OPTIONAL RTP  |
 //      | padding       |
 //      :               :
 //      +-+-+-+-+-+-+-+-+
 void VerifyBasicHeader(RTPTypeHeader* type, bool N, bool S, int part_id) {
-  ASSERT_TRUE(type != NULL);
+  ASSERT_TRUE(type != nullptr);
   EXPECT_EQ(N, type->Video.codecHeader.VP8.nonReference);
   EXPECT_EQ(S, type->Video.codecHeader.VP8.beginningOfPartition);
   EXPECT_EQ(part_id, type->Video.codecHeader.VP8.partitionId);
 }
 
 void VerifyExtensions(RTPTypeHeader* type,
                       int16_t picture_id,   /* I */
                       int16_t tl0_pic_idx,  /* L */
                       uint8_t temporal_idx, /* T */
                       int key_idx /* K */) {
-  ASSERT_TRUE(type != NULL);
+  ASSERT_TRUE(type != nullptr);
   EXPECT_EQ(picture_id, type->Video.codecHeader.VP8.pictureId);
   EXPECT_EQ(tl0_pic_idx, type->Video.codecHeader.VP8.tl0PicIdx);
   EXPECT_EQ(temporal_idx, type->Video.codecHeader.VP8.temporalIdx);
   EXPECT_EQ(key_idx, type->Video.codecHeader.VP8.keyIdx);
 }
 }  // namespace
 
 class RtpPacketizerVp8Test : public ::testing::Test {
  protected:
-  RtpPacketizerVp8Test() : helper_(NULL) {}
+  RtpPacketizerVp8Test() : helper_(nullptr) {}
   virtual void TearDown() { delete helper_; }
   bool Init(const size_t* partition_sizes, size_t num_partitions) {
     hdr_info_.pictureId = kNoPictureId;
     hdr_info_.nonReference = false;
     hdr_info_.temporalIdx = kNoTemporalIdx;
     hdr_info_.layerSync = false;
     hdr_info_.tl0PicIdx = kNoTl0PicIdx;
     hdr_info_.keyIdx = kNoKeyIdx;
-    if (helper_ != NULL)
+    if (helper_ != nullptr)
       return false;
     helper_ = new test::RtpFormatVp8TestHelper(&hdr_info_);
     return helper_->Init(partition_sizes, num_partitions);
   }
 
   RTPVideoHeaderVP8 hdr_info_;
   test::RtpFormatVp8TestHelper* helper_;
 };
 
 TEST_F(RtpPacketizerVp8Test, TestStrictMode) {
@@ skipping 160 matching lines @@
 
 // Verify that EqualSize mode is forced if fragmentation info is missing.
 TEST_F(RtpPacketizerVp8Test, TestEqualSizeModeFallback) {
   const size_t kSizeVector[] = {10, 10, 10};
   const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.pictureId = 200;          // > 0x7F should produce 2-byte PictureID
   const size_t kMaxPayloadSize = 12;  // Small enough to produce 4 packets.
   RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize);
-  packetizer.SetPayloadData(
-      helper_->payload_data(), helper_->payload_size(), NULL);
+  packetizer.SetPayloadData(helper_->payload_data(), helper_->payload_size(),
+                            nullptr);
 
   // Expecting three full packets, and one with the remainder.
   const size_t kExpectedSizes[] = {12, 11, 12, 11};
   const int kExpectedPart[] = {0, 0, 0, 0};  // Always 0 for equal size mode.
   // Frag start only true for first packet in equal size mode.
   const bool kExpectedFragStart[] = {true, false, false, false};
   const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
 
   helper_->set_sloppy_partitioning(true);
   helper_->GetAllPacketsAndCheck(&packetizer,
                                  kExpectedSizes,
                                  kExpectedPart,
                                  kExpectedFragStart,
                                  kExpectedNum);
 }
 
 // Verify that non-reference bit is set. EqualSize mode fallback is expected.
 TEST_F(RtpPacketizerVp8Test, TestNonReferenceBit) {
   const size_t kSizeVector[] = {10, 10, 10};
   const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.nonReference = true;
   const size_t kMaxPayloadSize = 25;  // Small enough to produce two packets.
   RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize);
-  packetizer.SetPayloadData(
-      helper_->payload_data(), helper_->payload_size(), NULL);
+  packetizer.SetPayloadData(helper_->payload_data(), helper_->payload_size(),
+                            nullptr);
 
   // EqualSize mode => First packet full; other not.
   const size_t kExpectedSizes[] = {16, 16};
   const int kExpectedPart[] = {0, 0};  // Always 0 for equal size mode.
   // Frag start only true for first packet in equal size mode.
   const bool kExpectedFragStart[] = {true, false};
   const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
 
@@ skipping 96 matching lines @@
 }
 
 class RtpDepacketizerVp8Test : public ::testing::Test {
  protected:
   RtpDepacketizerVp8Test()
       : depacketizer_(RtpDepacketizer::Create(kRtpVideoVp8)) {}
 
   void ExpectPacket(RtpDepacketizer::ParsedPayload* parsed_payload,
                     const uint8_t* data,
                     size_t length) {
-    ASSERT_TRUE(parsed_payload != NULL);
+    ASSERT_TRUE(parsed_payload != nullptr);
     EXPECT_THAT(std::vector<uint8_t>(
                     parsed_payload->payload,
                     parsed_payload->payload + parsed_payload->payload_length),
                 ::testing::ElementsAreArray(data, length));
   }
 
   std::unique_ptr<RtpDepacketizer> depacketizer_;
 };
 
 TEST_F(RtpDepacketizerVp8Test, BasicHeader) {
@@ skipping 141 matching lines @@
   uint8_t data[10] = {0};
   RtpPacketToSend packet(kNoExtensions);
   RTPVideoHeaderVP8 input_header;
   input_header.nonReference = true;
   input_header.pictureId = 300;
   input_header.temporalIdx = 1;
   input_header.layerSync = false;
   input_header.tl0PicIdx = kNoTl0PicIdx;  // Disable.
   input_header.keyIdx = 31;
   RtpPacketizerVp8 packetizer(input_header, 20);
-  packetizer.SetPayloadData(data, 10, NULL);
+  packetizer.SetPayloadData(data, 10, nullptr);
   bool last;
   ASSERT_TRUE(packetizer.NextPacket(&packet, &last));
   EXPECT_TRUE(last);
   EXPECT_TRUE(packet.Marker());
 
   auto rtp_payload = packet.payload();
   RtpDepacketizer::ParsedPayload payload;
   ASSERT_TRUE(
       depacketizer_->Parse(&payload, rtp_payload.data(), rtp_payload.size()));
   auto vp8_payload = rtp_payload.subview(kHeaderLength);
@@ skipping 10 matching lines @@
             input_header.layerSync);
 }
 
 TEST_F(RtpDepacketizerVp8Test, TestEmptyPayload) {
   // Using a wild pointer to crash on accesses from inside the depacketizer.
   uint8_t* garbage_ptr = reinterpret_cast<uint8_t*>(0x4711);
   RtpDepacketizer::ParsedPayload payload;
   EXPECT_FALSE(depacketizer_->Parse(&payload, garbage_ptr, 0));
 }
 }  // namespace webrtc