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

net/quic/crypto/aes_128_gcm_12_encrypter_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 "net/quic/crypto/aes_128_gcm_12_encrypter.h"
 
 #include "net/quic/test_tools/quic_test_utils.h"
 
 using base::StringPiece;
 
@@ skipping 199 matching lines @@
 // in an nonce and also to allocate the buffer needed for the ciphertext.
 QuicData* EncryptWithNonce(Aes128Gcm12Encrypter* encrypter,
                            StringPiece nonce,
                            StringPiece associated_data,
                            StringPiece plaintext) {
   size_t ciphertext_size = encrypter->GetCiphertextSize(plaintext.length());
   scoped_ptr<char[]> ciphertext(new char[ciphertext_size]);
 
   if (!encrypter->Encrypt(nonce, associated_data, plaintext,
                           reinterpret_cast<unsigned char*>(ciphertext.get()))) {
-    return NULL;
+    return nullptr;
   }
 
   return new QuicData(ciphertext.release(), ciphertext_size, true);
 }
 
 TEST(Aes128Gcm12EncrypterTest, Encrypt) {
   for (size_t i = 0; i < arraysize(test_group_array); i++) {
     SCOPED_TRACE(i);
     const TestVector* test_vectors = test_group_array[i];
     const TestGroupInfo& test_info = test_group_info[i];
-    for (size_t j = 0; test_vectors[j].key != NULL; j++) {
+    for (size_t j = 0; test_vectors[j].key != nullptr; j++) {
       // Decode the test vector.
       string key;
       string iv;
       string pt;
       string aad;
       string ct;
       string tag;
       ASSERT_TRUE(DecodeHexString(test_vectors[j].key, &key));
       ASSERT_TRUE(DecodeHexString(test_vectors[j].iv, &iv));
       ASSERT_TRUE(DecodeHexString(test_vectors[j].pt, &pt));
       ASSERT_TRUE(DecodeHexString(test_vectors[j].aad, &aad));
       ASSERT_TRUE(DecodeHexString(test_vectors[j].ct, &ct));
       ASSERT_TRUE(DecodeHexString(test_vectors[j].tag, &tag));
 
       // The test vector's lengths should look sane. Note that the lengths
       // in |test_info| are in bits.
       EXPECT_EQ(test_info.key_len, key.length() * 8);
       EXPECT_EQ(test_info.iv_len, iv.length() * 8);
       EXPECT_EQ(test_info.pt_len, pt.length() * 8);
       EXPECT_EQ(test_info.aad_len, aad.length() * 8);
       EXPECT_EQ(test_info.pt_len, ct.length() * 8);
       EXPECT_EQ(test_info.tag_len, tag.length() * 8);
 
       Aes128Gcm12Encrypter encrypter;
       ASSERT_TRUE(encrypter.SetKey(key));
       scoped_ptr<QuicData> encrypted(EncryptWithNonce(
           &encrypter, iv,
           // This deliberately tests that the encrypter can handle an AAD that
-          // is set to NULL, as opposed to a zero-length, non-NULL pointer.
+          // is set to nullptr, as opposed to a zero-length, non-nullptr
+          // pointer.
           aad.length() ? aad : StringPiece(), pt));
       ASSERT_TRUE(encrypted.get());
 
       // The test vectors have 16 byte authenticators but this code only uses
       // the first 12.
       ASSERT_LE(static_cast<size_t>(Aes128Gcm12Encrypter::kAuthTagSize),
                 tag.length());
       tag.resize(Aes128Gcm12Encrypter::kAuthTagSize);
 
       ASSERT_EQ(ct.length() + tag.length(), encrypted->length());
@@ skipping 15 matching lines @@
 
 TEST(Aes128Gcm12EncrypterTest, GetCiphertextSize) {
   Aes128Gcm12Encrypter encrypter;
   EXPECT_EQ(1012u, encrypter.GetCiphertextSize(1000));
   EXPECT_EQ(112u, encrypter.GetCiphertextSize(100));
   EXPECT_EQ(22u, encrypter.GetCiphertextSize(10));
 }
 
 }  // namespace test
 }  // namespace net