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

content/child/webcrypto/test/aes_kw_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/status.h"
 #include "content/child/webcrypto/test/test_helpers.h"
 #include "content/child/webcrypto/webcrypto_util.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 
 namespace content {
 
 namespace webcrypto {
 
 namespace {
 
 blink::WebCryptoAlgorithm CreateAesKwKeyGenAlgorithm(
     unsigned short key_length_bits) {
   return CreateAesKeyGenAlgorithm(blink::WebCryptoAlgorithmIdAesKw,
                                   key_length_bits);
 }
 
 TEST(WebCryptoAesKwTest, GenerateKeyBadLength) {
   const unsigned short kKeyLen[] = {0, 127, 257};
-  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey key;
   for (size_t i = 0; i < arraysize(kKeyLen); ++i) {
     SCOPED_TRACE(i);
     EXPECT_EQ(Status::ErrorGenerateKeyLength(),
               GenerateSecretKey(
                   CreateAesKwKeyGenAlgorithm(kKeyLen[i]), true, 0, &key));
   }
 }
 
 TEST(WebCryptoAesKwTest, ImportKeyJwkKeyOpsWrapUnwrap) {
-  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey key;
   base::DictionaryValue dict;
   dict.SetString("kty", "oct");
   dict.SetString("k", "GADWrMRHwQfoNaXU5fZvTg==");
   base::ListValue* key_ops = new base::ListValue;
   dict.Set("key_ops", key_ops);  // Takes ownership.
 
   key_ops->AppendString("wrapKey");
 
   EXPECT_EQ(
       Status::Success(),
@@ skipping 31 matching lines @@
 
   // AES-KW 256
   ImportExportJwkSymmetricKey(
       256,
       algorithm,
       blink::WebCryptoKeyUsageWrapKey | blink::WebCryptoKeyUsageUnwrapKey,
       "A256KW");
 }
 
 TEST(WebCryptoAesKwTest, AesKwKeyImport) {
-  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey key;
   blink::WebCryptoAlgorithm algorithm =
       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw);
 
   // Import a 128-bit Key Encryption Key (KEK)
   std::string key_raw_hex_in = "025a8cf3f08b4f6c5f33bbc76a471939";
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(HexStringToBytes(key_raw_hex_in)),
                       algorithm,
                       true,
@@ skipping 72 matching lines @@
 TEST(WebCryptoAesKwTest, UnwrapFailures) {
   // This test exercises the code path common to all unwrap operations.
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("aes_kw.json", &tests));
   base::DictionaryValue* test;
   ASSERT_TRUE(tests->GetDictionary(0, &test));
   const std::vector<uint8_t> test_kek = GetBytesFromHexString(test, "kek");
   const std::vector<uint8_t> test_ciphertext =
       GetBytesFromHexString(test, "ciphertext");
 
-  blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey unwrapped_key;
 
   // Using a wrapping algorithm that does not match the wrapping key algorithm
   // should fail.
   blink::WebCryptoKey wrapping_key =
       ImportSecretKeyFromRaw(test_kek,
                              CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw),
                              blink::WebCryptoKeyUsageUnwrapKey);
   EXPECT_EQ(Status::ErrorUnexpected(),
             UnwrapKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(test_ciphertext),
@@ skipping 36 matching lines @@
     std::vector<uint8_t> wrapped_key;
     ASSERT_EQ(Status::Success(),
               WrapKey(blink::WebCryptoKeyFormatRaw,
                       key,
                       wrapping_key,
                       wrapping_algorithm,
                       &wrapped_key));
     EXPECT_BYTES_EQ(test_ciphertext, wrapped_key);
 
     // Unwrap the known ciphertext to get a new test_key.
-    blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
+    blink::WebCryptoKey unwrapped_key;
     ASSERT_EQ(
         Status::Success(),
         UnwrapKey(blink::WebCryptoKeyFormatRaw,
                   CryptoData(test_ciphertext),
                   wrapping_key,
                   wrapping_algorithm,
                   CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha1),
                   true,
                   blink::WebCryptoKeyUsageSign,
                   &unwrapped_key));
@@ skipping 24 matching lines @@
   const std::vector<uint8_t> test_ciphertext =
       GetBytesFromHexString(test, "ciphertext");
   const blink::WebCryptoAlgorithm wrapping_algorithm =
       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw);
 
   // Import the wrapping key.
   blink::WebCryptoKey wrapping_key = ImportSecretKeyFromRaw(
       test_kek, wrapping_algorithm, blink::WebCryptoKeyUsageUnwrapKey);
 
   // Unwrap the known ciphertext.
-  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey key;
   ASSERT_EQ(
       Status::Success(),
       UnwrapKey(blink::WebCryptoKeyFormatRaw,
                 CryptoData(test_ciphertext),
                 wrapping_key,
                 wrapping_algorithm,
                 CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha1),
                 false,
                 blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageVerify,
                 &key));
@@ skipping 46 matching lines @@
       blink::WebCryptoKeyUsageWrapKey | blink::WebCryptoKeyUsageUnwrapKey);
   // Import the key to be wrapped.
   blink::WebCryptoKey key =
       ImportSecretKeyFromRaw(test_key,
                              CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
                              blink::WebCryptoKeyUsageEncrypt);
 
   // Unwrap with wrapped data too small must fail.
   const std::vector<uint8_t> small_data(test_ciphertext.begin(),
                                         test_ciphertext.begin() + 23);
