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

net/quic/crypto/quic_crypto_server_config_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/crypto/quic_crypto_server_config.h"
 
 #include <stdarg.h>
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
@@ skipping 38 matching lines @@
     return config->source_address_token_boxer ==
         &(server_config_->default_source_address_token_boxer_);
   }
 
   string NewSourceAddressToken(
       string config_id,
       IPEndPoint ip,
       QuicRandom* rand,
       QuicWallTime now) {
     return server_config_->NewSourceAddressToken(
-        *GetConfig(config_id), ip, rand, now, NULL);
+        *GetConfig(config_id), ip, rand, now, nullptr);
   }
 
   HandshakeFailureReason ValidateSourceAddressToken(string config_id,
                                                     StringPiece srct,
                                                     IPEndPoint ip,
                                                     QuicWallTime now) {
     return server_config_->ValidateSourceAddressToken(
         *GetConfig(config_id), srct, ip, now);
   }
 
   string NewServerNonce(QuicRandom* rand, QuicWallTime now) const {
     return server_config_->NewServerNonce(rand, now);
   }
 
   HandshakeFailureReason ValidateServerNonce(StringPiece token,
                                              QuicWallTime now) {
     return server_config_->ValidateServerNonce(token, now);
   }
 
   base::Lock* GetStrikeRegisterClientLock() {
     return &server_config_->strike_register_client_lock_;
   }
 
   // CheckConfigs compares the state of the Configs in |server_config_| to the
-  // description given as arguments. The arguments are given as NULL-terminated
-  // pairs. The first of each pair is the server config ID of a Config. The
-  // second is a boolean describing whether the config is the primary. For
-  // example:
-  //   CheckConfigs(NULL);  // checks that no Configs are loaded.
+  // description given as arguments. The arguments are given as
+  // nullptr-terminated pairs. The first of each pair is the server config ID of
+  // a Config. The second is a boolean describing whether the config is the
+  // primary. For example:
+  //   CheckConfigs(nullptr);  // checks that no Configs are loaded.
   //
   //   // Checks that exactly three Configs are loaded with the given IDs and
   //   // status.
   //   CheckConfigs(
   //     "id1", false,
   //     "id2", true,
   //     "id3", false,
-  //     NULL);
+  //     nullptr);
   void CheckConfigs(const char* server_config_id1, ...) {
     va_list ap;
     va_start(ap, server_config_id1);
 
     vector<pair<ServerConfigID, bool> > expected;
     bool first = true;
     for (;;) {
       const char* server_config_id;
       if (first) {
         server_config_id = server_config_id1;
@@ skipping 258 matching lines @@
   CryptoServerConfigsTest()
       : rand_(QuicRandom::GetInstance()),
         config_(QuicCryptoServerConfig::TESTING, rand_),
         test_peer_(&config_) {}
 
   virtual void SetUp() {
     clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1000));
   }
 
   // SetConfigs constructs suitable config protobufs and calls SetConfigs on
-  // |config_|. The arguments are given as NULL-terminated pairs. The first of
-  // each pair is the server config ID of a Config. The second is the
-  // |primary_time| of that Config, given in epoch seconds. (Although note
-  // that, in these tests, time is set to 1000 seconds since the epoch.) For
-  // example:
-  //   SetConfigs(NULL);  // calls |config_.SetConfigs| with no protobufs.
+  // |config_|. The arguments are given as nullptr-terminated pairs. The first
+  // of each pair is the server config ID of a Config. The second is the
+  // |primary_time| of that Config, given in epoch seconds. (Although note that,
+  // in these tests, time is set to 1000 seconds since the epoch.) For example:
+  //   SetConfigs(nullptr);  // calls |config_.SetConfigs| with no protobufs.
   //
   //   // Calls |config_.SetConfigs| with two protobufs: one for a Config with
   //   // a |primary_time| of 900 and priority 1, and another with
   //   // a |primary_time| of 1000 and priority 2.
 
   //   CheckConfigs(
   //     "id1", 900, 1,
   //     "id2", 1000, 2,
-  //     NULL);
+  //     nullptr);
   //
   // If the server config id starts with "INVALID" then the generated protobuf
   // will be invalid.
   void SetConfigs(const char* server_config_id1, ...) {
     const char kOrbit[] = "12345678";
 
     va_list ap;
     va_start(ap, server_config_id1);
     bool has_invalid = false;
     bool is_empty = true;
@@ skipping 37 matching lines @@
   }
 
  protected:
   QuicRandom* const rand_;
   MockClock clock_;
   QuicCryptoServerConfig config_;
   QuicCryptoServerConfigPeer test_peer_;
 };
 
 TEST_F(CryptoServerConfigsTest, NoConfigs) {
-  test_peer_.CheckConfigs(NULL);
+  test_peer_.CheckConfigs(nullptr);
 }
 
 TEST_F(CryptoServerConfigsTest, MakePrimaryFirst) {
   // Make sure that "b" is primary even though "a" comes first.
   SetConfigs("a", 1100, 1,
              "b", 900, 1,
-             NULL);
+             nullptr);
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
-      NULL);
+      nullptr);
 }
 
 TEST_F(CryptoServerConfigsTest, MakePrimarySecond) {
   // Make sure that a remains primary after b is added.
   SetConfigs("a", 900, 1,
              "b", 1100, 1,
-             NULL);
+             nullptr);
   test_peer_.CheckConfigs(
       "a", true,
       "b", false,
-      NULL);
+      nullptr);
 }
 
 TEST_F(CryptoServerConfigsTest, Delete) {
   // Ensure that configs get deleted when removed.
   SetConfigs("a", 800, 1,
              "b", 900, 1,
              "c", 1100, 1,
-             NULL);
+             nullptr);
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
       "c", false,
