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

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 20 matching lines @@
   dict->SetString(
       "n",
       "qLOyhK-OtQs4cDSoYPFGxJGfMYdjzWxVmMiuSBGh4KvEx-CwgtaTpef87Wdc9GaFEncsDLxk"
       "p0LGxjD1M8jMcvYq6DPEC_JYQumEu3i9v5fAEH1VvbZi9cTg-rmEXLUUjvc5LdOq_5OuHmtm"
       "e7PUJHYW1PW6ENTP0ibeiNOfFvs");
   dict->SetString("e", "AQAB");
 }
 
 TEST(WebCryptoRsaSsaTest, ImportExportSpki) {
   // Passing case: Import a valid RSA key in SPKI format.
-  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey key;
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatSpki,
                       CryptoData(HexStringToBytes(kPublicKeySpkiDerHex)),
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                           blink::WebCryptoAlgorithmIdSha256),
                       true,
                       blink::WebCryptoKeyUsageVerify,
                       &key));
   EXPECT_TRUE(key.handle());
@@ skipping 68 matching lines @@
   // (e.g. SHA-1 in OID, SHA-256 in params)
   // TODO(eroman): Failing test: Import a SPKI for RSA-SSA, but with params
   // as OAEP/PSS
 }
 
 TEST(WebCryptoRsaSsaTest, ImportExportPkcs8) {
   if (!SupportsRsaPrivateKeyImport())
     return;
 
   // Passing case: Import a valid RSA key in PKCS#8 format.
-  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey key;
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatPkcs8,
                       CryptoData(HexStringToBytes(kPrivateKeyPkcs8DerHex)),
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                           blink::WebCryptoAlgorithmIdSha1),
                       true,
                       blink::WebCryptoKeyUsageSign,
                       &key));
   EXPECT_TRUE(key.handle());
@@ skipping 78 matching lines @@
 
   for (size_t test_index = 0; test_index < arraysize(kOffsetsToCorrupt);
        ++test_index) {
     SCOPED_TRACE(test_index);
 
     unsigned int i = kOffsetsToCorrupt[test_index];
     std::vector<uint8_t> corrupted_data =
         HexStringToBytes(kPrivateKeyPkcs8DerHex);
     corrupted_data[i] = ~corrupted_data[i];
 
-    blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+    blink::WebCryptoKey key;
     EXPECT_EQ(Status::DataError(),
               ImportKey(blink::WebCryptoKeyFormatPkcs8,
                         CryptoData(corrupted_data),
                         CreateRsaHashedImportAlgorithm(
                             blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                             blink::WebCryptoAlgorithmIdSha1),
                         true,
                         blink::WebCryptoKeyUsageSign,
                         &key));
   }
 }
 
 // Tests JWK import and export by doing a roundtrip key conversion and ensuring
 // it was lossless:
 //
 //   PKCS8 --> JWK --> PKCS8
 TEST(WebCryptoRsaSsaTest, ImportRsaPrivateKeyJwkToPkcs8RoundTrip) {
   if (!SupportsRsaPrivateKeyImport())
     return;
 
-  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey key;
   ASSERT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatPkcs8,
                       CryptoData(HexStringToBytes(kPrivateKeyPkcs8DerHex)),
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                           blink::WebCryptoAlgorithmIdSha1),
                       true,
                       blink::WebCryptoKeyUsageSign,
                       &key));
 
@@ skipping 73 matching lines @@
 
     // Get the PKCS8 representation of the key.
     std::string pkcs8_hex_string;
     ASSERT_TRUE(key_values->GetString("pkcs8", &pkcs8_hex_string));
     std::vector<uint8_t> pkcs8_bytes = HexStringToBytes(pkcs8_hex_string);
 
     // Get the modulus length for the key.
     int modulus_length_bits = 0;
     ASSERT_TRUE(key_values->GetInteger("modulusLength", &modulus_length_bits));
 
