Rename USE_NSS to USE_NSS_CERTS.

content/child/webcrypto/nss/rsa_hashed_algorithm_nss.cc

 // Copyright 2014 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 "content/child/webcrypto/nss/rsa_hashed_algorithm_nss.h"
 
 #include <secasn1.h>
 
 #include "base/logging.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/generate_key_result.h"
 #include "content/child/webcrypto/jwk.h"
 #include "content/child/webcrypto/nss/key_nss.h"
 #include "content/child/webcrypto/nss/util_nss.h"
 #include "content/child/webcrypto/status.h"
 #include "content/child/webcrypto/webcrypto_util.h"
 #include "crypto/scoped_nss_types.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 
 namespace content {
 
 namespace webcrypto {
 
 namespace {
 
-#if defined(USE_NSS) && !defined(OS_CHROMEOS)
+#if defined(USE_NSS_CERTS) && !defined(OS_CHROMEOS)
 Status ErrorRsaPrivateKeyImportNotSupported() {
   return Status::ErrorUnsupported(
       "NSS version must be at least 3.16.2 for RSA private key import. See "
       "http://crbug.com/380424");
 }
 
 // Prior to NSS 3.16.2 RSA key parameters were not validated. This is
 // a security problem for RSA private key import from JWK which uses a
 // CKA_ID based on the public modulus to retrieve the private key.
 Status NssSupportsRsaPrivateKeyImport() {
@@ skipping 82 matching lines @@
   SECItem prime1;
   SECItem prime2;
   SECItem exponent1;
   SECItem exponent2;
   SECItem coefficient;
 };
 
 // The system NSS library doesn't have the new PK11_ExportDERPrivateKeyInfo
 // function yet (https://bugzilla.mozilla.org/show_bug.cgi?id=519255). So we
 // provide a fallback implementation.
-#if defined(USE_NSS)
+#if defined(USE_NSS_CERTS)
 const SEC_ASN1Template RSAPrivateKeyTemplate[] = {
     {SEC_ASN1_SEQUENCE, 0, NULL, sizeof(RSAPrivateKey)},
     {SEC_ASN1_INTEGER, offsetof(RSAPrivateKey, version)},
     {SEC_ASN1_INTEGER, offsetof(RSAPrivateKey, modulus)},
     {SEC_ASN1_INTEGER, offsetof(RSAPrivateKey, public_exponent)},
     {SEC_ASN1_INTEGER, offsetof(RSAPrivateKey, private_exponent)},
     {SEC_ASN1_INTEGER, offsetof(RSAPrivateKey, prime1)},
     {SEC_ASN1_INTEGER, offsetof(RSAPrivateKey, prime2)},
     {SEC_ASN1_INTEGER, offsetof(RSAPrivateKey, exponent1)},
     {SEC_ASN1_INTEGER, offsetof(RSAPrivateKey, exponent2)},
     {SEC_ASN1_INTEGER, offsetof(RSAPrivateKey, coefficient)},
     {0}};
-#endif  // defined(USE_NSS)
+#endif  // defined(USE_NSS_CERTS)
 
 // On success |value| will be filled with data which must be freed by
 // SECITEM_FreeItem(value, PR_FALSE);
 bool ReadUint(SECKEYPrivateKey* key,
               CK_ATTRIBUTE_TYPE attribute,
               SECItem* value) {
   SECStatus rv = PK11_ReadRawAttribute(PK11_TypePrivKey, key, attribute, value);
 
   // PK11_ReadRawAttribute() returns items of type siBuffer. However in order
   // for the ASN.1 encoding to be correct, the items must be of type
@@ skipping 93 matching lines @@
                   std::vector<CK_ATTRIBUTE>* templ) {
   AddAttribute(type, CryptoData(data), templ);
 }
 
 Status ExportKeyPkcs8Nss(SECKEYPrivateKey* key, std::vector<uint8_t>* buffer) {
   if (key->keyType != rsaKey)
     return Status::ErrorUnsupported();
 
 // TODO(rsleevi): Implement OAEP support according to the spec.
 
-#if defined(USE_NSS)
+#if defined(USE_NSS_CERTS)
   // PK11_ExportDERPrivateKeyInfo isn't available. Use our fallback code.
   const SECOidTag algorithm = SEC_OID_PKCS1_RSA_ENCRYPTION;
   const int kPrivateKeyInfoVersion = 0;
 
   SECKEYPrivateKeyInfo private_key_info = {};
   RSAPrivateKey rsa_private_key = {};
   scoped_ptr<RSAPrivateKey, FreeRsaPrivateKey> free_private_key(
       &rsa_private_key);
 
   // http://crbug.com/366427: the spec does not define any other failures for
@@ skipping 17 matching lines @@
   }
 
   if (!SEC_ASN1EncodeInteger(arena.get(), &private_key_info.version,
                              kPrivateKeyInfoVersion)) {
     return Status::OperationError();
   }
 
   crypto::ScopedSECItem encoded_key(
       SEC_ASN1EncodeItem(NULL, NULL, &private_key_info,
                          SEC_ASN1_GET(SECKEY_PrivateKeyInfoTemplate)));
-#else   // defined(USE_NSS)
+#else   // defined(USE_NSS_CERTS)
   crypto::ScopedSECItem encoded_key(PK11_ExportDERPrivateKeyInfo(key, NULL));
-#endif  // defined(USE_NSS)
+#endif  // defined(USE_NSS_CERTS)
 
   if (!encoded_key.get())
     return Status::OperationError();
 
   buffer->assign(encoded_key->data, encoded_key->data + encoded_key->len);
   return Status::Success();
 }
 
 Status ImportRsaPrivateKey(const blink::WebCryptoAlgorithm& algorithm,
                            bool extractable,
@@ skipping 545 matching lines @@
                  key->algorithm().rsaHashedParams()->publicExponent().size())) {
     return Status::ErrorUnexpected();
   }
 
   return Status::Success();
 }
 
 }  // namespace webcrypto
 
 }  // namespace content