Revert 266798 "[webcrypto] Make operations run on a background t..."

trunk/src/content/child/webcrypto/shared_crypto_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 "content/child/webcrypto/shared_crypto.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 49 matching lines @@
          a.error_details() == b.error_details();
 }
 
 bool operator!=(const content::webcrypto::Status& a,
                 const content::webcrypto::Status& b) {
   return !(a == b);
 }
 
 namespace {
 
-// -----------------------------------------------------------------------------
-// TODO(eroman): Remove these helpers and convert all of the tests to using the
-//               std::vector<> flavor of functions directly.
-// -----------------------------------------------------------------------------
-
-blink::WebArrayBuffer CreateArrayBuffer(const uint8* data,
-                                        unsigned int data_size) {
-  blink::WebArrayBuffer buffer = blink::WebArrayBuffer::create(data_size, 1);
-  DCHECK(!buffer.isNull());
-  if (data_size)  // data_size == 0 might mean the data pointer is invalid
-    memcpy(buffer.data(), data, data_size);
-  return buffer;
-}
-
-void AssignWebArrayBuffer(const std::vector<uint8>& in,
-                          blink::WebArrayBuffer* out) {
-  *out = CreateArrayBuffer(Uint8VectorStart(in), in.size());
-}
-
-Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
-               const blink::WebCryptoKey& key,
-               const CryptoData& data,
-               blink::WebArrayBuffer* web_buffer) {
-  std::vector<uint8> buffer;
-  Status status = Encrypt(algorithm, key, data, &buffer);
-  AssignWebArrayBuffer(buffer, web_buffer);
-  return status;
-}
-
-Status Decrypt(const blink::WebCryptoAlgorithm& algorithm,
-               const blink::WebCryptoKey& key,
-               const CryptoData& data,
-               blink::WebArrayBuffer* web_buffer) {
-  std::vector<uint8> buffer;
-  Status status = Decrypt(algorithm, key, data, &buffer);
-  AssignWebArrayBuffer(buffer, web_buffer);
-  return status;
-}
-
-Status Digest(const blink::WebCryptoAlgorithm& algorithm,
-              const CryptoData& data,
-              blink::WebArrayBuffer* web_buffer) {
-  std::vector<uint8> buffer;
-  Status status = Digest(algorithm, data, &buffer);
-  AssignWebArrayBuffer(buffer, web_buffer);
-  return status;
-}
-
-Status ExportKey(blink::WebCryptoKeyFormat format,
-                 const blink::WebCryptoKey& key,
-                 blink::WebArrayBuffer* web_buffer) {
-  std::vector<uint8> buffer;
-  Status status = webcrypto::ExportKey(format, key, &buffer);
-  AssignWebArrayBuffer(buffer, web_buffer);
-  return status;
-}
-
-Status Sign(const blink::WebCryptoAlgorithm& algorithm,
-            const blink::WebCryptoKey& key,
-            const CryptoData& data,
-            blink::WebArrayBuffer* web_buffer) {
-  std::vector<uint8> buffer;
-
-  Status status = Sign(algorithm, key, data, &buffer);
-  AssignWebArrayBuffer(buffer, web_buffer);
-  return status;
-}
-
-Status WrapKey(blink::WebCryptoKeyFormat format,
-               const blink::WebCryptoKey& wrapping_key,
-               const blink::WebCryptoKey& key_to_wrap,
-               const blink::WebCryptoAlgorithm& wrapping_algorithm,
-               blink::WebArrayBuffer* web_buffer) {
-  std::vector<uint8> buffer;
-
-  Status status = webcrypto::WrapKey(
-      format, wrapping_key, key_to_wrap, wrapping_algorithm, &buffer);
-  AssignWebArrayBuffer(buffer, web_buffer);
-  return status;
-}
-
-// -----------------------------------------------------------------------------
-
 // TODO(eroman): For Linux builds using system NSS, AES-GCM support is a
 // runtime dependency. Test it by trying to import a key.
 // TODO(padolph): Consider caching the result of the import key test.
 bool SupportsAesGcm() {
   std::vector<uint8> key_raw(16, 0);
 
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   Status status = ImportKey(blink::WebCryptoKeyFormatRaw,
                             CryptoData(key_raw),
                             CreateAlgorithm(blink::WebCryptoAlgorithmIdAesGcm),
@@ skipping 1788 matching lines @@
     EXPECT_EQ(test.usage, key.usages());
 
     // Export the key in raw format and compare to the original.
     blink::WebArrayBuffer key_raw_out;
     ASSERT_EQ(Status::Success(),
               ExportKey(blink::WebCryptoKeyFormatRaw, key, &key_raw_out));
     ExpectArrayBufferMatchesHex(test.key_hex, key_raw_out);
   }
 }
 
