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

content/renderer/webcrypto/shared_crypto.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/shared_crypto.h"
 
 #include "base/logging.h"
 #include "content/renderer/webcrypto/crypto_data.h"
 #include "content/renderer/webcrypto/platform_crypto.h"
 #include "content/renderer/webcrypto/webcrypto_util.h"
 #include "crypto/secure_util.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
 #include "third_party/WebKit/public/platform/WebCryptoKey.h"
 
 namespace content {
 
 namespace webcrypto {
 
 namespace {
 
 // TODO(eroman): Move this helper to WebCryptoKey.
 bool KeyUsageAllows(const blink::WebCryptoKey& key,
@@ skipping 155 matching lines @@
 
 Status SignRsaSsaPkcs1v1_5(const blink::WebCryptoAlgorithm& algorithm,
                            const blink::WebCryptoKey& key,
                            const CryptoData& data,
                            blink::WebArrayBuffer* buffer) {
   platform::PrivateKey* private_key;
   Status status = ToPlatformPrivateKey(key, &private_key);
   if (status.IsError())
     return status;
 
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
   return platform::SignRsaSsaPkcs1v1_5(
       private_key, key.algorithm().rsaHashedParams()->hash(), data, buffer);
-#else
-  return platform::SignRsaSsaPkcs1v1_5(
-      private_key, algorithm.rsaSsaParams()->hash(), data, buffer);
-#endif
 }
 
 Status VerifyRsaSsaPkcs1v1_5(const blink::WebCryptoAlgorithm& algorithm,
                              const blink::WebCryptoKey& key,
                              const CryptoData& signature,
                              const CryptoData& data,
                              bool* signature_match) {
   platform::PublicKey* public_key;
   Status status = ToPlatformPublicKey(key, &public_key);
   if (status.IsError())
     return status;
 
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
   return platform::VerifyRsaSsaPkcs1v1_5(
       public_key,
       key.algorithm().rsaHashedParams()->hash(),
       signature,
       data,
       signature_match);
-#else
-  return platform::VerifyRsaSsaPkcs1v1_5(public_key,
-                                         algorithm.rsaSsaParams()->hash(),
-                                         signature,
-                                         data,
-                                         signature_match);
-#endif
 }
 
 Status ImportKeyRaw(const CryptoData& key_data,
                     const blink::WebCryptoAlgorithm& algorithm_or_null,
                     bool extractable,
                     blink::WebCryptoKeyUsageMask usage_mask,
                     blink::WebCryptoKey* key) {
   if (algorithm_or_null.isNull())
     return Status::ErrorMissingAlgorithmImportRawKey();
 
@@ skipping 85 matching lines @@
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdAesCbc:
     case blink::WebCryptoAlgorithmIdAesGcm:
     case blink::WebCryptoAlgorithmIdAesKw: {
       if (!IsValidAesKeyLengthBits(algorithm.aesKeyGenParams()->lengthBits()))
         return Status::ErrorGenerateKeyLength();
       keylen_bytes = algorithm.aesKeyGenParams()->lengthBits() / 8;
       break;
     }
     case blink::WebCryptoAlgorithmIdHmac: {
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
       const blink::WebCryptoHmacKeyGenParams* params =
           algorithm.hmacKeyGenParams();
-#else
-      const blink::WebCryptoHmacKeyParams* params = algorithm.hmacKeyParams();
-#endif
       DCHECK(params);
       if (params->hasLengthBytes()) {
         keylen_bytes = params->optionalLengthBytes();
       } else {
         keylen_bytes = ShaBlockSizeBytes(params->hash().id());
         if (keylen_bytes == 0)
           return Status::ErrorUnsupported();
       }
       break;
     }
@@ skipping 11 matching lines @@
       algorithm, extractable, usage_mask, keylen_bytes, key);
 }
 
 Status GenerateKeyPair(const blink::WebCryptoAlgorithm& algorithm,
                        bool extractable,
                        blink::WebCryptoKeyUsageMask usage_mask,
                        blink::WebCryptoKey* public_key,
                        blink::WebCryptoKey* private_key) {
   // TODO(padolph): Handle other asymmetric algorithm key generation.
   switch (algorithm.paramsType()) {
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
     case blink::WebCryptoAlgorithmParamsTypeRsaHashedKeyGenParams:
     case blink::WebCryptoAlgorithmParamsTypeRsaKeyGenParams: {
       const blink::WebCryptoRsaKeyGenParams* params = NULL;
       blink::WebCryptoAlgorithm hash_or_null =
           blink::WebCryptoAlgorithm::createNull();
       if (algorithm.rsaHashedKeyGenParams()) {
         params = algorithm.rsaHashedKeyGenParams();
         hash_or_null = algorithm.rsaHashedKeyGenParams()->hash();
       } else {
         params = algorithm.rsaKeyGenParams();
       }
-#else
-    case blink::WebCryptoAlgorithmParamsTypeRsaKeyGenParams: {
-      const blink::WebCryptoRsaKeyGenParams* params =
-          algorithm.rsaKeyGenParams();
-      blink::WebCryptoAlgorithm hash_or_null =
-          blink::WebCryptoAlgorithm::createNull();
-#endif
 
       if (!params->modulusLengthBits())
         return Status::ErrorGenerateRsaZeroModulus();
 
       CryptoData publicExponent(params->publicExponent());
       if (!publicExponent.byte_length())
         return Status::ErrorGenerateKeyPublicExponent();
 
       return platform::GenerateRsaKeyPair(algorithm,
                                           extractable,
@@ skipping 107 matching lines @@
       return VerifyRsaSsaPkcs1v1_5(
           algorithm, key, signature, data, signature_match);
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 }  // namespace webcrypto
 
 }  // namespace content