Remove SSLPrivateKey metadata hooks.

net/ssl/ssl_private_key_test_util.cc

 // Copyright 2016 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 "net/ssl/ssl_private_key_test_util.h"
 
 #include <stdint.h>
 
 #include <vector>
 
@@ skipping 48 matching lines @@
     case SSLPrivateKey::Hash::SHA384:
       return EVP_sha384();
     case SSLPrivateKey::Hash::SHA512:
       return EVP_sha512();
   }
 
   NOTREACHED();
   return nullptr;
 }
 
-SSLPrivateKey::Type TypeForOpenSSLKey(EVP_PKEY* pkey) {
-  switch (EVP_PKEY_id(pkey)) {
-    case EVP_PKEY_RSA:
-      return SSLPrivateKey::Type::RSA;
-    case EVP_PKEY_EC: {
-      switch (EC_GROUP_get_curve_name(
-          EC_KEY_get0_group(EVP_PKEY_get0_EC_KEY(pkey)))) {
-        case NID_X9_62_prime256v1:
-          return SSLPrivateKey::Type::ECDSA_P256;
-        case NID_secp384r1:
-          return SSLPrivateKey::Type::ECDSA_P384;
-        case NID_secp521r1:
-          return SSLPrivateKey::Type::ECDSA_P521;
-      }
-    }
-  }
-
-  NOTREACHED();
-  return SSLPrivateKey::Type::RSA;
-}
-
 // Resize a string to |size| bytes of data, then return its data buffer address
 // cast as an 'uint8_t*', as expected by OpenSSL functions.
 // |str| the target string.
 // |size| the number of bytes to write into the string.
 // Return the string's new buffer in memory, as an 'uint8_t*' pointer.
 uint8_t* OpenSSLWriteInto(std::string* str, size_t size) {
   return reinterpret_cast<uint8_t*>(base::WriteInto(str, size + 1));
 }
 
 bool VerifyWithOpenSSL(const EVP_MD* md,
@@ skipping 50 matching lines @@
   key->SignDigest(
       hash, message,
       base::Bind(OnSignComplete, base::Unretained(&loop),
                  base::Unretained(&error), base::Unretained(result)));
   loop.Run();
   return error;
 }
 
 }  // namespace
 
-const char* SSLPrivateKeyTypeToString(SSLPrivateKey::Type type) {
-  switch (type) {
-    case SSLPrivateKey::Type::RSA:
-      return "RSA";
-    case SSLPrivateKey::Type::ECDSA_P256:
-      return "ECDSA_P256";
-    case SSLPrivateKey::Type::ECDSA_P384:
-      return "ECDSA_P384";
-    case SSLPrivateKey::Type::ECDSA_P521:
-      return "ECDSA_P521";
-  }
-
-  NOTREACHED();
-  return "";
-}
-
 void TestSSLPrivateKeyMatches(SSLPrivateKey* key, const std::string& pkcs8) {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
   // Create the equivalent OpenSSL key.
   CBS cbs;
   CBS_init(&cbs, reinterpret_cast<const uint8_t*>(pkcs8.data()), pkcs8.size());
   bssl::UniquePtr<EVP_PKEY> openssl_key(EVP_parse_private_key(&cbs));
   ASSERT_TRUE(openssl_key);
   EXPECT_EQ(0u, CBS_len(&cbs));
 
-  // Check the length and type matches.
-  EXPECT_EQ(TypeForOpenSSLKey(openssl_key.get()), key->GetType());
-  EXPECT_EQ(static_cast<size_t>(EVP_PKEY_size(openssl_key.get())),
-            key->GetMaxSignatureLengthInBytes());
-
   // Test all supported hash algorithms.
   std::vector<SSLPrivateKey::Hash> hashes = key->GetDigestPreferences();
 
   // To support TLS 1.1 and earlier, RSA keys must implicitly support MD5-SHA1,
   // despite not being advertised.
-  if (key->GetType() == SSLPrivateKey::Type::RSA)
+  if (EVP_PKEY_id(openssl_key.get()) == EVP_PKEY_RSA)
     hashes.push_back(SSLPrivateKey::Hash::MD5_SHA1);
 
   for (SSLPrivateKey::Hash hash : hashes) {
     SCOPED_TRACE(HashToString(hash));
     const EVP_MD* md = HashToMD(hash);
 
     std::string digest(EVP_MD_size(md), 'a');
 
     // Test the key generates valid signatures.
     std::string signature;
     Error error = DoKeySigningWithWrapper(key, hash, digest, &signature);
     EXPECT_THAT(error, IsOk());
     EXPECT_TRUE(VerifyWithOpenSSL(md, digest, openssl_key.get(), signature));
 
     // RSA signing is deterministic, so further check the signature matches.
-    if (key->GetType() == SSLPrivateKey::Type::RSA) {
+    if (EVP_PKEY_id(openssl_key.get()) == EVP_PKEY_RSA) {
       std::string openssl_signature;
       ASSERT_TRUE(
           SignWithOpenSSL(md, digest, openssl_key.get(), &openssl_signature));
       EXPECT_EQ(openssl_signature, signature);
     }
   }
 }
 
 }  // namespace net