-    blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
+    blink::WebCryptoKey private_key;
 
     // Import the key from JWK.
     ASSERT_EQ(
         Status::Success(),
         ImportKeyJwkFromDict(*key_jwk,
                              CreateRsaHashedImportAlgorithm(
                                  blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                  blink::WebCryptoAlgorithmIdSha256),
                              true,
                              blink::WebCryptoKeyUsageSign,
@@ skipping 27 matching lines @@
 
   scoped_ptr<base::ListValue> key_list;
   ASSERT_TRUE(ReadJsonTestFileToList("rsa_private_keys.json", &key_list));
 
   // Import a 1024-bit private key.
   base::DictionaryValue* key1_props;
   ASSERT_TRUE(key_list->GetDictionary(1, &key1_props));
   base::DictionaryValue* key1_jwk;
   ASSERT_TRUE(key1_props->GetDictionary("jwk", &key1_jwk));
 
-  blink::WebCryptoKey key1 = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey key1;
   ASSERT_EQ(Status::Success(),
             ImportKeyJwkFromDict(*key1_jwk,
                                  CreateRsaHashedImportAlgorithm(
                                      blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256),
                                  true,
                                  blink::WebCryptoKeyUsageSign,
                                  &key1));
 
   ASSERT_EQ(1024u, key1.algorithm().rsaHashedParams()->modulusLengthBits());
 
   // Construct a JWK using the modulus of key1, but all the other fields from
   // another key (also a 1024-bit private key).
   base::DictionaryValue* key2_props;
   ASSERT_TRUE(key_list->GetDictionary(5, &key2_props));
   base::DictionaryValue* key2_jwk;
   ASSERT_TRUE(key2_props->GetDictionary("jwk", &key2_jwk));
   std::string modulus;
   key1_jwk->GetString("n", &modulus);
   key2_jwk->SetString("n", modulus);
 
   // This should fail, as the n,e,d parameters are not consistent. It MUST NOT
   // somehow return the key created earlier.
-  blink::WebCryptoKey key2 = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey key2;
   ASSERT_EQ(Status::OperationError(),
             ImportKeyJwkFromDict(*key2_jwk,
                                  CreateRsaHashedImportAlgorithm(
                                      blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256),
                                  true,
                                  blink::WebCryptoKeyUsageSign,
                                  &key2));
 }
 
 // Import a JWK RSA private key with some optional parameters missing (q, dp,
 // dq, qi).
 //
 // The only optional parameter included is "p".
 //
 // This fails because JWA says that producers must include either ALL optional
 // parameters or NONE.
 TEST(WebCryptoRsaSsaTest, ImportRsaPrivateKeyJwkMissingOptionalParams) {
-  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey key;
 
   base::DictionaryValue dict;
   dict.SetString("kty", "RSA");
   dict.SetString("alg", "RS1");
 
   dict.SetString(
       "n",
       "pW5KDnAQF1iaUYfcfqhB0Vby7A42rVKkTf6x5h962ZHYxRBW_-2xYrTA8oOhKoijlN_"
       "1JqtykcuzB86r_OCx39XNlQgJbVsri2311nHvY3fAkhyyPCcKcOJZjm_4nRnxBazC0_"
       "DLNfKSgOE4a29kxO8i4eHyDQzoz_siSb2aITc");
@@ skipping 22 matching lines @@
 // Import a JWK RSA private key, without any of the optional parameters.
 //
 // According to JWA, such keys are valid, but applications SHOULD
 // include all the parameters when sending, and recipients MAY
 // accept them, but are not required to. Chromium's WebCrypto does
 // not allow such degenerate keys.
 TEST(WebCryptoRsaSsaTest, ImportRsaPrivateKeyJwkIncorrectOptionalEmpty) {
   if (!SupportsRsaPrivateKeyImport())
     return;
 
-  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey key;
 
   base::DictionaryValue dict;
   dict.SetString("kty", "RSA");
   dict.SetString("alg", "RS1");
 
   dict.SetString(
       "n",
       "pW5KDnAQF1iaUYfcfqhB0Vby7A42rVKkTf6x5h962ZHYxRBW_-2xYrTA8oOhKoijlN_"
       "1JqtykcuzB86r_OCx39XNlQgJbVsri2311nHvY3fAkhyyPCcKcOJZjm_4nRnxBazC0_"
       "DLNfKSgOE4a29kxO8i4eHyDQzoz_siSb2aITc");
@@ skipping 19 matching lines @@
   base::DictionaryValue dict;
 
   dict.SetString("kty", "RSA");
   dict.SetString("e", "AAEAAQ");  // 00 01 00 01
   dict.SetString(
       "n",
       "qLOyhK-OtQs4cDSoYPFGxJGfMYdjzWxVmMiuSBGh4KvEx-CwgtaTpef87Wdc9GaFEncsDLxk"
       "p0LGxjD1M8jMcvYq6DPEC_JYQumEu3i9v5fAEH1VvbZi9cTg-rmEXLUUjvc5LdOq_5OuHmtm"
       "e7PUJHYW1PW6ENTP0ibeiNOfFvs");
 
-  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey key;
 
   EXPECT_EQ(Status::ErrorJwkBigIntegerHasLeadingZero("e"),
             ImportKeyJwkFromDict(dict,
                                  CreateRsaHashedImportAlgorithm(
                                      blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256),
                                  false,
                                  blink::WebCryptoKeyUsageVerify,
                                  &key));
 }
 
 TEST(WebCryptoRsaSsaTest, GenerateKeyPairRsa) {
   // Note: using unrealistic short key lengths here to avoid bogging down tests.
 
   // Successful WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 key generation (sha256)
   const unsigned int modulus_length = 256;
   const std::vector<uint8_t> public_exponent = HexStringToBytes("010001");
   blink::WebCryptoAlgorithm algorithm =
       CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256,
                                      modulus_length,
                                      public_exponent);
   bool extractable = true;
   const blink::WebCryptoKeyUsageMask usage_mask = 0;
-  blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
-  blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey public_key;
+  blink::WebCryptoKey private_key;
 
   EXPECT_EQ(Status::Success(),
             GenerateKeyPair(
                 algorithm, extractable, usage_mask, &public_key, &private_key));
   EXPECT_FALSE(public_key.isNull());
   EXPECT_FALSE(private_key.isNull());
   EXPECT_EQ(blink::WebCryptoKeyTypePublic, public_key.type());
   EXPECT_EQ(blink::WebCryptoKeyTypePrivate, private_key.type());
   EXPECT_EQ(modulus_length,
             public_key.algorithm().rsaHashedParams()->modulusLengthBits());
@@ skipping 170 matching lines @@
 
   for (size_t i = 0; i < arraysize(kBadModulusBits); ++i) {
     const unsigned int modulus_length_bits = kBadModulusBits[i];
     blink::WebCryptoAlgorithm algorithm = CreateRsaHashedKeyGenAlgorithm(
         blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
         blink::WebCryptoAlgorithmIdSha256,
         modulus_length_bits,
         public_exponent);
     bool extractable = true;
     const blink::WebCryptoKeyUsageMask usage_mask = 0;
-    blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
-    blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
+    blink::WebCryptoKey public_key;
+    blink::WebCryptoKey private_key;
 
     EXPECT_EQ(
         Status::ErrorGenerateRsaUnsupportedModulus(),
         GenerateKeyPair(
             algorithm, extractable, usage_mask, &public_key, &private_key));
   }
 }
 
 // Try generating RSA key pairs using unsupported public exponents. Only
 // exponents of 3 and 65537 are supported. While both OpenSSL and NSS can
 // support other values, OpenSSL hangs when given invalid exponents, so use a
 // whitelist to validate the parameters.
 TEST(WebCryptoRsaSsaTest, GenerateKeyPairRsaBadExponent) {
   const unsigned int modulus_length = 1024;
 
   const char* const kPublicExponents[] = {
       "11",  // 17 - This is a valid public exponent, but currently disallowed.
       "00",     "01", "02",
       "010000",  // 65536
   };
 
   for (size_t i = 0; i < arraysize(kPublicExponents); ++i) {
     SCOPED_TRACE(i);
     blink::WebCryptoAlgorithm algorithm = CreateRsaHashedKeyGenAlgorithm(
         blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
         blink::WebCryptoAlgorithmIdSha256,
         modulus_length,
         HexStringToBytes(kPublicExponents[i]));
 
-    blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
-    blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
+    blink::WebCryptoKey public_key;
+    blink::WebCryptoKey private_key;
 
     EXPECT_EQ(Status::ErrorGenerateKeyPublicExponent(),
               GenerateKeyPair(algorithm, true, 0, &public_key, &private_key));
   }
 }
 
 TEST(WebCryptoRsaSsaTest, SignVerifyFailures) {
   if (!SupportsRsaPrivateKeyImport())
     return;
 
   // Import a key pair.
   blink::WebCryptoAlgorithm import_algorithm =
       CreateRsaHashedImportAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      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::WebCryptoKeyUsageVerify,
                        blink::WebCryptoKeyUsageSign,
                        &public_key,
                        &private_key));
 
