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

content/renderer/webcrypto/webcrypto_util.cc

 // Copyright 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 "content/renderer/webcrypto/webcrypto_util.h"
 
 #include "base/base64.h"
 #include "base/logging.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
 
 namespace content {
 
 namespace webcrypto {
 
 bool Status::IsError() const { return type_ == TYPE_ERROR; }
 
 bool Status::IsSuccess() const { return type_ == TYPE_SUCCESS; }
 
 bool Status::HasErrorDetails() const { return !error_details_.empty(); }
@@ skipping 182 matching lines @@
 }
 
 bool IsHashAlgorithm(blink::WebCryptoAlgorithmId alg_id) {
   return alg_id == blink::WebCryptoAlgorithmIdSha1 ||
          alg_id == blink::WebCryptoAlgorithmIdSha224 ||
          alg_id == blink::WebCryptoAlgorithmIdSha256 ||
          alg_id == blink::WebCryptoAlgorithmIdSha384 ||
          alg_id == blink::WebCryptoAlgorithmIdSha512;
 }
 
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
 blink::WebCryptoAlgorithm GetInnerHashAlgorithm(
     const blink::WebCryptoAlgorithm& algorithm) {
   DCHECK(!algorithm.isNull());
   switch (algorithm.paramsType()) {
     case blink::WebCryptoAlgorithmParamsTypeHmacImportParams:
       return algorithm.hmacImportParams()->hash();
     case blink::WebCryptoAlgorithmParamsTypeHmacKeyGenParams:
       return algorithm.hmacKeyGenParams()->hash();
     case blink::WebCryptoAlgorithmParamsTypeRsaHashedImportParams:
       return algorithm.rsaHashedImportParams()->hash();
     case blink::WebCryptoAlgorithmParamsTypeRsaHashedKeyGenParams:
       return algorithm.rsaHashedKeyGenParams()->hash();
     default:
       return blink::WebCryptoAlgorithm::createNull();
   }
 }
-#else
-blink::WebCryptoAlgorithm GetInnerHashAlgorithm(
-    const blink::WebCryptoAlgorithm& algorithm) {
-  DCHECK(!algorithm.isNull());
-  switch (algorithm.id()) {
-    case blink::WebCryptoAlgorithmIdHmac:
-      if (algorithm.hmacParams())
-        return algorithm.hmacParams()->hash();
-      else if (algorithm.hmacKeyParams())
-        return algorithm.hmacKeyParams()->hash();
-      break;
-    case blink::WebCryptoAlgorithmIdRsaOaep:
-      if (algorithm.rsaOaepParams())
-        return algorithm.rsaOaepParams()->hash();
-      break;
-    case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
-      if (algorithm.rsaSsaParams())
-        return algorithm.rsaSsaParams()->hash();
-      break;
-    default:
-      break;
-  }
-  return blink::WebCryptoAlgorithm::createNull();
-}
-#endif
 
 blink::WebCryptoAlgorithm CreateAlgorithm(blink::WebCryptoAlgorithmId id) {
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(id, NULL);
 }
 
 blink::WebCryptoAlgorithm CreateHmacImportAlgorithm(
     blink::WebCryptoAlgorithmId hash_id) {
   DCHECK(IsHashAlgorithm(hash_id));
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       blink::WebCryptoAlgorithmIdHmac,
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
       new blink::WebCryptoHmacImportParams(CreateAlgorithm(hash_id)));
-#else
-      new blink::WebCryptoHmacParams(CreateAlgorithm(hash_id)));
-#endif
 }
 
 blink::WebCryptoAlgorithm CreateRsaSsaImportAlgorithm(
     blink::WebCryptoAlgorithmId hash_id) {
   DCHECK(IsHashAlgorithm(hash_id));
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
       new blink::WebCryptoRsaHashedImportParams(CreateAlgorithm(hash_id)));
-#else
-      new blink::WebCryptoRsaSsaParams(CreateAlgorithm(hash_id)));
-#endif
 }
 
 blink::WebCryptoAlgorithm CreateRsaOaepImportAlgorithm(
     blink::WebCryptoAlgorithmId hash_id) {
   DCHECK(IsHashAlgorithm(hash_id));
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       blink::WebCryptoAlgorithmIdRsaOaep,
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
       new blink::WebCryptoRsaHashedImportParams(
           CreateAlgorithm(hash_id)));
-#else
-      new blink::WebCryptoRsaOaepParams(
-          CreateAlgorithm(hash_id), false, NULL, 0));
-#endif
 }
 
 
 unsigned int ShaBlockSizeBytes(blink::WebCryptoAlgorithmId hash_id) {
   switch (hash_id) {
     case blink::WebCryptoAlgorithmIdSha1:
     case blink::WebCryptoAlgorithmIdSha224:
     case blink::WebCryptoAlgorithmIdSha256:
       return 64;
     case blink::WebCryptoAlgorithmIdSha384:
     case blink::WebCryptoAlgorithmIdSha512:
       return 128;
     default:
       NOTREACHED();
       return 0;
   }
 }
 
-#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
 bool CreateSecretKeyAlgorithm(const blink::WebCryptoAlgorithm& algorithm,
                               unsigned keylen_bytes,
                               blink::WebCryptoKeyAlgorithm* key_algorithm) {
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdHmac: {
       blink::WebCryptoAlgorithm hash = GetInnerHashAlgorithm(algorithm);
       if (hash.isNull())
         return false;
       *key_algorithm = blink::WebCryptoKeyAlgorithm::adoptParamsAndCreate(
           algorithm.id(),
           new blink::WebCryptoHmacKeyAlgorithmParams(hash));
       return true;
     }
     case blink::WebCryptoAlgorithmIdAesKw:
     case blink::WebCryptoAlgorithmIdAesCbc:
     case blink::WebCryptoAlgorithmIdAesCtr:
     case blink::WebCryptoAlgorithmIdAesGcm:
       *key_algorithm = blink::WebCryptoKeyAlgorithm::adoptParamsAndCreate(
           algorithm.id(),
           new blink::WebCryptoAesKeyAlgorithmParams(keylen_bytes * 8));
       return true;
     default:
       return false;
   }
 }
-#else
-bool CreateSecretKeyAlgorithm(const blink::WebCryptoAlgorithm& algorithm,
-                              unsigned keylen_bytes,
-                              blink::WebCryptoAlgorithm* key_algorithm) {
-  *key_algorithm = algorithm;
-  return true;
-}
-#endif
 
 }  // namespace webcrypto
 
 }  // namespace content