[webcrypto] Remove code conditional on !defined(WEBCRYPTO_HAS_KEY_ALGORITHM).

content/renderer/webcrypto/platform_crypto_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/renderer/webcrypto/platform_crypto.h"
 
 #include <cryptohi.h>
 #include <pk11pub.h>
 #include <sechash.h>
 
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "content/renderer/webcrypto/crypto_data.h"
 #include "content/renderer/webcrypto/webcrypto_util.h"
 #include "crypto/nss_util.h"
 #include "crypto/scoped_nss_types.h"
 #include "third_party/WebKit/public/platform/WebArrayBuffer.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
-#endif
 
 #if defined(USE_NSS)
 #include <dlfcn.h>
 #endif
 
 // At the time of this writing:
 //   * Windows and Mac builds ship with their own copy of NSS (3.15+)
 //   * Linux builds use the system's libnss, which is 3.14 on Debian (but 3.15+
 //     on other distros).
 //
@@ skipping 328 matching lines @@
 }
 
 CK_MECHANISM_TYPE WebCryptoAlgorithmToGenMechanism(
     const blink::WebCryptoAlgorithm& algorithm) {
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdAesCbc:
     case blink::WebCryptoAlgorithmIdAesGcm:
     case blink::WebCryptoAlgorithmIdAesKw:
       return CKM_AES_KEY_GEN;
     case blink::WebCryptoAlgorithmIdHmac:
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
       return WebCryptoHashToHMACMechanism(algorithm.hmacKeyGenParams()->hash());
-#else
-      return WebCryptoHashToHMACMechanism(algorithm.hmacKeyParams()->hash());
-#endif
     default:
       return CKM_INVALID_MECHANISM;
   }
 }
 
 // Converts a (big-endian) WebCrypto BigInteger, with or without leading zeros,
 // to unsigned long.
 bool BigIntegerToLong(const uint8* data,
                       unsigned int data_size,
                       unsigned long* result) {
@@ skipping 13 matching lines @@
   }
   return true;
 }
 
 bool IsAlgorithmRsa(const blink::WebCryptoAlgorithm& algorithm) {
   return algorithm.id() == blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5 ||
          algorithm.id() == blink::WebCryptoAlgorithmIdRsaOaep ||
          algorithm.id() == blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5;
 }
 
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
 bool CreatePublicKeyAlgorithm(const blink::WebCryptoAlgorithm& algorithm,
                               SECKEYPublicKey* key,
                               blink::WebCryptoKeyAlgorithm* key_algorithm) {
   // TODO(eroman): What about other key types rsaPss, rsaOaep.
   if (!key || key->keyType != rsaKey)
     return false;
 
   unsigned int modulus_length_bits = SECKEY_PublicKeyStrength(key) * 8;
   CryptoData public_exponent(key->u.rsa.publicExponent.data,
                              key->u.rsa.publicExponent.len);
@@ skipping 22 matching lines @@
       return false;
   }
 }
 
 bool CreatePrivateKeyAlgorithm(const blink::WebCryptoAlgorithm& algorithm,
                                SECKEYPrivateKey* key,
                                blink::WebCryptoKeyAlgorithm* key_algorithm) {
   return CreatePublicKeyAlgorithm(
       algorithm, SECKEY_ConvertToPublicKey(key), key_algorithm);
 }
-#endif
 
 }  // namespace
 
 Status ImportKeyRaw(const blink::WebCryptoAlgorithm& algorithm,
                     const CryptoData& key_data,
                     bool extractable,
                     blink::WebCryptoKeyUsageMask usage_mask,
                     blink::WebCryptoKey* key) {
 
   DCHECK(!algorithm.isNull());
@@ skipping 48 matching lines @@
                                  mechanism,
                                  PK11_OriginUnwrap,
                                  CKA_FLAGS_ONLY,
                                  &key_item,
                                  flags,
                                  false,
                                  NULL));
   if (!pk11_sym_key.get())
     return Status::Error();
 
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
   blink::WebCryptoKeyAlgorithm key_algorithm;
   if (!CreateSecretKeyAlgorithm(
           algorithm, key_data.byte_length(), &key_algorithm))
     return Status::ErrorUnexpected();
-#else
-  const blink::WebCryptoAlgorithm& key_algorithm = algorithm;
-#endif
 
   *key = blink::WebCryptoKey::create(new SymKey(pk11_sym_key.Pass()),
                                      blink::WebCryptoKeyTypeSecret,
                                      extractable,
                                      key_algorithm,
                                      usage_mask);
   return Status::Success();
 }
 
 Status ExportKeyRaw(SymKey* key, blink::WebArrayBuffer* buffer) {
@@ skipping 72 matching lines @@
       SECKEY_ExtractPublicKey(spki.get()));
   if (!sec_public_key)
     return Status::Error();
 
   const KeyType sec_key_type = SECKEY_GetPublicKeyType(sec_public_key.get());
   blink::WebCryptoAlgorithm algorithm =
       ResolveNssKeyTypeWithInputAlgorithm(sec_key_type, algorithm_or_null);
   if (algorithm.isNull())
     return Status::Error();
 
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
   blink::WebCryptoKeyAlgorithm key_algorithm;
   if (!CreatePublicKeyAlgorithm(
           algorithm, sec_public_key.get(), &key_algorithm))
     return Status::ErrorUnexpected();
