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

net/quic/crypto/crypto_server_test.cc

 // Copyright (c) 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 <ostream>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/strings/string_number_conversions.h"
 #include "crypto/secure_hash.h"
@@ skipping 99 matching lines @@
     pub_hex_ = "#" + base::HexEncode(public_value, sizeof(public_value));
 
     CryptoHandshakeMessage client_hello = CryptoTestUtils::Message(
         "CHLO",
         "AEAD", "AESG",
         "KEXS", "C255",
         "PUBS", pub_hex_.c_str(),
         "NONC", nonce_hex_.c_str(),
         "VER\0", client_version_.data(),
         "$padding", static_cast<int>(kClientHelloMinimumSize),
-        NULL);
+        nullptr);
     ShouldSucceed(client_hello);
     // The message should be rejected because the source-address token is
     // missing.
     ASSERT_EQ(kREJ, out_.tag());
     const HandshakeFailureReason kRejectReasons[] = {
       SERVER_CONFIG_INCHOATE_HELLO_FAILURE
     };
     CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
 
     StringPiece srct;
@@ skipping 196 matching lines @@
   };
 
   string client_version = QuicUtils::TagToString(
       QuicVersionToQuicTag(supported_versions_.front()));
 
   for (size_t i = 0; i < arraysize(kBadSNIs); i++) {
     ShouldFailMentioning("SNI", InchoateClientHello(
         "CHLO",
         "SNI", kBadSNIs[i],
         "VER\0", client_version.data(),
-        NULL));
+        nullptr));
     const HandshakeFailureReason kRejectReasons[] = {
       SERVER_CONFIG_INCHOATE_HELLO_FAILURE
     };
     CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
   }
 }
 
 // TODO(rtenneti): Enable the DefaultCert test after implementing ProofSource.
 TEST_F(CryptoServerTest, DISABLED_DefaultCert) {
   // Check that the server replies with a default certificate when no SNI is
   // specified.
   ShouldSucceed(InchoateClientHello(
       "CHLO",
       "AEAD", "AESG",
       "KEXS", "C255",
       "SCID", scid_hex_.c_str(),
       "#004b5453", srct_hex_.c_str(),
       "PUBS", pub_hex_.c_str(),
       "NONC", nonce_hex_.c_str(),
       "$padding", static_cast<int>(kClientHelloMinimumSize),
       "PDMD", "X509",
       "VER\0", client_version_.data(),
-      NULL));
+      nullptr));
 
   StringPiece cert, proof;
   EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert));
   EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof));
   EXPECT_NE(0u, cert.size());
   EXPECT_NE(0u, proof.size());
   const HandshakeFailureReason kRejectReasons[] = {
     CLIENT_NONCE_INVALID_TIME_FAILURE
   };
   CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
 }
 
 TEST_P(CryptoServerTest, TooSmall) {
   ShouldFailMentioning("too small", CryptoTestUtils::Message(
         "CHLO",
         "VER\0", client_version_.data(),
-        NULL));
+        nullptr));
   const HandshakeFailureReason kRejectReasons[] = {
     SERVER_CONFIG_INCHOATE_HELLO_FAILURE
   };
   CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
 }
 
 TEST_P(CryptoServerTest, BadSourceAddressToken) {
   // Invalid source-address tokens should be ignored.
   static const char* kBadSourceAddressTokens[] = {
     "",
     "foo",
     "#0000",
     "#0000000000000000000000000000000000000000",
   };
 
   for (size_t i = 0; i < arraysize(kBadSourceAddressTokens); i++) {
     ShouldSucceed(InchoateClientHello(
         "CHLO",
         "STK", kBadSourceAddressTokens[i],
         "VER\0", client_version_.data(),
-        NULL));
+        nullptr));
     const HandshakeFailureReason kRejectReasons[] = {
       SERVER_CONFIG_INCHOATE_HELLO_FAILURE
     };
     CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
   }
 }
 
 TEST_P(CryptoServerTest, BadClientNonce) {
   // Invalid nonces should be ignored.
   static const char* kBadNonces[] = {
     "",
     "#0000",
     "#0000000000000000000000000000000000000000",
   };
 
   for (size_t i = 0; i < arraysize(kBadNonces); i++) {
     ShouldSucceed(InchoateClientHello(
         "CHLO",
         "NONC", kBadNonces[i],
         "VER\0", client_version_.data(),
-        NULL));
+        nullptr));
     const HandshakeFailureReason kRejectReasons[] = {
       SERVER_CONFIG_INCHOATE_HELLO_FAILURE
     };
     CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
   }
 }
 
 TEST_P(CryptoServerTest, DowngradeAttack) {
   if (supported_versions_.size() == 1) {
     // No downgrade attack is possible if the server only supports one version.
     return;
   }
   // Set the client's preferred version to a supported version that
   // is not the "current" version (supported_versions_.front()).
   string bad_version = QuicUtils::TagToString(
       QuicVersionToQuicTag(supported_versions_.back()));
 
   ShouldFailMentioning("Downgrade", InchoateClientHello(
       "CHLO",
       "VER\0", bad_version.data(),
-      NULL));
+      nullptr));
   const HandshakeFailureReason kRejectReasons[] = {
     SERVER_CONFIG_INCHOATE_HELLO_FAILURE
   };
   CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
 }
 
 TEST_P(CryptoServerTest, CorruptServerConfig) {
   // This tests corrupted server config.
   CryptoHandshakeMessage msg = CryptoTestUtils::Message(
       "CHLO",
       "AEAD", "AESG",
       "KEXS", "C255",
       "SCID", (string(1, 'X') + scid_hex_).c_str(),
       "#004b5453", srct_hex_.c_str(),
       "PUBS", pub_hex_.c_str(),
       "NONC", nonce_hex_.c_str(),
       "VER\0", client_version_.data(),
       "$padding", static_cast<int>(kClientHelloMinimumSize),
-      NULL);
+      nullptr);
   ShouldSucceed(msg);
   ASSERT_EQ(kREJ, out_.tag());
   const HandshakeFailureReason kRejectReasons[] = {
     SERVER_CONFIG_UNKNOWN_CONFIG_FAILURE
   };
   CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
 }
 
 TEST_P(CryptoServerTest, CorruptSourceAddressToken) {
   // This tests corrupted source address token.
   CryptoHandshakeMessage msg = CryptoTestUtils::Message(
       "CHLO",
       "AEAD", "AESG",
       "KEXS", "C255",
       "SCID", scid_hex_.c_str(),
       "#004b5453", (string(1, 'X') + srct_hex_).c_str(),
       "PUBS", pub_hex_.c_str(),
       "NONC", nonce_hex_.c_str(),
       "VER\0", client_version_.data(),
       "$padding", static_cast<int>(kClientHelloMinimumSize),
-      NULL);
+      nullptr);
   ShouldSucceed(msg);
   ASSERT_EQ(kREJ, out_.tag());
   const HandshakeFailureReason kRejectReasons[] = {
     SOURCE_ADDRESS_TOKEN_DECRYPTION_FAILURE
   };
   CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
 }
 
 TEST_P(CryptoServerTest, CorruptClientNonceAndSourceAddressToken) {
   // This test corrupts client nonce and source address token.
   CryptoHandshakeMessage msg = CryptoTestUtils::Message(
       "CHLO",
       "AEAD", "AESG",
       "KEXS", "C255",
       "SCID", scid_hex_.c_str(),
       "#004b5453", (string(1, 'X') + srct_hex_).c_str(),
       "PUBS", pub_hex_.c_str(),
       "NONC", (string(1, 'X') + nonce_hex_).c_str(),
       "VER\0", client_version_.data(),
       "$padding", static_cast<int>(kClientHelloMinimumSize),
-      NULL);
+      nullptr);
   ShouldSucceed(msg);
   ASSERT_EQ(kREJ, out_.tag());
   const HandshakeFailureReason kRejectReasons[] = {
     SOURCE_ADDRESS_TOKEN_DECRYPTION_FAILURE,
     CLIENT_NONCE_INVALID_FAILURE
   };
   CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
 }
 
 TEST_P(CryptoServerTest, CorruptMultipleTags) {
   // This test corrupts client nonce, server nonce and source address token.
   CryptoHandshakeMessage msg = CryptoTestUtils::Message(
       "CHLO",
       "AEAD", "AESG",
       "KEXS", "C255",
       "SCID", scid_hex_.c_str(),
       "#004b5453", (string(1, 'X') + srct_hex_).c_str(),
       "PUBS", pub_hex_.c_str(),
       "NONC", (string(1, 'X') + nonce_hex_).c_str(),
       "SNO\0", (string(1, 'X') + nonce_hex_).c_str(),
       "VER\0", client_version_.data(),
       "$padding", static_cast<int>(kClientHelloMinimumSize),
-      NULL);
+      nullptr);
   ShouldSucceed(msg);
   ASSERT_EQ(kREJ, out_.tag());
   const HandshakeFailureReason kRejectReasons[] = {
     SOURCE_ADDRESS_TOKEN_DECRYPTION_FAILURE,
     CLIENT_NONCE_INVALID_FAILURE,
     SERVER_NONCE_DECRYPTION_FAILURE,
   };
   CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
 }
 
 TEST_P(CryptoServerTest, ReplayProtection) {
   // This tests that disabling replay protection works.
   CryptoHandshakeMessage msg = CryptoTestUtils::Message(
       "CHLO",
       "AEAD", "AESG",
       "KEXS", "C255",
       "SCID", scid_hex_.c_str(),
       "#004b5453", srct_hex_.c_str(),
       "PUBS", pub_hex_.c_str(),
       "NONC", nonce_hex_.c_str(),
       "VER\0", client_version_.data(),
       "$padding", static_cast<int>(kClientHelloMinimumSize),
-      NULL);
+      nullptr);
   ShouldSucceed(msg);
   // The message should be rejected because the strike-register is still
   // quiescent.
   ASSERT_EQ(kREJ, out_.tag());
 
   const HandshakeFailureReason kRejectReasons[] = {
     CLIENT_NONCE_INVALID_TIME_FAILURE
   };
   CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
 
