[refactor] Misc post-NSS WebCrypto cleanups.

components/webcrypto/algorithms/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 "components/webcrypto/algorithm_dispatch.h"
 #include "components/webcrypto/algorithms/test_helpers.h"
 #include "components/webcrypto/crypto_data.h"
 #include "components/webcrypto/jwk.h"
 #include "components/webcrypto/status.h"
 #include "components/webcrypto/webcrypto_util.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 
 namespace webcrypto {
 
 namespace {
 
-bool SupportsEcdsa() {
-#if defined(USE_OPENSSL)
-  return true;
-#else
-  LOG(ERROR) << "Skipping ECDSA test because unsupported";
-  return false;
-#endif
-}
-
 blink::WebCryptoAlgorithm CreateEcdsaKeyGenAlgorithm(
     blink::WebCryptoNamedCurve named_curve) {
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       blink::WebCryptoAlgorithmIdEcdsa,
       new blink::WebCryptoEcKeyGenParams(named_curve));
 }
 
 blink::WebCryptoAlgorithm CreateEcdsaImportAlgorithm(
     blink::WebCryptoNamedCurve named_curve) {
   return CreateEcImportAlgorithm(blink::WebCryptoAlgorithmIdEcdsa, named_curve);
 }
 
 blink::WebCryptoAlgorithm CreateEcdsaAlgorithm(
     blink::WebCryptoAlgorithmId hash_id) {
   return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
       blink::WebCryptoAlgorithmIdEcdsa,
       new blink::WebCryptoEcdsaParams(CreateAlgorithm(hash_id)));
 }
 
 class WebCryptoEcdsaTest : public WebCryptoTestBase {};
 
 // Generates some ECDSA key pairs. Validates basic properties on the keys, and
 // ensures the serialized key (as JWK) is unique. This test does nothing to
 // ensure that the keys are otherwise usable (by trying to sign/verify with
 // them).
 TEST_F(WebCryptoEcdsaTest, GenerateKeyIsRandom) {
-  if (!SupportsEcdsa())
-    return;
-
   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(),
@@ skipping 17 matching lines @@
               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_F(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_F(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.
   scoped_ptr<base::ListValue> private_keys;
   ASSERT_TRUE(ReadJsonTestFileToList("ec_private_keys.json", &private_keys));
   const base::DictionaryValue* key_dict;
   ASSERT_TRUE(private_keys->GetDictionary(0, &key_dict));
   blink::WebCryptoNamedCurve curve = GetCurveNameFromDictionary(key_dict);
   const base::DictionaryValue* key_jwk;
   ASSERT_TRUE(key_dict->GetDictionary("jwk", &key_jwk));
@@ skipping 38 matching lines @@
   EXPECT_TRUE(signature_matches);
   ASSERT_EQ(Status::Success(),
             Verify(algorithm, public_key, CryptoData(signature2),
                    CryptoData(message), &signature_matches));
   EXPECT_TRUE(signature_matches);
 }
 
 // Tests verify() for ECDSA using an assortment of keys, curves and hashes.
 // These tests also include expected failures for bad signatures and keys.
 TEST_F(WebCryptoEcdsaTest, VerifyKnownAnswer) {
-  if (!SupportsEcdsa())
-    return;
-
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("ecdsa.json", &tests));
 
   for (size_t test_index = 0; test_index < tests->GetSize(); ++test_index) {
     SCOPED_TRACE(test_index);
 
     const base::DictionaryValue* test;
     ASSERT_TRUE(tests->GetDictionary(test_index, &test));
 
     blink::WebCryptoNamedCurve curve = GetCurveNameFromDictionary(test);
@@ skipping 62 matching lines @@
       return key->HasKey("d") ? kPrivateUsages : kPublicUsages;
     }
   }
 
   // Appease compiler.
   return kPrivateUsages;
 }
 
 // Tests importing bad public/private keys in a variety of formats.
 TEST_F(WebCryptoEcdsaTest, ImportBadKeys) {
-  if (!SupportsEcdsa())
-    return;
-
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("bad_ec_keys.json", &tests));
 
   for (size_t test_index = 0; test_index < tests->GetSize(); ++test_index) {
     SCOPED_TRACE(test_index);
 
     const base::DictionaryValue* test;
     ASSERT_TRUE(tests->GetDictionary(test_index, &test));
 
     blink::WebCryptoNamedCurve curve = GetCurveNameFromDictionary(test);
@@ skipping 10 matching lines @@
     ASSERT_EQ(expected_error, StatusToString(status));
   }
 }
 
 // Tests importing and exporting of EC private keys, using both JWK and PKCS8
 // formats.
 //
 // The test imports a key first using JWK, and then exporting it to JWK and
 // PKCS8. It does the same thing using PKCS8 as the original source of truth.
 TEST_F(WebCryptoEcdsaTest, ImportExportPrivateKey) {
-  if (!SupportsEcdsa())
-    return;
-
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("ec_private_keys.json", &tests));
 
   for (size_t test_index = 0; test_index < tests->GetSize(); ++test_index) {
     SCOPED_TRACE(test_index);
 
     const base::DictionaryValue* test;
     ASSERT_TRUE(tests->GetDictionary(test_index, &test));
 
     blink::WebCryptoNamedCurve curve = GetCurveNameFromDictionary(test);
@@ skipping 67 matching lines @@
     // Export the key as JWK
     ASSERT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatJwk, key, &exported_bytes));
     EXPECT_EQ(CryptoData(jwk_bytes), CryptoData(exported_bytes));
   }
 }
 
 }  // namespace
 
 }  // namespace webcrypto