[webcrypto] Change HMAC key generation length from bytes to bits.

content/renderer/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/renderer/webcrypto/shared_crypto.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 90 matching lines @@
                                        iv.size(),
                                        true,
                                        Uint8VectorStart(additional_data),
                                        additional_data.size(),
                                        true,
                                        tag_length_bits));
 }
 
 // Creates an HMAC algorithm whose parameters struct is compatible with key
 // generation. It is an error to call this with a hash_id that is not a SHA*.
-// The key_length_bytes parameter is optional, with zero meaning unspecified.
+// The key_length_bits parameter is optional, with zero meaning unspecified.
 blink::WebCryptoAlgorithm CreateHmacKeyGenAlgorithm(
     blink::WebCryptoAlgorithmId hash_id,
-    unsigned int key_length_bytes) {
+    unsigned int key_length_bits) {
+#ifndef WEBCRYPTO_HMAC_BITS

[Ryan Sleevi, 2014/03/06 21:51:37]

!defined

[eroman, 2014/03/06 21:54:18]

Done.

+  // TODO(eroman): Delete
+  key_length_bits /= 8;
+#endif
   DCHECK(IsHashAlgorithm(hash_id));
   // key_length_bytes == 0 means unspecified
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       blink::WebCryptoAlgorithmIdHmac,
       new blink::WebCryptoHmacKeyGenParams(
-          CreateAlgorithm(hash_id), (key_length_bytes != 0), key_length_bytes));
+          CreateAlgorithm(hash_id), (key_length_bits != 0), key_length_bits));
 }
 
 // Returns a slightly modified version of the input vector.
 //
 //  - For non-empty inputs a single bit is inverted.
 //  - For empty inputs, a byte is added.
 std::vector<uint8> Corrupted(const std::vector<uint8>& input) {
   std::vector<uint8> corrupted_data(input);
   if (corrupted_data.empty())
     corrupted_data.push_back(0);
@@ skipping 727 matching lines @@
   }
 }
 
 TEST_F(SharedCryptoTest, MAYBE(GenerateKeyHmac)) {
   // Generate a small sample of HMAC keys.
   std::vector<blink::WebArrayBuffer> keys;
   for (int i = 0; i < 16; ++i) {
     blink::WebArrayBuffer key_bytes;
     blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
     blink::WebCryptoAlgorithm algorithm =
-        CreateHmacKeyGenAlgorithm(blink::WebCryptoAlgorithmIdSha1, 64);
+        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());
 
     blink::WebArrayBuffer raw_key;
     ASSERT_STATUS_SUCCESS(
@@ skipping 1257 matching lines @@
                                         test_cipher_text,
                                         test_authentication_tag,
                                         &plain_text));
     }
   }
 }
 
 }  // namespace webcrypto
 
 }  // namespace content