-#else
-  const blink::WebCryptoAlgorithm& key_algorithm = algorithm;
-#endif
 
   *key = blink::WebCryptoKey::create(new PublicKey(sec_public_key.Pass()),
                                      blink::WebCryptoKeyTypePublic,
                                      extractable,
                                      key_algorithm,
                                      usage_mask);
 
   return Status::Success();
 }
 
@@ skipping 42 matching lines @@
   }
   DCHECK(seckey_private_key);
   crypto::ScopedSECKEYPrivateKey private_key(seckey_private_key);
 
   const KeyType sec_key_type = SECKEY_GetPrivateKeyType(private_key.get());
   blink::WebCryptoAlgorithm algorithm =
       ResolveNssKeyTypeWithInputAlgorithm(sec_key_type, algorithm_or_null);
   if (algorithm.isNull())
     return Status::Error();
 
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
   blink::WebCryptoKeyAlgorithm key_algorithm;
   if (!CreatePrivateKeyAlgorithm(algorithm, private_key.get(), &key_algorithm))
     return Status::ErrorUnexpected();
-#else
-  const blink::WebCryptoAlgorithm& key_algorithm = algorithm;
-#endif
 
   *key = blink::WebCryptoKey::create(new PrivateKey(private_key.Pass()),
                                      blink::WebCryptoKeyTypePrivate,
                                      extractable,
                                      key_algorithm,
                                      usage_mask);
 
   return Status::Success();
 }
 
@@ skipping 253 matching lines @@
                                       CKM_RSA_PKCS_KEY_PAIR_GEN,
                                       &rsa_gen_params,
                                       &sec_public_key,
                                       attribute_flags,
                                       operation_flags,
                                       operation_flags_mask,
                                       NULL));
   if (!private_key)
     return Status::Error();
 
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
   blink::WebCryptoKeyAlgorithm key_algorithm;
   if (!CreatePublicKeyAlgorithm(algorithm, sec_public_key, &key_algorithm))
     return Status::ErrorUnexpected();
-#else
-  const blink::WebCryptoAlgorithm& key_algorithm = algorithm;
-#endif
 
   *public_key = blink::WebCryptoKey::create(
       new PublicKey(crypto::ScopedSECKEYPublicKey(sec_public_key)),
       blink::WebCryptoKeyTypePublic,
       true,
       key_algorithm,
       usage_mask);
   *private_key =
       blink::WebCryptoKey::create(new PrivateKey(scoped_sec_private_key.Pass()),
                                   blink::WebCryptoKeyTypePrivate,
@@ skipping 52 matching lines @@
   crypto::ScopedPK11Slot slot(PK11_GetInternalKeySlot());
   if (!slot)
     return Status::Error();
 
   crypto::ScopedPK11SymKey pk11_key(
       PK11_KeyGen(slot.get(), mech, NULL, keylen_bytes, NULL));
 
   if (!pk11_key)
     return Status::Error();
 
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
   blink::WebCryptoKeyAlgorithm key_algorithm;
   if (!CreateSecretKeyAlgorithm(algorithm, keylen_bytes, &key_algorithm))
     return Status::ErrorUnexpected();
-#else
-  const blink::WebCryptoAlgorithm& key_algorithm = algorithm;
-#endif
 
   *key = blink::WebCryptoKey::create(new SymKey(pk11_key.Pass()),
                                      key_type,
                                      extractable,
                                      key_algorithm,
                                      usage_mask);
   return Status::Success();
 }
 
 Status ImportRsaPublicKey(const blink::WebCryptoAlgorithm& algorithm,
@@ skipping 40 matching lines @@
       SEC_ASN1EncodeItem(NULL, NULL, &pubkey_in, rsa_public_key_template));
   if (!pubkey_der)
     return Status::Error();
 
   // Import the DER-encoded public key to create an RSA SECKEYPublicKey.
   crypto::ScopedSECKEYPublicKey pubkey(
       SECKEY_ImportDERPublicKey(pubkey_der.get(), CKK_RSA));
   if (!pubkey)
     return Status::Error();
 
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
   blink::WebCryptoKeyAlgorithm key_algorithm;
   if (!CreatePublicKeyAlgorithm(algorithm, pubkey.get(), &key_algorithm))
     return Status::ErrorUnexpected();
-#else
-  const blink::WebCryptoAlgorithm& key_algorithm = algorithm;
-#endif
 
   *key = blink::WebCryptoKey::create(new PublicKey(pubkey.Pass()),
                                      blink::WebCryptoKeyTypePublic,
                                      extractable,
                                      key_algorithm,
                                      usage_mask);
   return Status::Success();
 }
 
 }  // namespace platform
 
 }  // namespace webcrypto
 
 }  // namespace content