Cleanup: Use default constructor for WebCryptoKey rather than createNull() factory method.

content/child/webcrypto/test/rsa_oaep_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/jwk.h"
 #include "content/child/webcrypto/status.h"
@@ skipping 29 matching lines @@
 }
 
 // Import a PKCS#8 private key that uses RSAPrivateKey with the
 // id-rsaEncryption OID.
 TEST(WebCryptoRsaOaepTest, ImportPkcs8WithRsaEncryption) {
   if (!SupportsRsaOaep()) {
     LOG(WARNING) << "RSA-OAEP support not present; skipping.";
     return;
   }
 
-  blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey private_key;
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatPkcs8,
                       CryptoData(HexStringToBytes(kPrivateKeyPkcs8DerHex)),
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaOaep,
                           blink::WebCryptoAlgorithmIdSha1),
                       true,
                       blink::WebCryptoKeyUsageDecrypt,
                       &private_key));
 }
 
 TEST(WebCryptoRsaOaepTest, ImportPublicJwkWithNoAlg) {
   if (!SupportsRsaOaep()) {
     LOG(WARNING) << "RSA-OAEP support not present; skipping.";
     return;
   }
 
   scoped_ptr<base::DictionaryValue> jwk(CreatePublicKeyJwkDict());
 
-  blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey public_key;
   ASSERT_EQ(Status::Success(),
             ImportKeyJwkFromDict(*jwk.get(),
                                  CreateRsaHashedImportAlgorithm(
                                      blink::WebCryptoAlgorithmIdRsaOaep,
                                      blink::WebCryptoAlgorithmIdSha1),
                                  true,
                                  blink::WebCryptoKeyUsageEncrypt,
                                  &public_key));
 }
 
 TEST(WebCryptoRsaOaepTest, ImportPublicJwkWithMatchingAlg) {
   if (!SupportsRsaOaep()) {
     LOG(WARNING) << "RSA-OAEP support not present; skipping.";
     return;
   }
 
   scoped_ptr<base::DictionaryValue> jwk(CreatePublicKeyJwkDict());
   jwk->SetString("alg", "RSA-OAEP");
 
-  blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey public_key;
   ASSERT_EQ(Status::Success(),
             ImportKeyJwkFromDict(*jwk.get(),
                                  CreateRsaHashedImportAlgorithm(
                                      blink::WebCryptoAlgorithmIdRsaOaep,
                                      blink::WebCryptoAlgorithmIdSha1),
                                  true,
                                  blink::WebCryptoKeyUsageEncrypt,
                                  &public_key));
 }
 
 TEST(WebCryptoRsaOaepTest, ImportPublicJwkWithMismatchedAlgFails) {
   if (!SupportsRsaOaep()) {
     LOG(WARNING) << "RSA-OAEP support not present; skipping.";
     return;
   }
 
   scoped_ptr<base::DictionaryValue> jwk(CreatePublicKeyJwkDict());
   jwk->SetString("alg", "RSA-OAEP-512");
 
-  blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey public_key;
   ASSERT_EQ(Status::ErrorJwkAlgorithmInconsistent(),
             ImportKeyJwkFromDict(*jwk.get(),
                                  CreateRsaHashedImportAlgorithm(
                                      blink::WebCryptoAlgorithmIdRsaOaep,
                                      blink::WebCryptoAlgorithmIdSha1),
                                  true,
                                  blink::WebCryptoKeyUsageEncrypt,
                                  &public_key));
 }
 
 TEST(WebCryptoRsaOaepTest, ImportPublicJwkWithMismatchedTypeFails) {
   if (!SupportsRsaOaep()) {
     LOG(WARNING) << "RSA-OAEP support not present; skipping.";
     return;
   }
 
   scoped_ptr<base::DictionaryValue> jwk(CreatePublicKeyJwkDict());
   jwk->SetString("kty", "oct");
   jwk->SetString("alg", "RSA-OAEP");
 
-  blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey public_key;
   ASSERT_EQ(Status::ErrorJwkUnexpectedKty("RSA"),
             ImportKeyJwkFromDict(*jwk.get(),
                                  CreateRsaHashedImportAlgorithm(
                                      blink::WebCryptoAlgorithmIdRsaOaep,
                                      blink::WebCryptoAlgorithmIdSha1),
                                  true,
                                  blink::WebCryptoKeyUsageEncrypt,
                                  &public_key));
 }
 
