Remove CertErrors::Add(); use CertErrors::AddError() instead.

net/cert/internal/verify_signed_data.cc

 // Copyright 2015 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/internal/verify_signed_data.h"
 
 #include <openssl/bytestring.h>
 #include <openssl/digest.h>
 #include <openssl/ec.h>
 #include <openssl/ec_key.h>
@@ skipping 149 matching lines @@
   if (!ImportPkeyFromSpki(public_key_spki, EVP_PKEY_RSA, pkey))
     return false;
 
   // Extract the modulus length from the key.
   crypto::ScopedRSA rsa(EVP_PKEY_get1_RSA(pkey->get()));
   if (!rsa)
     return false;
   unsigned int modulus_length_bits = BN_num_bits(rsa->n);
 
   if (!policy->IsAcceptableModulusLengthForRsa(modulus_length_bits, errors)) {
-    errors->Add(kUnacceptableRsaModulusLength);
+    errors->AddError(kUnacceptableRsaModulusLength);
     return false;
   }
 
   return true;
 }
 
 // Does signature verification using either RSA or ECDSA.
 WARN_UNUSED_RESULT bool DoVerify(const SignatureAlgorithm& algorithm,
                                  const der::Input& signed_data,
                                  const der::BitString& signature_value,
@@ skipping 88 matching lines @@
   if (!ImportPkeyFromSpki(public_key_spki, EVP_PKEY_EC, pkey))
     return false;
 
   // Extract the curve name.
   crypto::ScopedEC_KEY ec(EVP_PKEY_get1_EC_KEY(pkey->get()));
   if (!ec.get())
     return false;  // Unexpected.
   int curve_nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec.get()));
 
   if (!policy->IsAcceptableCurveForEcdsa(curve_nid, errors)) {
-    errors->Add(kUnacceptableEcdsaCurve);
+    errors->AddError(kUnacceptableEcdsaCurve);
     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
 bool VerifySignedData(const SignatureAlgorithm& signature_algorithm,
                       const der::Input& signed_data,
                       const der::BitString& signature_value,
                       const der::Input& public_key_spki,
                       const SignaturePolicy* policy,
                       CertErrors* errors) {
   if (!policy->IsAcceptableSignatureAlgorithm(signature_algorithm, errors)) {
-    errors->Add(kUnacceptableSignatureAlgorithm);
+    errors->AddError(kUnacceptableSignatureAlgorithm);
     return false;
   }
 
   crypto::ScopedEVP_PKEY public_key;
 
   // Parse the SPKI to an EVP_PKEY appropriate for the signature algorithm.
   switch (signature_algorithm.algorithm()) {
     case SignatureAlgorithmId::RsaPkcs1:
     case SignatureAlgorithmId::RsaPss:
       if (!ParseRsaKeyFromSpki(public_key_spki, &public_key, policy, errors))
         return false;
       break;
     case SignatureAlgorithmId::Ecdsa:
       if (!ParseEcKeyFromSpki(public_key_spki, &public_key, policy, errors))
         return false;
       break;
   }
 
   if (!DoVerify(signature_algorithm, signed_data, signature_value,
                 public_key.get())) {
-    errors->Add(kSignatureVerificationFailed);
+    errors->AddError(kSignatureVerificationFailed);
     return false;
   }
 
   return true;
 }
 
 }  // namespace net