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

net/quic/quic_crypto_client_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_client_stream.h"
 
 #include "base/metrics/histogram.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/crypto_utils.h"
 #include "net/quic/crypto/null_encrypter.h"
 #include "net/quic/quic_client_session_base.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_session.h"
 
 namespace net {
 
 QuicCryptoClientStream::ChannelIDSourceCallbackImpl::
 ChannelIDSourceCallbackImpl(QuicCryptoClientStream* stream)
     : stream_(stream) {}
 
 QuicCryptoClientStream::ChannelIDSourceCallbackImpl::
 ~ChannelIDSourceCallbackImpl() {}
 
 void QuicCryptoClientStream::ChannelIDSourceCallbackImpl::Run(
     scoped_ptr<ChannelIDKey>* channel_id_key) {
-  if (stream_ == NULL) {
+  if (stream_ == nullptr) {
     return;
   }
 
   stream_->channel_id_key_.reset(channel_id_key->release());
   stream_->channel_id_source_callback_run_ = true;
-  stream_->channel_id_source_callback_ = NULL;
-  stream_->DoHandshakeLoop(NULL);
+  stream_->channel_id_source_callback_ = nullptr;
+  stream_->DoHandshakeLoop(nullptr);
 
   // The ChannelIDSource owns this object and will delete it when this method
   // returns.
 }
 
 void QuicCryptoClientStream::ChannelIDSourceCallbackImpl::Cancel() {
-  stream_ = NULL;
+  stream_ = nullptr;
 }
 
 QuicCryptoClientStream::ProofVerifierCallbackImpl::ProofVerifierCallbackImpl(
     QuicCryptoClientStream* stream)
     : stream_(stream) {}
 
 QuicCryptoClientStream::ProofVerifierCallbackImpl::
 ~ProofVerifierCallbackImpl() {}
 
 void QuicCryptoClientStream::ProofVerifierCallbackImpl::Run(
     bool ok,
     const string& error_details,
     scoped_ptr<ProofVerifyDetails>* details) {
-  if (stream_ == NULL) {
+  if (stream_ == nullptr) {
     return;
   }
 
   stream_->verify_ok_ = ok;
   stream_->verify_error_details_ = error_details;
   stream_->verify_details_.reset(details->release());
-  stream_->proof_verify_callback_ = NULL;
-  stream_->DoHandshakeLoop(NULL);
+  stream_->proof_verify_callback_ = nullptr;
+  stream_->DoHandshakeLoop(nullptr);
 
   // The ProofVerifier owns this object and will delete it when this method
   // returns.
 }
 
 void QuicCryptoClientStream::ProofVerifierCallbackImpl::Cancel() {
-  stream_ = NULL;
+  stream_ = nullptr;
 }
 
 QuicCryptoClientStream::QuicCryptoClientStream(
     const QuicServerId& server_id,
     QuicClientSessionBase* session,
     ProofVerifyContext* verify_context,
     QuicCryptoClientConfig* crypto_config)
     : QuicCryptoStream(session),
       next_state_(STATE_IDLE),
       num_client_hellos_(0),
       crypto_config_(crypto_config),
       server_id_(server_id),
       generation_counter_(0),
       channel_id_sent_(false),
       channel_id_source_callback_run_(false),
-      channel_id_source_callback_(NULL),
+      channel_id_source_callback_(nullptr),
       verify_context_(verify_context),
-      proof_verify_callback_(NULL) {
-}
+      proof_verify_callback_(nullptr) {}
 
 QuicCryptoClientStream::~QuicCryptoClientStream() {
   if (channel_id_source_callback_) {
     channel_id_source_callback_->Cancel();
   }
   if (proof_verify_callback_) {
     proof_verify_callback_->Cancel();
   }
 }
 
@@ skipping 17 matching lines @@
   if (handshake_confirmed()) {
     CloseConnection(QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE);
     return;
   }
 
   DoHandshakeLoop(&message);
 }
 
 bool QuicCryptoClientStream::CryptoConnect() {
   next_state_ = STATE_INITIALIZE;
-  DoHandshakeLoop(NULL);
+  DoHandshakeLoop(nullptr);
   return true;
 }
 
 int QuicCryptoClientStream::num_sent_client_hellos() const {
   return num_client_hellos_;
 }
 
 bool QuicCryptoClientStream::WasChannelIDSent() const {
   return channel_id_sent_;
 }
@@ skipping 19 matching lines @@
     CloseConnectionWithDetails(
         error, "Server config update invalid: " + error_details);
     return;
   }
 
   DCHECK(handshake_confirmed());
   if (proof_verify_callback_) {
     proof_verify_callback_->Cancel();
   }
   next_state_ = STATE_INITIALIZE_SCUP;
-  DoHandshakeLoop(NULL);
+  DoHandshakeLoop(nullptr);
 }
 
 // kMaxClientHellos is the maximum number of times that we'll send a client
 // hello. The value 3 accounts for:
 //   * One failure due to an incorrect or missing source-address token.
 //   * One failure due the server's certificate chain being unavailible and the
 //     server being unwilling to send it without a valid source-address token.
 static const int kMaxClientHellos = 3;
 
 void QuicCryptoClientStream::DoHandshakeLoop(
@@ skipping 113 matching lines @@
       &crypto_negotiated_params_,
       &out,
       &error_details);
   if (error != QUIC_NO_ERROR) {
     // Flush the cached config so that, if it's bad, the server has a
     // chance to send us another in the future.
     cached->InvalidateServerConfig();
     CloseConnectionWithDetails(error, error_details);
     return;
   }