@@ skipping 11 matching lines @@
                    {blink::WebCryptoAlgorithmIdSha384, "RSA-OAEP-384"},
                    {blink::WebCryptoAlgorithmIdSha512, "RSA-OAEP-512"}};
   for (size_t i = 0; i < arraysize(kTestData); ++i) {
     const TestData& test_data = kTestData[i];
     SCOPED_TRACE(test_data.expected_jwk_alg);
 
     scoped_ptr<base::DictionaryValue> jwk(CreatePublicKeyJwkDict());
     jwk->SetString("alg", test_data.expected_jwk_alg);
 
     // Import the key in a known-good format
-    blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
+    blink::WebCryptoKey public_key;
     ASSERT_EQ(Status::Success(),
               ImportKeyJwkFromDict(
                   *jwk.get(),
                   CreateRsaHashedImportAlgorithm(
                       blink::WebCryptoAlgorithmIdRsaOaep, test_data.hash_alg),
                   true,
                   blink::WebCryptoKeyUsageEncrypt,
                   &public_key));
 
     // Now export the key as JWK and verify its contents
@@ skipping 29 matching lines @@
     std::vector<uint8_t> public_key_der =
         GetBytesFromHexString(test, "public_key");
     std::vector<uint8_t> private_key_der =
         GetBytesFromHexString(test, "private_key");
     std::vector<uint8_t> ciphertext = GetBytesFromHexString(test, "ciphertext");
     std::vector<uint8_t> plaintext = GetBytesFromHexString(test, "plaintext");
     std::vector<uint8_t> label = GetBytesFromHexString(test, "label");
 
     blink::WebCryptoAlgorithm import_algorithm = CreateRsaHashedImportAlgorithm(
         blink::WebCryptoAlgorithmIdRsaOaep, digest_algorithm.id());
-    blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
-    blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
+    blink::WebCryptoKey public_key;
+    blink::WebCryptoKey private_key;
 
     ASSERT_NO_FATAL_FAILURE(ImportRsaKeyPair(public_key_der,
                                              private_key_der,
                                              import_algorithm,
                                              false,
                                              blink::WebCryptoKeyUsageEncrypt,
                                              blink::WebCryptoKeyUsageDecrypt,
                                              &public_key,
                                              &private_key));
 
@@ skipping 24 matching lines @@
   if (!SupportsRsaOaep()) {
     LOG(WARNING) << "RSA-OAEP support not present; skipping.";
     return;
   }
 
   const blink::WebCryptoAlgorithmId kHash = blink::WebCryptoAlgorithmIdSha1;
   const size_t kHashSize = 20;
 
   scoped_ptr<base::DictionaryValue> jwk(CreatePublicKeyJwkDict());
 
-  blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey public_key;
   ASSERT_EQ(Status::Success(),
             ImportKeyJwkFromDict(*jwk.get(),
                                  CreateRsaHashedImportAlgorithm(
                                      blink::WebCryptoAlgorithmIdRsaOaep, kHash),
                                  true,
                                  blink::WebCryptoKeyUsageEncrypt,
                                  &public_key));
 
   // The maximum size of an encrypted message is:
   //   modulus length
@@ skipping 46 matching lines @@
 TEST(WebCryptoRsaOaepTest, EncryptWithLargeDigestFails) {
   if (!SupportsRsaOaep()) {
     LOG(WARNING) << "RSA-OAEP support not present; skipping.";
     return;
   }
 
   const blink::WebCryptoAlgorithmId kHash = blink::WebCryptoAlgorithmIdSha512;
 
   scoped_ptr<base::DictionaryValue> jwk(CreatePublicKeyJwkDict());
 
-  blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey public_key;
   ASSERT_EQ(Status::Success(),
             ImportKeyJwkFromDict(*jwk.get(),
                                  CreateRsaHashedImportAlgorithm(
                                      blink::WebCryptoAlgorithmIdRsaOaep, kHash),
                                  true,
                                  blink::WebCryptoKeyUsageEncrypt,
                                  &public_key));
 
   // The label has no influence on the maximum message size. For simplicity,
   // use the empty string.
   std::vector<uint8_t> label;
   blink::WebCryptoAlgorithm op_algorithm = CreateRsaOaepAlgorithm(label);
 
   std::string small_message("A");
   std::vector<uint8_t> ciphertext;
   // This is an operation error, as the internal consistency checking of the
   // algorithm parameters is up to the implementation.
   ASSERT_EQ(
       Status::OperationError(),
       Encrypt(
           op_algorithm, public_key, CryptoData(small_message), &ciphertext));
 }
 
 TEST(WebCryptoRsaOaepTest, DecryptWithLargeMessageFails) {
   if (!SupportsRsaOaep()) {
     LOG(WARNING) << "RSA-OAEP support not present; skipping.";
     return;
   }
 
-  blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey private_key;
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatPkcs8,
                       CryptoData(HexStringToBytes(kPrivateKeyPkcs8DerHex)),
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaOaep,
                           blink::WebCryptoAlgorithmIdSha1),
                       true,
                       blink::WebCryptoKeyUsageDecrypt,
                       &private_key));
 
