Rework how webcrypto tests are disabled for inprogress OpenSSL implementation.

content/renderer/webcrypto/webcrypto_impl_unittest.cc

 // Copyright 2013 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/renderer/webcrypto/webcrypto_impl.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/renderer_webkitplatformsupport_impl.h"
 #include "content/renderer/webcrypto/webcrypto_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebArrayBuffer.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKey.h"
 
+// The OpenSSL implementation of WebCrypto is less complete, so don't run all of
+// the tests: http://crbug.com/267888
+#if defined(USE_OPENSSL)
+#define NSSONLY(test_name) DISABLED_##test_name
+#else
+#define NSSONLY(test_name) test_name
+#endif

[Ryan Sleevi, 2013/12/08 05:20:48]

Please do not use macros like this.

As we discussed on IM, we talked about the following pattern:

#if defined(USE_NSS)
#define MAYBE_Foo Foo
#else
#define MAYBE_Foo DISABLED_Foo
#endif

This is a pattern that Chrome uses extensively. I don't think it's warranted to
deviate from this, personal opinions on prettiness aside.

+
 namespace content {
 
 namespace {
 
 std::vector<uint8> HexStringToBytes(const std::string& hex) {
   std::vector<uint8> bytes;
   base::HexStringToBytes(hex, &bytes);
   return bytes;
 }
 
@@ skipping 18 matching lines @@
 // dictionary to a good state
 void RestoreJwkOctDictionary(base::DictionaryValue* dict) {
   dict->Clear();
   dict->SetString("kty", "oct");
   dict->SetString("alg", "A128CBC");
   dict->SetString("use", "enc");
   dict->SetBoolean("extractable", false);
   dict->SetString("k", "GADWrMRHwQfoNaXU5fZvTg==");
 }
 
-#if !defined(USE_OPENSSL)
-
 // Helper for ImportJwkRsaFailures. Restores the JWK JSON
 // dictionary to a good state
 void RestoreJwkRsaDictionary(base::DictionaryValue* dict) {
   dict->Clear();
   dict->SetString("kty", "RSA");
   dict->SetString("alg", "RSA1_5");
   dict->SetString("use", "enc");
   dict->SetBoolean("extractable", false);
   dict->SetString("n",
       "qLOyhK-OtQs4cDSoYPFGxJGfMYdjzWxVmMiuSBGh4KvEx-CwgtaTpef87Wdc9GaFEncsDLxk"
       "p0LGxjD1M8jMcvYq6DPEC_JYQumEu3i9v5fAEH1VvbZi9cTg-rmEXLUUjvc5LdOq_5OuHmtm"
       "e7PUJHYW1PW6ENTP0ibeiNOfFvs");
   dict->SetString("e", "AQAB");
 }
 
-blink::WebCryptoAlgorithm CreateRsaKeyGenAlgorithm(
-    blink::WebCryptoAlgorithmId algorithm_id,
-    unsigned modulus_length,
-    const std::vector<uint8>& public_exponent) {
-  DCHECK(algorithm_id == blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5 ||
-         algorithm_id == blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5 ||
-         algorithm_id == blink::WebCryptoAlgorithmIdRsaOaep);
-  return blink::WebCryptoAlgorithm::adoptParamsAndCreate(
-      algorithm_id,
-      new blink::WebCryptoRsaKeyGenParams(
-          modulus_length,
-          webcrypto::Uint8VectorStart(public_exponent),
-          public_exponent.size()));
-}
-
 // Determines if two ArrayBuffers have identical content.
 bool ArrayBuffersEqual(
     const blink::WebArrayBuffer& a,
     const blink::WebArrayBuffer& b) {
   return a.byteLength() == b.byteLength() &&
          memcmp(a.data(), b.data(), a.byteLength()) == 0;
 }
 
 // Given a vector of WebArrayBuffers, determines if there are any copies.
 bool CopiesExist(std::vector<blink::WebArrayBuffer> bufs) {
   for (size_t i = 0; i < bufs.size(); ++i) {
     for (size_t j = i + 1; j < bufs.size(); ++j) {
       if (ArrayBuffersEqual(bufs[i], bufs[j]))
         return true;
     }
   }
   return false;
 }
 
-#endif  // #if !defined(USE_OPENSSL)
-
 }  // namespace
 
 class WebCryptoImplTest : public testing::Test {
  protected:
   blink::WebCryptoKey ImportSecretKeyFromRawHexString(
       const std::string& key_hex,
       const blink::WebCryptoAlgorithm& algorithm,
       blink::WebCryptoKeyUsageMask usage) {
     std::vector<uint8> key_raw = HexStringToBytes(key_hex);
 
@@ skipping 364 matching lines @@
         algorithm,
         key,
         kLongSignature,
         sizeof(kLongSignature),
         message_raw,
         &signature_match));
     EXPECT_FALSE(signature_match);
   }
 }
 
