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

net/quic/test_tools/crypto_test_utils.cc

 // Copyright (c) 2012 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/test_tools/crypto_test_utils.h"
 
 #include "net/quic/crypto/channel_id.h"
 #include "net/quic/crypto/common_cert_set.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/crypto/quic_crypto_server_config.h"
@@ skipping 112 matching lines @@
     return true;
   }
   if (c >= 'A' && c <= 'F') {
     *value = c - 'A' + 10;
     return true;
   }
   return false;
 }
 
 // A ChannelIDSource that works in asynchronous mode unless the |callback|
-// argument to GetChannelIDKey is NULL.
+// argument to GetChannelIDKey is nullptr.
 class AsyncTestChannelIDSource : public ChannelIDSource,
                                  public CryptoTestUtils::CallbackSource {
  public:
   // Takes ownership of |sync_source|, a synchronous ChannelIDSource.
   explicit AsyncTestChannelIDSource(ChannelIDSource* sync_source)
       : sync_source_(sync_source) {}
   virtual ~AsyncTestChannelIDSource() {}
 
   // ChannelIDSource implementation.
   virtual QuicAsyncStatus GetChannelIDKey(
       const string& hostname,
       scoped_ptr<ChannelIDKey>* channel_id_key,
       ChannelIDSourceCallback* callback) OVERRIDE {
     // Synchronous mode.
     if (!callback) {
-      return sync_source_->GetChannelIDKey(hostname, channel_id_key, NULL);
+      return sync_source_->GetChannelIDKey(hostname, channel_id_key, nullptr);
     }
 
     // Asynchronous mode.
     QuicAsyncStatus status =
-        sync_source_->GetChannelIDKey(hostname, &channel_id_key_, NULL);
+        sync_source_->GetChannelIDKey(hostname, &channel_id_key_, nullptr);
     if (status != QUIC_SUCCESS) {
       return QUIC_FAILURE;
     }
     callback_.reset(callback);
     return QUIC_PENDING;
   }
 
   // CallbackSource implementation.
   virtual void RunPendingCallbacks() OVERRIDE {
     if (callback_.get()) {
@@ skipping 55 matching lines @@
   QuicCryptoClientConfig crypto_config;
 
   client_session.config()->SetDefaults();
   crypto_config.SetDefaults();
   if (!options.dont_verify_certs) {
     // TODO(wtc): replace this with ProofVerifierForTesting() when we have
     // a working ProofSourceForTesting().
     crypto_config.SetProofVerifier(FakeProofVerifierForTesting());
   }
   bool is_https = false;
-  AsyncTestChannelIDSource* async_channel_id_source = NULL;
+  AsyncTestChannelIDSource* async_channel_id_source = nullptr;
   if (options.channel_id_enabled) {
     is_https = true;
 
     ChannelIDSource* source = ChannelIDSourceForTesting();
     if (options.channel_id_source_async) {
       async_channel_id_source = new AsyncTestChannelIDSource(source);
       source = async_channel_id_source;
     }
     crypto_config.SetChannelIDSource(source);
   }
   QuicServerId server_id(kServerHostname, kServerPort, is_https,
                          PRIVACY_MODE_DISABLED);
   QuicCryptoClientStream client(server_id, &client_session,
                                 ProofVerifyContextForTesting(),
                                 &crypto_config);
   client_session.SetCryptoStream(&client);
 
   CHECK(client.CryptoConnect());
   CHECK_EQ(1u, client_conn->packets_.size());
 
   CommunicateHandshakeMessagesAndRunCallbacks(
       client_conn, &client, server_conn, server, async_channel_id_source);
 
   CompareClientAndServerKeys(&client, server);
 
   if (options.channel_id_enabled) {
     scoped_ptr<ChannelIDKey> channel_id_key;
-    QuicAsyncStatus status =
-        crypto_config.channel_id_source()->GetChannelIDKey(kServerHostname,
-                                                           &channel_id_key,
-                                                           NULL);
+    QuicAsyncStatus status = crypto_config.channel_id_source()->GetChannelIDKey(
+        kServerHostname, &channel_id_key, nullptr);
     EXPECT_EQ(QUIC_SUCCESS, status);
     EXPECT_EQ(channel_id_key->SerializeKey(),
               server->crypto_negotiated_params().channel_id);
     EXPECT_EQ(options.channel_id_source_async,
               client.WasChannelIDSourceCallbackRun());
   }
 
   return client.num_sent_client_hellos();
 }
 
 // static
 void CryptoTestUtils::SetupCryptoServerConfigForTest(
     const QuicClock* clock,
     QuicRandom* rand,
     QuicConfig* config,
     QuicCryptoServerConfig* crypto_config) {
   config->SetDefaults();
   QuicCryptoServerConfig::ConfigOptions options;
   options.channel_id_enabled = true;
   scoped_ptr<CryptoHandshakeMessage> scfg(
       crypto_config->AddDefaultConfig(rand, clock, options));
 }
 
 // static
 void CryptoTestUtils::CommunicateHandshakeMessages(
     PacketSavingConnection* a_conn,
     QuicCryptoStream* a,
     PacketSavingConnection* b_conn,
     QuicCryptoStream* b) {
-  CommunicateHandshakeMessagesAndRunCallbacks(a_conn, a, b_conn, b, NULL);
+  CommunicateHandshakeMessagesAndRunCallbacks(a_conn, a, b_conn, b, nullptr);
 }
 
 // static
 void CryptoTestUtils::CommunicateHandshakeMessagesAndRunCallbacks(
     PacketSavingConnection* a_conn,
     QuicCryptoStream* a,
     PacketSavingConnection* b_conn,
     QuicCryptoStream* b,
     CallbackSource* callback_source) {
   size_t a_i = 0, b_i = 0;
@@ skipping 271 matching lines @@
 }
 
 // static
 CryptoHandshakeMessage CryptoTestUtils::BuildMessage(const char* message_tag,
                                                      va_list ap) {
   CryptoHandshakeMessage msg;
   msg.set_tag(ParseTag(message_tag));
 
   for (;;) {
     const char* tagstr = va_arg(ap, const char*);
-    if (tagstr == NULL) {
+    if (tagstr == nullptr) {
       break;
     }
 
     if (tagstr[0] == '$') {
       // Special value.
       const char* const special = tagstr + 1;
       if (strcmp(special, "padding") == 0) {
         const int min_bytes = va_arg(ap, int);
         msg.set_minimum_size(min_bytes);
       } else {
@@ skipping 35 matching lines @@
   scoped_ptr<QuicData> bytes(CryptoFramer::ConstructHandshakeMessage(msg));
   scoped_ptr<CryptoHandshakeMessage> parsed(
       CryptoFramer::ParseMessage(bytes->AsStringPiece()));
   CHECK(parsed.get());
 
   return *parsed;
 }
 
 }  // namespace test
 }  // namespace net