Rename USE_NSS to USE_NSS_CERTS.

crypto/rsa_private_key_nss.cc

 // Copyright (c) 2011 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 "crypto/rsa_private_key.h"
 
 #include <cryptohi.h>
 #include <keyhi.h>
 #include <pk11pub.h>
 #include <secmod.h>
@@ skipping 20 matching lines @@
   if (rv != SECSuccess) {
     NOTREACHED();
     return false;
   }
 
   output->assign(item.data, item.data + item.len);
   SECITEM_FreeItem(&item, PR_FALSE);
   return true;
 }
 
-#if defined(USE_NSS)
+#if defined(USE_NSS_CERTS)
 struct PublicKeyInfoDeleter {
   inline void operator()(CERTSubjectPublicKeyInfo* spki) {
     SECKEY_DestroySubjectPublicKeyInfo(spki);
   }
 };
 
 typedef scoped_ptr<CERTSubjectPublicKeyInfo, PublicKeyInfoDeleter>
     ScopedPublicKeyInfo;
 
 // The function decodes RSA public key from the |input|.
 crypto::ScopedSECKEYPublicKey GetRSAPublicKey(const std::vector<uint8>& input) {
   // First, decode and save the public key.
   SECItem key_der;
   key_der.type = siBuffer;
   key_der.data = const_cast<unsigned char*>(&input[0]);
   key_der.len = input.size();
 
   ScopedPublicKeyInfo spki(SECKEY_DecodeDERSubjectPublicKeyInfo(&key_der));
   if (!spki)
     return crypto::ScopedSECKEYPublicKey();
 
   crypto::ScopedSECKEYPublicKey result(SECKEY_ExtractPublicKey(spki.get()));
 
   // Make sure the key is an RSA key.. If not, that's an error.
   if (!result || result->keyType != rsaKey)
     return crypto::ScopedSECKEYPublicKey();
   return result.Pass();
 }
-#endif  // defined(USE_NSS)
+#endif  // defined(USE_NSS_CERTS)
 
 }  // namespace
 
 namespace crypto {
 
 RSAPrivateKey::~RSAPrivateKey() {
   if (key_)
     SECKEY_DestroyPrivateKey(key_);
   if (public_key_)
     SECKEY_DestroyPublicKey(public_key_);
@@ skipping 16 matching lines @@
   EnsureNSSInit();
 
   ScopedPK11Slot slot(PK11_GetInternalSlot());
   return CreateFromPrivateKeyInfoWithParams(
       slot.get(),
       input,
       false /* not permanent */,
       false /* not sensitive */);
 }
 
-#if defined(USE_NSS)
+#if defined(USE_NSS_CERTS)
 // static
 RSAPrivateKey* RSAPrivateKey::CreateSensitive(PK11SlotInfo* slot,
                                               uint16 num_bits) {
   return CreateWithParams(slot,
                           num_bits,
                           true /* permanent */,
                           true /* sensitive */);
 }
 
 // static
@@ skipping 188 matching lines @@
   if (rv != SECSuccess)
     return NULL;
 
   result->public_key_ = SECKEY_ConvertToPublicKey(result->key_);
   if (!result->public_key_)
     return NULL;
 
   return result.release();
 }
 
-#if defined(USE_NSS)
+#if defined(USE_NSS_CERTS)
 // static
 RSAPrivateKey* RSAPrivateKey::InitPublicPart(const std::vector<uint8>& input) {
   EnsureNSSInit();
 
   scoped_ptr<RSAPrivateKey> result(new RSAPrivateKey());
   result->public_key_ = GetRSAPublicKey(input).release();
   if (!result->public_key_) {
     NOTREACHED();
     return NULL;
   }
 
   return result.release();
 }
-#endif  // defined(USE_NSS)
+#endif  // defined(USE_NSS_CERTS)
 
 }  // namespace crypto