-  channel_id_sent_ = (channel_id_key_.get() != NULL);
+  channel_id_sent_ = (channel_id_key_.get() != nullptr);
   if (cached->proof_verify_details()) {
     client_session()->OnProofVerifyDetailsAvailable(
         *cached->proof_verify_details());
   }
   next_state_ = STATE_RECV_SHLO;
   SendHandshakeMessage(out);
   // Be prepared to decrypt with the new server write key.
   session()->connection()->SetAlternativeDecrypter(
       crypto_negotiated_params_.initial_crypters.decrypter.release(),
       ENCRYPTION_INITIAL,
@@ skipping 163 matching lines @@
   next_state_ = STATE_SEND_CHLO;
 }
 
 void QuicCryptoClientStream::DoReceiveSHLO(
     const CryptoHandshakeMessage* in,
     QuicCryptoClientConfig::CachedState* cached) {
   next_state_ = STATE_NONE;
   // We sent a CHLO that we expected to be accepted and now we're hoping
   // for a SHLO from the server to confirm that.
   if (in->tag() == kREJ) {
-    // alternative_decrypter will be NULL if the original alternative
+    // alternative_decrypter will be nullptr if the original alternative
     // decrypter latched and became the primary decrypter. That happens
     // if we received a message encrypted with the INITIAL key.
-    if (session()->connection()->alternative_decrypter() == NULL) {
+    if (session()->connection()->alternative_decrypter() == nullptr) {
       // The rejection was sent encrypted!
       CloseConnectionWithDetails(QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT,
                                  "encrypted REJ message");
       return;
     }
     next_state_ = STATE_RECV_REJ;
     return;
   }
 
   if (in->tag() != kSHLO) {
     CloseConnectionWithDetails(QUIC_INVALID_CRYPTO_MESSAGE_TYPE,
                                "Expected SHLO or REJ");
     return;
   }
 
-  // alternative_decrypter will be NULL if the original alternative
+  // alternative_decrypter will be nullptr if the original alternative
   // decrypter latched and became the primary decrypter. That happens
   // if we received a message encrypted with the INITIAL key.
-  if (session()->connection()->alternative_decrypter() != NULL) {
+  if (session()->connection()->alternative_decrypter() != nullptr) {
     // The server hello was sent without encryption.
     CloseConnectionWithDetails(QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT,
                                "unencrypted SHLO message");
     return;
   }
 
   string error_details;
   QuicErrorCode error = crypto_config_->ProcessServerHello(
       *in, session()->connection()->connection_id(),
       session()->connection()->server_supported_versions(),
@@ skipping 76 matching lines @@
     }
   }
   return false;
 }
 
 QuicClientSessionBase* QuicCryptoClientStream::client_session() {
   return reinterpret_cast<QuicClientSessionBase*>(session());
 }
 
 }  // namespace net