[webcrypto] Remove ifdefs for whether hmac key algorithm has length.

content/child/webcrypto/shared_crypto_unittest.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/shared_crypto.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 657 matching lines @@
 
     blink::WebCryptoAlgorithm importAlgorithm =
         CreateHmacImportAlgorithm(test_hash.id());
 
     blink::WebCryptoKey key = ImportSecretKeyFromRaw(
         test_key,
         importAlgorithm,
         blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageVerify);
 
     EXPECT_EQ(test_hash.id(), key.algorithm().hmacParams()->hash().id());
-#if defined(WEBCRYPTO_HMAC_KEY_HAS_LENGTH)
     EXPECT_EQ(test_key.size() * 8, key.algorithm().hmacParams()->lengthBits());
-#endif
 
     // Verify exported raw key is identical to the imported data
     blink::WebArrayBuffer raw_key;
     EXPECT_STATUS_SUCCESS(
         ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
     EXPECT_TRUE(ArrayBufferMatches(test_key, raw_key));
 
     blink::WebArrayBuffer output;
 
     ASSERT_STATUS_SUCCESS(
@@ skipping 260 matching lines @@
     blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
     blink::WebCryptoAlgorithm algorithm =
         CreateHmacKeyGenAlgorithm(blink::WebCryptoAlgorithmIdSha1, 512);
     ASSERT_STATUS_SUCCESS(GenerateSecretKey(algorithm, true, 0, &key));
     EXPECT_FALSE(key.isNull());
     EXPECT_TRUE(key.handle());
     EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
     EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, key.algorithm().id());
     EXPECT_EQ(blink::WebCryptoAlgorithmIdSha1,
               key.algorithm().hmacParams()->hash().id());
-#if defined(WEBCRYPTO_HMAC_KEY_HAS_LENGTH)
     EXPECT_EQ(512u, key.algorithm().hmacParams()->lengthBits());
-#endif
 
     blink::WebArrayBuffer raw_key;
     ASSERT_STATUS_SUCCESS(
         ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
     EXPECT_EQ(64U, raw_key.byteLength());
     keys.push_back(raw_key);
   }
   // Ensure all entries in the key sample set are unique. This is a simplistic
   // estimate of whether the generated keys appear random.
   EXPECT_FALSE(CopiesExist(keys));
 }
 
 // If the key length is not provided, then the block size is used.
 TEST_F(SharedCryptoTest, MAYBE(GenerateKeyHmacNoLength)) {
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   blink::WebCryptoAlgorithm algorithm =
       CreateHmacKeyGenAlgorithm(blink::WebCryptoAlgorithmIdSha1, 0);
   ASSERT_STATUS_SUCCESS(GenerateSecretKey(algorithm, true, 0, &key));
   EXPECT_TRUE(key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, key.algorithm().id());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha1,
             key.algorithm().hmacParams()->hash().id());
-#if defined(WEBCRYPTO_HMAC_KEY_HAS_LENGTH)
-    EXPECT_EQ(512u, key.algorithm().hmacParams()->lengthBits());
-#endif
+  EXPECT_EQ(512u, key.algorithm().hmacParams()->lengthBits());
   blink::WebArrayBuffer raw_key;
   ASSERT_STATUS_SUCCESS(ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
   EXPECT_EQ(64U, raw_key.byteLength());
 
   // The block size for HMAC SHA-512 is larger.
   algorithm = CreateHmacKeyGenAlgorithm(blink::WebCryptoAlgorithmIdSha512, 0);
   ASSERT_STATUS_SUCCESS(GenerateSecretKey(algorithm, true, 0, &key));
   EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, key.algorithm().id());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha512,
             key.algorithm().hmacParams()->hash().id());
-#if defined(WEBCRYPTO_HMAC_KEY_HAS_LENGTH)
-    EXPECT_EQ(1024u, key.algorithm().hmacParams()->lengthBits());
-#endif
+  EXPECT_EQ(1024u, key.algorithm().hmacParams()->lengthBits());
   ASSERT_STATUS_SUCCESS(ExportKey(blink::WebCryptoKeyFormatRaw, key, &raw_key));
   EXPECT_EQ(128U, raw_key.byteLength());
 }
 
 TEST_F(SharedCryptoTest, MAYBE(ImportSecretKeyNoAlgorithm)) {
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
 
   // This fails because the algorithm is null.
   EXPECT_STATUS(Status::ErrorMissingAlgorithmImportRawKey(),
                 ImportKey(blink::WebCryptoKeyFormatRaw,
@@ skipping 356 matching lines @@
   dict.SetString("k", "l3nZEgZCeX8XRwJdWyK3rGB8qwjhdY8vOkbIvh4lxTuMao9Y_--hdg");
   std::vector<uint8> json_vec = MakeJsonVector(dict);
   EXPECT_STATUS_SUCCESS(ImportKeyJwk(
       CryptoData(json_vec), algorithm, extractable, usage_mask, &key));
   EXPECT_TRUE(key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
   EXPECT_EQ(extractable, key.extractable());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, key.algorithm().id());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha256,
             key.algorithm().hmacParams()->hash().id());
-#if defined(WEBCRYPTO_HMAC_KEY_HAS_LENGTH)
-    EXPECT_EQ(320u, key.algorithm().hmacParams()->lengthBits());
-#endif
+  EXPECT_EQ(320u, key.algorithm().hmacParams()->lengthBits());
   EXPECT_EQ(blink::WebCryptoKeyUsageVerify, key.usages());
   key = blink::WebCryptoKey::createNull();
 
   // Consistency rules when JWK value exists: Fail if inconsistency is found.
 
   // Pass: All input values are consistent with the JWK values.
   dict.Clear();
   dict.SetString("kty", "oct");
   dict.SetString("alg", "HS256");
   dict.SetString("use", "sig");
@@ skipping 1238 matching lines @@
                                   blink::WebCryptoKeyUsageVerify,
                                   &unwrapped_key));
 
   // Validate the new key's attributes.
   EXPECT_FALSE(unwrapped_key.isNull());
   EXPECT_TRUE(unwrapped_key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, unwrapped_key.type());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdHmac, unwrapped_key.algorithm().id());
   EXPECT_EQ(blink::WebCryptoAlgorithmIdSha256,
             unwrapped_key.algorithm().hmacParams()->hash().id());
-#if defined(WEBCRYPTO_HMAC_KEY_HAS_LENGTH)
   EXPECT_EQ(256u, unwrapped_key.algorithm().hmacParams()->lengthBits());
-#endif
   EXPECT_EQ(true, unwrapped_key.extractable());
   EXPECT_EQ(blink::WebCryptoKeyUsageVerify, unwrapped_key.usages());
 
   // Export the new key's raw data and compare to the known original.
   blink::WebArrayBuffer raw_key;
   EXPECT_STATUS_SUCCESS(
       ExportKey(blink::WebCryptoKeyFormatRaw, unwrapped_key, &raw_key));
   EXPECT_TRUE(ArrayBufferMatches(key_data, raw_key));
 }
 
@@ skipping 343 matching lines @@
                           wrapping_algorithm,
                           key_algorithm,
                           true,
                           blink::WebCryptoKeyUsageSign,
                           &unwrapped_key));
 }
 
 }  // namespace webcrypto
 
 }  // namespace content