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

net/quic/crypto/aes_128_gcm_12_decrypter_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_decrypter.h"
 
 #include "net/quic/test_tools/quic_test_utils.h"
 
 using base::StringPiece;
 
@@ skipping 244 matching lines @@
 QuicData* DecryptWithNonce(Aes128Gcm12Decrypter* decrypter,
                            StringPiece nonce,
                            StringPiece associated_data,
                            StringPiece ciphertext) {
   size_t plaintext_size = ciphertext.length();
   scoped_ptr<char[]> plaintext(new char[plaintext_size]);
 
   if (!decrypter->Decrypt(nonce, associated_data, ciphertext,
                           reinterpret_cast<unsigned char*>(plaintext.get()),
                           &plaintext_size)) {
-    return NULL;
+    return nullptr;
   }
   return new QuicData(plaintext.release(), plaintext_size, true);
 }
 
 TEST(Aes128Gcm12DecrypterTest, Decrypt) {
   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++) {
       // If not present then decryption is expected to fail.
       bool has_pt = test_vectors[j].pt;
 
       // Decode the test vector.
       string key;
       string iv;
       string ct;
       string aad;
       string tag;
       string pt;
@@ skipping 23 matching lines @@
                 tag.length());
       tag.resize(Aes128Gcm12Decrypter::kAuthTagSize);
       string ciphertext = ct + tag;
 
       Aes128Gcm12Decrypter decrypter;
       ASSERT_TRUE(decrypter.SetKey(key));
 
       scoped_ptr<QuicData> decrypted(DecryptWithNonce(
           &decrypter, iv,
           // This deliberately tests that the decrypter 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(), ciphertext));
       if (!decrypted.get()) {
         EXPECT_FALSE(has_pt);
         continue;
       }
       EXPECT_TRUE(has_pt);
 
       ASSERT_EQ(pt.length(), decrypted->length());
       test::CompareCharArraysWithHexError("plaintext", decrypted->data(),
                                           pt.length(), pt.data(), pt.length());
     }
   }
 }
 
 }  // namespace test
 }  // namespace net