QUIC - (no behavior change) s/NULL/nullptr/g in .../quic/...

net/quic/quic_unacked_packet_map_test.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_unacked_packet_map.h"
 
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::min;
 
 namespace net {
 namespace test {
 namespace {
 
 // Default packet length.
 const uint32 kDefaultAckLength = 50;
 const uint32 kDefaultLength = 1000;
 
 class QuicUnackedPacketMapTest : public ::testing::Test {
  protected:
   QuicUnackedPacketMapTest()
       : now_(QuicTime::Zero().Add(QuicTime::Delta::FromMilliseconds(1000))) {
   }
 
   SerializedPacket CreateRetransmittablePacket(
       QuicPacketSequenceNumber sequence_number) {
-    return SerializedPacket(sequence_number, PACKET_1BYTE_SEQUENCE_NUMBER, NULL,
-                            0, new RetransmittableFrames());
+    return SerializedPacket(sequence_number, PACKET_1BYTE_SEQUENCE_NUMBER,
+                            nullptr, 0, new RetransmittableFrames());
   }
 
   SerializedPacket CreateNonRetransmittablePacket(
       QuicPacketSequenceNumber sequence_number) {
-    return SerializedPacket(
-        sequence_number, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL);
+    return SerializedPacket(sequence_number, PACKET_1BYTE_SEQUENCE_NUMBER,
+                            nullptr, 0, nullptr);
   }
 
   void VerifyInFlightPackets(QuicPacketSequenceNumber* packets,
                              size_t num_packets) {
     unacked_packets_.RemoveObsoletePackets();
     if (num_packets == 0) {
       EXPECT_FALSE(unacked_packets_.HasInFlightPackets());
       EXPECT_FALSE(unacked_packets_.HasMultipleInFlightPackets());
       return;
     }
@@ skipping 31 matching lines @@
     }
     EXPECT_EQ(num_packets, unacked_packets_.GetNumUnackedPacketsDebugOnly());
   }
 
   void VerifyRetransmittablePackets(QuicPacketSequenceNumber* packets,
                                     size_t num_packets) {
     unacked_packets_.RemoveObsoletePackets();
     size_t num_retransmittable_packets = 0;
     for (QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
          it != unacked_packets_.end(); ++it) {
-      if (it->retransmittable_frames != NULL) {
+      if (it->retransmittable_frames != nullptr) {
         ++num_retransmittable_packets;
       }
     }
     EXPECT_EQ(num_packets, num_retransmittable_packets);
     for (size_t i = 0; i < num_packets; ++i) {
       EXPECT_TRUE(unacked_packets_.HasRetransmittableFrames(packets[i]))
           << " packets[" << i << "]:" << packets[i];
     }
   }
 
   QuicUnackedPacketMap unacked_packets_;
   QuicTime now_;
 };
 
 TEST_F(QuicUnackedPacketMapTest, RttOnly) {
   // Acks are only tracked for RTT measurement purposes.
   unacked_packets_.AddPacket(CreateNonRetransmittablePacket(1));
   unacked_packets_.SetSent(1, now_, kDefaultAckLength, false);
 
   QuicPacketSequenceNumber unacked[] = { 1 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
-  VerifyInFlightPackets(NULL, 0);
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyInFlightPackets(nullptr, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 
   unacked_packets_.IncreaseLargestObserved(1);
-  VerifyUnackedPackets(NULL, 0);
-  VerifyInFlightPackets(NULL, 0);
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyUnackedPackets(nullptr, 0);
+  VerifyInFlightPackets(nullptr, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 }
 
 TEST_F(QuicUnackedPacketMapTest, DiscardOldRttOnly) {
   // Acks are only tracked for RTT measurement purposes, and are discarded
   // when more than 200 accumulate.
   const size_t kNumUnackedPackets = 200;
   for (size_t i = 1; i < 400; ++i) {
     unacked_packets_.AddPacket(CreateNonRetransmittablePacket(i));
     unacked_packets_.SetSent(i, now_, kDefaultAckLength, false);
     unacked_packets_.RemoveObsoletePackets();
     EXPECT_EQ(min(i, kNumUnackedPackets),
               unacked_packets_.GetNumUnackedPacketsDebugOnly());
   }
 }
 
 TEST_F(QuicUnackedPacketMapTest, RetransmittableInflightAndRtt) {
   // Simulate a retransmittable packet being sent and acked.
   unacked_packets_.AddPacket(CreateRetransmittablePacket(1));
   unacked_packets_.SetSent(1, now_, kDefaultLength, true);
 
   QuicPacketSequenceNumber unacked[] = { 1 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyInFlightPackets(unacked, arraysize(unacked));
   VerifyRetransmittablePackets(unacked, arraysize(unacked));
 
   unacked_packets_.RemoveRetransmittability(1);
   VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyInFlightPackets(unacked, arraysize(unacked));
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 
   unacked_packets_.IncreaseLargestObserved(1);
   VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyInFlightPackets(unacked, arraysize(unacked));
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 
   unacked_packets_.RemoveFromInFlight(1);
-  VerifyUnackedPackets(NULL, 0);
-  VerifyInFlightPackets(NULL, 0);
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyUnackedPackets(nullptr, 0);
+  VerifyInFlightPackets(nullptr, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 }
 
 TEST_F(QuicUnackedPacketMapTest, RetransmittedPacket) {
   // Simulate a retransmittable packet being sent, retransmitted, and the first
   // transmission being acked.
   unacked_packets_.AddPacket(CreateRetransmittablePacket(1));
   unacked_packets_.SetSent(1, now_, kDefaultLength, true);
   unacked_packets_.OnRetransmittedPacket(1, 2, LOSS_RETRANSMISSION);
   unacked_packets_.SetSent(2, now_, kDefaultLength, true);
 
   QuicPacketSequenceNumber unacked[] = { 1, 2 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyInFlightPackets(unacked, arraysize(unacked));
   QuicPacketSequenceNumber retransmittable[] = { 2 };
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 
   unacked_packets_.RemoveRetransmittability(1);
   VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyInFlightPackets(unacked, arraysize(unacked));
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 
   unacked_packets_.IncreaseLargestObserved(2);
   VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyInFlightPackets(unacked, arraysize(unacked));
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 
   unacked_packets_.RemoveFromInFlight(2);
   QuicPacketSequenceNumber unacked2[] = { 1 };
   VerifyUnackedPackets(unacked, arraysize(unacked2));
   VerifyInFlightPackets(unacked, arraysize(unacked2));
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 
   unacked_packets_.RemoveFromInFlight(1);
-  VerifyUnackedPackets(NULL, 0);
-  VerifyInFlightPackets(NULL, 0);
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyUnackedPackets(nullptr, 0);
+  VerifyInFlightPackets(nullptr, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 }
 
 TEST_F(QuicUnackedPacketMapTest, RetransmitThreeTimes) {
   // Simulate a retransmittable packet being sent and retransmitted twice.
   unacked_packets_.AddPacket(CreateRetransmittablePacket(1));
   unacked_packets_.SetSent(1, now_, kDefaultLength, true);
   unacked_packets_.AddPacket(CreateRetransmittablePacket(2));
   unacked_packets_.SetSent(2, now_, kDefaultLength, true);
 
   QuicPacketSequenceNumber unacked[] = { 1, 2 };
@@ skipping 161 matching lines @@
   EXPECT_TRUE(unacked_packets_.IsUnacked(3));
   EXPECT_FALSE(unacked_packets_.IsUnacked(4));
   EXPECT_TRUE(unacked_packets_.IsUnacked(5));
   EXPECT_EQ(5u, unacked_packets_.largest_sent_packet());
 }
 
 
 }  // namespace
 }  // namespace test
 }  // namespace net