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

net/quic/quic_config.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/quic_config.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 
 using std::min;
 using std::string;
 
 namespace net {
 
 // Reads the value corresponding to |name_| from |msg| into |out|. If the
 // |name_| is absent in |msg| and |presence| is set to OPTIONAL |out| is set
 // to |default_value|.
 QuicErrorCode ReadUint32(const CryptoHandshakeMessage& msg,
                          QuicTag tag,
                          QuicConfigPresence presence,
                          uint32 default_value,
                          uint32* out,
                          string* error_details) {
-  DCHECK(error_details != NULL);
+  DCHECK(error_details != nullptr);
   QuicErrorCode error = msg.GetUint32(tag, out);
   switch (error) {
     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
       if (presence == PRESENCE_REQUIRED) {
         *error_details = "Missing " + QuicUtils::TagToString(tag);
         break;
       }
       error = QUIC_NO_ERROR;
       *out = default_value;
       break;
@@ skipping 49 matching lines @@
   } else {
     out->SetValue(tag_, max_value_);
   }
 }
 
 QuicErrorCode QuicNegotiableUint32::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
     HelloType hello_type,
     string* error_details) {
   DCHECK(!negotiated_);
-  DCHECK(error_details != NULL);
+  DCHECK(error_details != nullptr);
   uint32 value;
   QuicErrorCode error = ReadUint32(peer_hello,
                                    tag_,
                                    presence_,
                                    default_value_,
                                    &value,
                                    error_details);
   if (error != QUIC_NO_ERROR) {
     return error;
   }
@@ skipping 38 matching lines @@
   } else {
     out->SetVector(tag_, possible_values_);
   }
 }
 
 QuicErrorCode QuicNegotiableTag::ReadVector(
     const CryptoHandshakeMessage& msg,
     const QuicTag** out,
     size_t* out_length,
     string* error_details) const {
-  DCHECK(error_details != NULL);
+  DCHECK(error_details != nullptr);
   QuicErrorCode error = msg.GetTaglist(tag_, out, out_length);
   switch (error) {
     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
       if (presence_ == PRESENCE_REQUIRED) {
         *error_details = "Missing " + QuicUtils::TagToString(tag_);
         break;
       }
       error = QUIC_NO_ERROR;
       *out_length = 1;
       *out = &default_value_;
 
     case QUIC_NO_ERROR:
       break;
     default:
       *error_details = "Bad " + QuicUtils::TagToString(tag_);
       break;
   }
   return error;
 }
 
 QuicErrorCode QuicNegotiableTag::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
     HelloType hello_type,
     string* error_details) {
   DCHECK(!negotiated_);
-  DCHECK(error_details != NULL);
+  DCHECK(error_details != nullptr);
   const QuicTag* received_tags;
   size_t received_tags_length;
   QuicErrorCode error = ReadVector(peer_hello, &received_tags,
                                    &received_tags_length, error_details);
   if (error != QUIC_NO_ERROR) {
     return error;
   }
 
   if (hello_type == SERVER) {
     if (received_tags_length != 1 ||
         !ContainsQuicTag(possible_values_,  *received_tags)) {
       *error_details = "Invalid " + QuicUtils::TagToString(tag_);
       return QUIC_INVALID_NEGOTIATED_VALUE;
     }
     negotiated_tag_ = *received_tags;
   } else {
     QuicTag negotiated_tag;
     if (!QuicUtils::FindMutualTag(possible_values_,
                                   received_tags,
                                   received_tags_length,
                                   QuicUtils::LOCAL_PRIORITY,
                                   &negotiated_tag,
-                                  NULL)) {
+                                  nullptr)) {
       *error_details = "Unsupported " + QuicUtils::TagToString(tag_);
       return QUIC_CRYPTO_MESSAGE_PARAMETER_NO_OVERLAP;
     }
     negotiated_tag_ = negotiated_tag;
   }
 
   negotiated_ = true;
   return QUIC_NO_ERROR;
 }
 
@@ skipping 37 matching lines @@
 void QuicFixedUint32::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
   if (has_send_value_) {
     out->SetValue(tag_, send_value_);
   }
 }
 
 QuicErrorCode QuicFixedUint32::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
     HelloType hello_type,
     string* error_details) {
-  DCHECK(error_details != NULL);
+  DCHECK(error_details != nullptr);
   QuicErrorCode error = peer_hello.GetUint32(tag_, &receive_value_);
   switch (error) {
     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
       if (presence_ == PRESENCE_OPTIONAL) {
         return QUIC_NO_ERROR;
       }
       *error_details = "Missing " + QuicUtils::TagToString(tag_);
       break;
     case QUIC_NO_ERROR:
       has_receive_value_ = true;
@@ skipping 47 matching lines @@
 void QuicFixedTag::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
   if (has_send_value_) {
     out->SetValue(tag_, send_value_);
   }
 }
 
 QuicErrorCode QuicFixedTag::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
     HelloType hello_type,
     string* error_details) {
-  DCHECK(error_details != NULL);
+  DCHECK(error_details != nullptr);
   QuicErrorCode error = peer_hello.GetUint32(tag_, &receive_value_);
   switch (error) {
     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
       if (presence_ == PRESENCE_OPTIONAL) {
         return QUIC_NO_ERROR;
       }
       *error_details = "Missing " + QuicUtils::TagToString(tag_);
       break;
     case QUIC_NO_ERROR:
       has_receive_value_ = true;
@@ skipping 47 matching lines @@
 void QuicFixedTagVector::ToHandshakeMessage(CryptoHandshakeMessage* out) const {
   if (has_send_values_) {
     out->SetVector(tag_, send_values_);
   }
 }
 
 QuicErrorCode QuicFixedTagVector::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
     HelloType hello_type,
     string* error_details) {
-  DCHECK(error_details != NULL);
+  DCHECK(error_details != nullptr);
   const QuicTag* received_tags;
   size_t received_tags_length;
   QuicErrorCode error =
       peer_hello.GetTaglist(tag_, &received_tags, &received_tags_length);
   switch (error) {
     case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
       if (presence_ == PRESENCE_OPTIONAL) {
         return QUIC_NO_ERROR;
       }
       *error_details = "Missing " + QuicUtils::TagToString(tag_);
@@ skipping 248 matching lines @@
   initial_stream_flow_control_window_bytes_.ToHandshakeMessage(out);
   initial_session_flow_control_window_bytes_.ToHandshakeMessage(out);
   socket_receive_buffer_.ToHandshakeMessage(out);
   connection_options_.ToHandshakeMessage(out);
 }
 
 QuicErrorCode QuicConfig::ProcessPeerHello(
     const CryptoHandshakeMessage& peer_hello,
     HelloType hello_type,
     string* error_details) {
-  DCHECK(error_details != NULL);
+  DCHECK(error_details != nullptr);
 
   QuicErrorCode error = QUIC_NO_ERROR;
   if (error == QUIC_NO_ERROR) {
     error = congestion_feedback_.ProcessPeerHello(
         peer_hello,  hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = idle_connection_state_lifetime_seconds_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
@@ skipping 30 matching lines @@
         peer_hello, hello_type, error_details);
   }
   if (error == QUIC_NO_ERROR) {
     error = connection_options_.ProcessPeerHello(
         peer_hello, hello_type, error_details);
   }
   return error;
 }
 
 }  // namespace net