Check that usage isn't empty when generateKey() is called

content/child/webcrypto/test/ecdsa_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 "base/stl_util.h"
 #include "content/child/webcrypto/algorithm_dispatch.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/jwk.h"
 #include "content/child/webcrypto/status.h"
 #include "content/child/webcrypto/test/test_helpers.h"
@@ skipping 46 matching lines @@
   blink::WebCryptoNamedCurve named_curve = blink::WebCryptoNamedCurveP256;
 
   std::vector<std::vector<uint8_t>> serialized_keys;
 
   // Generate a small sample of keys.
   for (int j = 0; j < 4; ++j) {
     blink::WebCryptoKey public_key;
     blink::WebCryptoKey private_key;
 
     ASSERT_EQ(Status::Success(),
-              GenerateKeyPair(CreateEcdsaKeyGenAlgorithm(named_curve), true, 0,
-                              &public_key, &private_key));
+              GenerateKeyPair(CreateEcdsaKeyGenAlgorithm(named_curve), true,
+                              blink::WebCryptoKeyUsageSign, &public_key,
+                              &private_key));
 
     // Basic sanity checks on the generated key pair.
     EXPECT_EQ(blink::WebCryptoKeyTypePublic, public_key.type());
     EXPECT_EQ(blink::WebCryptoKeyTypePrivate, private_key.type());
     EXPECT_EQ(named_curve, public_key.algorithm().ecParams()->namedCurve());
     EXPECT_EQ(named_curve, private_key.algorithm().ecParams()->namedCurve());
 
     // Export the key pair to JWK.
     std::vector<uint8_t> key_bytes;
     ASSERT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatJwk, public_key, &key_bytes));
     serialized_keys.push_back(key_bytes);
 
     ASSERT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatJwk, private_key, &key_bytes));
     serialized_keys.push_back(key_bytes);
   }
 
   // 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(serialized_keys));
 }
 
+TEST(WebCryptoEcdsaTest, GenerateKeyEmptyUsage) {
+  if (!SupportsEcdsa())
+    return;
+
+  blink::WebCryptoNamedCurve named_curve = blink::WebCryptoNamedCurveP256;
+  blink::WebCryptoKey public_key;
+  blink::WebCryptoKey private_key;
+  ASSERT_EQ(Status::ErrorCreateKeyEmptyUsages(),
+            GenerateKeyPair(CreateEcdsaKeyGenAlgorithm(named_curve), true, 0,
+                            &public_key, &private_key));
+}
+
 // Verify that ECDSA signatures are probabilistic. Signing the same message two
 // times should yield different signatures. However both signatures should
 // verify correctly.
 TEST(WebCryptoEcdsaTest, SignatureIsRandom) {
   if (!SupportsEcdsa())
     return;
 
   // Import a public and private keypair from "ec_private_keys.json". It doesn't
   // really matter which one is used since they are all valid. In this case
   // using the first one.
@@ skipping 192 matching lines @@
               ExportKey(blink::WebCryptoKeyFormatJwk, key, &exported_bytes));
     EXPECT_EQ(CryptoData(jwk_bytes), CryptoData(exported_bytes));
   }
 }
 
 }  // namespace
 
 }  // namespace webcrypto
 
 }  // namespace content