Revert "Reland: Use unique_ptr and ArrayView in SSLFingerprint"

This reverts commit 47f3240a6621e90a17d92e620ae765c353c87e11.

Reason for revert: Breaks WebRTC roll into Chromium.

Original change's description:
> Reland: Use unique_ptr and ArrayView in SSLFingerprint
> 
> Bug: webrtc:9860
> Change-Id: I550528556aa27050015de29d9d7d99cd9df59ce5
> Reviewed-on: https://webrtc-review.googlesource.com/c/105520
> Reviewed-by: Benjamin Wright <benwright@webrtc.org>
> Reviewed-by: Qingsi Wang <qingsi@webrtc.org>
> Commit-Queue: Steve Anton <steveanton@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#25149}

TBR=steveanton@webrtc.org,qingsi@webrtc.org,benwright@webrtc.org

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: webrtc:9860
Change-Id: Ib1b5759abf6e79a569ca04b66eabc3021d4c16e4
Reviewed-on: https://webrtc-review.googlesource.com/c/106060
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25173}
diff --git a/rtc_base/sslfingerprint.cc b/rtc_base/sslfingerprint.cc
index c62f703..4f1ae8f 100644
--- a/rtc_base/sslfingerprint.cc
+++ b/rtc_base/sslfingerprint.cc
@@ -20,67 +20,57 @@
 namespace rtc {
 
 SSLFingerprint* SSLFingerprint::Create(const std::string& algorithm,
-                                       const rtc::SSLIdentity& identity) {
-  return CreateUnique(algorithm, identity).release();
+                                       const rtc::SSLIdentity* identity) {
+  if (!identity) {
+    return nullptr;
+  }
+
+  return Create(algorithm, &(identity->certificate()));
 }
 
-std::unique_ptr<SSLFingerprint> SSLFingerprint::CreateUnique(
-    const std::string& algorithm,
-    const rtc::SSLIdentity& identity) {
-  return Create(algorithm, identity.certificate());
-}
-
-std::unique_ptr<SSLFingerprint> SSLFingerprint::Create(
-    const std::string& algorithm,
-    const rtc::SSLCertificate& cert) {
+SSLFingerprint* SSLFingerprint::Create(const std::string& algorithm,
+                                       const rtc::SSLCertificate* cert) {
   uint8_t digest_val[64];
   size_t digest_len;
-  bool ret = cert.ComputeDigest(algorithm, digest_val, sizeof(digest_val),
-                                &digest_len);
+  bool ret = cert->ComputeDigest(algorithm, digest_val, sizeof(digest_val),
+                                 &digest_len);
   if (!ret) {
     return nullptr;
   }
-  return absl::make_unique<SSLFingerprint>(
-      algorithm, ArrayView<const uint8_t>(digest_val, digest_len));
+
+  return new SSLFingerprint(algorithm, digest_val, digest_len);
 }
 
 SSLFingerprint* SSLFingerprint::CreateFromRfc4572(
     const std::string& algorithm,
     const std::string& fingerprint) {
-  return CreateUniqueFromRfc4572(algorithm, fingerprint).release();
-}
-
-std::unique_ptr<SSLFingerprint> SSLFingerprint::CreateUniqueFromRfc4572(
-    const std::string& algorithm,
-    const std::string& fingerprint) {
   if (algorithm.empty() || !rtc::IsFips180DigestAlgorithm(algorithm))
     return nullptr;
 
   if (fingerprint.empty())
     return nullptr;
 
+  size_t value_len;
   char value[rtc::MessageDigest::kMaxSize];
-  size_t value_len = rtc::hex_decode_with_delimiter(
+  value_len = rtc::hex_decode_with_delimiter(
       value, sizeof(value), fingerprint.c_str(), fingerprint.length(), ':');
   if (!value_len)
     return nullptr;
 
-  return absl::make_unique<SSLFingerprint>(
-      algorithm,
-      ArrayView<const uint8_t>(reinterpret_cast<uint8_t*>(value), value_len));
+  return new SSLFingerprint(algorithm, reinterpret_cast<uint8_t*>(value),
+                            value_len);
 }
 
-std::unique_ptr<SSLFingerprint> SSLFingerprint::CreateFromCertificate(
-    const RTCCertificate& cert) {
+SSLFingerprint* SSLFingerprint::CreateFromCertificate(
+    const RTCCertificate* cert) {
   std::string digest_alg;
-  if (!cert.ssl_certificate().GetSignatureDigestAlgorithm(&digest_alg)) {
+  if (!cert->ssl_certificate().GetSignatureDigestAlgorithm(&digest_alg)) {
     RTC_LOG(LS_ERROR)
         << "Failed to retrieve the certificate's digest algorithm";
     return nullptr;
   }
 
-  std::unique_ptr<SSLFingerprint> fingerprint =
-      CreateUnique(digest_alg, *cert.identity());
+  SSLFingerprint* fingerprint = Create(digest_alg, cert->identity());
   if (!fingerprint) {
     RTC_LOG(LS_ERROR) << "Failed to create identity fingerprint, alg="
                       << digest_alg;
@@ -89,13 +79,11 @@
 }
 
 SSLFingerprint::SSLFingerprint(const std::string& algorithm,
-                               ArrayView<const uint8_t> digest_view)
-    : algorithm(algorithm), digest(digest_view.data(), digest_view.size()) {}
-
-SSLFingerprint::SSLFingerprint(const std::string& algorithm,
                                const uint8_t* digest_in,
                                size_t digest_len)
-    : SSLFingerprint(algorithm, MakeArrayView(digest_in, digest_len)) {}
+    : algorithm(algorithm) {
+  digest.SetData(digest_in, digest_len);
+}
 
 SSLFingerprint::SSLFingerprint(const SSLFingerprint& from)
     : algorithm(from.algorithm), digest(from.digest) {}