Revert of Removing #defines previously used for building without BoringSSL/OpenSSL.

webrtc/base/sslidentity.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 // Handling of certificates and keypairs for SSLStreamAdapter's peer mode.
 #include "webrtc/base/sslidentity.h"
 
 #include <ctime>
 #include <string>
 
 #include "webrtc/base/base64.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/base/sslconfig.h"
+#include "webrtc/base/sslfingerprint.h"
+
+#if SSL_USE_OPENSSL
+
 #include "webrtc/base/opensslidentity.h"
-#include "webrtc/base/sslfingerprint.h"
+
+#endif  // SSL_USE_OPENSSL
 
 namespace rtc {
 
 const char kPemTypeCertificate[] = "CERTIFICATE";
 const char kPemTypeRsaPrivateKey[] = "RSA PRIVATE KEY";
 const char kPemTypeEcPrivateKey[] = "EC PRIVATE KEY";
 
 SSLCertificateStats::SSLCertificateStats(
     std::string&& fingerprint,
     std::string&& fingerprint_algorithm,
@@ skipping 168 matching lines @@
 }
 
 SSLCertChain::SSLCertChain(const SSLCertificate* cert) {
   certs_.push_back(cert->GetReference());
 }
 
 SSLCertChain::~SSLCertChain() {
   std::for_each(certs_.begin(), certs_.end(), DeleteCert);
 }
 
+#if SSL_USE_OPENSSL
+
 // static
 SSLCertificate* SSLCertificate::FromPEMString(const std::string& pem_string) {
   return OpenSSLCertificate::FromPEMString(pem_string);
 }
 
 // static
 SSLIdentity* SSLIdentity::GenerateWithExpiration(const std::string& common_name,
                                                  const KeyParams& key_params,
                                                  time_t certificate_lifetime) {
   return OpenSSLIdentity::GenerateWithExpiration(common_name, key_params,
@@ skipping 25 matching lines @@
 }
 
 bool operator==(const SSLIdentity& a, const SSLIdentity& b) {
   return static_cast<const OpenSSLIdentity&>(a) ==
          static_cast<const OpenSSLIdentity&>(b);
 }
 bool operator!=(const SSLIdentity& a, const SSLIdentity& b) {
   return !(a == b);
 }
 
+#else  // !SSL_USE_OPENSSL
+
+#error "No SSL implementation"
+
+#endif  // SSL_USE_OPENSSL
+
 // Read |n| bytes from ASN1 number string at *|pp| and return the numeric value.
 // Update *|pp| and *|np| to reflect number of read bytes.
 static inline int ASN1ReadInt(const unsigned char** pp, size_t* np, size_t n) {
   const unsigned char* p = *pp;
   int x = 0;
   for (size_t i = 0; i < n; i++)
     x = 10 * x + p[i] - '0';
   *pp = p + n;
   *np = *np - n;
   return x;
@@ skipping 51 matching lines @@
 
   if (bytes_left != 1) {
     // Now just Z should remain.  Its existence was asserted above.
     return -1;
   }
 
   return TmToSeconds(tm);
 }
 
 }  // namespace rtc