Remove platform-specific implementations of RSAPrivateKey and SignatureCreator

net/cert/x509_certificate_nss.cc

 // Copyright (c) 2012 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/cert/x509_certificate.h"
 
 #include <cert.h>
 #include <cryptohi.h>
 #include <keyhi.h>
 #include <nss.h>
 #include <pk11pub.h>
 #include <prtime.h>
 #include <seccomon.h>
 #include <secder.h>
 #include <sechash.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pickle.h"
 #include "base/strings/stringprintf.h"
 #include "base/time.h"
 #include "crypto/nss_util.h"
-#include "crypto/rsa_private_key.h"
 #include "crypto/scoped_nss_types.h"
 #include "net/cert/x509_util_nss.h"
 
 namespace net {
 
 void X509Certificate::Initialize() {
   x509_util::ParsePrincipal(&cert_handle_->subject, &subject_);
   x509_util::ParsePrincipal(&cert_handle_->issuer, &issuer_);
 
   x509_util::ParseDate(&cert_handle_->validity.notBefore, &valid_start_);
@@ skipping 73 matching lines @@
     case SERVER_CERT:
       result = subject_.GetDisplayName();
       break;
     case UNKNOWN_CERT:
     default:
       break;
   }
   return result;
 }
 
-// static
-X509Certificate* X509Certificate::CreateSelfSigned(
-    crypto::RSAPrivateKey* key,
-    const std::string& subject,
-    uint32 serial_number,
-    base::TimeDelta valid_duration) {
-  DCHECK(key);
-  base::Time not_valid_before = base::Time::Now();
-  base::Time not_valid_after = not_valid_before + valid_duration;
-  CERTCertificate* cert = x509_util::CreateSelfSignedCert(key->public_key(),
-                                                          key->key(),
-                                                          subject,
-                                                          serial_number,
-                                                          not_valid_before,
-                                                          not_valid_after);
-  if (!cert)
-    return NULL;
-
-  X509Certificate* x509_cert = X509Certificate::CreateFromHandle(
-      cert, X509Certificate::OSCertHandles());
-  CERT_DestroyCertificate(cert);
-  return x509_cert;
-}
-
 void X509Certificate::GetSubjectAltName(
     std::vector<std::string>* dns_names,
     std::vector<std::string>* ip_addrs) const {
   x509_util::GetSubjectAltName(cert_handle_, dns_names, ip_addrs);
 }
 
 bool X509Certificate::IsIssuedByEncoded(
     const std::vector<std::string>& valid_issuers) {
   // Get certificate chain as scoped list of CERTCertificate objects.
   std::vector<CERTCertificate*> cert_chain;
@@ skipping 134 matching lines @@
 }
 
 // static
 void X509Certificate::GetPublicKeyInfo(OSCertHandle cert_handle,
                                        size_t* size_bits,
                                        PublicKeyType* type) {
   x509_util::GetPublicKeyInfo(cert_handle, size_bits, type);
 }
 
 }  // namespace net