@@ skipping 84 matching lines @@
  public:
   virtual void SetUp() {
     // Deliberately don't add a config so that we can test this situation.
   }
 };
 
 TEST_P(CryptoServerTestNoConfig, DontCrash) {
   ShouldFailMentioning("No config", InchoateClientHello(
       "CHLO",
       "VER\0", client_version_.data(),
-      NULL));
+      nullptr));
 
   const HandshakeFailureReason kRejectReasons[] = {
     SERVER_CONFIG_INCHOATE_HELLO_FAILURE
   };
   CheckRejectReasons(kRejectReasons, arraysize(kRejectReasons));
 }
 
 class AsyncStrikeServerVerificationTest : public CryptoServerTest {
  protected:
   AsyncStrikeServerVerificationTest() {
@@ skipping 21 matching lines @@
   CryptoHandshakeMessage msg = CryptoTestUtils::Message(
       "CHLO",
       "AEAD", "AESG",
       "KEXS", "C255",
       "SCID", scid_hex_.c_str(),
       "#004b5453", srct_hex_.c_str(),
       "PUBS", pub_hex_.c_str(),
       "NONC", nonce_hex_.c_str(),
       "VER\0", client_version_.data(),
       "$padding", static_cast<int>(kClientHelloMinimumSize),
-      NULL);
+      nullptr);
 
   // Clear the message tag.
   out_.set_tag(0);
 
   bool called = false;
   RunValidate(msg, new ValidateCallback(this, true, "", &called));
   // The verification request was queued.
   ASSERT_FALSE(called);
   EXPECT_EQ(0u, out_.tag());
   EXPECT_EQ(1, strike_register_client_->PendingVerifications());
@@ skipping 13 matching lines @@
 
   strike_register_client_->RunPendingVerifications();
   ASSERT_TRUE(called);
   EXPECT_EQ(0, strike_register_client_->PendingVerifications());
   // The message should be rejected now.
   EXPECT_EQ(kREJ, out_.tag());
 }
 
 }  // namespace test
 }  // namespace net