-  blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey unwrapped_key;
   EXPECT_EQ(Status::ErrorDataTooSmall(),
             UnwrapKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(small_data),
                       wrapping_key,
                       wrapping_algorithm,
                       key_algorithm,
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &unwrapped_key));
 
@@ skipping 25 matching lines @@
       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw);
 
   // Import the wrapping key.
   blink::WebCryptoKey wrapping_key = ImportSecretKeyFromRaw(
       test_kek,
       wrapping_algorithm,
       blink::WebCryptoKeyUsageWrapKey | blink::WebCryptoKeyUsageUnwrapKey);
 
   // Unwrap of a corrupted version of the known ciphertext should fail, due to
   // AES-KW's built-in integrity check.
-  blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey unwrapped_key;
   EXPECT_EQ(Status::OperationError(),
             UnwrapKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(Corrupted(test_ciphertext)),
                       wrapping_key,
                       wrapping_algorithm,
                       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &unwrapped_key));
 }
@@ skipping 16 matching lines @@
   const std::vector<uint8_t> wrapping_key_data =
       HexStringToBytes("000102030405060708090A0B0C0D0E0F");
   const blink::WebCryptoAlgorithm wrapping_algorithm =
       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw);
 
   // Import the wrapping key.
   blink::WebCryptoKey wrapping_key = ImportSecretKeyFromRaw(
       wrapping_key_data, wrapping_algorithm, blink::WebCryptoKeyUsageUnwrapKey);
 
   // Unwrap the known wrapped key data to produce a new key
-  blink::WebCryptoKey unwrapped_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey unwrapped_key;
   ASSERT_EQ(
       Status::Success(),
       UnwrapKey(blink::WebCryptoKeyFormatJwk,
                 CryptoData(wrapped_key_data),
                 wrapping_key,
                 wrapping_algorithm,
                 CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha256),
                 true,
                 blink::WebCryptoKeyUsageVerify,
                 &unwrapped_key));
@@ skipping 30 matching lines @@
       blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageUnwrapKey,
       blink::WebCryptoKeyUsageDeriveBits,
       blink::WebCryptoKeyUsageUnwrapKey | blink::WebCryptoKeyUsageVerify,
   };
 
   std::vector<uint8_t> key_bytes(16);
 
   for (size_t i = 0; i < arraysize(bad_usages); ++i) {
     SCOPED_TRACE(i);
 
-    blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+    blink::WebCryptoKey key;
     ASSERT_EQ(Status::ErrorCreateKeyBadUsages(),
               ImportKey(blink::WebCryptoKeyFormatRaw,
                         CryptoData(key_bytes),
                         algorithm,
                         true,
                         bad_usages[i],
                         &key));
   }
 }
 
 // Try unwrapping an HMAC key with unsupported usages using JWK format and
 // AES-KW. HMAC keys support the following usages:
 //   'sign', 'verify'
 TEST(WebCryptoAesKwTest, UnwrapHmacKeyBadUsage_JWK) {
   const blink::WebCryptoAlgorithm unwrap_algorithm =
       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesKw);
 
   blink::WebCryptoKeyUsageMask bad_usages[] = {
       blink::WebCryptoKeyUsageEncrypt,
       blink::WebCryptoKeyUsageDecrypt,
       blink::WebCryptoKeyUsageWrapKey,
       blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageWrapKey,
       blink::WebCryptoKeyUsageVerify | blink::WebCryptoKeyUsageDeriveKey,
   };
 
   // Import the wrapping key.
