[WebCrypto] Throw syntaxError if keyUsage is empty in ImportKey

content/child/webcrypto/test/rsa_ssa_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/logging.h"
 #include "base/stl_util.h"
 #include "content/child/webcrypto/algorithm_dispatch.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/status.h"
 #include "content/child/webcrypto/test/test_helpers.h"
@@ skipping 337 matching lines @@
                                          public_key, &public_key_spki));
 
   if (SupportsRsaPrivateKeyImport()) {
     public_key = blink::WebCryptoKey::createNull();
     EXPECT_EQ(
         Status::Success(),
         ImportKey(blink::WebCryptoKeyFormatSpki, CryptoData(public_key_spki),
                   CreateRsaHashedImportAlgorithm(
                       blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                       blink::WebCryptoAlgorithmIdSha256),
-                  true, usages, &public_key));
+                  true, blink::WebCryptoKeyUsageVerify, &public_key));

[eroman, 2014/12/05 20:45:51]

sync the code, this has already changed:

https://codereview.chromium.org/757873003/diff/20001/content/child/webcrypto/...

[Habib Virji, 2014/12/08 15:05:21]

Done.

     EXPECT_EQ(modulus_length,
               public_key.algorithm().rsaHashedParams()->modulusLengthBits());
 
     std::vector<uint8_t> private_key_pkcs8;
     EXPECT_EQ(Status::Success(), ExportKey(blink::WebCryptoKeyFormatPkcs8,
                                            private_key, &private_key_pkcs8));
     private_key = blink::WebCryptoKey::createNull();
     EXPECT_EQ(
         Status::Success(),
         ImportKey(blink::WebCryptoKeyFormatPkcs8, CryptoData(private_key_pkcs8),
                   CreateRsaHashedImportAlgorithm(
                       blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                       blink::WebCryptoAlgorithmIdSha256),
-                  true, usages, &private_key));
+                  true, blink::WebCryptoKeyUsageSign, &private_key));
     EXPECT_EQ(modulus_length,
               private_key.algorithm().rsaHashedParams()->modulusLengthBits());
   }
 
   // Fail with bad modulus.
   algorithm = CreateRsaHashedKeyGenAlgorithm(
       blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
       blink::WebCryptoAlgorithmIdSha256, 0, public_exponent);
   EXPECT_EQ(Status::ErrorGenerateRsaUnsupportedModulus(),
             GenerateKeyPair(algorithm, extractable, usages, &public_key,
@@ skipping 559 matching lines @@
 
     const base::DictionaryValue* test;
     ASSERT_TRUE(tests->GetDictionary(test_index, &test));
 
     blink::WebCryptoKeyFormat key_format = GetKeyFormatFromJsonTestCase(test);
     std::vector<uint8_t> key_data =
         GetKeyDataFromJsonTestCase(test, key_format);
     std::string test_error;
     ASSERT_TRUE(test->GetString("error", &test_error));
 
+    blink::WebCryptoKeyUsage keyUsage = blink::WebCryptoKeyUsageSign;
+    if (key_format == blink::WebCryptoKeyFormatSpki)
+        keyUsage = blink::WebCryptoKeyUsageVerify;
+
     blink::WebCryptoKey key;
     Status status = ImportKey(key_format, CryptoData(key_data),
                               CreateRsaHashedImportAlgorithm(
                                   blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                   blink::WebCryptoAlgorithmIdSha256),
-                              true, 0, &key);
+                              true, keyUsage, &key);
+
     EXPECT_EQ(test_error, StatusToString(status));
   }
 }
 
 }  // namespace
 
 }  // namespace webcrypto
 
 }  // namespace content