@@ skipping 71 matching lines @@
   // signature itself (undesired), the verify will pass, while if the hash type
   // is specified by the key algorithm (desired), the verify will fail.
 
   // Compute a signature using SHA-1 as the inner hash.
   EXPECT_EQ(Status::Success(),
             Sign(CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5),
                  private_key,
                  CryptoData(data),
                  &signature));
 
-  blink::WebCryptoKey public_key_256 = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey public_key_256;
   EXPECT_EQ(Status::Success(),
             ImportKey(blink::WebCryptoKeyFormatSpki,
                       CryptoData(HexStringToBytes(kPublicKeySpkiDerHex)),
                       CreateRsaHashedImportAlgorithm(
                           blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                           blink::WebCryptoAlgorithmIdSha256),
                       true,
                       blink::WebCryptoKeyUsageVerify,
                       &public_key_256));
 
@@ skipping 21 matching lines @@
   if (!SupportsRsaPrivateKeyImport())
     return;
 
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("pkcs1v15_sign.json", &tests));
 
   // Import the key pair.
   blink::WebCryptoAlgorithm import_algorithm =
       CreateRsaHashedImportAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      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::WebCryptoKeyUsageVerify,
                        blink::WebCryptoKeyUsageSign,
                        &public_key,
                        &private_key));
 