@@ skipping 13 matching lines @@
 }
 
 TEST(WebCryptoRsaOaepTest, WrapUnwrapRawKey) {
   if (!SupportsRsaOaep()) {
     LOG(WARNING) << "RSA-OAEP support not present; skipping.";
     return;
   }
 
   blink::WebCryptoAlgorithm import_algorithm = CreateRsaHashedImportAlgorithm(
       blink::WebCryptoAlgorithmIdRsaOaep, blink::WebCryptoAlgorithmIdSha1);
-  blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
-  blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey public_key;
+  blink::WebCryptoKey private_key;
 
   ASSERT_NO_FATAL_FAILURE(ImportRsaKeyPair(
       HexStringToBytes(kPublicKeySpkiDerHex),
       HexStringToBytes(kPrivateKeyPkcs8DerHex),
       import_algorithm,
       false,
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageWrapKey,
       blink::WebCryptoKeyUsageDecrypt | blink::WebCryptoKeyUsageUnwrapKey,
       &public_key,
       &private_key));
@@ skipping 23 matching lines @@
   // Because |private_key| supports both decrypt and unwrap, this is valid.
   std::vector<uint8_t> decrypted_key;
   ASSERT_EQ(Status::Success(),
             Decrypt(wrapping_algorithm,
                     private_key,
                     CryptoData(wrapped_key),
                     &decrypted_key));
   EXPECT_BYTES_EQ_HEX(key_hex, decrypted_key);
 
   // Now attempt to unwrap the key, which should also decrypt the data.
-  blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey unwrapped_key;
   ASSERT_EQ(Status::Success(),
             UnwrapKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(wrapped_key),
                       private_key,
                       wrapping_algorithm,
                       key_algorithm,
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &unwrapped_key));
   ASSERT_FALSE(unwrapped_key.isNull());
@@ skipping 52 matching lines @@
       "b578f59ed4cb724c47dba94d3b484c1876dcd70281807f15bc7d2406007cac2b138a96af"
       "2d1e00276b84da593132c253fcb73212732dfd25824c2a615bc3d9b7f2c8d2fa542d3562"
       "b0c7738e61eeff580a6056239fb367ea9e5efe73d4f846033602e90c36a78db6fa8ea792"
       "0769675ec58e237bd994d189c8045a96f5dd3a4f12547257ce224e3c9af830a4da3c0eab"
       "9227a0035ae9028180067caea877e0b23090fc689322b71fbcce63d6596e66ab5fcdbaa0"
       "0d49e93aba8effb4518c2da637f209028401a68f344865b4956b032c69acde51d29177ca"
       "3db99fdbf5e74848ed4fa7bdfc2ebb60e2aaa5354770a763e1399ab7a2099762d525fea0"
       "37f3e1972c45a477e66db95c9609bb27f862700ef93379930786cf751b";
   blink::WebCryptoAlgorithm import_algorithm = CreateRsaHashedImportAlgorithm(
       blink::WebCryptoAlgorithmIdRsaOaep, blink::WebCryptoAlgorithmIdSha1);
