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

net/quic/crypto/p256_key_exchange_nss.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/p256_key_exchange.h"
 
 #include "base/logging.h"
 #include "base/sys_byteorder.h"
 
 using base::StringPiece;
@@ skipping 23 matching lines @@
   memcpy(public_key_, public_key, sizeof(public_key_));
 }
 
 P256KeyExchange::~P256KeyExchange() {
 }
 
 // static
 P256KeyExchange* P256KeyExchange::New(StringPiece key) {
   if (key.size() < 2) {
     DVLOG(1) << "Key pair is too small.";
-    return NULL;
+    return nullptr;
   }
 
   const uint8* data = reinterpret_cast<const uint8*>(key.data());
   size_t size = static_cast<size_t>(data[0]) |
                 (static_cast<size_t>(data[1]) << 8);
   key.remove_prefix(2);
   if (key.size() < size) {
     DVLOG(1) << "Key pair does not contain key material.";
-    return NULL;
+    return nullptr;
   }
 
   StringPiece private_piece(key.data(), size);
   key.remove_prefix(size);
   if (key.empty()) {
     DVLOG(1) << "Key pair does not contain public key.";
-    return NULL;
+    return nullptr;
   }
 
   StringPiece public_piece(key);
 
   scoped_ptr<crypto::ECPrivateKey> key_pair(
       crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
           kExportPassword,
           // TODO(thaidn): fix this interface to avoid copying secrets.
           StringPieceToVector(private_piece),
           StringPieceToVector(public_piece)));
 
   if (!key_pair.get()) {
     DVLOG(1) << "Can't decrypt private key.";
-    return NULL;
+    return nullptr;
   }
 
   // Perform some sanity checks on the public key.
   SECKEYPublicKey* public_key = key_pair->public_key();
   if (public_key->keyType != ecKey ||
       public_key->u.ec.publicValue.len != kUncompressedP256PointBytes ||
       !public_key->u.ec.publicValue.data ||
       public_key->u.ec.publicValue.data[0] != kUncompressedECPointForm) {
     DVLOG(1) << "Key is invalid.";
-    return NULL;
+    return nullptr;
   }
 
   // Ensure that the key is using the correct curve, i.e., NIST P-256.
   const SECOidData* oid_data = SECOID_FindOIDByTag(SEC_OID_SECG_EC_SECP256R1);
   if (!oid_data) {
     DVLOG(1) << "Can't get P-256's OID.";
-    return NULL;
+    return nullptr;
   }
 
   if (public_key->u.ec.DEREncodedParams.len != oid_data->oid.len + 2 ||
       !public_key->u.ec.DEREncodedParams.data ||
       public_key->u.ec.DEREncodedParams.data[0] != SEC_ASN1_OBJECT_ID ||
       public_key->u.ec.DEREncodedParams.data[1] != oid_data->oid.len ||
       memcmp(public_key->u.ec.DEREncodedParams.data + 2,
              oid_data->oid.data, oid_data->oid.len) != 0) {
     DVLOG(1) << "Key is invalid.";
   }
@@ skipping 83 matching lines @@
   // As this function is used for SSL/TLS's ECDH key exchanges it has many
   // arguments, most of which are not required in QUIC.
   // Key derivation function CKD_NULL is used because the return value of
   // |CalculateSharedKey| is the actual ECDH shared key, not any derived keys
   // from it.
   crypto::ScopedPK11SymKey premaster_secret(
       PK11_PubDeriveWithKDF(
           key_pair_->key(),
           &peer_public_key,
           PR_FALSE,
-          NULL,
-          NULL,
+          nullptr,
+          nullptr,
           CKM_ECDH1_DERIVE, /* mechanism */
           CKM_GENERIC_SECRET_KEY_GEN, /* target */
           CKA_DERIVE,
           0,
           CKD_NULL, /* kdf */
-          NULL,
-          NULL));
+          nullptr,
+          nullptr));
 
   if (!premaster_secret.get()) {
     DVLOG(1) << "Can't derive ECDH shared key.";
     return false;
   }
 
   if (PK11_ExtractKeyValue(premaster_secret.get()) != SECSuccess) {
     DVLOG(1) << "Can't extract raw ECDH shared key.";
     return false;
   }
 
   SECItem* key_data = PK11_GetKeyData(premaster_secret.get());
   if (!key_data || !key_data->data || key_data->len != kP256FieldBytes) {
     DVLOG(1) << "ECDH shared key is invalid.";
     return false;
   }
 
   out_result->assign(reinterpret_cast<char*>(key_data->data), key_data->len);
   return true;
 }
 
 StringPiece P256KeyExchange::public_value() const {
   return StringPiece(reinterpret_cast<const char*>(public_key_),
                      sizeof(public_key_));
 }
 
 QuicTag P256KeyExchange::tag() const { return kP256; }
 
 }  // namespace net
-