@@ skipping 40 matching lines @@
   blink::WebCryptoKeyUsageMask bad_usages[] = {
       blink::WebCryptoKeyUsageSign,
       blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageVerify,
       blink::WebCryptoKeyUsageEncrypt,
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt,
   };
 
   for (size_t i = 0; i < arraysize(bad_usages); ++i) {
     SCOPED_TRACE(i);
 
-    blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
+    blink::WebCryptoKey public_key;
     ASSERT_EQ(Status::ErrorCreateKeyBadUsages(),
               ImportKey(blink::WebCryptoKeyFormatSpki,
                         CryptoData(HexStringToBytes(kPublicKeySpkiDerHex)),
                         algorithm,
                         false,
                         bad_usages[i],
                         &public_key));
   }
 }
 
@@ skipping 12 matching lines @@
   };
 
   base::DictionaryValue dict;
   RestoreJwkRsaDictionary(&dict);
   dict.Remove("use", NULL);
   dict.SetString("alg", "RS256");
 
   for (size_t i = 0; i < arraysize(bad_usages); ++i) {
     SCOPED_TRACE(i);
 
-    blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
+    blink::WebCryptoKey public_key;
     ASSERT_EQ(Status::ErrorCreateKeyBadUsages(),
               ImportKeyJwkFromDict(
                   dict, algorithm, false, bad_usages[i], &public_key));
   }
 }
 
 // Generate an RSA-SSA key pair with invalid usages. RSA-SSA supports:
 //   'sign', 'verify'
 TEST(WebCryptoRsaSsaTest, GenerateKeyBadUsages) {
   blink::WebCryptoKeyUsageMask bad_usages[] = {
       blink::WebCryptoKeyUsageDecrypt,
       blink::WebCryptoKeyUsageVerify | blink::WebCryptoKeyUsageDecrypt,
       blink::WebCryptoKeyUsageWrapKey,
   };
 
   const unsigned int modulus_length = 256;
   const std::vector<uint8_t> public_exponent = HexStringToBytes("010001");
 
   for (size_t i = 0; i < arraysize(bad_usages); ++i) {
     SCOPED_TRACE(i);
 
-    blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
-    blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
+    blink::WebCryptoKey public_key;
+    blink::WebCryptoKey private_key;
 
     ASSERT_EQ(Status::ErrorCreateKeyBadUsages(),
               GenerateKeyPair(CreateRsaHashedKeyGenAlgorithm(
                                   blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                   blink::WebCryptoAlgorithmIdSha256,
                                   modulus_length,
                                   public_exponent),
                               true,
                               bad_usages[i],
                               &public_key,
                               &private_key));
   }
 }
 
 // Generate an RSA-SSA key pair. The public and private keys should select the
 // key usages which are applicable, and not have the exact same usages as was
 // specified to GenerateKey
 TEST(WebCryptoRsaSsaTest, GenerateKeyPairIntersectUsages) {
   const unsigned int modulus_length = 256;
   const std::vector<uint8_t> public_exponent = HexStringToBytes("010001");
 
-  blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
-  blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey public_key;
+  blink::WebCryptoKey private_key;
 
   ASSERT_EQ(Status::Success(),
             GenerateKeyPair(
                 CreateRsaHashedKeyGenAlgorithm(
                     blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                     blink::WebCryptoAlgorithmIdSha256,
                     modulus_length,
                     public_exponent),
                 true,
                 blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageVerify,
@@ skipping 36 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::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5, 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());
 
     // Export the new key as spki and compare to the original.
     std::vector<uint8_t> spki;
     ASSERT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatSpki, public_key2, &spki));
     EXPECT_BYTES_EQ_HEX(kPublicKeySpkiDerHex, CryptoData(spki));
   }
 }
 
 TEST(WebCryptoRsaSsaTest, ImportJwkRsaFailures) {
   base::DictionaryValue dict;
   RestoreJwkRsaDictionary(&dict);
   blink::WebCryptoAlgorithm algorithm =
       CreateRsaHashedImportAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
                                      blink::WebCryptoAlgorithmIdSha256);
   blink::WebCryptoKeyUsageMask usage_mask = blink::WebCryptoKeyUsageVerify;
-  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
+  blink::WebCryptoKey key;
 
   // An RSA public key JWK _must_ have an "n" (modulus) and an "e" (exponent)
   // entry, while an RSA private key must have those plus at least a "d"
   // (private exponent) entry.
   // See http://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-18,
   // section 6.3.
 
   // Baseline pass.
   EXPECT_EQ(Status::Success(),
             ImportKeyJwkFromDict(dict, algorithm, false, usage_mask, &key));
@@ skipping 25 matching lines @@
               ImportKeyJwkFromDict(dict, algorithm, false, usage_mask, &key));
     RestoreJwkRsaDictionary(&dict);
   }
 }
 
 }  // namespace
 
 }  // namespace webcrypto
 
 }  // namespace content