-#if !defined(USE_OPENSSL)
-
 TEST_F(WebCryptoImplTest, AesCbcFailures) {
   const std::string key_hex = "2b7e151628aed2a6abf7158809cf4f3c";
   blink::WebCryptoKey key = ImportSecretKeyFromRawHexString(
       key_hex,
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt);
 
   // Verify exported raw key is identical to the imported data
   blink::WebArrayBuffer raw_key;
   EXPECT_TRUE(ExportKeyInternal(blink::WebCryptoKeyFormatRaw, key, &raw_key));
@@ skipping 51 matching lines @@
                                    blink::WebCryptoKeyUsageEncrypt,
                                    &key));
   }
 
   // Fail exporting the key in SPKI and PKCS#8 formats (not allowed for secret
   // keys).
   EXPECT_FALSE(ExportKeyInternal(blink::WebCryptoKeyFormatSpki, key, &output));
   EXPECT_FALSE(ExportKeyInternal(blink::WebCryptoKeyFormatPkcs8, key, &output));
 }
 
-TEST_F(WebCryptoImplTest, AesCbcSampleSets) {
+TEST_F(WebCryptoImplTest, NSSONLY(AesCbcSampleSets)) {
   struct TestCase {
     const char* key;
     const char* iv;
     const char* plain_text;
     const char* cipher_text;
   };
 
   TestCase kTests[] = {
     // F.2.1 (CBC-AES128.Encrypt)
     // http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
@@ skipping 115 matching lines @@
     if (cipher_text.size() > 3) {
       EXPECT_FALSE(DecryptInternal(webcrypto::CreateAesCbcAlgorithm(iv),
                                    key,
                                    &cipher_text[0],
                                    cipher_text.size() - 3,
                                    &output));
     }
   }
 }
 
-TEST_F(WebCryptoImplTest, GenerateKeyAes) {
+TEST_F(WebCryptoImplTest, NSSONLY(GenerateKeyAes)) {
   // Generate a small sample of AES keys.
   std::vector<blink::WebArrayBuffer> keys;
   blink::WebArrayBuffer key_bytes;
   for (int i = 0; i < 16; ++i) {
     blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
     ASSERT_TRUE(
         GenerateKeyInternal(webcrypto::CreateAesCbcKeyGenAlgorithm(128), &key));
     EXPECT_TRUE(key.handle());
     EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
     ASSERT_TRUE(
         ExportKeyInternal(blink::WebCryptoKeyFormatRaw, key, &key_bytes));
     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(keys));
 }
 
-TEST_F(WebCryptoImplTest, GenerateKeyAesBadLength) {
+TEST_F(WebCryptoImplTest, NSSONLY(GenerateKeyAesBadLength)) {
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   EXPECT_FALSE(
       GenerateKeyInternal(webcrypto::CreateAesCbcKeyGenAlgorithm(0), &key));
   EXPECT_FALSE(
       GenerateKeyInternal(webcrypto::CreateAesCbcKeyGenAlgorithm(0), &key));
   EXPECT_FALSE(
       GenerateKeyInternal(webcrypto::CreateAesCbcKeyGenAlgorithm(129), &key));
 }
 
-TEST_F(WebCryptoImplTest, GenerateKeyHmac) {
+TEST_F(WebCryptoImplTest, NSSONLY(GenerateKeyHmac)) {
   // Generate a small sample of HMAC keys.
   std::vector<blink::WebArrayBuffer> keys;
   for (int i = 0; i < 16; ++i) {
     blink::WebArrayBuffer key_bytes;
     blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
     blink::WebCryptoAlgorithm algorithm = webcrypto::CreateHmacKeyGenAlgorithm(
         blink::WebCryptoAlgorithmIdSha1, 128);
     ASSERT_TRUE(GenerateKeyInternal(algorithm, &key));
     EXPECT_FALSE(key.isNull());
     EXPECT_TRUE(key.handle());
     EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
   }
   // 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(keys));
 }
 
-TEST_F(WebCryptoImplTest, GenerateKeyHmacNoLength) {
+TEST_F(WebCryptoImplTest, NSSONLY(GenerateKeyHmacNoLength)) {
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   blink::WebCryptoAlgorithm algorithm =
       webcrypto::CreateHmacKeyGenAlgorithm(blink::WebCryptoAlgorithmIdSha1, 0);
   ASSERT_TRUE(GenerateKeyInternal(algorithm, &key));
   EXPECT_TRUE(key.handle());
   EXPECT_EQ(blink::WebCryptoKeyTypeSecret, key.type());
 }
 
-TEST_F(WebCryptoImplTest, ImportSecretKeyNoAlgorithm) {
+TEST_F(WebCryptoImplTest, NSSONLY(ImportSecretKeyNoAlgorithm)) {
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
 
   // This fails because the algorithm is null.
   EXPECT_FALSE(ImportKeyInternal(
       blink::WebCryptoKeyFormatRaw,
       HexStringToBytes("00000000000000000000"),
       blink::WebCryptoAlgorithm::createNull(),
       true,
       blink::WebCryptoKeyUsageEncrypt,
       &key));
 }
 
-#endif  //#if !defined(USE_OPENSSL)
 
 TEST_F(WebCryptoImplTest, ImportJwkFailures) {
 
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   blink::WebCryptoAlgorithm algorithm =
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc);
   blink::WebCryptoKeyUsageMask usage_mask = blink::WebCryptoKeyUsageEncrypt;
 
   // Baseline pass: each test below breaks a single item, so we start with a
   // passing case to make sure each failure is caused by the isolated break.
@@ skipping 89 matching lines @@
   RestoreJwkOctDictionary(&dict);
 
   // Fail on k actual length (120 bits) inconsistent with the embedded JWK alg
   // value (128) for an AES key.
   dict.SetString("k", "AVj42h0Y5aqGtE3yluKL");
   EXPECT_FALSE(ImportKeyJwk(
       MakeJsonVector(dict), algorithm, false, usage_mask, &key));
   RestoreJwkOctDictionary(&dict);
 }
 
-#if !defined(USE_OPENSSL)
-
-TEST_F(WebCryptoImplTest, ImportJwkRsaFailures) {
+TEST_F(WebCryptoImplTest, NSSONLY(ImportJwkRsaFailures)) {
 
   base::DictionaryValue dict;
   RestoreJwkRsaDictionary(&dict);
   blink::WebCryptoAlgorithm algorithm =
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5);
   blink::WebCryptoKeyUsageMask usage_mask = blink::WebCryptoKeyUsageEncrypt;
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
 
   // 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"
@@ skipping 35 matching lines @@
   }
 
   // Fail if "d" parameter is present, implying the JWK is a private key, which
   // is not supported.
   dict.SetString("d", "Qk3f0Dsyt");
   EXPECT_FALSE(ImportKeyJwk(
       MakeJsonVector(dict), algorithm, false, usage_mask, &key));
   RestoreJwkRsaDictionary(&dict);
 }
 
-#endif  // #if !defined(USE_OPENSSL)
-
-TEST_F(WebCryptoImplTest, ImportJwkInputConsistency) {
+TEST_F(WebCryptoImplTest, NSSONLY(ImportJwkInputConsistency)) {
   // The Web Crypto spec says that if a JWK value is present, but is
   // inconsistent with the input value, the operation must fail.
 
   // Consistency rules when JWK value is not present: Inputs should be used.
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   bool extractable = false;
   blink::WebCryptoAlgorithm algorithm =
       webcrypto::CreateHmacAlgorithmByHashId(blink::WebCryptoAlgorithmIdSha256);
   blink::WebCryptoKeyUsageMask usage_mask = blink::WebCryptoKeyUsageVerify;
   base::DictionaryValue dict;
@@ skipping 88 matching lines @@
   EXPECT_FALSE(
       ImportKeyJwk(json_vec, algorithm, extractable, usage_mask, &key));
   usage_mask = blink::WebCryptoKeyUsageSign | blink::WebCryptoKeyUsageVerify;
 
   // TODO(padolph): kty vs alg consistency tests: Depending on the kty value,
   // only certain alg values are permitted. For example, when kty = "RSA" alg
   // must be of the RSA family, or when kty = "oct" alg must be symmetric
   // algorithm.
 }
 
-TEST_F(WebCryptoImplTest, ImportJwkHappy) {
+TEST_F(WebCryptoImplTest, NSSONLY(ImportJwkHappy)) {
 
   // This test verifies the happy path of JWK import, including the application
   // of the imported key material.
 
   blink::WebCryptoKey key = blink::WebCryptoKey::createNull();
   bool extractable = false;
   blink::WebCryptoAlgorithm algorithm =
       webcrypto::CreateHmacAlgorithmByHashId(blink::WebCryptoAlgorithmIdSha256);
   blink::WebCryptoKeyUsageMask usage_mask = blink::WebCryptoKeyUsageSign;
 
@@ skipping 21 matching lines @@
   ASSERT_TRUE(SignInternal(algorithm, key, message_raw, &output));
 
   const std::string mac_raw =
       "769f00d3e6a6cc1fb426a14a4f76c6462e6149726e0dee0ec0cf97a16605ac8b";
 
   ExpectArrayBufferMatchesHex(mac_raw, output);
 
   // TODO(padolph): Import an RSA public key JWK and use it
 }
 
-#if !defined(USE_OPENSSL)
-
-TEST_F(WebCryptoImplTest, ImportExportSpki) {
+TEST_F(WebCryptoImplTest, NSSONLY(ImportExportSpki)) {
   // openssl genrsa -out pair.pem 2048
   // openssl rsa -in pair.pem -out pubkey.der -outform DER -pubout
   // xxd -p pubkey.der
   const std::string hex_rsa_spki_der =
       "30820122300d06092a864886f70d01010105000382010f003082010a0282"
       "010100f19e40f94e3780858701577a571cca000cb9795db89ddf8e98ab0e"
       "5eecfa47516cb08dc591cae5ab7fa43d6db402e95991d4a2de52e7cd3a66"
       "4f58284be2eb4675d5a849a2582c585d2b3c6c225a8f2c53a0414d5dbd06"
       "172371cefdf953e9ec3000fc9ad000743023f74e82d12aa93917a2c9b832"
       "696085ee0711154cf98a6d098f44cee00ea3b7584236503a5483ba8b6792"
@@ skipping 70 matching lines @@
       HexStringToBytes(hex_rsa_spki_der),
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5),
       false,
       blink::WebCryptoKeyUsageEncrypt,
       &key));
   EXPECT_TRUE(key.handle());
   EXPECT_FALSE(key.extractable());
   EXPECT_FALSE(ExportKeyInternal(blink::WebCryptoKeyFormatSpki, key, &output));
 }
 
-TEST_F(WebCryptoImplTest, ImportPkcs8) {
+TEST_F(WebCryptoImplTest, NSSONLY(ImportPkcs8)) {
 
   // The following is a DER-encoded PKCS#8 representation of the RSA key from
   // Example 1 of NIST's "Test vectors for RSA PKCS#1 v1.5 Signature".
   // ftp://ftp.rsa.com/pub/rsalabs/tmp/pkcs1v15sign-vectors.txt
   const std::string hex_rsa_pkcs8_der =
       "30820275020100300D06092A864886F70D01010105000482025F3082025B020100028181"
       "00A56E4A0E701017589A5187DC7EA841D156F2EC0E36AD52A44DFEB1E61F7AD991D8C510"
       "56FFEDB162B4C0F283A12A88A394DFF526AB7291CBB307CEABFCE0B1DFD5CD9508096D5B"
       "2B8B6DF5D671EF6377C0921CB23C270A70E2598E6FF89D19F105ACC2D3F0CB35F29280E1"
       "386B6F64C4EF22E1E1F20D0CE8CFFB2249BD9A2137020301000102818033A5042A90B27D"
@@ skipping 57 matching lines @@
   // Failing case: Import RSA key but provide an inconsistent input algorithm.
   EXPECT_FALSE(ImportKeyInternal(
       blink::WebCryptoKeyFormatPkcs8,
       HexStringToBytes(hex_rsa_pkcs8_der),
       webcrypto::CreateAlgorithm(blink::WebCryptoAlgorithmIdAesCbc),
       true,
       blink::WebCryptoKeyUsageSign,
       &key));
 }
 
-TEST_F(WebCryptoImplTest, GenerateKeyPairRsa) {
+TEST_F(WebCryptoImplTest, NSSONLY(GenerateKeyPairRsa)) {
   // Note: using unrealistic short key lengths here to avoid bogging down tests.
 
   // Successful WebCryptoAlgorithmIdRsaEsPkcs1v1_5 key generation.
   const unsigned modulus_length = 256;
   const std::vector<uint8> public_exponent = HexStringToBytes("010001");
   blink::WebCryptoAlgorithm algorithm = webcrypto::CreateRsaKeyGenAlgorithm(
       blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5,
       modulus_length,
       public_exponent);
   bool extractable = false;
@@ skipping 93 matching lines @@
   EXPECT_EQ(usage_mask, private_key.usages());
 
   // Fail SPKI export of private key. This is an ExportKey test, but do it here
   // since it is expensive to generate an RSA key pair and we already have a
   // private key here.
   blink::WebArrayBuffer output;
   EXPECT_FALSE(
       ExportKeyInternal(blink::WebCryptoKeyFormatSpki, private_key, &output));
 }
 
-TEST_F(WebCryptoImplTest, RsaEsRoundTrip) {
+TEST_F(WebCryptoImplTest, NSSONLY(RsaEsRoundTrip)) {
   // Note: using unrealistic short key length here to avoid bogging down tests.
 
   // Create a key pair.
   const unsigned kModulusLength = 256;
   blink::WebCryptoAlgorithm algorithm =
-      CreateRsaKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5,
-                               kModulusLength,
-                               HexStringToBytes("010001"));
+      webcrypto::CreateRsaKeyGenAlgorithm(
+          blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5,
+          kModulusLength,
+          HexStringToBytes("010001"));
   const blink::WebCryptoKeyUsageMask usage_mask =
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt;
   blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
   blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
   EXPECT_TRUE(GenerateKeyPairInternal(
       algorithm, false, usage_mask, &public_key, &private_key));
   EXPECT_FALSE(public_key.isNull());
   EXPECT_FALSE(private_key.isNull());
 
   // Make a maximum-length data message. RSAES can operate on messages up to
@@ skipping 27 matching lines @@
     ASSERT_TRUE(DecryptInternal(
         algorithm,
         private_key,
         reinterpret_cast<const unsigned char*>(encrypted_data.data()),
         encrypted_data.byteLength(),
         &decrypted_data));
     ExpectArrayBufferMatchesHex(kTestDataHex[i], decrypted_data);
   }
 }
 
-TEST_F(WebCryptoImplTest, RsaEsKnownAnswer) {
+TEST_F(WebCryptoImplTest, NSSONLY(RsaEsKnownAnswer)) {
   // Because the random data in PKCS1.5 padding makes the encryption output non-
   // deterministic, we cannot easily do a typical known-answer test for RSA
   // encryption / decryption. Instead we will take a known-good encrypted
   // message, decrypt it, re-encrypt it, then decrypt again, verifying that the
   // original known cleartext is the result.
 
   // The RSA public and private keys used for this test are produced by the
   // openssl command line:
   // % openssl genrsa -out pair.pem 1024
   // % openssl rsa -in pair.pem -out spki.der -outform DER -pubout
@@ skipping 105 matching lines @@
   ASSERT_TRUE(DecryptInternal(
       algorithm,
       private_key,
       reinterpret_cast<const unsigned char*>(encrypted_data.data()),
       encrypted_data.byteLength(),
       &decrypted_data));
   EXPECT_FALSE(decrypted_data.isNull());
   ExpectArrayBufferMatchesHex(cleartext_hex, decrypted_data);
 }
 
-TEST_F(WebCryptoImplTest, RsaEsFailures) {
+TEST_F(WebCryptoImplTest, NSSONLY(RsaEsFailures)) {
   // Note: using unrealistic short key length here to avoid bogging down tests.
 
   // Create a key pair.
   const unsigned kModulusLength = 256;
   blink::WebCryptoAlgorithm algorithm =
-      CreateRsaKeyGenAlgorithm(blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5,
-                               kModulusLength,
-                               HexStringToBytes("010001"));
+      webcrypto::CreateRsaKeyGenAlgorithm(
+          blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5,
+          kModulusLength,
+          HexStringToBytes("010001"));
   const blink::WebCryptoKeyUsageMask usage_mask =
       blink::WebCryptoKeyUsageEncrypt | blink::WebCryptoKeyUsageDecrypt;
   blink::WebCryptoKey public_key = blink::WebCryptoKey::createNull();
   blink::WebCryptoKey private_key = blink::WebCryptoKey::createNull();
   EXPECT_TRUE(GenerateKeyPairInternal(
       algorithm, false, usage_mask, &public_key, &private_key));
   EXPECT_FALSE(public_key.isNull());
   EXPECT_FALSE(private_key.isNull());
 
   // Fail encrypt with a private key.
@@ skipping 44 matching lines @@
   // Do a successful decrypt with good data just for confirmation.
   EXPECT_TRUE(DecryptInternal(
       algorithm,
       private_key,
       reinterpret_cast<const unsigned char*>(encrypted_data.data()),
       encrypted_data.byteLength(),
       &decrypted_data));
   ExpectArrayBufferMatchesHex(message_hex_str, decrypted_data);
 }
 
-#endif  // #if !defined(USE_OPENSSL)
-
 }  // namespace content