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

net/quic/quic_crypto_server_stream.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/quic_crypto_server_stream.h"
 
 #include "base/base64.h"
 #include "crypto/secure_hash.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/crypto_utils.h"
@@ skipping 12 matching lines @@
     int num_retransmitted_bytes,
     QuicTime::Delta delta_largest_observed) {
   server_stream_->OnServerHelloAcked();
 }
 
 QuicCryptoServerStream::QuicCryptoServerStream(
     const QuicCryptoServerConfig& crypto_config,
     QuicSession* session)
     : QuicCryptoStream(session),
       crypto_config_(crypto_config),
-      validate_client_hello_cb_(NULL),
+      validate_client_hello_cb_(nullptr),
       num_handshake_messages_(0),
-      num_server_config_update_messages_sent_(0) {
-}
+      num_server_config_update_messages_sent_(0) {}
 
 QuicCryptoServerStream::~QuicCryptoServerStream() {
   CancelOutstandingCallbacks();
 }
 
 void QuicCryptoServerStream::CancelOutstandingCallbacks() {
   // Detach from the validation callback.  Calling this multiple times is safe.
-  if (validate_client_hello_cb_ != NULL) {
+  if (validate_client_hello_cb_ != nullptr) {
     validate_client_hello_cb_->Cancel();
   }
 }
 
 void QuicCryptoServerStream::OnHandshakeMessage(
     const CryptoHandshakeMessage& message) {
   QuicCryptoStream::OnHandshakeMessage(message);
   ++num_handshake_messages_;
 
   // Do not process handshake messages after the handshake is confirmed.
   if (handshake_confirmed_) {
     CloseConnection(QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE);
     return;
   }
 
   if (message.tag() != kCHLO) {
     CloseConnection(QUIC_INVALID_CRYPTO_MESSAGE_TYPE);
     return;
   }
 
-  if (validate_client_hello_cb_ != NULL) {
+  if (validate_client_hello_cb_ != nullptr) {
     // Already processing some other handshake message.  The protocol
     // does not allow for clients to send multiple handshake messages
     // before the server has a chance to respond.
     CloseConnection(QUIC_CRYPTO_MESSAGE_WHILE_VALIDATING_CLIENT_HELLO);
     return;
   }
 
   validate_client_hello_cb_ = new ValidateCallback(this);
   return crypto_config_.ValidateClientHello(
       message,
       session()->connection()->peer_address(),
       session()->connection()->clock(),
       validate_client_hello_cb_);
 }
 
 void QuicCryptoServerStream::FinishProcessingHandshakeMessage(
     const CryptoHandshakeMessage& message,
     const ValidateClientHelloResultCallback::Result& result) {
   // Clear the callback that got us here.
-  DCHECK(validate_client_hello_cb_ != NULL);
-  validate_client_hello_cb_ = NULL;
+  DCHECK(validate_client_hello_cb_ != nullptr);
+  validate_client_hello_cb_ = nullptr;
 
   string error_details;
   CryptoHandshakeMessage reply;
   QuicErrorCode error = ProcessClientHello(
       message, result, &reply, &error_details);
 
   if (error != QUIC_NO_ERROR) {
     CloseConnectionWithDetails(error, error_details);
     return;
   }
@@ skipping 49 matching lines @@
   session()->connection()->SetAlternativeDecrypter(
       crypto_negotiated_params_.forward_secure_crypters.decrypter.release(),
       ENCRYPTION_FORWARD_SECURE, false /* don't latch */);
 
   encryption_established_ = true;
   handshake_confirmed_ = true;
   session()->OnCryptoHandshakeEvent(QuicSession::HANDSHAKE_CONFIRMED);
 
   // Now that the handshake is complete, send an updated server config and
   // source-address token to the client.
-  SendServerConfigUpdate(NULL);
+  SendServerConfigUpdate(nullptr);
 }
 
 void QuicCryptoServerStream::SendServerConfigUpdate(
     const CachedNetworkParameters* cached_network_params) {
   if (session()->connection()->version() <= QUIC_VERSION_21 ||
       !handshake_confirmed_) {
     return;
   }
 
   CryptoHandshakeMessage server_config_update_message;
   if (!crypto_config_.BuildServerConfigUpdateMessage(
           session()->connection()->peer_address(),
           session()->connection()->clock(),
           session()->connection()->random_generator(),
           crypto_negotiated_params_,
           cached_network_params,
           &server_config_update_message)) {
     DVLOG(1) << "Server: Failed to build server config update (SCUP)!";
     return;
   }
 
   DVLOG(1) << "Server: Sending server config update: "
            << server_config_update_message.DebugString();
   const QuicData& data = server_config_update_message.GetSerialized();
-  WriteOrBufferData(string(data.data(), data.length()), false, NULL);
+  WriteOrBufferData(string(data.data(), data.length()), false, nullptr);
 
   ++num_server_config_update_messages_sent_;
 }
 
 void QuicCryptoServerStream::OnServerHelloAcked() {
   session()->connection()->OnHandshakeComplete();
 }
 
 bool QuicCryptoServerStream::GetBase64SHA256ClientChannelID(
     string* output) const {
@@ skipping 41 matching lines @@
       &crypto_negotiated_params_, reply, error_details);
 }
 
 void QuicCryptoServerStream::OverrideQuicConfigDefaults(QuicConfig* config) {
 }
 
 QuicCryptoServerStream::ValidateCallback::ValidateCallback(
     QuicCryptoServerStream* parent) : parent_(parent) {
 }
 
-void QuicCryptoServerStream::ValidateCallback::Cancel() {
-  parent_ = NULL;
-}
+void QuicCryptoServerStream::ValidateCallback::Cancel() { parent_ = nullptr; }
 
 void QuicCryptoServerStream::ValidateCallback::RunImpl(
     const CryptoHandshakeMessage& client_hello,
     const Result& result) {
-  if (parent_ != NULL) {
+  if (parent_ != nullptr) {
     parent_->FinishProcessingHandshakeMessage(client_hello, result);
   }
 }
 
 }  // namespace net