Cut down on usage of deprecated APIs in //crypto.

crypto/ec_private_key_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 "crypto/ec_private_key.h"
 
 extern "C" {
 // Work around NSS missing SEC_BEGIN_PROTOS in secmodt.h.  This must come before
 // other NSS headers.
 #include <secmodt.h>
 }
 
 #include <cryptohi.h>
 #include <keyhi.h>
 #include <pk11pub.h>
 #include <secmod.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "crypto/nss_util.h"
 #include "crypto/nss_util_internal.h"
 #include "crypto/scoped_nss_types.h"
 #include "crypto/third_party/nss/chromium-nss.h"
 
 namespace {
 
-// Copied from rsa_private_key_nss.cc.
-static bool ReadAttribute(SECKEYPrivateKey* key,
-                          CK_ATTRIBUTE_TYPE type,
-                          std::vector<uint8_t>* output) {
+static bool AppendAttribute(SECKEYPrivateKey* key,
+                            CK_ATTRIBUTE_TYPE type,
+                            std::vector<uint8_t>* output) {
   SECItem item;
   SECStatus rv;
   rv = PK11_ReadRawAttribute(PK11_TypePrivKey, key, type, &item);
   if (rv != SECSuccess) {
     DLOG(ERROR) << "PK11_ReadRawAttribute: " << PORT_GetError();
     return false;
   }
 
-  output->assign(item.data, item.data + item.len);
+  output->insert(output->end(), item.data, item.data + item.len);
   SECITEM_FreeItem(&item, PR_FALSE);
   return true;
 }
 
 }  // namespace
 
 namespace crypto {
 
 ECPrivateKey::~ECPrivateKey() {
   if (key_)
@@ skipping 252 matching lines @@
   const unsigned char* const data = public_key_->u.ec.publicValue.data;
   const unsigned int len = public_key_->u.ec.publicValue.len;
   if (len != kExpectedKeyLength || data[0] != 0x04)
     return false;
 
   output->assign(reinterpret_cast<const char*>(data + 1),
                  kExpectedKeyLength - 1);
   return true;
 }
 
-bool ECPrivateKey::ExportValue(std::vector<uint8_t>* output) {
-  return ReadAttribute(key_, CKA_VALUE, output);
-}
-
-bool ECPrivateKey::ExportECParams(std::vector<uint8_t>* output) {
-  return ReadAttribute(key_, CKA_EC_PARAMS, output);
+bool ECPrivateKey::ExportValueForTesting(std::vector<uint8_t>* output) {
+  // This serialization format is purely for testing equality, so just
+  // concatenate the raw private key (always 32 bytes for P-256) with the
+  // parameters.
+  output->clear();
+  return AppendAttribute(key_, CKA_VALUE, output) &&
+         output->size() == 32 &&
+         AppendAttribute(key_, CKA_EC_PARAMS, output);
 }
 
 ECPrivateKey::ECPrivateKey() : key_(NULL), public_key_(NULL) {}
 
 }  // namespace crypto