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

net/quic/quic_sent_packet_manager_test.cc

 // Copyright 2013 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_sent_packet_manager.h"
 
 #include "base/stl_util.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/test_tools/quic_config_peer.h"
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
@@ skipping 163 matching lines @@
         &manager_, new_sequence_number));
   }
 
   SerializedPacket CreateDataPacket(QuicPacketSequenceNumber sequence_number) {
     return CreatePacket(sequence_number, true);
   }
 
   SerializedPacket CreatePacket(QuicPacketSequenceNumber sequence_number,
                                 bool retransmittable) {
     packets_.push_back(QuicPacket::NewDataPacket(
-        NULL, kDefaultLength, false, PACKET_8BYTE_CONNECTION_ID, false,
+        nullptr, kDefaultLength, false, PACKET_8BYTE_CONNECTION_ID, false,
         PACKET_6BYTE_SEQUENCE_NUMBER));
     return SerializedPacket(
-        sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER,
-        packets_.back(), 0u,
-        retransmittable ? new RetransmittableFrames() : NULL);
+        sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER, packets_.back(), 0u,
+        retransmittable ? new RetransmittableFrames() : nullptr);
   }
 
   SerializedPacket CreateFecPacket(QuicPacketSequenceNumber sequence_number) {
     packets_.push_back(QuicPacket::NewFecPacket(
-        NULL, kDefaultLength, false, PACKET_8BYTE_CONNECTION_ID, false,
+        nullptr, kDefaultLength, false, PACKET_8BYTE_CONNECTION_ID, false,
         PACKET_6BYTE_SEQUENCE_NUMBER));
     return SerializedPacket(sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER,
-                            packets_.back(), 0u, NULL);
+                            packets_.back(), 0u, nullptr);
   }
 
   void SendDataPacket(QuicPacketSequenceNumber sequence_number) {
     EXPECT_CALL(*send_algorithm_,
                 OnPacketSent(_, BytesInFlight(), sequence_number, _, _))
                     .Times(1).WillOnce(Return(true));
     SerializedPacket packet(CreateDataPacket(sequence_number));
     manager_.OnPacketSent(&packet, 0, clock_.Now(),
                           packet.packet->length(), NOT_RETRANSMISSION,
                           HAS_RETRANSMITTABLE_DATA);
@@ skipping 54 matching lines @@
 
   QuicSentPacketManager manager_;
   vector<QuicPacket*> packets_;
   MockClock clock_;
   QuicConnectionStats stats_;
   MockSendAlgorithm* send_algorithm_;
   scoped_ptr<MockNetworkChangeVisitor> network_change_visitor_;
 };
 
 TEST_F(QuicSentPacketManagerTest, IsUnacked) {
-  VerifyUnackedPackets(NULL, 0);
+  VerifyUnackedPackets(nullptr, 0);
   SendDataPacket(1);
 
   QuicPacketSequenceNumber unacked[] = { 1 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   QuicPacketSequenceNumber retransmittable[] = { 1 };
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 }
 
 TEST_F(QuicSentPacketManagerTest, IsUnAckedRetransmit) {
   SendDataPacket(1);
@@ skipping 14 matching lines @@
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 2;
   ack_frame.missing_packets.insert(1);
   ExpectAck(2);
   manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   // Packet 1 is unacked, pending, but not retransmittable.
   QuicPacketSequenceNumber unacked[] = { 1 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckBeforeSend) {
   SendDataPacket(1);
   QuicSentPacketManagerPeer::MarkForRetransmission(
       &manager_, 1, TLP_RETRANSMISSION);
   EXPECT_TRUE(manager_.HasPendingRetransmissions());
 
   // Ack 1.
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 1;
   ExpectAck(1);
   manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   // There should no longer be a pending retransmission.
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // No unacked packets remain.
-  VerifyUnackedPackets(NULL, 0);
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyUnackedPackets(nullptr, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
   EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted);
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPrevious) {
   SendDataPacket(1);
   RetransmitAndSendPacket(1, 2);
   QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
   clock_.AdvanceTime(rtt);
 
   // Ack 1 but not 2.
   ExpectAck(1);
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 1;
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   // 2 remains unacked, but no packets have retransmittable data.
   QuicPacketSequenceNumber unacked[] = { 2 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 
   EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted);
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPreviousThenNackRetransmit) {
   SendDataPacket(1);
   RetransmitAndSendPacket(1, 2);
   QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
   clock_.AdvanceTime(rtt);
 
@@ skipping 16 matching lines @@
 
   ack_frame.largest_observed = 4;
   ExpectAck(4);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   ack_frame.largest_observed = 5;
   ExpectAckAndLoss(true, 5, 2);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   // No packets remain unacked.
-  VerifyUnackedPackets(NULL, 0);
+  VerifyUnackedPackets(nullptr, 0);
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 
   // Verify that the retransmission alarm would not fire,
   // since there is no retransmittable data outstanding.
   EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckPreviousBeforeSend) {
   SendDataPacket(1);
   RetransmitAndSendPacket(1, 2);
 
@@ skipping 11 matching lines @@
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 1;
   ExpectUpdatedRtt(1);
   EXPECT_CALL(*send_algorithm_, RevertRetransmissionTimeout());
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   // Since 2 was marked for retransmit, when 1 is acked, 2 is kept for RTT.
   QuicPacketSequenceNumber unacked[] = { 2 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 
   // Verify that the retransmission alarm would not fire,
   // since there is no retransmittable data outstanding.
   EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckFirst) {
   StrictMock<MockDebugDelegate> debug_delegate;
   EXPECT_CALL(debug_delegate, OnSpuriousPacketRetransmition(
       TLP_RETRANSMISSION, kDefaultLength)).Times(2);
   manager_.set_debug_delegate(&debug_delegate);
 
   SendDataPacket(1);
   RetransmitAndSendPacket(1, 2);
   RetransmitAndSendPacket(2, 3);
   QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
   clock_.AdvanceTime(rtt);
 
   // Ack 1 but not 2 or 3.
   ExpectAck(1);
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 1;
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   // 2 and 3 remain unacked, but no packets have retransmittable data.
   QuicPacketSequenceNumber unacked[] = { 2, 3 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 
   // Ensure packet 2 is lost when 4 is sent and 3 and 4 are acked.
   SendDataPacket(4);
   ack_frame.largest_observed = 4;
   ack_frame.missing_packets.insert(2);
   QuicPacketSequenceNumber acked[] = { 3, 4 };
-  ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0);
+  ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   QuicPacketSequenceNumber unacked2[] = { 2 };
   VerifyUnackedPackets(unacked2, arraysize(unacked2));
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
 
   SendDataPacket(5);
   ack_frame.largest_observed = 5;
   ExpectAckAndLoss(true, 5, 2);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
-  VerifyUnackedPackets(NULL, 0);
+  VerifyUnackedPackets(nullptr, 0);
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   EXPECT_EQ(2u, stats_.packets_spuriously_retransmitted);
 }
 
 TEST_F(QuicSentPacketManagerTest, LoseButDontRetransmitRevivedPacket) {
   SendDataPacket(1);
   SendDataPacket(2);
   SendFecPacket(3);
   SendDataPacket(4);
 
   // Ack 2 and 3, and mark 1 as revived.
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 3;
   ack_frame.missing_packets.insert(1);
   ack_frame.revived_packets.insert(1);
   QuicPacketSequenceNumber acked[] = { 2, 3 };
-  ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0);
+  ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
   QuicPacketSequenceNumber unacked[] = { 1, 4 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   QuicPacketSequenceNumber retransmittable[] = { 4 };
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 
   // Ack the 4th packet and expect the 1st to be considered lost.
   ack_frame.largest_observed = 4;
   ExpectAckAndLoss(true, 4, 1);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 }
 
 TEST_F(QuicSentPacketManagerTest, MarkLostThenReviveAndDontRetransmitPacket) {
   SendDataPacket(1);
   SendDataPacket(2);
   SendDataPacket(3);
   SendDataPacket(4);
   SendFecPacket(5);
 
   // Ack 2, 3, and 4, and expect the 1st to be considered lost.
@@ skipping 12 matching lines @@
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 
   // Ack 5th packet (FEC) and revive 1st packet. 1st packet should now be
   // removed from pending retransmissions map.
   ack_frame.largest_observed = 5;
   ack_frame.revived_packets.insert(1);
   ExpectAck(5);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 }
 
 TEST_F(QuicSentPacketManagerTest, TruncatedAck) {
   SendDataPacket(1);
   RetransmitAndSendPacket(1, 2);
   RetransmitAndSendPacket(2, 3);
   RetransmitAndSendPacket(3, 4);
   RetransmitAndSendPacket(4, 5);
 
   // Truncated ack with 4 NACKs, so the first packet is lost.
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 4;
   ack_frame.missing_packets.insert(1);
   ack_frame.missing_packets.insert(2);
   ack_frame.missing_packets.insert(3);
   ack_frame.missing_packets.insert(4);
   ack_frame.is_truncated = true;
 
   QuicPacketSequenceNumber lost[] = { 1 };
-  ExpectAcksAndLosses(true, NULL, 0, lost, arraysize(lost));
+  ExpectAcksAndLosses(true, nullptr, 0, lost, arraysize(lost));
   manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   // High water mark will be raised.
   QuicPacketSequenceNumber unacked[] = { 2, 3, 4, 5 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   QuicPacketSequenceNumber retransmittable[] = { 5 };
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 }
 
 TEST_F(QuicSentPacketManagerTest, AckPreviousTransmissionThenTruncatedAck) {
@@ skipping 45 matching lines @@
   SendDataPacket(1);
   EXPECT_EQ(1u, manager_.GetLeastUnacked());
 }
 
 TEST_F(QuicSentPacketManagerTest, GetLeastUnackedUnackedFec) {
   SendFecPacket(1);
   EXPECT_EQ(1u, manager_.GetLeastUnacked());
 }
 
 TEST_F(QuicSentPacketManagerTest, GetLeastUnackedAndDiscard) {
-  VerifyUnackedPackets(NULL, 0);
+  VerifyUnackedPackets(nullptr, 0);
 
   SendFecPacket(1);
   EXPECT_EQ(1u, manager_.GetLeastUnacked());
 
   SendFecPacket(2);
   EXPECT_EQ(1u, manager_.GetLeastUnacked());
 
   SendFecPacket(3);
   EXPECT_EQ(1u, manager_.GetLeastUnacked());
 
   QuicPacketSequenceNumber unacked[] = { 1, 2, 3 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 
   // Ack 2, so there's an rtt update.
   ExpectAck(2);
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 2;
   ack_frame.missing_packets.insert(1);
   manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   EXPECT_EQ(1u, manager_.GetLeastUnacked());
 }
 
 TEST_F(QuicSentPacketManagerTest, GetSentTime) {
-  VerifyUnackedPackets(NULL, 0);
+  VerifyUnackedPackets(nullptr, 0);
 
   QuicTime sent_time = clock_.Now();
   SendFecPacket(1);
   QuicTime sent_time2 = clock_.Now();
   SendFecPacket(2);
   QuicPacketSequenceNumber unacked[] = { 1, 2 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 
   EXPECT_TRUE(manager_.HasUnackedPackets());
   EXPECT_EQ(sent_time, QuicSentPacketManagerPeer::GetSentTime(&manager_, 1));
   EXPECT_EQ(sent_time2, QuicSentPacketManagerPeer::GetSentTime(&manager_, 2));
 }
 
 TEST_F(QuicSentPacketManagerTest, AckAckAndUpdateRtt) {
   SendDataPacket(1);
   SendAckPacket(2);
 
@@ skipping 120 matching lines @@
   ack_frame.largest_observed = 3;
   ack_frame.missing_packets.insert(1);
   ack_frame.missing_packets.insert(2);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
 
   // Acking two more packets will lose both of them due to nacks.
   ack_frame.largest_observed = 5;
   QuicPacketSequenceNumber lost[] = { 1, 2 };
-  ExpectAcksAndLosses(false, NULL, 0, lost, arraysize(lost));
+  ExpectAcksAndLosses(false, nullptr, 0, lost, arraysize(lost));
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   EXPECT_EQ(2u, stats_.tlp_count);
   EXPECT_EQ(0u, stats_.rto_count);
 }
 
 TEST_F(QuicSentPacketManagerTest, TailLossProbeThenRTO) {
   QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
@@ skipping 71 matching lines @@
   EXPECT_EQ(QuicTime::Delta::Zero(),
             manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
   RetransmitNextPacket(8);
   RetransmitNextPacket(9);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
 
   // Now ack the two crypto packets and the speculatively encrypted request,
   // and ensure the first four crypto packets get abandoned, but not lost.
   QuicPacketSequenceNumber acked[] = { 3, 4, 5, 8, 9 };
-  ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0);
+  ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0);
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 9;
   ack_frame.missing_packets.insert(1);
   ack_frame.missing_packets.insert(2);
   ack_frame.missing_packets.insert(6);
   ack_frame.missing_packets.insert(7);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
 }
@@ skipping 113 matching lines @@
 
   // Retransmit the crypto packet as 3.
   manager_.OnRetransmissionTimeout();
   RetransmitNextPacket(3);
 
   // Now neuter all unacked unencrypted packets, which occurs when the
   // connection goes forward secure.
   manager_.NeuterUnencryptedPackets();
   QuicPacketSequenceNumber unacked[] = { 1, 2, 3};
   VerifyUnackedPackets(unacked, arraysize(unacked));
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
 
   // Ensure both packets get discarded when packet 2 is acked.
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 3;
   ack_frame.missing_packets.insert(1);
   ack_frame.missing_packets.insert(2);
   ExpectUpdatedRtt(3);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
-  VerifyUnackedPackets(NULL, 0);
-  VerifyRetransmittablePackets(NULL, 0);
+  VerifyUnackedPackets(nullptr, 0);
+  VerifyRetransmittablePackets(nullptr, 0);
 }
 
 TEST_F(QuicSentPacketManagerTest, ResetRecentMinRTTWithEmptyWindow) {
   QuicTime::Delta min_rtt = QuicTime::Delta::FromMilliseconds(50);
   QuicSentPacketManagerPeer::GetRttStats(&manager_)->UpdateRtt(
       min_rtt, QuicTime::Delta::Zero(), QuicTime::Zero());
   EXPECT_EQ(min_rtt,
             QuicSentPacketManagerPeer::GetRttStats(&manager_)->min_rtt());
   EXPECT_EQ(min_rtt,
             QuicSentPacketManagerPeer::GetRttStats(
@@ skipping 339 matching lines @@
       .WillOnce(Return(100 * kDefaultTCPMSS));
   manager_.SetFromConfig(config);
 
   EXPECT_EQ(initial_rtt_us,
             manager_.GetRttStats()->SmoothedRtt().ToMicroseconds());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net