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

net/tools/quic/quic_time_wait_list_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/tools/quic/quic_time_wait_list_manager.h"
 
 #include <errno.h>
 
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/null_encrypter.h"
@@ skipping 88 matching lines @@
   virtual ~QuicTimeWaitListManagerTest() OVERRIDE {}
 
   virtual void SetUp() OVERRIDE {
     EXPECT_CALL(writer_, IsWriteBlocked())
         .WillRepeatedly(ReturnPointee(&writer_is_blocked_));
     EXPECT_CALL(writer_, IsWriteBlockedDataBuffered())
         .WillRepeatedly(Return(false));
   }
 
   void AddConnectionId(QuicConnectionId connection_id) {
-    AddConnectionId(connection_id, QuicVersionMax(), NULL);
+    AddConnectionId(connection_id, QuicVersionMax(), nullptr);
   }
 
   void AddConnectionId(QuicConnectionId connection_id,
                        QuicVersion version,
                        QuicEncryptedPacket* packet) {
     time_wait_list_manager_.AddConnectionIdToTimeWait(
         connection_id, version, packet);
   }
 
   bool IsConnectionIdInTimeWait(QuicConnectionId connection_id) {
     return time_wait_list_manager_.IsConnectionIdInTimeWait(connection_id);
   }
 
   void ProcessPacket(QuicConnectionId connection_id,
                      QuicPacketSequenceNumber sequence_number) {
-    QuicEncryptedPacket packet(NULL, 0);
+    QuicEncryptedPacket packet(nullptr, 0);
     time_wait_list_manager_.ProcessPacket(server_address_,
                                           client_address_,
                                           connection_id,
                                           sequence_number,
                                           packet);
   }
 
   QuicEncryptedPacket* ConstructEncryptedPacket(
       EncryptionLevel level,
       QuicConnectionId connection_id,
       QuicPacketSequenceNumber sequence_number) {
     QuicPacketHeader header;
     header.public_header.connection_id = connection_id;
     header.public_header.connection_id_length = PACKET_8BYTE_CONNECTION_ID;
     header.public_header.version_flag = false;
     header.public_header.reset_flag = false;
     header.public_header.sequence_number_length = PACKET_6BYTE_SEQUENCE_NUMBER;
     header.packet_sequence_number = sequence_number;
     header.entropy_flag = false;
     header.entropy_hash = 0;
     header.fec_flag = false;
     header.is_in_fec_group = NOT_IN_FEC_GROUP;
     header.fec_group = 0;
     QuicStreamFrame stream_frame(1, false, 0, MakeIOVector("data"));
     QuicFrame frame(&stream_frame);
     QuicFrames frames;
     frames.push_back(frame);
     scoped_ptr<QuicPacket> packet(
         BuildUnsizedDataPacket(&framer_, header, frames).packet);
-    EXPECT_TRUE(packet != NULL);
+    EXPECT_TRUE(packet != nullptr);
     QuicEncryptedPacket* encrypted = framer_.EncryptPacket(ENCRYPTION_NONE,
                                                            sequence_number,
                                                            *packet);
-    EXPECT_TRUE(encrypted != NULL);
+    EXPECT_TRUE(encrypted != nullptr);
     return encrypted;
   }
 
   NiceMock<MockFakeTimeEpollServer> epoll_server_;
   StrictMock<MockPacketWriter> writer_;
   StrictMock<MockQuicServerSessionVisitor> visitor_;
   QuicTimeWaitListManager time_wait_list_manager_;
   QuicFramer framer_;
   QuicConnectionId connection_id_;
   IPEndPoint server_address_;
@@ skipping 200 matching lines @@
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK,
                                    other_packet->length())));
   time_wait_list_manager_.OnCanWrite();
 }
 
 TEST_F(QuicTimeWaitListManagerTest, GetQuicVersionFromMap) {
   const int kConnectionId1 = 123;
   const int kConnectionId2 = 456;
   const int kConnectionId3 = 789;
 
-  AddConnectionId(kConnectionId1, QuicVersionMin(), NULL);
-  AddConnectionId(kConnectionId2, QuicVersionMax(), NULL);
-  AddConnectionId(kConnectionId3, QuicVersionMax(), NULL);
+  AddConnectionId(kConnectionId1, QuicVersionMin(), nullptr);
+  AddConnectionId(kConnectionId2, QuicVersionMax(), nullptr);
+  AddConnectionId(kConnectionId3, QuicVersionMax(), nullptr);
 
   EXPECT_EQ(QuicVersionMin(),
             QuicTimeWaitListManagerPeer::GetQuicVersionFromConnectionId(
                 &time_wait_list_manager_, kConnectionId1));
   EXPECT_EQ(QuicVersionMax(),
             QuicTimeWaitListManagerPeer::GetQuicVersionFromConnectionId(
                 &time_wait_list_manager_, kConnectionId2));
   EXPECT_EQ(QuicVersionMax(),
             QuicTimeWaitListManagerPeer::GetQuicVersionFromConnectionId(
                 &time_wait_list_manager_, kConnectionId3));
@@ skipping 59 matching lines @@
   EXPECT_CALL(epoll_server_, RegisterAlarm(_, _));
 
   time_wait_list_manager_.CleanUpOldConnectionIds();
   EXPECT_FALSE(IsConnectionIdInTimeWait(kConnectionId1));
   EXPECT_TRUE(IsConnectionIdInTimeWait(kConnectionId2));
 }
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net