Add ECPrivateKey for Elliptic Curve keypair generation.

chrome/third_party/mozilla_security_manager/nsNSSCertHelper.cpp

 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
@@ skipping 31 matching lines @@
 
 #include <keyhi.h>
 #include <prprf.h>
 #include <unicode/uidna.h>
 
 #include "base/i18n/number_formatting.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/net/x509_certificate_model.h"
+#include "crypto/scoped_nss_types.h"
 #include "grit/generated_resources.h"
 #include "net/base/net_util.h"
 #include "net/third_party/mozilla_security_manager/nsNSSCertTrust.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 std::string BMPtoUTF8(PRArenaPool* arena, unsigned char* data,
                       unsigned int len) {
   if (len % 2 != 0)
@@ skipping 514 matching lines @@
       break;
     rv += text;
     current = CERT_GetNextGeneralName(current);
   } while (current != name_list);
   return rv;
 }
 
 std::string ProcessAltName(SECItem* extension_data) {
   CERTGeneralName* name_list;
 
-  ScopedPRArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
+  crypto::ScopedPLArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
   CHECK(arena.get());
 
   name_list = CERT_DecodeAltNameExtension(arena.get(), extension_data);
   if (!name_list)
     return l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
 
   return ProcessGeneralNames(arena.get(), name_list);
 }
 
 std::string ProcessSubjectKeyId(SECItem* extension_data) {
   SECItem decoded;
-  ScopedPRArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
+  crypto::ScopedPLArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
   CHECK(arena.get());
 
   std::string rv;
   if (SEC_QuickDERDecodeItem(arena.get(), &decoded,
                              SEC_ASN1_GET(SEC_OctetStringTemplate),
                              extension_data) != SECSuccess) {
     rv = l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
     return rv;
   }
 
   rv = l10n_util::GetStringFUTF8(IDS_CERT_KEYID_FORMAT,
                                  ASCIIToUTF16(ProcessRawBytes(&decoded)));
   return rv;
 }
 
 std::string ProcessAuthKeyId(SECItem* extension_data) {
   CERTAuthKeyID* ret;
-  ScopedPRArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
+  crypto::ScopedPLArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
   std::string rv;
 
   CHECK(arena.get());
 
   ret = CERT_DecodeAuthKeyID(arena.get(), extension_data);
 
   if (ret->keyID.len > 0) {
     rv += l10n_util::GetStringFUTF8(IDS_CERT_KEYID_FORMAT,
                                     ASCIIToUTF16(ProcessRawBytes(&ret->keyID)));
     rv += '\n';
@@ skipping 143 matching lines @@
     {RF_UNUSED, IDS_CERT_REVOCATION_REASON_UNUSED},
     {RF_KEY_COMPROMISE, IDS_CERT_REVOCATION_REASON_KEY_COMPROMISE},
     {RF_CA_COMPROMISE, IDS_CERT_REVOCATION_REASON_CA_COMPROMISE},
     {RF_AFFILIATION_CHANGED, IDS_CERT_REVOCATION_REASON_AFFILIATION_CHANGED},
     {RF_SUPERSEDED, IDS_CERT_REVOCATION_REASON_SUPERSEDED},
     {RF_CESSATION_OF_OPERATION,
      IDS_CERT_REVOCATION_REASON_CESSATION_OF_OPERATION},
     {RF_CERTIFICATE_HOLD, IDS_CERT_REVOCATION_REASON_CERTIFICATE_HOLD},
   };
 
-  ScopedPRArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
+  crypto::ScopedPLArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
   CHECK(arena.get());
 
   crldp = CERT_DecodeCRLDistributionPoints(arena.get(), extension_data);
   if (!crldp || !crldp->distPoints) {
     rv = l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
     return rv;
   }
 
   for (points = crldp->distPoints; *points; ++points) {
     point = *points;
@@ skipping 26 matching lines @@
           UTF8ToUTF16(ProcessGeneralNames(arena.get(), point->crlIssuer)));
     }
   }
   return rv;
 }
 
 std::string ProcessAuthInfoAccess(SECItem* extension_data) {
   std::string rv;
   CERTAuthInfoAccess** aia;
   CERTAuthInfoAccess* desc;
-  ScopedPRArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
+  crypto::ScopedPLArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
   CHECK(arena.get());
 
   aia = CERT_DecodeAuthInfoAccessExtension(arena.get(), extension_data);
   if (aia == NULL)
     return l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
 
   while (*aia != NULL) {
     desc = *aia++;
     string16 location_str = UTF8ToUTF16(ProcessGeneralName(arena.get(),
                                                            desc->location));
@@ skipping 22 matching lines @@
                          extension_data) != SECSuccess)
     return l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
   std::string rv((char*)item.data, item.len);  // ASCII data.
   PORT_Free(item.data);
   return rv;
 }
 
 std::string ProcessBMPString(SECItem* extension_data) {
   std::string rv;
   SECItem item;
-  ScopedPRArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
+  crypto::ScopedPLArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
   CHECK(arena.get());
 
   if (SEC_ASN1DecodeItem(arena.get(), &item,
                          SEC_ASN1_GET(SEC_BMPStringTemplate), extension_data) ==
       SECSuccess)
     rv = BMPtoUTF8(arena.get(), item.data, item.len);
   return rv;
 }
 
 struct MaskIdPair {
@@ skipping 177 matching lines @@
   if (trust.HasAnyCA())
     return net::CA_CERT;
   if (trust.HasPeer(PR_TRUE, PR_FALSE, PR_FALSE))
     return net::SERVER_CERT;
   if (CERT_IsCACert(cert, NULL))
     return net::CA_CERT;
   return net::UNKNOWN_CERT;
 }
 
 }  // namespace mozilla_security_manager