Replace NULL with nullptr in all C++ files.

webrtc/modules/video_coding/jitter_buffer_unittest.cc

 /*
  *  Copyright (c) 2011 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 250 matching lines @@
     VCMEncodedFrame* found_frame = jitter_buffer_->NextCompleteFrame(10);
     if (!found_frame)
       return nullptr;
     return jitter_buffer_->ExtractAndSetDecode(found_frame->TimeStamp());
   }
 
   VCMEncodedFrame* DecodeIncompleteFrame() {
     uint32_t timestamp = 0;
     bool found_frame = jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp);
     if (!found_frame)
-      return NULL;
+      return nullptr;
     VCMEncodedFrame* frame = jitter_buffer_->ExtractAndSetDecode(timestamp);
     return frame;
   }
 
   void CheckOutFrame(VCMEncodedFrame* frame_out,
                      unsigned int size,
                      bool startCode) {
     ASSERT_TRUE(frame_out);
 
     const uint8_t* outData = frame_out->Buffer();
@@ skipping 129 matching lines @@
     clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
   }
 
   bool DecodeCompleteFrame() {
     VCMEncodedFrame* found_frame = jitter_buffer_->NextCompleteFrame(0);
     if (!found_frame)
       return false;
 
     VCMEncodedFrame* frame =
         jitter_buffer_->ExtractAndSetDecode(found_frame->TimeStamp());
-    bool ret = (frame != NULL);
+    bool ret = (frame != nullptr);
     jitter_buffer_->ReleaseFrame(frame);
     return ret;
   }
 
   bool DecodeIncompleteFrame() {
     uint32_t timestamp = 0;
     bool found_frame = jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp);
     if (!found_frame)
       return false;
     VCMEncodedFrame* frame = jitter_buffer_->ExtractAndSetDecode(timestamp);
-    bool ret = (frame != NULL);
+    bool ret = (frame != nullptr);
     jitter_buffer_->ReleaseFrame(frame);
     return ret;
   }
 
   VCMJitterBuffer* jitter_buffer_;
   StreamGenerator* stream_generator_;
   std::unique_ptr<SimulatedClock> clock_;
   NullEventFactory event_factory_;
   size_t max_nack_list_size_;
   int oldest_packet_to_nack_;
   uint8_t data_buffer_[kDataBufferSize];
 };
 
 class TestJitterBufferNack : public TestRunningJitterBuffer {
  protected:
   TestJitterBufferNack() {}
   virtual void SetUp() {
     TestRunningJitterBuffer::SetUp();
     jitter_buffer_->SetNackMode(kNack, -1, -1);
   }
 
   virtual void TearDown() { TestRunningJitterBuffer::TearDown(); }
 };
 
 TEST_F(TestBasicJitterBuffer, StopRunning) {
   jitter_buffer_->Stop();
-  EXPECT_TRUE(NULL == DecodeCompleteFrame());
-  EXPECT_TRUE(NULL == DecodeIncompleteFrame());
+  EXPECT_TRUE(nullptr == DecodeCompleteFrame());
+  EXPECT_TRUE(nullptr == DecodeIncompleteFrame());
   jitter_buffer_->Start();
   // Allow selective errors.
   jitter_buffer_->SetDecodeErrorMode(kSelectiveErrors);
 
   // No packets inserted.
-  EXPECT_TRUE(NULL == DecodeCompleteFrame());
-  EXPECT_TRUE(NULL == DecodeIncompleteFrame());
+  EXPECT_TRUE(nullptr == DecodeCompleteFrame());
+  EXPECT_TRUE(nullptr == DecodeIncompleteFrame());
 
   // Allow decoding with errors.
   jitter_buffer_->SetDecodeErrorMode(kWithErrors);
 
   // No packets inserted.
-  EXPECT_TRUE(NULL == DecodeCompleteFrame());
-  EXPECT_TRUE(NULL == DecodeIncompleteFrame());
+  EXPECT_TRUE(nullptr == DecodeCompleteFrame());
+  EXPECT_TRUE(nullptr == DecodeIncompleteFrame());
 }
 
 TEST_F(TestBasicJitterBuffer, SinglePacketFrame) {
   // Always start with a complete key frame when not allowing errors.
   jitter_buffer_->SetDecodeErrorMode(kNoErrors);
   packet_->frameType = kVideoFrameKey;
   packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->timestamp += 123 * 90;
 
@@ skipping 48 matching lines @@
 TEST_F(TestBasicJitterBuffer, DualPacketFrame) {
   packet_->frameType = kVideoFrameKey;
   packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   // Should not be complete.
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
 
   ++seq_num_;
   packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
   CheckOutFrame(frame_out, 2 * size_, false);
 
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
 TEST_F(TestBasicJitterBuffer, 100PacketKeyFrame) {
   packet_->frameType = kVideoFrameKey;
   packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
   // Frame should not be complete.
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
 
   // Insert 98 frames.
   int loop = 0;
   do {
     seq_num_++;
     packet_->is_first_packet_in_frame = false;
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
 
     EXPECT_EQ(kIncomplete,
@@ skipping 20 matching lines @@
 TEST_F(TestBasicJitterBuffer, 100PacketDeltaFrame) {
   // Always start with a complete key frame.
   packet_->frameType = kVideoFrameKey;
   packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
 
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
-  EXPECT_FALSE(frame_out == NULL);
+  EXPECT_FALSE(frame_out == nullptr);
   jitter_buffer_->ReleaseFrame(frame_out);
 
   ++seq_num_;
   packet_->seqNum = seq_num_;
   packet_->markerBit = false;
   packet_->frameType = kVideoFrameDelta;
   packet_->timestamp += 33 * 90;
 
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
 
   // Frame should not be complete.
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
 
   packet_->is_first_packet_in_frame = false;
   // Insert 98 frames.
   int loop = 0;
   do {
     ++seq_num_;
     packet_->seqNum = seq_num_;
 
     // Insert a packet into a frame.
     EXPECT_EQ(kIncomplete,
@@ skipping 25 matching lines @@
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
 
   // Insert 98 packets.
   int loop = 0;
   do {
     seq_num_--;
     packet_->is_first_packet_in_frame = false;
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
 
     EXPECT_EQ(kIncomplete,
@@ skipping 22 matching lines @@
   packet_->frameType = kVideoFrameDelta;
   packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
 
   seq_num_++;
   packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   // check that we fail to get frame since seqnum is not continuous
   frame_out = DecodeCompleteFrame();
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
 
   seq_num_ -= 3;
   timestamp_ -= 33 * 90;
   packet_->frameType = kVideoFrameKey;
   packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
 
   // It should not be complete.
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
 
   seq_num_++;
   packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
@@ skipping 10 matching lines @@
 TEST_F(TestBasicJitterBuffer, TestReorderingWithPadding) {
   packet_->frameType = kVideoFrameKey;
   packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
 
   // Send in an initial good packet/frame (Frame A) to start things off.
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
-  EXPECT_TRUE(frame_out != NULL);
+  EXPECT_TRUE(frame_out != nullptr);
   jitter_buffer_->ReleaseFrame(frame_out);
 
   // Now send in a complete delta frame (Frame C), but with a sequence number
   // gap. No pic index either, so no temporal scalability cheating :)
   packet_->frameType = kVideoFrameDelta;
   // Leave a gap of 2 sequence numbers and two frames.
   packet_->seqNum = seq_num_ + 3;
   packet_->timestamp = timestamp_ + (66 * 90);
   // Still isFirst = marker = true.
   // Session should be complete (frame is complete), but there's nothing to
   // decode yet.
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   frame_out = DecodeCompleteFrame();
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
 
   // Now send in a complete delta frame (Frame B) that is continuous from A, but
   // doesn't fill the full gap to C. The rest of the gap is going to be padding.
   packet_->seqNum = seq_num_ + 1;
   packet_->timestamp = timestamp_ + (33 * 90);
   // Still isFirst = marker = true.
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   frame_out = DecodeCompleteFrame();
-  EXPECT_TRUE(frame_out != NULL);
+  EXPECT_TRUE(frame_out != nullptr);
   jitter_buffer_->ReleaseFrame(frame_out);
 
   // But Frame C isn't continuous yet.
   frame_out = DecodeCompleteFrame();
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
 
   // Add in the padding. These are empty packets (data length is 0) with no
   // marker bit and matching the timestamp of Frame B.
   WebRtcRTPHeader rtpHeader;
   memset(&rtpHeader, 0, sizeof(rtpHeader));
   rtpHeader.header.sequenceNumber = seq_num_ + 2;
   rtpHeader.header.timestamp = timestamp_ + (33 * 90);
   rtpHeader.header.markerBit = false;
   VCMPacket empty_packet(data_, 0, rtpHeader);
   EXPECT_EQ(kOldPacket,
             jitter_buffer_->InsertPacket(empty_packet, &retransmitted));
   empty_packet.seqNum += 1;
   EXPECT_EQ(kOldPacket,
             jitter_buffer_->InsertPacket(empty_packet, &retransmitted));
 
   // But now Frame C should be ready!
   frame_out = DecodeCompleteFrame();
-  EXPECT_TRUE(frame_out != NULL);
+  EXPECT_TRUE(frame_out != nullptr);
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
 TEST_F(TestBasicJitterBuffer, DuplicatePackets) {
   packet_->frameType = kVideoFrameKey;
   packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   EXPECT_EQ(0, jitter_buffer_->num_packets());
   EXPECT_EQ(0, jitter_buffer_->num_duplicated_packets());
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
   EXPECT_EQ(1, jitter_buffer_->num_packets());
   EXPECT_EQ(0, jitter_buffer_->num_duplicated_packets());
 
   // Insert a packet into a frame.
   EXPECT_EQ(kDuplicatePacket,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   EXPECT_EQ(2, jitter_buffer_->num_packets());
   EXPECT_EQ(1, jitter_buffer_->num_duplicated_packets());
 
   seq_num_++;
   packet_->seqNum = seq_num_;
   packet_->markerBit = true;
   packet_->is_first_packet_in_frame = false;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
-  ASSERT_TRUE(frame_out != NULL);
+  ASSERT_TRUE(frame_out != nullptr);
   CheckOutFrame(frame_out, 2 * size_, false);
 
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   EXPECT_EQ(3, jitter_buffer_->num_packets());
   EXPECT_EQ(1, jitter_buffer_->num_duplicated_packets());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
 TEST_F(TestBasicJitterBuffer, DuplicatePreviousDeltaFramePacket) {
   packet_->frameType = kVideoFrameKey;
   packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   jitter_buffer_->SetDecodeErrorMode(kNoErrors);
   EXPECT_EQ(0, jitter_buffer_->num_packets());
   EXPECT_EQ(0, jitter_buffer_->num_duplicated_packets());
 
   bool retransmitted = false;
   // Insert first complete frame.
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
-  ASSERT_TRUE(frame_out != NULL);
+  ASSERT_TRUE(frame_out != nullptr);
   CheckOutFrame(frame_out, size_, false);
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 
   // Insert 3 delta frames.
   for (uint16_t i = 1; i <= 3; ++i) {
     packet_->seqNum = seq_num_ + i;
     packet_->timestamp = timestamp_ + (i * 33) * 90;
     packet_->frameType = kVideoFrameDelta;
     EXPECT_EQ(kCompleteSession,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
     EXPECT_EQ(i + 1, jitter_buffer_->num_packets());
     EXPECT_EQ(0, jitter_buffer_->num_duplicated_packets());
   }
 
   // Retransmit second delta frame.
   packet_->seqNum = seq_num_ + 2;
   packet_->timestamp = timestamp_ + 66 * 90;
 
   EXPECT_EQ(kDuplicatePacket,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   EXPECT_EQ(5, jitter_buffer_->num_packets());
   EXPECT_EQ(1, jitter_buffer_->num_duplicated_packets());
 
   // Should be able to decode 3 delta frames, key frame already decoded.
   for (size_t i = 0; i < 3; ++i) {
     frame_out = DecodeCompleteFrame();
-    ASSERT_TRUE(frame_out != NULL);
+    ASSERT_TRUE(frame_out != nullptr);
     CheckOutFrame(frame_out, size_, false);
     EXPECT_EQ(kVideoFrameDelta, frame_out->FrameType());
     jitter_buffer_->ReleaseFrame(frame_out);
   }
 }
 
 TEST_F(TestBasicJitterBuffer, TestSkipForwardVp9) {
   // Verify that JB skips forward to next base layer frame.
   //  -------------------------------------------------
   // | 65485 | 65486 | 65487 | 65488 | 65489 | ...
@@ skipping 212 matching lines @@
   packet_->timestamp = timestamp_;
   packet_->insertStartCode = true;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
   // Frame should not be complete.
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
 
   seq_num_++;
   packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
@@ skipping 154 matching lines @@
     EXPECT_TRUE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
   }
 
   packet_->seqNum++;
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_TRUE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   frame_out = DecodeIncompleteFrame();
-  ASSERT_FALSE(NULL == frame_out);
+  ASSERT_FALSE(nullptr == frame_out);
   CheckOutFrame(frame_out, 9 * size_, false);
   EXPECT_EQ(kVideoFrameDelta, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 
   packet_->markerBit = true;
   packet_->seqNum++;
   EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 }
 
 // Make sure first packet is present before a frame can be decoded.
@@ skipping 132 matching lines @@
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   uint32_t next_timestamp;
   VCMEncodedFrame* frame = jitter_buffer_->NextCompleteFrame(0);
   EXPECT_NE(frame, nullptr);
   EXPECT_EQ(packet_->timestamp, frame->TimeStamp());
   frame = jitter_buffer_->ExtractAndSetDecode(frame->TimeStamp());
-  EXPECT_TRUE(frame != NULL);
+  EXPECT_TRUE(frame != nullptr);
   jitter_buffer_->ReleaseFrame(frame);
 
   // Drop a complete frame.
   timestamp_ += 2 * 33 * 90;
   seq_num_ += 2;
   packet_->frameType = kVideoFrameDelta;
   packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
@@ skipping 45 matching lines @@
     packet_->seqNum = seq_num_;
     packet_->timestamp = timestamp_;
     packet_->completeNALU = kNaluStart;
 
     EXPECT_EQ(kDecodableSession,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
     VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
     // Should not be complete.
-    EXPECT_TRUE(frame_out == NULL);
+    EXPECT_TRUE(frame_out == nullptr);
 
     seq_num_ += 2;
     packet_->is_first_packet_in_frame = false;
     packet_->markerBit = true;
     packet_->seqNum = seq_num_;
     packet_->completeNALU = kNaluEnd;
 
     EXPECT_EQ(jitter_buffer_->InsertPacket(*packet_, &retransmitted),
               kDecodableSession);
 
@@ skipping 56 matching lines @@
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
 
   int loop = 0;
   do {
     seq_num_++;
     packet_->is_first_packet_in_frame = false;
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
 
     EXPECT_EQ(kIncomplete,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
     frame_out = DecodeCompleteFrame();
 
-    EXPECT_TRUE(frame_out == NULL);
+    EXPECT_TRUE(frame_out == nullptr);
 
     loop++;
   } while (loop < 98);
 
   seq_num_++;
   packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   EXPECT_EQ(kCompleteSession,
@@ skipping 14 matching lines @@
   packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
 
   // Should not be complete.
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
 
   // Insert 98 frames.
   int loop = 0;
   do {
     seq_num_--;
     packet_->is_first_packet_in_frame = false;
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
 
     EXPECT_EQ(kIncomplete,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
     frame_out = DecodeCompleteFrame();
 
-    EXPECT_TRUE(frame_out == NULL);
+    EXPECT_TRUE(frame_out == nullptr);
 
     loop++;
   } while (loop < 98);
 
   // Insert last packet.
   seq_num_--;
   packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
 
@@ skipping 90 matching lines @@
   packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
 
   seq_num_++;
   packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
   CheckOutFrame(frame_out, 2 * size_, false);
   jitter_buffer_->ReleaseFrame(frame_out);
 
   seq_num_++;
   timestamp_ += 33 * 90;
   packet_->frameType = kVideoFrameDelta;
   packet_->is_first_packet_in_frame = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
 
   seq_num_++;
   packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeCompleteFrame();
@@ skipping 112 matching lines @@
 
   // Max number of packets inserted.
   // Insert one more packet.
   seq_num_++;
   packet_->is_first_packet_in_frame = false;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
 
   // Insert the packet -> frame recycled.
   EXPECT_EQ(kSizeError, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
-  EXPECT_TRUE(NULL == DecodeCompleteFrame());
+  EXPECT_TRUE(nullptr == DecodeCompleteFrame());
 }
 
 TEST_F(TestBasicJitterBuffer, ExceedNumOfFrameWithSeqNumWrap) {
   // TEST fill JB with more than max number of frame (50 delta frames +
   // 51 key frames) with wrap in seq_num_
   //
   //  --------------------------------------------------------------
   // | 65485 | 65486 | 65487 | .... | 65535 | 0 | 1 | 2 | .....| 50 |
   //  --------------------------------------------------------------
   // |<-----------delta frames------------->|<------key frames----->|
@@ skipping 61 matching lines @@
     seq_num_++;
     packet_->is_first_packet_in_frame = false;
     packet_->markerBit = false;
     packet_->seqNum = seq_num_;
     packet_->timestamp = timestamp_;
     packet_->frameType = kEmptyFrame;
 
     EXPECT_EQ(kNoError, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
     VCMEncodedFrame* testFrame = DecodeIncompleteFrame();
     // Timestamp should never be the last TS inserted.
-    if (testFrame != NULL) {
+    if (testFrame != nullptr) {
       EXPECT_TRUE(testFrame->TimeStamp() < timestamp_);
       jitter_buffer_->ReleaseFrame(testFrame);
     }
   }
 }
 
 TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
   jitter_buffer_->SetNackMode(kNoNack, -1, -1);
   jitter_buffer_->SetDecodeErrorMode(kWithErrors);
   ++seq_num_;
@@ skipping 136 matching lines @@
   emptypacket.completeNALU = kNaluComplete;
   emptypacket.markerBit = true;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(emptypacket, &retransmitted));
   // This packet should not be decoded because it is an incomplete NAL if it
   // is the last.
 
   // Will be sent to the decoder, as a packet belonging to a subsequent frame
   // has arrived.
   frame_out = DecodeIncompleteFrame();
-  EXPECT_TRUE(frame_out != NULL);
+  EXPECT_TRUE(frame_out != nullptr);
   jitter_buffer_->ReleaseFrame(frame_out);
 
   // Test that a frame can include an empty packet.
   seq_num_++;
   timestamp_ += 33 * 90;
 
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   packet_->frameType = kVideoFrameKey;
   packet_->is_first_packet_in_frame = true;
@@ skipping 26 matching lines @@
   jitter_buffer_->SetDecodeErrorMode(kWithErrors);
   // Start with a complete key frame - insert and decode.
   packet_->frameType = kVideoFrameKey;
   packet_->is_first_packet_in_frame = true;
   packet_->markerBit = true;
   bool retransmitted = false;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
-  EXPECT_TRUE(frame_out != NULL);
+  EXPECT_TRUE(frame_out != nullptr);
   jitter_buffer_->ReleaseFrame(frame_out);
 
   packet_->seqNum += 2;
   packet_->timestamp += 33 * 90;
   packet_->frameType = kVideoFrameDelta;
   packet_->is_first_packet_in_frame = false;
   packet_->markerBit = false;
 
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeIncompleteFrame();
-  EXPECT_TRUE(frame_out == NULL);
+  EXPECT_TRUE(frame_out == nullptr);
 
   packet_->seqNum += 2;
   packet_->timestamp += 33 * 90;
   packet_->is_first_packet_in_frame = true;
 
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
 
   frame_out = DecodeIncompleteFrame();
   CheckOutFrame(frame_out, packet_->sizeBytes, false);
@@ skipping 239 matching lines @@
   // No list generated, and a key frame request is signaled.
   EXPECT_EQ(0u, nack_list.size());
   EXPECT_TRUE(request_key_frame);
 }
 
 TEST_F(TestJitterBufferNack, NackListBuiltBeforeFirstDecode) {
   stream_generator_->Init(0, clock_->TimeInMilliseconds());
   InsertFrame(kVideoFrameKey);
   stream_generator_->GenerateFrame(kVideoFrameDelta, 2, 0,
                                    clock_->TimeInMilliseconds());
-  stream_generator_->NextPacket(NULL);  // Drop packet.
+  stream_generator_->NextPacket(nullptr);  // Drop packet.
   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
   EXPECT_TRUE(DecodeCompleteFrame());
   bool extended = false;
   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
   EXPECT_EQ(1u, nack_list.size());
 }
 
 TEST_F(TestJitterBufferNack, VerifyRetransmittedFlag) {
   stream_generator_->Init(0, clock_->TimeInMilliseconds());
   stream_generator_->GenerateFrame(kVideoFrameKey, 3, 0,
@@ skipping 78 matching lines @@
   stream_generator_->GenerateFrame(kVideoFrameKey, 100, 0,
                                    clock_->TimeInMilliseconds());
   clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
   EXPECT_EQ(kDecodableSession, InsertPacketAndPop(0));
   // Verify that the frame is incomplete.
   EXPECT_FALSE(DecodeCompleteFrame());
   while (stream_generator_->PacketsRemaining() > 1) {
     if (stream_generator_->NextSequenceNumber() % 10 != 0) {
       EXPECT_EQ(kDecodableSession, InsertPacketAndPop(0));
     } else {
-      stream_generator_->NextPacket(NULL);  // Drop packet
+      stream_generator_->NextPacket(nullptr);  // Drop packet
     }
   }
   EXPECT_EQ(kDecodableSession, InsertPacketAndPop(0));
   EXPECT_EQ(0, stream_generator_->PacketsRemaining());
   EXPECT_FALSE(DecodeCompleteFrame());
   EXPECT_FALSE(DecodeIncompleteFrame());
   bool request_key_frame = false;
 
   // Verify the NACK list.
   std::vector<uint16_t> nack_list =
@@ skipping 14 matching lines @@
   EXPECT_FALSE(request_key_frame);
   EXPECT_TRUE(DecodeCompleteFrame());
   stream_generator_->GenerateFrame(kVideoFrameDelta, 100, 0,
                                    clock_->TimeInMilliseconds());
   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
   while (stream_generator_->PacketsRemaining() > 1) {
     if (stream_generator_->NextSequenceNumber() % 10 != 0) {
       EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
       EXPECT_FALSE(request_key_frame);
     } else {
-      stream_generator_->NextPacket(NULL);  // Drop packet
+      stream_generator_->NextPacket(nullptr);  // Drop packet
     }
   }
   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
   EXPECT_FALSE(request_key_frame);
   EXPECT_EQ(0, stream_generator_->PacketsRemaining());
   EXPECT_FALSE(DecodeCompleteFrame());
   EXPECT_FALSE(DecodeCompleteFrame());
   bool extended = false;
   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
   // Verify the NACK list.
@@ skipping 13 matching lines @@
   EXPECT_FALSE(request_key_frame);
   EXPECT_TRUE(DecodeCompleteFrame());
   stream_generator_->GenerateFrame(kVideoFrameDelta, 1, 0,
                                    clock_->TimeInMilliseconds());
   clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
   for (int i = 0; i < 5; ++i) {
     if (stream_generator_->NextSequenceNumber() != 65535) {
       EXPECT_EQ(kCompleteSession, InsertPacketAndPop(0));
       EXPECT_FALSE(request_key_frame);
     } else {
-      stream_generator_->NextPacket(NULL);  // Drop packet
+      stream_generator_->NextPacket(nullptr);  // Drop packet
     }
     stream_generator_->GenerateFrame(kVideoFrameDelta, 1, 0,
                                      clock_->TimeInMilliseconds());
     clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
   }
   EXPECT_EQ(kCompleteSession, InsertPacketAndPop(0));
   EXPECT_FALSE(request_key_frame);
   bool extended = false;
   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
   // Verify the NACK list.
@@ skipping 20 matching lines @@
   EXPECT_EQ(0u, nack_list.size());
 
   // Stream should be decodable from this point.
   clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
   InsertFrame(kVideoFrameDelta);
   EXPECT_TRUE(DecodeCompleteFrame());
   nack_list = jitter_buffer_->GetNackList(&extended);
   EXPECT_EQ(0u, nack_list.size());
 }
 }  // namespace webrtc