-  blink::WebCryptoKey wrapping_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey wrapping_key;
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(std::vector<uint8_t>(16)),
                       unwrap_algorithm,
                       true,
                       blink::WebCryptoKeyUsageUnwrapKey,
                       &wrapping_key));
 
   // The JWK plain text is:
   //   {   "kty": "oct","alg": "HS256","k": "GADWrMRHwQfoNaXU5fZvTg=="}
   const char* kWrappedJwk =
       "0AA245F17064FFB2A7A094436A39BEBFC962C627303D1327EA750CE9F917688C2782A943"
       "7AE7586547AC490E8AE7D5B02D63868D5C3BB57D36C4C8C5BF3962ACEC6F42E767E5706"
       "4";
 
   for (size_t i = 0; i < arraysize(bad_usages); ++i) {
     SCOPED_TRACE(i);
 
-    blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+    blink::WebCryptoKey key;
 
     ASSERT_EQ(
         Status::ErrorCreateKeyBadUsages(),
         UnwrapKey(blink::WebCryptoKeyFormatJwk,
                   CryptoData(HexStringToBytes(kWrappedJwk)),
                   wrapping_key,
                   unwrap_algorithm,
                   CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha256),
                   true,
                   bad_usages[i],
@@ skipping 10 matching lines @@
 
   blink::WebCryptoKeyUsageMask bad_usages[] = {
       blink::WebCryptoKeyUsageEncrypt,
       blink::WebCryptoKeyUsageSign,
       blink::WebCryptoKeyUsageDecrypt,
       blink::WebCryptoKeyUsageWrapKey,
       blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageWrapKey,
   };
 
   // Import the wrapping key.
-  blink::WebCryptoKey wrapping_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey wrapping_key;
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatRaw,
                       CryptoData(std::vector<uint8_t>(16)),
                       unwrap_algorithm,
                       true,
                       blink::WebCryptoKeyUsageUnwrapKey,
                       &wrapping_key));
 
   // The JWK plaintext is:
   // {    "kty": "RSA","alg": "RS256","n": "...","e": "AQAB"}
 
   const char* kWrappedJwk =
       "CE8DAEF99E977EE58958B8C4494755C846E883B2ECA575C5366622839AF71AB30875F152"
       "E8E33E15A7817A3A2874EB53EFE05C774D98BC936BA9BA29BEB8BB3F3C3CE2323CB3359D"
       "E3F426605CF95CCF0E01E870ABD7E35F62E030B5FB6E520A5885514D1D850FB64B57806D"
       "1ADA57C6E27DF345D8292D80F6B074F1BE51C4CF3D76ECC8886218551308681B44FAC60B"
       "8CF6EA439BC63239103D0AE81ADB96F908680586C6169284E32EB7DD09D31103EBDAC0C2"
       "40C72DCF0AEA454113CC47457B13305B25507CBEAB9BDC8D8E0F867F9167F9DCEF0D9F9B"
       "30F2EE83CEDFD51136852C8A5939B768";
 
   for (size_t i = 0; i < arraysize(bad_usages); ++i) {
     SCOPED_TRACE(i);
 
-    blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+    blink::WebCryptoKey key;
 
     ASSERT_EQ(Status::ErrorCreateKeyBadUsages(),
               UnwrapKey(blink::WebCryptoKeyFormatJwk,
                         CryptoData(HexStringToBytes(kWrappedJwk)),
                         wrapping_key,
                         unwrap_algorithm,
                         CreateRsaHashedImportAlgorithm(
                             blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                             blink::WebCryptoAlgorithmIdSha256),
                         true,
                         bad_usages[i],
                         &key));
   }
 }
 
 }  // namespace
 
 }  // namespace webcrypto
 
 }  // namespace content