-  blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
-  blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey public_key;
+  blink::WebCryptoKey private_key;
 
   ASSERT_NO_FATAL_FAILURE(ImportRsaKeyPair(
       HexStringToBytes(kPublicKey2048SpkiDerHex),
       HexStringToBytes(kPrivateKey2048Pkcs8DerHex),
       import_algorithm,
       false,
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageWrapKey,
       blink::WebCryptoKeyUsageDecrypt | blink::WebCryptoKeyUsageUnwrapKey,
       &public_key,
       &private_key));
@@ skipping 24 matching lines @@
   std::vector<uint8_t> decrypted_jwk;
   ASSERT_EQ(Status::Success(),
             Decrypt(wrapping_algorithm,
                     private_key,
                     CryptoData(wrapped_key),
                     &decrypted_jwk));
   EXPECT_TRUE(VerifySecretJwk(
       decrypted_jwk, "A128CBC", key_hex, blink::WebCryptoKeyUsageEncrypt));
 
   // Now attempt to unwrap the key, which should also decrypt the data.
-  blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey unwrapped_key;
   ASSERT_EQ(Status::Success(),
             UnwrapKey(blink::WebCryptoKeyFormatJwk,
                       CryptoData(wrapped_key),
                       private_key,
                       wrapping_algorithm,
                       key_algorithm,
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &unwrapped_key));
   ASSERT_FALSE(unwrapped_key.isNull());
@@ skipping 26 matching lines @@
 
   for (size_t test_index = 0; test_index < arraysize(kTests); ++test_index) {
     SCOPED_TRACE(test_index);
     const TestCase& test = kTests[test_index];
 
     const blink::WebCryptoAlgorithm import_algorithm =
         CreateRsaHashedImportAlgorithm(blink::WebCryptoAlgorithmIdRsaOaep,
                                        test.hash);
 
     // Import the spki to create a public key
-    blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
+    blink::WebCryptoKey public_key;
     ASSERT_EQ(Status::Success(),
               ImportKey(blink::WebCryptoKeyFormatSpki,
                         CryptoData(HexStringToBytes(kPublicKeySpkiDerHex)),
                         import_algorithm,
                         true,
                         test.usage,
                         &public_key));
 
     // Export the public key as JWK and verify its contents
     std::vector<uint8_t> jwk;
     ASSERT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatJwk, public_key, &jwk));
     EXPECT_TRUE(VerifyPublicJwk(jwk,
                                 test.jwk_alg,
                                 kPublicKeyModulusHex,
                                 kPublicKeyExponentHex,
                                 test.usage));
 
     // Import the JWK back in to create a new key
-    blink::WebCryptoKey public_key2 = blink::WebCryptoKey::createNull();
+    blink::WebCryptoKey public_key2;
     ASSERT_EQ(Status::Success(),
               ImportKey(blink::WebCryptoKeyFormatJwk,
                         CryptoData(jwk),
                         import_algorithm,
                         true,
                         test.usage,
                         &public_key2));
     ASSERT_TRUE(public_key2.handle());
     EXPECT_EQ(blink::WebCryptoKeyTypePublic, public_key2.type());
     EXPECT_TRUE(public_key2.extractable());
     EXPECT_EQ(import_algorithm.id(), public_key2.algorithm().id());
 
     // TODO(eroman): Export the SPKI and verify matches.
   }
 }
 
 }  // namespace
 
 }  // namespace webcrypto
 
 }  // namespace content