-      NULL);
+      nullptr);
   SetConfigs("b", 900, 1,
              "c", 1100, 1,
-             NULL);
+             nullptr);
   test_peer_.CheckConfigs(
       "b", true,
       "c", false,
-      NULL);
+      nullptr);
 }
 
 TEST_F(CryptoServerConfigsTest, DeletePrimary) {
   // Ensure that deleting the primary config works.
   SetConfigs("a", 800, 1,
              "b", 900, 1,
              "c", 1100, 1,
-             NULL);
+             nullptr);
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
       "c", false,
-      NULL);
+      nullptr);
   SetConfigs("a", 800, 1,
              "c", 1100, 1,
-             NULL);
+             nullptr);
   test_peer_.CheckConfigs(
       "a", true,
       "c", false,
-      NULL);
+      nullptr);
 }
 
 TEST_F(CryptoServerConfigsTest, FailIfDeletingAllConfigs) {
   // Ensure that configs get deleted when removed.
   SetConfigs("a", 800, 1,
              "b", 900, 1,
-             NULL);
+             nullptr);
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
-      NULL);
-  SetConfigs(NULL);
+      nullptr);
+  SetConfigs(nullptr);
   // Config change is rejected, still using old configs.
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
-      NULL);
+      nullptr);
 }
 
 TEST_F(CryptoServerConfigsTest, ChangePrimaryTime) {
   // Check that updates to primary time get picked up.
   SetConfigs("a", 400, 1,
              "b", 800, 1,
              "c", 1200, 1,
-             NULL);
+             nullptr);
   test_peer_.SelectNewPrimaryConfig(500);
   test_peer_.CheckConfigs(
       "a", true,
       "b", false,
       "c", false,
-      NULL);
+      nullptr);
   SetConfigs("a", 1200, 1,
              "b", 800, 1,
              "c", 400, 1,
-             NULL);
+             nullptr);
   test_peer_.SelectNewPrimaryConfig(500);
   test_peer_.CheckConfigs(
       "a", false,
       "b", false,
       "c", true,
-      NULL);
+      nullptr);
 }
 
 TEST_F(CryptoServerConfigsTest, AllConfigsInThePast) {
   // Check that the most recent config is selected.
   SetConfigs("a", 400, 1,
              "b", 800, 1,
              "c", 1200, 1,
-             NULL);
+             nullptr);
   test_peer_.SelectNewPrimaryConfig(1500);
   test_peer_.CheckConfigs(
       "a", false,
       "b", false,
       "c", true,
-      NULL);
+      nullptr);
 }
 
 TEST_F(CryptoServerConfigsTest, AllConfigsInTheFuture) {
   // Check that the first config is selected.
   SetConfigs("a", 400, 1,
              "b", 800, 1,
              "c", 1200, 1,
-             NULL);
+             nullptr);
   test_peer_.SelectNewPrimaryConfig(100);
   test_peer_.CheckConfigs(
       "a", true,
       "b", false,
       "c", false,
-      NULL);
+      nullptr);
 }
 
 TEST_F(CryptoServerConfigsTest, SortByPriority) {
   // Check that priority is used to decide on a primary config when
   // configs have the same primary time.
   SetConfigs("a", 900, 1,
              "b", 900, 2,
              "c", 900, 3,
-             NULL);
+             nullptr);
   test_peer_.CheckConfigs(
       "a", true,
       "b", false,
       "c", false,
-      NULL);
+      nullptr);
   test_peer_.SelectNewPrimaryConfig(800);
   test_peer_.CheckConfigs(
       "a", true,
       "b", false,
       "c", false,
-      NULL);
+      nullptr);
   test_peer_.SelectNewPrimaryConfig(1000);
   test_peer_.CheckConfigs(
       "a", true,
       "b", false,
       "c", false,
-      NULL);
+      nullptr);
 
   // Change priorities and expect sort order to change.
   SetConfigs("a", 900, 2,
              "b", 900, 1,
              "c", 900, 0,
-             NULL);
+             nullptr);
   test_peer_.CheckConfigs(
       "a", false,
       "b", false,
       "c", true,
-      NULL);
+      nullptr);
   test_peer_.SelectNewPrimaryConfig(800);
   test_peer_.CheckConfigs(
       "a", false,
       "b", false,
       "c", true,
-      NULL);
+      nullptr);
   test_peer_.SelectNewPrimaryConfig(1000);
   test_peer_.CheckConfigs(
       "a", false,
       "b", false,
       "c", true,
-      NULL);
+      nullptr);
 }
 
 TEST_F(CryptoServerConfigsTest, AdvancePrimary) {
   // Check that a new primary config is enabled at the right time.
   SetConfigs("a", 900, 1,
              "b", 1100, 1,
-             NULL);
+             nullptr);
   test_peer_.SelectNewPrimaryConfig(1000);
   test_peer_.CheckConfigs(
       "a", true,
       "b", false,
-      NULL);
+      nullptr);
   test_peer_.SelectNewPrimaryConfig(1101);
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
-      NULL);
+      nullptr);
 }
 
 TEST_F(CryptoServerConfigsTest, InvalidConfigs) {
   // Ensure that invalid configs don't change anything.
   SetConfigs("a", 800, 1,
              "b", 900, 1,
              "c", 1100, 1,
-             NULL);
+             nullptr);
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
       "c", false,
-      NULL);
+      nullptr);
   SetConfigs("a", 800, 1,
              "c", 1100, 1,
              "INVALID1", 1000, 1,
-             NULL);
+             nullptr);
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
       "c", false,
-      NULL);
+      nullptr);
 }
 
 }  // namespace test
 }  // namespace net