-TEST_F(SharedCryptoTest, MAYBE(ExportJwkEmptySymmetricKey)) {
-  const blink::WebCryptoAlgorithm import_algorithm =
-      webcrypto::CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha1);
-
-  blink::WebCryptoKeyUsageMask usages = blink::WebCryptoKeyUsageSign;
-  blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
-
-  // Import a zero-byte HMAC key.
-  const char key_data_hex[] = "";
-  key = ImportSecretKeyFromRaw(
-      HexStringToBytes(key_data_hex), import_algorithm, usages);
-  EXPECT_EQ(0u, key.algorithm().hmacParams()->lengthBits());
-
-  // Export the key in JWK format and validate.
-  blink::WebArrayBuffer json;
-  ASSERT_EQ(Status::Success(),
-            ExportKey(blink::WebCryptoKeyFormatJwk, key, &json));
-  EXPECT_TRUE(VerifySecretJwk(json, "HS1", key_data_hex, usages));
-
-  // Now try re-importing the JWK key.
-  key = blink::WebCryptoKey::createNull();
-  EXPECT_EQ(Status::Success(),
-            ImportKey(blink::WebCryptoKeyFormatJwk,
-                      CryptoData(json),
-                      import_algorithm,
-                      true,
-                      usages,
-                      &key));
-
-  EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
-  EXPECT_EQ(0u, key.algorithm().hmacParams()->lengthBits());
-
-  blink::WebArrayBuffer exported_key_data;
-  EXPECT_EQ(Status::Success(),
-            ExportKey(blink::WebCryptoKeyFormatRaw, key, &exported_key_data));
-
-  EXPECT_EQ(0u, exported_key_data.byteLength());
-}
-
 TEST_F(SharedCryptoTest, MAYBE(ImportExportSpki)) {
   // Passing case: Import a valid RSA key in SPKI format.
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   ASSERT_EQ(
       Status::Success(),
       ImportKey(blink::WebCryptoKeyFormatSpki,
                 CryptoData(HexStringToBytes(kPublicKeySpkiDerHex)),
                 CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5),
                 true,
                 blink::WebCryptoKeyUsageEncrypt,
@@ skipping 233 matching lines @@
                 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_TRUE(public_key.extractable());
   EXPECT_EQ(extractable, private_key.extractable());
   EXPECT_EQ(usage_mask, public_key.usages());
   EXPECT_EQ(usage_mask, private_key.usages());
 
-  // Successful WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 key generation (sha256)
-  algorithm =
-      CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5,
-                                     blink::WebCryptoAlgorithmIdSha256,
-                                     modulus_length,
-                                     public_exponent);
+  // Successful WebCryptoAlgorithmIdRsaOaep key generation.
+  algorithm = CreateRsaHashedKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaOaep,
+                                             blink::WebCryptoAlgorithmIdSha256,
+                                             modulus_length,
+                                             public_exponent);
   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());
   EXPECT_EQ(modulus_length,
@@ skipping 1252 matching lines @@
                       algorithm,
                       CreateAesCbcAlgorithm(std::vector<uint8>(0, 16)),
                       true,
                       blink::WebCryptoKeyUsageEncrypt,
                       &unwrapped_key));
 }
 
 }  // namespace webcrypto
 
 }  // namespace content