--- a/netwerk/base/public/nsINSSErrorsService.idl
+++ b/netwerk/base/public/nsINSSErrorsService.idl
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "nsISupports.idl"
 
-[scriptable, uuid(dc8013f2-4aed-47a8-bc4e-9fd7a6cc60fa)]
+[scriptable, uuid(12f60021-e14b-4020-99d1-ed2c795be66a)]
 interface nsINSSErrorsService : nsISupports
 {
     /**
      *  @param aNSPRCode An error code obtained using PR_GetError()
      *  @return True if it is error code defined by the NSS library
      */
     boolean isNSSErrorCode(in int32_t aNSPRCode);
 
@@ -49,17 +49,20 @@ interface nsINSSErrorsService : nsISuppo
     const long NSS_SEC_ERROR_BASE  = -(0x2000);
     const long NSS_SEC_ERROR_LIMIT = (NSS_SEC_ERROR_BASE + 1000);
     const long NSS_SSL_ERROR_BASE  = -(0x3000);
     const long NSS_SSL_ERROR_LIMIT = (NSS_SSL_ERROR_BASE + 1000);
 
     /**
      * The error codes within each module must fit in 16 bits. We want these
      * errors to fit in the same module as the NSS errors but not overlap with
-     * any of them. Converting an NSS SEC, NSS SSL, or PSM error to an NS error
-     * involves negating the value of the error and then synthesizing an error
-     * in the NS_ERROR_MODULE_SECURITY module. Hence, PSM errors will start at
-     * a negative value that both doesn't overlap with the current value
-     * ranges for NSS errors and that will fit in 16 bits when negated.
+     * any of them. Converting an NSS SEC, NSS SSL, or mozilla::pkix error to
+     * an NS error involves negating the value of the error and then
+     * synthesizing an error in the NS_ERROR_MODULE_SECURITY module. Hence,
+     * mozilla::pkix errors will start at a negative value that both doesn't
+     * overlap with the current value ranges for NSS errors and that will fit
+     * in 16 bits when negated.
+     *
+     * Keep these in sync with pkixnss.h.
      */
-    const long PSM_ERROR_BASE  = -(0x4000);
-    const long PSM_ERROR_LIMIT = (PSM_ERROR_BASE + 1000);
+    const long MOZILLA_PKIX_ERROR_BASE  = -(0x4000);
+    const long MOZILLA_PKIX_ERROR_LIMIT = (MOZILLA_PKIX_ERROR_BASE + 1000);
 };

--- a/security/apps/AppSignatureVerification.cpp
+++ b/security/apps/AppSignatureVerification.cpp
@@ -6,16 +6,17 @@
 
 #ifdef MOZ_LOGGING
 #define FORCE_PR_LOG 1
 #endif
 
 #include "nsNSSCertificateDB.h"
 
 #include "pkix/pkix.h"
+#include "pkix/pkixnss.h"
 #include "mozilla/RefPtr.h"
 #include "CryptoTask.h"
 #include "AppTrustDomain.h"
 #include "nsComponentManagerUtils.h"
 #include "nsCOMPtr.h"
 #include "nsDataSignatureVerifier.h"
 #include "nsHashKeys.h"
 #include "nsIFile.h"
@@ -536,23 +537,24 @@ VerifyCertificate(CERTCertificate* signe
   }
   const VerifyCertificateContext& context =
     *reinterpret_cast<const VerifyCertificateContext*>(voidContext);
 
   AppTrustDomain trustDomain(context.builtChain, pinArg);
   if (trustDomain.SetTrustedRoot(context.trustedRoot) != SECSuccess) {
     return MapSECStatus(SECFailure);
   }
-  if (BuildCertChain(trustDomain, signerCert->derCert, PR_Now(),
-                     EndEntityOrCA::MustBeEndEntity,
-                     KeyUsage::digitalSignature,
-                     KeyPurposeId::id_kp_codeSigning,
-                     CertPolicyId::anyPolicy,
-                     nullptr/*stapledOCSPResponse*/) != SECSuccess) {
-    return MapSECStatus(SECFailure);
+  Result rv = BuildCertChain(trustDomain, signerCert->derCert, PR_Now(),
+                             EndEntityOrCA::MustBeEndEntity,
+                             KeyUsage::digitalSignature,
+                             KeyPurposeId::id_kp_codeSigning,
+                             CertPolicyId::anyPolicy,
+                             nullptr/*stapledOCSPResponse*/);
+  if (rv != Success) {
+    return mozilla::psm::GetXPCOMFromNSSError(MapResultToPRErrorCode(rv));
   }
 
   return NS_OK;
 }
 
 nsresult
 VerifySignature(AppTrustedRoot trustedRoot, const SECItem& buffer,
                 const SECItem& detachedDigest,

--- a/security/apps/AppTrustDomain.cpp
+++ b/security/apps/AppTrustDomain.cpp
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifdef MOZ_LOGGING
 #define FORCE_PR_LOG 1
 #endif
 
 #include "AppTrustDomain.h"
 #include "certdb.h"
-#include "pkix/pkix.h"
+#include "pkix/pkixnss.h"
 #include "mozilla/ArrayUtils.h"
 #include "nsIX509CertDB.h"
 #include "nsNSSCertificate.h"
 #include "prerror.h"
 #include "secerr.h"
 
 // Generated in Makefile.in
 #include "marketplace-prod-public.inc"
@@ -88,25 +88,24 @@ AppTrustDomain::SetTrustedRoot(AppTruste
                                          &trustedDER, nullptr, false, true);
   if (!mTrustedRoot) {
     return SECFailure;
   }
 
   return SECSuccess;
 }
 
-SECStatus
+Result
 AppTrustDomain::FindIssuer(const SECItem& encodedIssuerName,
                            IssuerChecker& checker, PRTime time)
 
 {
   MOZ_ASSERT(mTrustedRoot);
   if (!mTrustedRoot) {
-    PR_SetError(PR_INVALID_STATE_ERROR, 0);
-    return SECFailure;
+    return Result::FATAL_ERROR_INVALID_STATE;
   }
 
   // TODO(bug 1035418): If/when mozilla::pkix relaxes the restriction that
   // FindIssuer must only pass certificates with a matching subject name to
   // checker.Check, we can stop using CERT_CreateSubjectCertList and instead
   // use logic like this:
   //
   // 1. First, try the trusted trust anchor.
@@ -114,60 +113,58 @@ AppTrustDomain::FindIssuer(const SECItem
   //    message, passing each one to checker.Check.
   ScopedCERTCertList
     candidates(CERT_CreateSubjectCertList(nullptr, CERT_GetDefaultCertDB(),
                                           &encodedIssuerName, time, true));
   if (candidates) {
     for (CERTCertListNode* n = CERT_LIST_HEAD(candidates);
          !CERT_LIST_END(n, candidates); n = CERT_LIST_NEXT(n)) {
       bool keepGoing;
-      SECStatus srv = checker.Check(n->cert->derCert,
-                                    nullptr/*additionalNameConstraints*/,
-                                    keepGoing);
-      if (srv != SECSuccess) {
-        return SECFailure;
+      Result rv = checker.Check(n->cert->derCert,
+                                nullptr/*additionalNameConstraints*/,
+                                keepGoing);
+      if (rv != Success) {
+        return rv;
       }
       if (!keepGoing) {
         break;
       }
     }
   }
 
-  return SECSuccess;
+  return Success;
 }
 
-SECStatus
+Result
 AppTrustDomain::GetCertTrust(EndEntityOrCA endEntityOrCA,
                              const CertPolicyId& policy,
                              const SECItem& candidateCertDER,
                      /*out*/ TrustLevel* trustLevel)
 {
   MOZ_ASSERT(policy.IsAnyPolicy());
   MOZ_ASSERT(trustLevel);
   MOZ_ASSERT(mTrustedRoot);
   if (!trustLevel || !policy.IsAnyPolicy()) {
-    PR_SetError(SEC_ERROR_INVALID_ARGS, 0);
-    return SECFailure;
+    return Result::FATAL_ERROR_INVALID_ARGS;
   }
   if (!mTrustedRoot) {
-    PR_SetError(PR_INVALID_STATE_ERROR, 0);
-    return SECFailure;
+    return Result::FATAL_ERROR_INVALID_STATE;
   }
 
   // Handle active distrust of the certificate.
 
   // XXX: This would be cleaner and more efficient if we could get the trust
   // information without constructing a CERTCertificate here, but NSS doesn't
   // expose it in any other easy-to-use fashion.
   ScopedCERTCertificate candidateCert(
     CERT_NewTempCertificate(CERT_GetDefaultCertDB(),
                             const_cast<SECItem*>(&candidateCertDER), nullptr,
                             false, true));
   if (!candidateCert) {
-    return SECFailure;
+    return MapPRErrorCodeToResult(PR_GetError());
   }
 
   CERTCertTrust trust;
   if (CERT_GetCertTrust(candidateCert.get(), &trust) == SECSuccess) {
     PRUint32 flags = SEC_GET_TRUST_FLAGS(&trust, trustObjectSigning);
 
     // For DISTRUST, we use the CERTDB_TRUSTED or CERTDB_TRUSTED_CA bit,
     // because we can have active distrust for either type of cert. Note that
@@ -175,60 +172,65 @@ AppTrustDomain::GetCertTrust(EndEntityOr
     // relevant trust bit isn't set then that means the cert must be considered
     // distrusted.
     PRUint32 relevantTrustBit = endEntityOrCA == EndEntityOrCA::MustBeCA
                               ? CERTDB_TRUSTED_CA
                               : CERTDB_TRUSTED;
     if (((flags & (relevantTrustBit | CERTDB_TERMINAL_RECORD)))
             == CERTDB_TERMINAL_RECORD) {
       *trustLevel = TrustLevel::ActivelyDistrusted;
-      return SECSuccess;
+      return Success;
     }
   }
 
   // mTrustedRoot is the only trust anchor for this validation.
   if (CERT_CompareCerts(mTrustedRoot.get(), candidateCert.get())) {
     *trustLevel = TrustLevel::TrustAnchor;
-    return SECSuccess;
+    return Success;
   }
 
   *trustLevel = TrustLevel::InheritsTrust;
-  return SECSuccess;
+  return Success;
 }
 
-SECStatus
+Result
 AppTrustDomain::VerifySignedData(const SignedDataWithSignature& signedData,
                                  const SECItem& subjectPublicKeyInfo)
 {
   return ::mozilla::pkix::VerifySignedData(signedData, subjectPublicKeyInfo,
                                            mPinArg);
 }
 
-SECStatus
+Result
 AppTrustDomain::DigestBuf(const SECItem& item, /*out*/ uint8_t* digestBuf,
                           size_t digestBufLen)
 {
   return ::mozilla::pkix::DigestBuf(item, digestBuf, digestBufLen);
 }
 
-SECStatus
+Result
 AppTrustDomain::CheckRevocation(EndEntityOrCA, const CertID&, PRTime time,
                                 /*optional*/ const SECItem*,
                                 /*optional*/ const SECItem*)
 {
   // We don't currently do revocation checking. If we need to distrust an Apps
   // certificate, we will use the active distrust mechanism.
-  return SECSuccess;
+  return Success;
 }
 
-SECStatus
+Result
 AppTrustDomain::IsChainValid(const DERArray& certChain)
 {
-  return ConstructCERTCertListFromReversedDERArray(certChain, mCertChain);
+  SECStatus srv = ConstructCERTCertListFromReversedDERArray(certChain,
+                                                            mCertChain);
+  if (srv != SECSuccess) {
+    return MapPRErrorCodeToResult(PR_GetError());
+  }
+  return Success;
 }
 
-SECStatus
+Result
 AppTrustDomain::CheckPublicKey(const SECItem& subjectPublicKeyInfo)
 {
   return ::mozilla::pkix::CheckPublicKey(subjectPublicKeyInfo);
 }
 
 } } // namespace mozilla::psm

--- a/security/apps/AppTrustDomain.h
+++ b/security/apps/AppTrustDomain.h
@@ -12,38 +12,43 @@
 #include "nsIX509CertDB.h"
 #include "ScopedNSSTypes.h"
 
 namespace mozilla { namespace psm {
 
 class AppTrustDomain MOZ_FINAL : public mozilla::pkix::TrustDomain
 {
 public:
+  typedef mozilla::pkix::Result Result;
+
   AppTrustDomain(ScopedCERTCertList&, void* pinArg);
 
   SECStatus SetTrustedRoot(AppTrustedRoot trustedRoot);
 
-  SECStatus GetCertTrust(mozilla::pkix::EndEntityOrCA endEntityOrCA,
-                         const mozilla::pkix::CertPolicyId& policy,
-                         const SECItem& candidateCertDER,
-                 /*out*/ mozilla::pkix::TrustLevel* trustLevel) MOZ_OVERRIDE;
-  SECStatus FindIssuer(const SECItem& encodedIssuerName,
-                       IssuerChecker& checker, PRTime time) MOZ_OVERRIDE;
-  SECStatus CheckRevocation(mozilla::pkix::EndEntityOrCA endEntityOrCA,
-                            const mozilla::pkix::CertID& certID, PRTime time,
-                            /*optional*/ const SECItem* stapledOCSPresponse,
-                            /*optional*/ const SECItem* aiaExtension);
-  SECStatus IsChainValid(const mozilla::pkix::DERArray& certChain);
-
-  SECStatus VerifySignedData(
-              const mozilla::pkix::SignedDataWithSignature& signedData,
-              const SECItem& subjectPublicKeyInfo) MOZ_OVERRIDE;
-  SECStatus DigestBuf(const SECItem& item, /*out*/ uint8_t* digestBuf,
-                      size_t digestBufLen) MOZ_OVERRIDE;
-  SECStatus CheckPublicKey(const SECItem& subjectPublicKeyInfo) MOZ_OVERRIDE;
+  virtual Result GetCertTrust(mozilla::pkix::EndEntityOrCA endEntityOrCA,
+                              const mozilla::pkix::CertPolicyId& policy,
+                              const SECItem& candidateCertDER,
+                              /*out*/ mozilla::pkix::TrustLevel* trustLevel)
+                              MOZ_OVERRIDE;
+  virtual Result FindIssuer(const SECItem& encodedIssuerName,
+                            IssuerChecker& checker,
+                            PRTime time) MOZ_OVERRIDE;
+  virtual Result CheckRevocation(mozilla::pkix::EndEntityOrCA endEntityOrCA,
+                                 const mozilla::pkix::CertID& certID, PRTime time,
+                                 /*optional*/ const SECItem* stapledOCSPresponse,
+                                 /*optional*/ const SECItem* aiaExtension);
+  virtual Result IsChainValid(const mozilla::pkix::DERArray& certChain)
+                              MOZ_OVERRIDE;
+  virtual Result CheckPublicKey(const SECItem& subjectPublicKeyInfo)
+                                MOZ_OVERRIDE;
+  virtual Result VerifySignedData(
+           const mozilla::pkix::SignedDataWithSignature& signedData,
+           const SECItem& subjectPublicKeyInfo) MOZ_OVERRIDE;
+  virtual Result DigestBuf(const SECItem& item, /*out*/ uint8_t* digestBuf,
+                           size_t digestBufLen) MOZ_OVERRIDE;
 
 private:
   /*out*/ ScopedCERTCertList& mCertChain;
   void* mPinArg; // non-owning!
   ScopedCERTCertificate mTrustedRoot;
 };
 
 } } // namespace mozilla::psm

--- a/security/certverifier/CertVerifier.cpp
+++ b/security/certverifier/CertVerifier.cpp
@@ -10,16 +10,17 @@
 
 #include "ExtendedValidation.h"
 #include "NSSCertDBTrustDomain.h"
 #include "NSSErrorsService.h"
 #include "PublicKeyPinningService.h"
 #include "cert.h"
 #include "pk11pub.h"
 #include "pkix/pkix.h"
+#include "pkix/pkixnss.h"
 #include "prerror.h"
 #include "secerr.h"
 #include "sslerr.h"
 
 using namespace mozilla::pkix;
 using namespace mozilla::psm;
 
 #ifdef PR_LOGGING
@@ -149,36 +150,36 @@ SECStatus chainValidationCallback(void* 
                           CertVerifier::pinningEnforceTestMode);
   *chainOK = PublicKeyPinningService::
     ChainHasValidPins(certList, callbackState->hostname, callbackState->time,
                       enforceTestMode);
 
   return SECSuccess;
 }
 
-static SECStatus
+static Result
 BuildCertChainForOneKeyUsage(TrustDomain& trustDomain, CERTCertificate* cert,
                              PRTime time, KeyUsage ku1, KeyUsage ku2,
                              KeyUsage ku3, KeyPurposeId eku,
                              const CertPolicyId& requiredPolicy,
                              const SECItem* stapledOCSPResponse)
 {
-  SECStatus rv = BuildCertChain(trustDomain, cert->derCert, time,
-                                EndEntityOrCA::MustBeEndEntity, ku1,
-                                eku, requiredPolicy, stapledOCSPResponse);
-  if (rv != SECSuccess && PR_GetError() == SEC_ERROR_INADEQUATE_KEY_USAGE) {
+  Result rv = BuildCertChain(trustDomain, cert->derCert, time,
+                             EndEntityOrCA::MustBeEndEntity, ku1,
+                             eku, requiredPolicy, stapledOCSPResponse);
+  if (rv == Result::ERROR_INADEQUATE_KEY_USAGE) {
     rv = BuildCertChain(trustDomain, cert->derCert, time,
                         EndEntityOrCA::MustBeEndEntity, ku2,
                         eku, requiredPolicy, stapledOCSPResponse);
-    if (rv != SECSuccess && PR_GetError() == SEC_ERROR_INADEQUATE_KEY_USAGE) {
+    if (rv == Result::ERROR_INADEQUATE_KEY_USAGE) {
       rv = BuildCertChain(trustDomain, cert->derCert, time,
                           EndEntityOrCA::MustBeEndEntity, ku3,
                           eku, requiredPolicy, stapledOCSPResponse);
-      if (rv != SECSuccess) {
-        PR_SetError(SEC_ERROR_INADEQUATE_KEY_USAGE, 0);
+      if (rv != Success) {
+        rv = Result::ERROR_INADEQUATE_KEY_USAGE;
       }
     }
   }
   return rv;
 }
 
 SECStatus
 CertVerifier::VerifyCert(CERTCertificate* cert, SECCertificateUsage usage,
@@ -217,17 +218,17 @@ CertVerifier::VerifyCert(CERTCertificate
     = !mOCSPDownloadEnabled ||
       (flags & FLAG_LOCAL_ONLY) ? NSSCertDBTrustDomain::NeverFetchOCSP
     : !mOCSPStrict              ? NSSCertDBTrustDomain::FetchOCSPForDVSoftFail
                                 : NSSCertDBTrustDomain::FetchOCSPForDVHardFail;
 
   ocsp_get_config ocspGETConfig = mOCSPGETEnabled ? ocsp_get_enabled
                                                   : ocsp_get_disabled;
 
-  SECStatus rv;
+  Result rv;
 
   switch (usage) {
     case certificateUsageSSLClient: {
       // XXX: We don't really have a trust bit for SSL client authentication so
       // just use trustEmail as it is the closest alternative.
       NSSCertDBTrustDomain trustDomain(trustEmail, ocspFetching, mOCSPCache,
                                        pinArg, ocspGETConfig, nullptr,
                                        builtChain);
@@ -243,43 +244,42 @@ CertVerifier::VerifyCert(CERTCertificate
       // TODO: When verifying a certificate in an SSL handshake, we should
       // restrict the acceptable key usage based on the key exchange method
       // chosen by the server.
 
 #ifndef MOZ_NO_EV_CERTS
       // Try to validate for EV first.
       CertPolicyId evPolicy;
       SECOidTag evPolicyOidTag;
-      rv = GetFirstEVPolicy(cert, evPolicy, evPolicyOidTag);
-      if (rv == SECSuccess) {
+      SECStatus srv = GetFirstEVPolicy(cert, evPolicy, evPolicyOidTag);
+      if (srv == SECSuccess) {
         NSSCertDBTrustDomain
           trustDomain(trustSSL,
                       ocspFetching == NSSCertDBTrustDomain::NeverFetchOCSP
                         ? NSSCertDBTrustDomain::LocalOnlyOCSPForEV
                         : NSSCertDBTrustDomain::FetchOCSPForEV,
                       mOCSPCache, pinArg, ocspGETConfig,
                       &callbackContainer, builtChain);
         rv = BuildCertChainForOneKeyUsage(trustDomain, cert, time,
                                           KeyUsage::digitalSignature,// (EC)DHE
                                           KeyUsage::keyEncipherment, // RSA
                                           KeyUsage::keyAgreement,    // (EC)DH
                                           KeyPurposeId::id_kp_serverAuth,
                                           evPolicy, stapledOCSPResponse);
-        if (rv == SECSuccess) {
+        if (rv == Success) {
           if (evOidPolicy) {
             *evOidPolicy = evPolicyOidTag;
           }
           break;
         }
       }
 #endif
 
       if (flags & FLAG_MUST_BE_EV) {
-        PR_SetError(SEC_ERROR_POLICY_VALIDATION_FAILED, 0);
-        rv = SECFailure;
+        rv = Result::ERROR_POLICY_VALIDATION_FAILED;
         break;
       }
 
       // Now try non-EV.
       NSSCertDBTrustDomain trustDomain(trustSSL, ocspFetching, mOCSPCache,
                                        pinArg, ocspGETConfig, &callbackContainer,
                                        builtChain);
       rv = BuildCertChainForOneKeyUsage(trustDomain, cert, time,
@@ -322,17 +322,17 @@ CertVerifier::VerifyCert(CERTCertificate
       NSSCertDBTrustDomain trustDomain(trustEmail, ocspFetching, mOCSPCache,
                                        pinArg, ocspGETConfig, nullptr,
                                        builtChain);
       rv = BuildCertChain(trustDomain, cert->derCert, time,
                           EndEntityOrCA::MustBeEndEntity,
                           KeyUsage::keyEncipherment, // RSA
                           KeyPurposeId::id_kp_emailProtection,
                           CertPolicyId::anyPolicy, stapledOCSPResponse);
-      if (rv != SECSuccess && PR_GetError() == SEC_ERROR_INADEQUATE_KEY_USAGE) {
+      if (rv == Result::ERROR_INADEQUATE_KEY_USAGE) {
         rv = BuildCertChain(trustDomain, cert->derCert, time,
                             EndEntityOrCA::MustBeEndEntity,
                             KeyUsage::keyAgreement, // ECDH/DH
                             KeyPurposeId::id_kp_emailProtection,
                             CertPolicyId::anyPolicy, stapledOCSPResponse);
       }
       break;
     }
@@ -368,43 +368,47 @@ CertVerifier::VerifyCert(CERTCertificate
         eku = KeyPurposeId::id_kp_OCSPSigning;
       }
 
       NSSCertDBTrustDomain sslTrust(trustSSL, ocspFetching, mOCSPCache, pinArg,
                                     ocspGETConfig, nullptr, builtChain);
       rv = BuildCertChain(sslTrust, cert->derCert, time, endEntityOrCA,
                           keyUsage, eku, CertPolicyId::anyPolicy,
                           stapledOCSPResponse);
-      if (rv == SECFailure && PR_GetError() == SEC_ERROR_UNKNOWN_ISSUER) {
+      if (rv == Result::ERROR_UNKNOWN_ISSUER) {
         NSSCertDBTrustDomain emailTrust(trustEmail, ocspFetching, mOCSPCache,
                                         pinArg, ocspGETConfig, nullptr,
                                         builtChain);
         rv = BuildCertChain(emailTrust, cert->derCert, time, endEntityOrCA,
                             keyUsage, eku, CertPolicyId::anyPolicy,
                             stapledOCSPResponse);
-        if (rv == SECFailure && PR_GetError() == SEC_ERROR_UNKNOWN_ISSUER) {
+        if (rv == Result::ERROR_UNKNOWN_ISSUER) {
           NSSCertDBTrustDomain objectSigningTrust(trustObjectSigning,
                                                   ocspFetching, mOCSPCache,
                                                   pinArg, ocspGETConfig,
                                                   nullptr, builtChain);
           rv = BuildCertChain(objectSigningTrust, cert->derCert, time,
                               endEntityOrCA, keyUsage, eku,
                               CertPolicyId::anyPolicy, stapledOCSPResponse);
         }
       }
 
       break;
     }
 
     default:
-      PR_SetError(SEC_ERROR_INVALID_ARGS, 0);
-      return SECFailure;
+      rv = Result::FATAL_ERROR_INVALID_ARGS;
   }
 
-  return rv;
+  if (rv != Success) {
+    PR_SetError(MapResultToPRErrorCode(rv), 0);
+    return SECFailure;
+  }
+
+  return SECSuccess;
 }
 
 SECStatus
 CertVerifier::VerifySSLServerCert(CERTCertificate* peerCert,
                      /*optional*/ const SECItem* stapledOCSPResponse,
                                   PRTime time,
                      /*optional*/ void* pinarg,
                                   const char* hostname,

--- a/security/certverifier/NSSCertDBTrustDomain.cpp
+++ b/security/certverifier/NSSCertDBTrustDomain.cpp
@@ -12,16 +12,17 @@
 #include "nsNSSCertificate.h"
 #include "NSSErrorsService.h"
 #include "OCSPRequestor.h"
 #include "certdb.h"
 #include "mozilla/Telemetry.h"
 #include "nss.h"
 #include "pk11pub.h"
 #include "pkix/pkix.h"
+#include "pkix/pkixnss.h"
 #include "pkix/ScopedPtr.h"
 #include "prerror.h"
 #include "prmem.h"
 #include "prprf.h"
 #include "ScopedNSSTypes.h"
 #include "secerr.h"
 #include "secmod.h"
 
@@ -101,17 +102,17 @@ static const uint8_t PERMIT_FRANCE_GOV_N
                        "\x30\x05\x82\x03" ".tf";
 
 static const SECItem PERMIT_FRANCE_GOV_NAME_CONSTRAINTS = {
   siBuffer,
   const_cast<uint8_t*>(PERMIT_FRANCE_GOV_NAME_CONSTRAINTS_DATA),
   sizeof(PERMIT_FRANCE_GOV_NAME_CONSTRAINTS_DATA) - 1
 };
 
-SECStatus
+Result
 NSSCertDBTrustDomain::FindIssuer(const SECItem& encodedIssuerName,
                                  IssuerChecker& checker, PRTime time)
 {
   // TODO: NSS seems to be ambiguous between "no potential issuers found" and
   // "there was an error trying to retrieve the potential issuers."
   ScopedCERTCertList
     candidates(CERT_CreateSubjectCertList(nullptr, CERT_GetDefaultCertDB(),
                                           &encodedIssuerName, time, true));
@@ -119,62 +120,59 @@ NSSCertDBTrustDomain::FindIssuer(const S
     for (CERTCertListNode* n = CERT_LIST_HEAD(candidates);
          !CERT_LIST_END(n, candidates); n = CERT_LIST_NEXT(n)) {
       const SECItem* additionalNameConstraints = nullptr;
       // TODO: Use CERT_CompareName or equivalent
       if (SECITEM_ItemsAreEqual(&encodedIssuerName, &ANSSI_SUBJECT)) {
         additionalNameConstraints = &PERMIT_FRANCE_GOV_NAME_CONSTRAINTS;
       }
       bool keepGoing;
-      SECStatus srv = checker.Check(n->cert->derCert,
-                                    additionalNameConstraints, keepGoing);
-      if (srv != SECSuccess) {
-        return SECFailure;
+      Result rv = checker.Check(n->cert->derCert,
+                                additionalNameConstraints, keepGoing);
+      if (rv != Success) {
+        return rv;
       }
       if (!keepGoing) {
         break;
       }
     }
   }
 
-  return SECSuccess;
+  return Success;
 }
 
-SECStatus
+Result
 NSSCertDBTrustDomain::GetCertTrust(EndEntityOrCA endEntityOrCA,
                                    const CertPolicyId& policy,
                                    const SECItem& candidateCertDER,
                                    /*out*/ TrustLevel* trustLevel)
 {
   PR_ASSERT(trustLevel);
-
   if (!trustLevel) {
-    PR_SetError(SEC_ERROR_INVALID_ARGS, 0);
-    return SECFailure;
+    return Result::FATAL_ERROR_INVALID_ARGS;
   }
 
 #ifdef MOZ_NO_EV_CERTS
   if (!policy.IsAnyPolicy()) {
-    PR_SetError(SEC_ERROR_POLICY_VALIDATION_FAILED, 0);
-    return SECFailure;
+    return Result::ERROR_POLICY_VALIDATION_FAILED;
   }
 #endif
 
   // XXX: This would be cleaner and more efficient if we could get the trust
   // information without constructing a CERTCertificate here, but NSS doesn't
   // expose it in any other easy-to-use fashion. The use of
   // CERT_NewTempCertificate to get a CERTCertificate shouldn't be a
   // performance problem because NSS will just find the existing
   // CERTCertificate in its in-memory cache and return it.
   ScopedCERTCertificate candidateCert(
     CERT_NewTempCertificate(CERT_GetDefaultCertDB(),
                             const_cast<SECItem*>(&candidateCertDER), nullptr,
                             false, true));
   if (!candidateCert) {
-    return SECFailure;
+    return MapPRErrorCodeToResult(PR_GetError());
   }
 
   // XXX: CERT_GetCertTrust seems to be abusing SECStatus as a boolean, where
   // SECSuccess means that there is a trust record and SECFailure means there
   // is not a trust record. I looked at NSS's internal uses of
   // CERT_GetCertTrust, and all that code uses the result as a boolean meaning
   // "We have a trust record."
   CERTCertTrust trust;
@@ -187,49 +185,49 @@ NSSCertDBTrustDomain::GetCertTrust(EndEn
     // relevant trust bit isn't set then that means the cert must be considered
     // distrusted.
     PRUint32 relevantTrustBit =
       endEntityOrCA == EndEntityOrCA::MustBeCA ? CERTDB_TRUSTED_CA
                                                : CERTDB_TRUSTED;
     if (((flags & (relevantTrustBit|CERTDB_TERMINAL_RECORD)))
             == CERTDB_TERMINAL_RECORD) {
       *trustLevel = TrustLevel::ActivelyDistrusted;
-      return SECSuccess;
+      return Success;
     }
 
     // For TRUST, we only use the CERTDB_TRUSTED_CA bit, because Gecko hasn't
     // needed to consider end-entity certs to be their own trust anchors since
     // Gecko implemented nsICertOverrideService.
     if (flags & CERTDB_TRUSTED_CA) {
       if (policy.IsAnyPolicy()) {
         *trustLevel = TrustLevel::TrustAnchor;
-        return SECSuccess;
+        return Success;
       }
 #ifndef MOZ_NO_EV_CERTS
       if (CertIsAuthoritativeForEVPolicy(candidateCert.get(), policy)) {
         *trustLevel = TrustLevel::TrustAnchor;
-        return SECSuccess;
+        return Success;
       }
 #endif
     }
   }
 
   *trustLevel = TrustLevel::InheritsTrust;
-  return SECSuccess;
+  return Success;
 }
 
-SECStatus
+Result
 NSSCertDBTrustDomain::VerifySignedData(const SignedDataWithSignature& signedData,
                                        const SECItem& subjectPublicKeyInfo)
 {
   return ::mozilla::pkix::VerifySignedData(signedData, subjectPublicKeyInfo,
                                            mPinArg);
 }
 
-SECStatus
+Result
 NSSCertDBTrustDomain::DigestBuf(const SECItem& item,
                                 /*out*/ uint8_t* digestBuf, size_t digestBufLen)
 {
   return ::mozilla::pkix::DigestBuf(item, digestBuf, digestBufLen);
 }
 
 
 static PRIntervalTime
@@ -252,68 +250,66 @@ OCSPFetchingTypeToTimeoutTime(NSSCertDBT
   return PR_SecondsToInterval(2);
 }
 
 // Copied and modified from CERT_GetOCSPAuthorityInfoAccessLocation and
 // CERT_GetGeneralNameByType. Returns SECFailure on error, SECSuccess
 // with url == nullptr when an OCSP URI was not found, and SECSuccess with
 // url != nullptr when an OCSP URI was found. The output url will be owned
 // by the arena.
-static SECStatus
+static Result
 GetOCSPAuthorityInfoAccessLocation(PLArenaPool* arena,
                                    const SECItem& aiaExtension,
                                    /*out*/ char const*& url)
 {
   url = nullptr;
 
   // TODO(bug 1028380): Remove the const_cast.
   CERTAuthInfoAccess** aia = CERT_DecodeAuthInfoAccessExtension(
                                 arena,
                                 const_cast<SECItem*>(&aiaExtension));
   if (!aia) {
-    PR_SetError(SEC_ERROR_CERT_BAD_ACCESS_LOCATION, 0);
-    return SECFailure;
+    return Result::ERROR_CERT_BAD_ACCESS_LOCATION;
   }
   for (size_t i = 0; aia[i]; ++i) {
     if (SECOID_FindOIDTag(&aia[i]->method) == SEC_OID_PKIX_OCSP) {
       // NSS chooses the **last** OCSP URL; we choose the **first**
       CERTGeneralName* current = aia[i]->location;
       if (!current) {
         continue;
       }
       do {
         if (current->type == certURI) {
           const SECItem& location = current->name.other;
           // (location.len + 1) must be small enough to fit into a uint32_t,
           // but we limit it to a smaller bound to reduce OOM risk.
           if (location.len > 1024 || memchr(location.data, 0, location.len)) {
             // Reject embedded nulls. (NSS doesn't do this)
-            PR_SetError(SEC_ERROR_CERT_BAD_ACCESS_LOCATION, 0);
-            return SECFailure;
+            return Result::ERROR_CERT_BAD_ACCESS_LOCATION;
           }
           // Copy the non-null-terminated SECItem into a null-terminated string.
           char* nullTerminatedURL(static_cast<char*>(
                                     PORT_ArenaAlloc(arena, location.len + 1)));
           if (!nullTerminatedURL) {
-            return SECFailure;
+            return Result::FATAL_ERROR_NO_MEMORY;
           }
           memcpy(nullTerminatedURL, location.data, location.len);
           nullTerminatedURL[location.len] = 0;
           url = nullTerminatedURL;
-          return SECSuccess;
+          return Success;
         }
         current = CERT_GetNextGeneralName(current);
       } while (current != aia[i]->location);
     }
   }
 
-  return SECSuccess;
+  return Success;
 }
 
-SECStatus
+Result
 NSSCertDBTrustDomain::CheckRevocation(EndEntityOrCA endEntityOrCA,
                                       const CertID& certID, PRTime time,
                          /*optional*/ const SECItem* stapledOCSPResponse,
                          /*optional*/ const SECItem* aiaExtension)
 {
   // Actively distrusted certificates will have already been blocked by
   // GetCertTrust.
 
@@ -333,363 +329,345 @@ NSSCertDBTrustDomain::CheckRevocation(En
   }
 
   // If we have a stapled OCSP response then the verification of that response
   // determines the result unless the OCSP response is expired. We make an
   // exception for expired responses because some servers, nginx in particular,
   // are known to serve expired responses due to bugs.
   // We keep track of the result of verifying the stapled response but don't
   // immediately return failure if the response has expired.
-  PRErrorCode stapledOCSPResponseErrorCode = 0;
+  Result stapledOCSPResponseResult = Success;
   if (stapledOCSPResponse) {
     PR_ASSERT(endEntityOrCA == EndEntityOrCA::MustBeEndEntity);
     bool expired;
-    SECStatus rv = VerifyAndMaybeCacheEncodedOCSPResponse(certID, time,
-                                                          maxOCSPLifetimeInDays,
-                                                          *stapledOCSPResponse,
-                                                          ResponseWasStapled,
-                                                          expired);
-    if (rv == SECSuccess) {
+    stapledOCSPResponseResult =
+      VerifyAndMaybeCacheEncodedOCSPResponse(certID, time,
+                                             maxOCSPLifetimeInDays,
+                                             *stapledOCSPResponse,
+                                             ResponseWasStapled, expired);
+    if (stapledOCSPResponseResult == Success) {
       // stapled OCSP response present and good
       Telemetry::Accumulate(Telemetry::SSL_OCSP_STAPLING, 1);
       PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
              ("NSSCertDBTrustDomain: stapled OCSP response: good"));
-      return rv;
+      return Success;
     }
-    stapledOCSPResponseErrorCode = PR_GetError();
-    if (stapledOCSPResponseErrorCode == SEC_ERROR_OCSP_OLD_RESPONSE ||
+    if (stapledOCSPResponseResult == Result::ERROR_OCSP_OLD_RESPONSE ||
         expired) {
       // stapled OCSP response present but expired
       Telemetry::Accumulate(Telemetry::SSL_OCSP_STAPLING, 3);
       PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
              ("NSSCertDBTrustDomain: expired stapled OCSP response"));
     } else {
       // stapled OCSP response present but invalid for some reason
       Telemetry::Accumulate(Telemetry::SSL_OCSP_STAPLING, 4);
       PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
              ("NSSCertDBTrustDomain: stapled OCSP response: failure"));
-      return rv;
+      return stapledOCSPResponseResult;
     }
   } else {
     // no stapled OCSP response
     Telemetry::Accumulate(Telemetry::SSL_OCSP_STAPLING, 2);
     PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
            ("NSSCertDBTrustDomain: no stapled OCSP response"));
   }
 
-  PRErrorCode cachedResponseErrorCode = 0;
+  Result cachedResponseResult = Success;
   PRTime cachedResponseValidThrough = 0;
   bool cachedResponsePresent = mOCSPCache.Get(certID,
-                                              cachedResponseErrorCode,
+                                              cachedResponseResult,
                                               cachedResponseValidThrough);
   if (cachedResponsePresent) {
-    if (cachedResponseErrorCode == 0 && cachedResponseValidThrough >= time) {
+    if (cachedResponseResult == Success && cachedResponseValidThrough >= time) {
       PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
              ("NSSCertDBTrustDomain: cached OCSP response: good"));
-      return SECSuccess;
+      return Success;
     }
     // If we have a cached revoked response, use it.
-    if (cachedResponseErrorCode == SEC_ERROR_REVOKED_CERTIFICATE) {
+    if (cachedResponseResult == Result::ERROR_REVOKED_CERTIFICATE) {
       PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
              ("NSSCertDBTrustDomain: cached OCSP response: revoked"));
-      PR_SetError(SEC_ERROR_REVOKED_CERTIFICATE, 0);
-      return SECFailure;
+      return Result::ERROR_REVOKED_CERTIFICATE;
     }
     // The cached response may indicate an unknown certificate or it may be
     // expired. Don't return with either of these statuses yet - we may be
     // able to fetch a more recent one.
     PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
            ("NSSCertDBTrustDomain: cached OCSP response: error %ld valid "
-           "until %lld", cachedResponseErrorCode, cachedResponseValidThrough));
+           "until %lld", cachedResponseResult, cachedResponseValidThrough));
     // When a good cached response has expired, it is more convenient
     // to convert that to an error code and just deal with
-    // cachedResponseErrorCode from here on out.
-    if (cachedResponseErrorCode == 0 && cachedResponseValidThrough < time) {
-      cachedResponseErrorCode = SEC_ERROR_OCSP_OLD_RESPONSE;
+    // cachedResponseResult from here on out.
+    if (cachedResponseResult == Success && cachedResponseValidThrough < time) {
+      cachedResponseResult = Result::ERROR_OCSP_OLD_RESPONSE;
     }
     // We may have a cached indication of server failure. Ignore it if
     // it has expired.
-    if (cachedResponseErrorCode != 0 &&
-        cachedResponseErrorCode != SEC_ERROR_OCSP_UNKNOWN_CERT &&
-        cachedResponseErrorCode != SEC_ERROR_OCSP_OLD_RESPONSE &&
+    if (cachedResponseResult != Success &&
+        cachedResponseResult != Result::ERROR_OCSP_UNKNOWN_CERT &&
+        cachedResponseResult != Result::ERROR_OCSP_OLD_RESPONSE &&
         cachedResponseValidThrough < time) {
-      cachedResponseErrorCode = 0;
+      cachedResponseResult = Success;
       cachedResponsePresent = false;
     }
   } else {
     PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
            ("NSSCertDBTrustDomain: no cached OCSP response"));
   }
-  // At this point, if and only if cachedErrorResponseCode is 0, there was no
+  // At this point, if and only if cachedErrorResult is Success, there was no
   // cached response.
-  PR_ASSERT((!cachedResponsePresent && cachedResponseErrorCode == 0) ||
-            (cachedResponsePresent && cachedResponseErrorCode != 0));
+  PR_ASSERT((!cachedResponsePresent && cachedResponseResult == Success) ||
+            (cachedResponsePresent && cachedResponseResult != Success));
 
   // TODO: We still need to handle the fallback for expired responses. But,
   // if/when we disable OCSP fetching by default, it would be ambiguous whether
   // security.OCSP.enable==0 means "I want the default" or "I really never want
   // you to ever fetch OCSP."
 
   if ((mOCSPFetching == NeverFetchOCSP) ||
       (endEntityOrCA == EndEntityOrCA::MustBeCA &&
        (mOCSPFetching == FetchOCSPForDVHardFail ||
         mOCSPFetching == FetchOCSPForDVSoftFail))) {
     // We're not going to be doing any fetching, so if there was a cached
     // "unknown" response, say so.
-    if (cachedResponseErrorCode == SEC_ERROR_OCSP_UNKNOWN_CERT) {
-      PR_SetError(SEC_ERROR_OCSP_UNKNOWN_CERT, 0);
-      return SECFailure;
+    if (cachedResponseResult == Result::ERROR_OCSP_UNKNOWN_CERT) {
+      return Result::ERROR_OCSP_UNKNOWN_CERT;
     }
     // If we're doing hard-fail, we want to know if we have a cached response
     // that has expired.
     if (mOCSPFetching == FetchOCSPForDVHardFail &&
-        cachedResponseErrorCode == SEC_ERROR_OCSP_OLD_RESPONSE) {
-      PR_SetError(SEC_ERROR_OCSP_OLD_RESPONSE, 0);
-      return SECFailure;
+        cachedResponseResult == Result::ERROR_OCSP_OLD_RESPONSE) {
+      return Result::ERROR_OCSP_OLD_RESPONSE;
     }
 
-    return SECSuccess;
+    return Success;
   }
 
   if (mOCSPFetching == LocalOnlyOCSPForEV) {
-    PR_SetError(cachedResponseErrorCode != 0 ? cachedResponseErrorCode
-                                             : SEC_ERROR_OCSP_UNKNOWN_CERT, 0);
-    return SECFailure;
+    if (cachedResponseResult != Success) {
+      return cachedResponseResult;
+    }
+    return Result::ERROR_OCSP_UNKNOWN_CERT;
   }
 
   ScopedPLArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
   if (!arena) {
-    return SECFailure;
+    return Result::FATAL_ERROR_NO_MEMORY;
   }
 
+  Result rv;
   const char* url = nullptr; // owned by the arena
 
   if (aiaExtension) {
-    if (GetOCSPAuthorityInfoAccessLocation(arena.get(), *aiaExtension, url)
-          != SECSuccess) {
-      return SECFailure;
+    rv = GetOCSPAuthorityInfoAccessLocation(arena.get(), *aiaExtension, url);
+    if (rv != Success) {
+      return rv;
     }
   }
 
   if (!url) {
     if (mOCSPFetching == FetchOCSPForEV ||
-        cachedResponseErrorCode == SEC_ERROR_OCSP_UNKNOWN_CERT) {
-      PR_SetError(SEC_ERROR_OCSP_UNKNOWN_CERT, 0);
-      return SECFailure;
+        cachedResponseResult == Result::ERROR_OCSP_UNKNOWN_CERT) {
+      return Result::ERROR_OCSP_UNKNOWN_CERT;
     }
-    if (cachedResponseErrorCode == SEC_ERROR_OCSP_OLD_RESPONSE) {
-      PR_SetError(SEC_ERROR_OCSP_OLD_RESPONSE, 0);
-      return SECFailure;
+    if (cachedResponseResult == Result::ERROR_OCSP_OLD_RESPONSE) {
+      return Result::ERROR_OCSP_OLD_RESPONSE;
     }
-    if (stapledOCSPResponseErrorCode != 0) {
-      PR_SetError(stapledOCSPResponseErrorCode, 0);
-      return SECFailure;
+    if (stapledOCSPResponseResult != Success) {
+      return stapledOCSPResponseResult;
     }
 
     // Nothing to do if we don't have an OCSP responder URI for the cert; just
     // assume it is good. Note that this is the confusing, but intended,
     // interpretation of "strict" revocation checking in the face of a
     // certificate that lacks an OCSP responder URI.
-    return SECSuccess;
+    return Success;
   }
 
   // Only request a response if we didn't have a cached indication of failure
   // (don't keep requesting responses from a failing server).
   const SECItem* response;
   bool attemptedRequest;
-  // Initialize error here to a value we check that it isn't later, because
-  // the compiler on windows isn't smart enough to figure out that it's
-  // always initialized before it gets used.
-  PRErrorCode error = 0;
-  if (cachedResponseErrorCode == 0 ||
-      cachedResponseErrorCode == SEC_ERROR_OCSP_UNKNOWN_CERT ||
-      cachedResponseErrorCode == SEC_ERROR_OCSP_OLD_RESPONSE) {
-    const SECItem* request(CreateEncodedOCSPRequest(*this, arena.get(),
-                                                    certID));
-    if (!request) {
-      return SECFailure;
+  if (cachedResponseResult == Success ||
+      cachedResponseResult == Result::ERROR_OCSP_UNKNOWN_CERT ||
+      cachedResponseResult == Result::ERROR_OCSP_OLD_RESPONSE) {
+    uint8_t ocspRequest[OCSP_REQUEST_MAX_LENGTH];
+    size_t ocspRequestLength;
+    rv = CreateEncodedOCSPRequest(*this, certID, ocspRequest,
+                                  ocspRequestLength);
+    if (rv != Success) {
+      return rv;
     }
-
-    response = DoOCSPRequest(arena.get(), url, request,
+    SECItem ocspRequestItem = {
+      siBuffer,
+      ocspRequest,
+      static_cast<unsigned int>(ocspRequestLength)
+    };
+    response = DoOCSPRequest(arena.get(), url, &ocspRequestItem,
                              OCSPFetchingTypeToTimeoutTime(mOCSPFetching),
                              mOCSPGetConfig == CertVerifier::ocsp_get_enabled);
     if (!response) {
-      error = PR_GetError();
+      rv = MapPRErrorCodeToResult(PR_GetError());
     }
     attemptedRequest = true;
   } else {
-    error = cachedResponseErrorCode;
+    rv = cachedResponseResult;
     response = nullptr;
     attemptedRequest = false;
   }
 
   // If we don't have a response, either something went wrong when fetching it
   // or we didn't attempt to fetch a response because of a failing responder.
   if (!response) {
-    MOZ_ASSERT(error != 0);
-    // If we haven't actually attempted to fetch a response, we have nothing
-    // new to tell the cache. Otherwise, we do.
+    Result error = rv;
     if (attemptedRequest) {
       PRTime timeout = time + ServerFailureDelay;
-      SECStatus rv = mOCSPCache.Put(certID, error, time, timeout);
-      if (rv != SECSuccess) {
-        return SECFailure;
+      rv = mOCSPCache.Put(certID, error, time, timeout);
+      if (rv != Success) {
+        return rv;
       }
     }
-    PR_SetError(error, 0);
     if (mOCSPFetching != FetchOCSPForDVSoftFail) {
       PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
              ("NSSCertDBTrustDomain: returning SECFailure after "
               "OCSP request failure"));
-      return SECFailure;
+      return error;
     }
-    if (cachedResponseErrorCode == SEC_ERROR_OCSP_UNKNOWN_CERT) {
+    if (cachedResponseResult == Result::ERROR_OCSP_UNKNOWN_CERT) {
       PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
              ("NSSCertDBTrustDomain: returning SECFailure from cached "
               "response after OCSP request failure"));
-      PR_SetError(cachedResponseErrorCode, 0);
-      return SECFailure;
+      return cachedResponseResult;
     }
-    if (stapledOCSPResponseErrorCode != 0) {
+    if (stapledOCSPResponseResult != Success) {
       PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
              ("NSSCertDBTrustDomain: returning SECFailure from expired "
               "stapled response after OCSP request failure"));
-      PR_SetError(stapledOCSPResponseErrorCode, 0);
-      return SECFailure;
+      return stapledOCSPResponseResult;
     }
 
     PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
            ("NSSCertDBTrustDomain: returning SECSuccess after "
             "OCSP request failure"));
-    return SECSuccess; // Soft fail -> success :(
+    return Success; // Soft fail -> success :(
   }
 
   // If the response from the network has expired but indicates a revoked
   // or unknown certificate, PR_GetError() will return the appropriate error.
   // We actually ignore expired here.
   bool expired;
-  SECStatus rv = VerifyAndMaybeCacheEncodedOCSPResponse(certID, time,
-                                                        maxOCSPLifetimeInDays,
-                                                        *response,
-                                                        ResponseIsFromNetwork,
-                                                        expired);
-  if (rv == SECSuccess || mOCSPFetching != FetchOCSPForDVSoftFail) {
+  rv = VerifyAndMaybeCacheEncodedOCSPResponse(certID, time,
+                                              maxOCSPLifetimeInDays,
+                                              *response, ResponseIsFromNetwork,
+                                              expired);
+  if (rv == Success || mOCSPFetching != FetchOCSPForDVSoftFail) {
     PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
       ("NSSCertDBTrustDomain: returning after VerifyEncodedOCSPResponse"));
     return rv;
   }
 
-  error = PR_GetError();
-  if (error == SEC_ERROR_OCSP_UNKNOWN_CERT ||
-      error == SEC_ERROR_REVOKED_CERTIFICATE) {
+  if (rv == Result::ERROR_OCSP_UNKNOWN_CERT ||
+      rv == Result::ERROR_REVOKED_CERTIFICATE) {
     return rv;
   }
-
-  if (stapledOCSPResponseErrorCode != 0) {
+  if (stapledOCSPResponseResult != Success) {
     PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
            ("NSSCertDBTrustDomain: returning SECFailure from expired stapled "
             "response after OCSP request verification failure"));
-    PR_SetError(stapledOCSPResponseErrorCode, 0);
-    return SECFailure;
+    return stapledOCSPResponseResult;
   }
 
   PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
          ("NSSCertDBTrustDomain: end of CheckRevocation"));
 
-  return SECSuccess; // Soft fail -> success :(
+  return Success; // Soft fail -> success :(
 }
 
-SECStatus
+Result
 NSSCertDBTrustDomain::VerifyAndMaybeCacheEncodedOCSPResponse(
   const CertID& certID, PRTime time, uint16_t maxLifetimeInDays,
   const SECItem& encodedResponse, EncodedResponseSource responseSource,
   /*out*/ bool& expired)
 {
   PRTime thisUpdate = 0;
   PRTime validThrough = 0;
-  SECStatus rv = VerifyEncodedOCSPResponse(*this, certID, time,
-                                           maxLifetimeInDays, encodedResponse,
-                                           expired, &thisUpdate, &validThrough);
-  PRErrorCode error = (rv == SECSuccess ? 0 : PR_GetError());
+  Result rv = VerifyEncodedOCSPResponse(*this, certID, time,
+                                        maxLifetimeInDays, encodedResponse,
+                                        expired, &thisUpdate, &validThrough);
   // If a response was stapled and expired, we don't want to cache it. Return
   // early to simplify the logic here.
   if (responseSource == ResponseWasStapled && expired) {
-    PR_ASSERT(rv != SECSuccess);
+    PR_ASSERT(rv != Success);
     return rv;
   }
   // validThrough is only trustworthy if the response successfully verifies
   // or it indicates a revoked or unknown certificate.
   // If this isn't the case, store an indication of failure (to prevent
   // repeatedly requesting a response from a failing server).
-  if (rv != SECSuccess && error != SEC_ERROR_REVOKED_CERTIFICATE &&
-      error != SEC_ERROR_OCSP_UNKNOWN_CERT) {
+  if (rv != Success && rv != Result::ERROR_REVOKED_CERTIFICATE &&
+      rv != Result::ERROR_OCSP_UNKNOWN_CERT) {
     validThrough = time + ServerFailureDelay;
   }
   if (responseSource == ResponseIsFromNetwork ||
-      rv == SECSuccess ||
-      error == SEC_ERROR_REVOKED_CERTIFICATE ||
-      error == SEC_ERROR_OCSP_UNKNOWN_CERT) {
+      rv == Success ||
+      rv == Result::ERROR_REVOKED_CERTIFICATE ||
+      rv == Result::ERROR_OCSP_UNKNOWN_CERT) {
     PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
            ("NSSCertDBTrustDomain: caching OCSP response"));
-    if (mOCSPCache.Put(certID, error, thisUpdate, validThrough) != SECSuccess) {
-      return SECFailure;
+    Result putRV = mOCSPCache.Put(certID, rv, thisUpdate, validThrough);
+    if (putRV != Success) {
+      return putRV;
     }
   }
 
-  // If the verification failed, re-set to that original error
-  // (the call to Put may have un-set it).
-  if (rv != SECSuccess) {
-    PR_SetError(error, 0);
-  }
   return rv;
 }
 
-SECStatus
+Result
 NSSCertDBTrustDomain::IsChainValid(const DERArray& certArray)
 {
   PR_LOG(gCertVerifierLog, PR_LOG_DEBUG,
       ("NSSCertDBTrustDomain: Top of IsChainValid mCheckChainCallback=%p",
        mCheckChainCallback));
 
   if (!mBuiltChain && !mCheckChainCallback) {
     // No need to create a CERTCertList, and nothing else to do.
-    return SECSuccess;
+    return Success;
   }
 
   ScopedCERTCertList certList;
-  SECStatus rv = ConstructCERTCertListFromReversedDERArray(certArray, certList);
-  if (rv != SECSuccess) {
-    return rv;
+  SECStatus srv = ConstructCERTCertListFromReversedDERArray(certArray,
+                                                            certList);
+  if (srv != SECSuccess) {
+    return MapPRErrorCodeToResult(PR_GetError());
   }
 
   if (mCheckChainCallback) {
     if (!mCheckChainCallback->isChainValid) {
-      PR_SetError(SEC_ERROR_INVALID_ARGS, 0);
-      return SECFailure;
+      return Result::FATAL_ERROR_INVALID_ARGS;
     }
     PRBool chainOK;
-    rv = (mCheckChainCallback->isChainValid)(
+    srv = (mCheckChainCallback->isChainValid)(
             mCheckChainCallback->isChainValidArg, certList.get(), &chainOK);
-    if (rv != SECSuccess) {
-      return rv;
+    if (srv != SECSuccess) {
+      return MapPRErrorCodeToResult(PR_GetError());
     }
     if (!chainOK) {
-      PR_SetError(PSM_ERROR_KEY_PINNING_FAILURE, 0);
-      return SECFailure;
+      return Result::ERROR_KEY_PINNING_FAILURE;
     }
   }
 
   if (mBuiltChain) {
     *mBuiltChain = certList.forget();
   }
 
-  return SECSuccess;
+  return Success;
 }
 
-SECStatus
+Result
 NSSCertDBTrustDomain::CheckPublicKey(const SECItem& subjectPublicKeyInfo)
 {
   return ::mozilla::pkix::CheckPublicKey(subjectPublicKeyInfo);
 }
 
 namespace {
 
 static char*

--- a/security/certverifier/NSSCertDBTrustDomain.h
+++ b/security/certverifier/NSSCertDBTrustDomain.h
@@ -36,61 +36,67 @@ void UnloadLoadableRoots(const char* mod
 char* DefaultServerNicknameForCert(CERTCertificate* cert);
 
 void SaveIntermediateCerts(const ScopedCERTCertList& certList);
 
 class NSSCertDBTrustDomain : public mozilla::pkix::TrustDomain
 {
 
 public:
+  typedef mozilla::pkix::Result Result;
+
   enum OCSPFetching {
     NeverFetchOCSP = 0,
     FetchOCSPForDVSoftFail = 1,
     FetchOCSPForDVHardFail = 2,
     FetchOCSPForEV = 3,
     LocalOnlyOCSPForEV = 4,
   };
   NSSCertDBTrustDomain(SECTrustType certDBTrustType, OCSPFetching ocspFetching,
                        OCSPCache& ocspCache, void* pinArg,
                        CertVerifier::ocsp_get_config ocspGETConfig,
           /*optional*/ CERTChainVerifyCallback* checkChainCallback = nullptr,
           /*optional*/ ScopedCERTCertList* builtChain = nullptr);
 
-  virtual SECStatus FindIssuer(const SECItem& encodedIssuerName,
-                               IssuerChecker& checker, PRTime time);
+  virtual Result FindIssuer(const SECItem& encodedIssuerName,
+                            IssuerChecker& checker,
+                            PRTime time) MOZ_OVERRIDE;
 
-  virtual SECStatus GetCertTrust(mozilla::pkix::EndEntityOrCA endEntityOrCA,
-                                 const mozilla::pkix::CertPolicyId& policy,
-                                 const SECItem& candidateCertDER,
-                         /*out*/ mozilla::pkix::TrustLevel* trustLevel);
+  virtual Result GetCertTrust(mozilla::pkix::EndEntityOrCA endEntityOrCA,
+                              const mozilla::pkix::CertPolicyId& policy,
+                              const SECItem& candidateCertDER,
+                              /*out*/ mozilla::pkix::TrustLevel* trustLevel)
+                              MOZ_OVERRIDE;
 
-  virtual SECStatus VerifySignedData(
-                      const mozilla::pkix::SignedDataWithSignature& signedData,
-                      const SECItem& subjectPublicKeyInfo);
+  virtual Result CheckPublicKey(const SECItem& subjectPublicKeyInfo)
+                                MOZ_OVERRIDE;
 
-  virtual SECStatus DigestBuf(const SECItem& item, /*out*/ uint8_t* digestBuf,
-                              size_t digestBufLen);
+  virtual Result VerifySignedData(
+                   const mozilla::pkix::SignedDataWithSignature& signedData,
+                   const SECItem& subjectPublicKeyInfo) MOZ_OVERRIDE;
+
+  virtual Result DigestBuf(const SECItem& item, /*out*/ uint8_t* digestBuf,
+                           size_t digestBufLen) MOZ_OVERRIDE;
 
-  virtual SECStatus CheckRevocation(mozilla::pkix::EndEntityOrCA endEntityOrCA,
-                                    const mozilla::pkix::CertID& certID,
-                                    PRTime time,
-                       /*optional*/ const SECItem* stapledOCSPResponse,
-                       /*optional*/ const SECItem* aiaExtension);
+  virtual Result CheckRevocation(mozilla::pkix::EndEntityOrCA endEntityOrCA,
+                                 const mozilla::pkix::CertID& certID,
+                                 PRTime time,
+                    /*optional*/ const SECItem* stapledOCSPResponse,
+                    /*optional*/ const SECItem* aiaExtension) MOZ_OVERRIDE;
 
-  virtual SECStatus IsChainValid(const mozilla::pkix::DERArray& certChain);
-
-  virtual SECStatus CheckPublicKey(const SECItem& subjectPublicKeyInfo);
+  virtual Result IsChainValid(const mozilla::pkix::DERArray& certChain)
+                              MOZ_OVERRIDE;
 
 private:
   enum EncodedResponseSource {
     ResponseIsFromNetwork = 1,
     ResponseWasStapled = 2
   };
   static const PRTime ServerFailureDelay = 5 * 60 * PR_USEC_PER_SEC;
-  SECStatus VerifyAndMaybeCacheEncodedOCSPResponse(
+  Result VerifyAndMaybeCacheEncodedOCSPResponse(
     const mozilla::pkix::CertID& certID, PRTime time,
     uint16_t maxLifetimeInDays, const SECItem& encodedResponse,
     EncodedResponseSource responseSource, /*out*/ bool& expired);
 
   const SECTrustType mCertDBTrustType;
   const OCSPFetching mOCSPFetching;
   OCSPCache& mOCSPCache; // non-owning!
   void* mPinArg; // non-owning!

--- a/security/certverifier/OCSPCache.cpp
+++ b/security/certverifier/OCSPCache.cpp
@@ -23,17 +23,17 @@
  */
 
 #include "OCSPCache.h"
 
 #include <limits>
 
 #include "NSSCertDBTrustDomain.h"
 #include "pk11pub.h"
-#include "pkix/pkixtypes.h"
+#include "pkix/pkixnss.h"
 #include "ScopedNSSTypes.h"
 #include "secerr.h"
 
 #ifdef PR_LOGGING
 extern PRLogModuleInfo* gCertVerifierLog;
 #endif
 
 using namespace mozilla::pkix;
@@ -79,24 +79,28 @@ CertIDHash(SHA384Buffer& buf, const Cert
   uint32_t outLen = 0;
   rv = PK11_DigestFinal(context.get(), buf, &outLen, SHA384_LENGTH);
   if (outLen != SHA384_LENGTH) {
     return SECFailure;
   }
   return rv;
 }
 
-SECStatus
-OCSPCache::Entry::Init(const CertID& aCertID, PRErrorCode aErrorCode,
+Result
+OCSPCache::Entry::Init(const CertID& aCertID, Result aResult,
                        PRTime aThisUpdate, PRTime aValidThrough)
 {
-  mErrorCode = aErrorCode;
+  mResult = aResult;
   mThisUpdate = aThisUpdate;
   mValidThrough = aValidThrough;
-  return CertIDHash(mIDHash, aCertID);
+  SECStatus srv = CertIDHash(mIDHash, aCertID);
+  if (srv != SECSuccess) {
+    return MapPRErrorCodeToResult(PR_GetError());
+  }
+  return Success;
 }
 
 OCSPCache::OCSPCache()
   : mMutex("OCSPCache-mutex")
 {
 }
 
 OCSPCache::~OCSPCache()
@@ -145,123 +149,117 @@ OCSPCache::MakeMostRecentlyUsed(size_t a
   Entry* entry = mEntries[aIndex];
   // Since mEntries is sorted with the most-recently-used entry at the end,
   // aIndex is likely to be near the end, so this is likely to be fast.
   mEntries.erase(mEntries.begin() + aIndex);
   mEntries.append(entry);
 }
 
 bool
-OCSPCache::Get(const CertID& aCertID, PRErrorCode& aErrorCode,
-               PRTime& aValidThrough)
+OCSPCache::Get(const CertID& aCertID, Result& aResult, PRTime& aValidThrough)
 {
   MutexAutoLock lock(mMutex);
 
   size_t index;
   if (!FindInternal(aCertID, index, lock)) {
     LogWithCertID("OCSPCache::Get(%p) not in cache", aCertID);
     return false;
   }
   LogWithCertID("OCSPCache::Get(%p) in cache", aCertID);
-  aErrorCode = mEntries[index]->mErrorCode;
+  aResult = mEntries[index]->mResult;
   aValidThrough = mEntries[index]->mValidThrough;
   MakeMostRecentlyUsed(index, lock);
   return true;
 }
 
-SECStatus
-OCSPCache::Put(const CertID& aCertID, PRErrorCode aErrorCode,
+Result
+OCSPCache::Put(const CertID& aCertID, Result aResult,
                PRTime aThisUpdate, PRTime aValidThrough)
 {
   MutexAutoLock lock(mMutex);
 
   size_t index;
   if (FindInternal(aCertID, index, lock)) {
     // Never replace an entry indicating a revoked certificate.
-    if (mEntries[index]->mErrorCode == SEC_ERROR_REVOKED_CERTIFICATE) {
+    if (mEntries[index]->mResult == Result::ERROR_REVOKED_CERTIFICATE) {
       LogWithCertID("OCSPCache::Put(%p) already in cache as revoked - "
                     "not replacing", aCertID);
       MakeMostRecentlyUsed(index, lock);
-      return SECSuccess;
+      return Success;
     }
 
     // Never replace a newer entry with an older one unless the older entry
     // indicates a revoked certificate, which we want to remember.
     if (mEntries[index]->mThisUpdate > aThisUpdate &&
-        aErrorCode != SEC_ERROR_REVOKED_CERTIFICATE) {
+        aResult != Result::ERROR_REVOKED_CERTIFICATE) {
       LogWithCertID("OCSPCache::Put(%p) already in cache with more recent "
                     "validity - not replacing", aCertID);
       MakeMostRecentlyUsed(index, lock);
-      return SECSuccess;
+      return Success;
     }
 
     // Only known good responses or responses indicating an unknown
     // or revoked certificate should replace previously known responses.
-    if (aErrorCode != 0 && aErrorCode != SEC_ERROR_OCSP_UNKNOWN_CERT &&
-        aErrorCode != SEC_ERROR_REVOKED_CERTIFICATE) {
+    if (aResult != Success &&
+        aResult != Result::ERROR_OCSP_UNKNOWN_CERT &&
+        aResult != Result::ERROR_REVOKED_CERTIFICATE) {
       LogWithCertID("OCSPCache::Put(%p) already in cache - not replacing "
                     "with less important status", aCertID);
       MakeMostRecentlyUsed(index, lock);
-      return SECSuccess;
+      return Success;
     }
 
     LogWithCertID("OCSPCache::Put(%p) already in cache - replacing", aCertID);
-    mEntries[index]->mErrorCode = aErrorCode;
+    mEntries[index]->mResult = aResult;
     mEntries[index]->mThisUpdate = aThisUpdate;
     mEntries[index]->mValidThrough = aValidThrough;
     MakeMostRecentlyUsed(index, lock);
-    return SECSuccess;
+    return Success;
   }
 
   if (mEntries.length() == MaxEntries) {
     LogWithCertID("OCSPCache::Put(%p) too full - evicting an entry", aCertID);
     for (Entry** toEvict = mEntries.begin(); toEvict != mEntries.end();
          toEvict++) {
       // Never evict an entry that indicates a revoked or unknokwn certificate,
       // because revoked responses are more security-critical to remember.
-      if ((*toEvict)->mErrorCode != SEC_ERROR_REVOKED_CERTIFICATE &&
-          (*toEvict)->mErrorCode != SEC_ERROR_OCSP_UNKNOWN_CERT) {
+      if ((*toEvict)->mResult != Result::ERROR_REVOKED_CERTIFICATE &&
+          (*toEvict)->mResult != Result::ERROR_OCSP_UNKNOWN_CERT) {
         delete *toEvict;
         mEntries.erase(toEvict);
         break;
       }
     }
     // Well, we tried, but apparently everything is revoked or unknown.
     // We don't want to remove a cached revoked or unknown response. If we're
     // trying to insert a good response, we can just return "successfully"
     // without doing so. This means we'll lose some speed, but it's not a
     // security issue. If we're trying to insert a revoked or unknown response,
     // we can't. We should return with an error that causes the current
     // verification to fail.
     if (mEntries.length() == MaxEntries) {
-      if (aErrorCode != 0) {
-        PR_SetError(aErrorCode, 0);
-        return SECFailure;
-      }
-      return SECSuccess;
+      return aResult;
     }
   }
 
-  Entry* newEntry = new Entry();
+  Entry* newEntry = new (std::nothrow) Entry();
   // Normally we don't have to do this in Gecko, because OOM is fatal.
   // However, if we want to embed this in another project, OOM might not
   // be fatal, so handle this case.
   if (!newEntry) {
-    PR_SetError(SEC_ERROR_NO_MEMORY, 0);
-    return SECFailure;
+    return Result::FATAL_ERROR_NO_MEMORY;
   }
-  SECStatus rv = newEntry->Init(aCertID, aErrorCode, aThisUpdate,
-                                aValidThrough);
-  if (rv != SECSuccess) {
+  Result rv = newEntry->Init(aCertID, aResult, aThisUpdate, aValidThrough);
+  if (rv != Success) {
     delete newEntry;
     return rv;
   }
   mEntries.append(newEntry);
   LogWithCertID("OCSPCache::Put(%p) added to cache", aCertID);
-  return SECSuccess;
+  return Success;
 }
 
 void
 OCSPCache::Clear()
 {
   MutexAutoLock lock(mMutex);
   PR_LOG(gCertVerifierLog, PR_LOG_DEBUG, ("OCSPCache::Clear: clearing cache"));
   // First go through and delete the memory being pointed to by the pointers

--- a/security/certverifier/OCSPCache.h
+++ b/security/certverifier/OCSPCache.h
@@ -23,16 +23,17 @@
  */
 
 #ifndef mozilla_psm_OCSPCache_h
 #define mozilla_psm_OCSPCache_h
 
 #include "hasht.h"
 #include "mozilla/Mutex.h"
 #include "mozilla/Vector.h"
+#include "pkix/Result.h"
 #include "prerror.h"
 #include "prtime.h"
 #include "seccomon.h"
 
 namespace mozilla { namespace pkix {
 struct CertID;
 } } // namespace mozilla::pkix
 
@@ -53,41 +54,44 @@ public:
   OCSPCache();
   ~OCSPCache();
 
   // Returns true if the status of the given certificate (issued by the given
   // issuer) is in the cache, and false otherwise.
   // If it is in the cache, returns by reference the error code of the cached
   // status and the time through which the status is considered trustworthy.
   bool Get(const mozilla::pkix::CertID& aCertID,
-           /* out */ PRErrorCode& aErrorCode, /* out */ PRTime& aValidThrough);
+           /*out*/ mozilla::pkix::Result& aResult,
+           /*out*/ PRTime& aValidThrough);
 
   // Caches the status of the given certificate (issued by the given issuer).
   // The status is considered trustworthy through the given time.
   // A status with an error code of SEC_ERROR_REVOKED_CERTIFICATE will not
   // be replaced or evicted.
   // A status with an error code of SEC_ERROR_OCSP_UNKNOWN_CERT will not
   // be evicted when the cache is full.
   // A status with a more recent thisUpdate will not be replaced with a
   // status with a less recent thisUpdate unless the less recent status
   // indicates the certificate is revoked.
-  SECStatus Put(const mozilla::pkix::CertID& aCertID, PRErrorCode aErrorCode,
-                PRTime aThisUpdate, PRTime aValidThrough);
+  mozilla::pkix::Result Put(const mozilla::pkix::CertID& aCertID,
+                            mozilla::pkix::Result aResult, PRTime aThisUpdate,
+                            PRTime aValidThrough);
 
   // Removes everything from the cache.
   void Clear();
 
 private:
   class Entry
   {
   public:
-    SECStatus Init(const mozilla::pkix::CertID& aCertID, PRErrorCode aErrorCode,
-                   PRTime aThisUpdate, PRTime aValidThrough);
+    mozilla::pkix::Result Init(const mozilla::pkix::CertID& aCertID,
+                               mozilla::pkix::Result aResult,
+                               PRTime aThisUpdate, PRTime aValidThrough);
 
-    PRErrorCode mErrorCode;
+    mozilla::pkix::Result mResult;
     PRTime mThisUpdate;
     PRTime mValidThrough;
     // The SHA-384 hash of the concatenation of the DER encodings of the
     // issuer name and issuer key, followed by the serial number.
     // See the documentation for CertIDHash in OCSPCache.cpp.
     SHA384Buffer mIDHash;
   };
 

--- a/security/certverifier/moz.build
+++ b/security/certverifier/moz.build
@@ -27,16 +27,17 @@ DIRS += [
 ]
 
 CXXFLAGS += ['-Wall']
 if CONFIG['_MSC_VER']:
   # -Wall with Visual C++ enables too many problematic warnings
   CXXFLAGS += [
     '-wd4480', # nonstandard extension used: specifying underlying type for
                # enum 'enum'
+    '-wd4481', # nonstandard extension used: override specifier 'keyword'
     '-wd4510', # default constructor could not be generated
     '-wd4512', # assignment operator could not be generated
     '-wd4514', # 'function': unreferenced inline function has been removed
     '-wd4610', # struct 'symbol' can never be instantiated - user defined
                # constructor required
     '-wd4619', # pragma warning: there is no warning 'warning'
     '-wd4625', # copy constructor could not be generated because a base
                # class copy constructor is inaccessible or deleted

--- a/security/manager/ssl/src/NSSErrorsService.cpp
+++ b/security/manager/ssl/src/NSSErrorsService.cpp
@@ -1,50 +1,40 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "NSSErrorsService.h"
 
 #include "nsNSSComponent.h"
 #include "nsServiceManagerUtils.h"
+#include "pkix/pkixnss.h"
 #include "secerr.h"
 #include "sslerr.h"
 
 #define PIPNSS_STRBUNDLE_URL "chrome://pipnss/locale/pipnss.properties"
 #define NSSERR_STRBUNDLE_URL "chrome://pipnss/locale/nsserrors.properties"
 
 namespace mozilla {
 namespace psm {
 
-static const struct PRErrorMessage PSMErrorTableText[] = {
-  { "PSM_ERROR_KEY_PINNING_FAILURE",
-    "The server uses key pinning (HPKP) but no trusted certificate chain "
-    "could be constructed that matches the pinset. Key pinning violations "
-    "cannot be overridden." }
-};
-
-static const struct PRErrorTable PSMErrorTable = {
-  PSMErrorTableText,
-  "psmerrors",
-  nsINSSErrorsService::PSM_ERROR_BASE,
-  PR_ARRAY_SIZE(PSMErrorTableText)
-};
-
-void
-RegisterPSMErrorTable()
-{
-  PR_ErrorInstallTable(&PSMErrorTable);
-}
+static_assert(mozilla::pkix::ERROR_BASE ==
+                nsINSSErrorsService::MOZILLA_PKIX_ERROR_BASE,
+              "MOZILLA_PKIX_ERROR_BASE and "
+                "nsINSSErrorsService::MOZILLA_PKIX_ERROR_BASE do not match.");
+static_assert(mozilla::pkix::ERROR_LIMIT ==
+                nsINSSErrorsService::MOZILLA_PKIX_ERROR_LIMIT,
+              "MOZILLA_PKIX_ERROR_LIMIT and "
+                "nsINSSErrorsService::MOZILLA_PKIX_ERROR_LIMIT do not match.");
 
 static bool
 IsPSMError(PRErrorCode error)
 {
-  return (error >= nsINSSErrorsService::PSM_ERROR_BASE &&
-          error < nsINSSErrorsService::PSM_ERROR_LIMIT);
+  return (error >= mozilla::pkix::ERROR_BASE &&
+          error < mozilla::pkix::ERROR_LIMIT);
 }
 
 NS_IMPL_ISUPPORTS(NSSErrorsService, nsINSSErrorsService)
 
 NSSErrorsService::~NSSErrorsService() { }
 
 nsresult
 NSSErrorsService::Init()

--- a/security/manager/ssl/src/NSSErrorsService.h
+++ b/security/manager/ssl/src/NSSErrorsService.h
@@ -1,31 +1,24 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef NSSErrorsService_h
 #define NSSErrorsService_h
 
 #include "nsINSSErrorsService.h"
-
 #include "mozilla/Attributes.h"
 #include "nsCOMPtr.h"
 #include "nsIStringBundle.h"
 #include "prerror.h"
 
 namespace mozilla {
 namespace psm {
 
-enum PSMErrorCodes {
-  PSM_ERROR_KEY_PINNING_FAILURE = (nsINSSErrorsService::PSM_ERROR_BASE + 0)
-};
-
-void RegisterPSMErrorTable();
-
 class NSSErrorsService MOZ_FINAL : public nsINSSErrorsService
 {
   NS_DECL_ISUPPORTS
   NS_DECL_NSINSSERRORSSERVICE
 
 public:
   nsresult Init();
 

--- a/security/manager/ssl/src/nsNSSComponent.cpp
+++ b/security/manager/ssl/src/nsNSSComponent.cpp
@@ -46,16 +46,17 @@
 #include "nsIBufEntropyCollector.h"
 #include "nsITokenPasswordDialogs.h"
 #include "nsServiceManagerUtils.h"
 #include "nsNSSShutDown.h"
 #include "SharedSSLState.h"
 #include "NSSErrorsService.h"
 
 #include "nss.h"
+#include "pkix/pkixnss.h"
 #include "ssl.h"
 #include "sslproto.h"
 #include "secmod.h"
 #include "secerr.h"
 #include "sslerr.h"
 
 #include "nsXULAppAPI.h"
 
@@ -1204,17 +1205,17 @@ nsNSSComponent::InitializeNSS()
   setValidationOptions(true, lock);
 
   mHttpForNSS.initTable();
 
 #ifndef MOZ_DISABLE_CRYPTOLEGACY
   LaunchSmartCardThreads();
 #endif
 
-  RegisterPSMErrorTable();
+  mozilla::pkix::RegisterErrorTable();
 
   PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("NSS Initialization done\n"));
   return NS_OK;
 }
 
 void
 nsNSSComponent::ShutdownNSS()
 {

--- a/security/manager/ssl/tests/gtest/OCSPCacheTest.cpp
+++ b/security/manager/ssl/tests/gtest/OCSPCacheTest.cpp
@@ -26,30 +26,31 @@ class OCSPCacheTest : public ::testing::
       NSS_NoDB_Init(nullptr);
       mozilla::psm::InitCertVerifierLog();
     }
 
     mozilla::psm::OCSPCache cache;
 };
 
 static void
-PutAndGet(OCSPCache& cache, const CertID& certID, PRErrorCode error,
+PutAndGet(OCSPCache& cache, const CertID& certID, Result result,
           PRTime time)
 {
   // The first time is thisUpdate. The second is validUntil.
   // The caller is expecting the validUntil returned with Get
   // to be equal to the passed-in time. Since these values will
   // be different in practice, make thisUpdate less than validUntil.
   ASSERT_TRUE(time >= 10);
-  SECStatus rv = cache.Put(certID, error, time - 10, time);
-  ASSERT_TRUE(rv == SECSuccess);
-  PRErrorCode errorOut;
+  Result rv = cache.Put(certID, result, time - 10, time);
+  ASSERT_TRUE(rv == Success);
+  Result resultOut;
   PRTime timeOut;
-  ASSERT_TRUE(cache.Get(certID, errorOut, timeOut));
-  ASSERT_TRUE(error == errorOut && time == timeOut);
+  ASSERT_TRUE(cache.Get(certID, resultOut, timeOut));
+  ASSERT_EQ(result, resultOut);
+  ASSERT_EQ(time, timeOut);
 }
 
 static const SECItem fakeIssuer1 = {
   siBuffer,
   const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>("CN=issuer1")),
   10
 };
 static const SECItem fakeKey000 = {
@@ -77,69 +78,75 @@ TEST_F(OCSPCacheTest, TestPutAndGet)
   };
   static const SECItem fakeSerial001 = {
     siBuffer,
     const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>("001")),
     3
   };
 
   SCOPED_TRACE("");
-  PutAndGet(cache, CertID(fakeIssuer1, fakeKey000, fakeSerial001), 0, PR_Now());
-  PRErrorCode errorOut;
+  PutAndGet(cache, CertID(fakeIssuer1, fakeKey000, fakeSerial001),
+            Success, PR_Now());
+  Result resultOut;
   PRTime timeOut;
   ASSERT_FALSE(cache.Get(CertID(fakeIssuer1, fakeKey001, fakeSerial000),
-                         errorOut, timeOut));
+                         resultOut, timeOut));
 }
 
 TEST_F(OCSPCacheTest, TestVariousGets)
 {
   SCOPED_TRACE("");
   PRTime timeIn = PR_Now();
   for (int i = 0; i < MaxCacheEntries; i++) {
     char serialBuf[8];
     PR_snprintf(serialBuf, sizeof(serialBuf), "%04d", i);
     const SECItem fakeSerial = {
       siBuffer,
       const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(serialBuf)),
       4
     };
-    PutAndGet(cache, CertID(fakeIssuer1, fakeKey000, fakeSerial), 0, timeIn + i);
+    PutAndGet(cache, CertID(fakeIssuer1, fakeKey000, fakeSerial),
+              Success, timeIn + i);
   }
 
-  PRErrorCode errorOut;
+  Result resultOut;
   PRTime timeOut;
 
   // This will be at the end of the list in the cache
   CertID cert0000(fakeIssuer1, fakeKey000, fakeSerial0000);
-  ASSERT_TRUE(cache.Get(cert0000, errorOut, timeOut));
-  ASSERT_TRUE(errorOut == 0 && timeOut == timeIn);
+  ASSERT_TRUE(cache.Get(cert0000, resultOut, timeOut));
+  ASSERT_EQ(Success, resultOut);
+  ASSERT_EQ(timeIn, timeOut);
   // Once we access it, it goes to the front
-  ASSERT_TRUE(cache.Get(cert0000, errorOut, timeOut));
-  ASSERT_TRUE(errorOut == 0 && timeOut == timeIn);
+  ASSERT_TRUE(cache.Get(cert0000, resultOut, timeOut));
+  ASSERT_EQ(Success, resultOut);
+  ASSERT_EQ(timeIn, timeOut);
 
   // This will be in the middle
   static const SECItem fakeSerial0512 = {
     siBuffer,
     const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>("0512")),
     4
   };
   CertID cert0512(fakeIssuer1, fakeKey000, fakeSerial0512);
-  ASSERT_TRUE(cache.Get(cert0512, errorOut, timeOut));
-  ASSERT_TRUE(errorOut == 0 && timeOut == timeIn + 512);
-  ASSERT_TRUE(cache.Get(cert0512, errorOut, timeOut));
-  ASSERT_TRUE(errorOut == 0 && timeOut == timeIn + 512);
+  ASSERT_TRUE(cache.Get(cert0512, resultOut, timeOut));
+  ASSERT_EQ(Success, resultOut);
+  ASSERT_EQ(timeIn + 512, timeOut);
+  ASSERT_TRUE(cache.Get(cert0512, resultOut, timeOut));
+  ASSERT_EQ(Success, resultOut);
+  ASSERT_EQ(timeIn + 512, timeOut);
 
   // We've never seen this certificate
   static const SECItem fakeSerial1111 = {
     siBuffer,
     const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>("1111")),
     4
   };
   ASSERT_FALSE(cache.Get(CertID(fakeIssuer1, fakeKey000, fakeSerial1111),
-                         errorOut, timeOut));
+                         resultOut, timeOut));
 }
 
 TEST_F(OCSPCacheTest, TestEviction)
 {
   SCOPED_TRACE("");
   PRTime timeIn = PR_Now();
 
   // By putting more distinct entries in the cache than it can hold,
@@ -147,99 +154,100 @@ TEST_F(OCSPCacheTest, TestEviction)
   for (int i = 0; i < MaxCacheEntries + 1; i++) {
     char serialBuf[8];
     PR_snprintf(serialBuf, sizeof(serialBuf), "%04d", i);
     const SECItem fakeSerial = {
       siBuffer,
       const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(serialBuf)),
       4
     };
-    PutAndGet(cache, CertID(fakeIssuer1, fakeKey000, fakeSerial), 0, timeIn + i);
+    PutAndGet(cache, CertID(fakeIssuer1, fakeKey000, fakeSerial),
+              Success, timeIn + i);
   }
 
-  PRErrorCode errorOut;
+  Result resultOut;
   PRTime timeOut;
   ASSERT_FALSE(cache.Get(CertID(fakeIssuer1, fakeKey001, fakeSerial0000),
-                         errorOut, timeOut));
+                         resultOut, timeOut));
 }
 
 TEST_F(OCSPCacheTest, TestNoEvictionForRevokedResponses)
 {
   SCOPED_TRACE("");
   PRTime timeIn = PR_Now();
   CertID notEvicted(fakeIssuer1, fakeKey000, fakeSerial0000);
-  PutAndGet(cache, notEvicted, SEC_ERROR_REVOKED_CERTIFICATE, timeIn);
+  PutAndGet(cache, notEvicted, Result::ERROR_REVOKED_CERTIFICATE, timeIn);
   // By putting more distinct entries in the cache than it can hold,
   // we cause the least recently used entry that isn't revoked to be evicted.
   for (int i = 1; i < MaxCacheEntries + 1; i++) {
     char serialBuf[8];
     PR_snprintf(serialBuf, sizeof(serialBuf), "%04d", i);
     const SECItem fakeSerial = {
       siBuffer,
       reinterpret_cast<uint8_t*>(serialBuf),
       4
     };
-    PutAndGet(cache, CertID(fakeIssuer1, fakeKey000, fakeSerial), 0, timeIn + i);
+    PutAndGet(cache, CertID(fakeIssuer1, fakeKey000, fakeSerial),
+              Success, timeIn + i);
   }
-  PRErrorCode errorOut;
+  Result resultOut;
   PRTime timeOut;
-  ASSERT_TRUE(cache.Get(notEvicted, errorOut, timeOut));
-  ASSERT_TRUE(errorOut == SEC_ERROR_REVOKED_CERTIFICATE && timeOut == timeIn);
+  ASSERT_TRUE(cache.Get(notEvicted, resultOut, timeOut));
+  ASSERT_EQ(Result::ERROR_REVOKED_CERTIFICATE, resultOut);
+  ASSERT_EQ(timeIn, timeOut);
 
   const SECItem fakeSerial0001 = {
     siBuffer,
     const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>("0001")),
     4
   };
   CertID evicted(fakeIssuer1, fakeKey000, fakeSerial0001);
-  ASSERT_FALSE(cache.Get(evicted, errorOut, timeOut));
+  ASSERT_FALSE(cache.Get(evicted, resultOut, timeOut));
 }
 
 TEST_F(OCSPCacheTest, TestEverythingIsRevoked)
 {
   SCOPED_TRACE("");
   PRTime timeIn = PR_Now();
   // Fill up the cache with revoked responses.
   for (int i = 0; i < MaxCacheEntries; i++) {
     char serialBuf[8];
     PR_snprintf(serialBuf, sizeof(serialBuf), "%04d", i);
     const SECItem fakeSerial = {
       siBuffer,
       reinterpret_cast<uint8_t*>(serialBuf),
       4
     };
     PutAndGet(cache, CertID(fakeIssuer1, fakeKey000, fakeSerial),
-              SEC_ERROR_REVOKED_CERTIFICATE, timeIn + i);
+              Result::ERROR_REVOKED_CERTIFICATE, timeIn + i);
   }
   const SECItem fakeSerial1025 = {
     siBuffer,
     const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>("1025")),
     4
   };
   CertID good(fakeIssuer1, fakeKey000, fakeSerial1025);
   // This will "succeed", allowing verification to continue. However,
   // nothing was actually put in the cache.
-  SECStatus result = cache.Put(good, 0, timeIn + 1025 - 50, timeIn + 1025);
-  ASSERT_TRUE(result == SECSuccess);
-  PRErrorCode errorOut;
+  Result result = cache.Put(good, Success, timeIn + 1025 - 50, timeIn + 1025);
+  ASSERT_EQ(Success, result);
+  Result resultOut;
   PRTime timeOut;
-  ASSERT_FALSE(cache.Get(good, errorOut, timeOut));
+  ASSERT_FALSE(cache.Get(good, resultOut, timeOut));
 
   const SECItem fakeSerial1026 = {
     siBuffer,
     const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>("1026")),
     4
   };
   CertID revoked(fakeIssuer1, fakeKey000, fakeSerial1026);
   // This will fail, causing verification to fail.
-  result = cache.Put(revoked, SEC_ERROR_REVOKED_CERTIFICATE,
+  result = cache.Put(revoked, Result::ERROR_REVOKED_CERTIFICATE,
                      timeIn + 1026 - 50, timeIn + 1026);
-  PRErrorCode error = PR_GetError();
-  ASSERT_TRUE(result == SECFailure);
-  ASSERT_TRUE(error == SEC_ERROR_REVOKED_CERTIFICATE);
+  ASSERT_EQ(Result::ERROR_REVOKED_CERTIFICATE, result);
 }
 
 TEST_F(OCSPCacheTest, VariousIssuers)
 {
   SCOPED_TRACE("");
   static const SECItem fakeIssuer2 = {
     siBuffer,
     const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>("CN=issuer2")),
@@ -248,68 +256,73 @@ TEST_F(OCSPCacheTest, VariousIssuers)
   static const SECItem fakeSerial001 = {
     siBuffer,
     const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>("001")),
     3
   };
 
   PRTime timeIn = PR_Now();
   CertID subject(fakeIssuer1, fakeKey000, fakeSerial001);
-  PutAndGet(cache, subject, 0, timeIn);
-  PRErrorCode errorOut;
+  PutAndGet(cache, subject, Success, timeIn);
+  Result resultOut;
   PRTime timeOut;
-  ASSERT_TRUE(cache.Get(subject, errorOut, timeOut));
-  ASSERT_TRUE(errorOut == 0 && timeOut == timeIn);
+  ASSERT_TRUE(cache.Get(subject, resultOut, timeOut));
+  ASSERT_EQ(Success, resultOut);
+  ASSERT_EQ(timeIn, timeOut);
   // Test that we don't match a different issuer DN
   ASSERT_FALSE(cache.Get(CertID(fakeIssuer2, fakeKey000, fakeSerial001),
-                         errorOut, timeOut));
+                         resultOut, timeOut));
   // Test that we don't match a different issuer key
   ASSERT_FALSE(cache.Get(CertID(fakeIssuer1, fakeKey001, fakeSerial001),
-                         errorOut, timeOut));
+                         resultOut, timeOut));
 }
 
 TEST_F(OCSPCacheTest, Times)
 {
   SCOPED_TRACE("");
   CertID certID(fakeIssuer1, fakeKey000, fakeSerial0000);
-  PutAndGet(cache, certID, SEC_ERROR_OCSP_UNKNOWN_CERT, 100);
-  PutAndGet(cache, certID, 0, 200);
+  PutAndGet(cache, certID, Result::ERROR_OCSP_UNKNOWN_CERT, 100);
+  PutAndGet(cache, certID, Success, 200);
   // This should not override the more recent entry.
-  ASSERT_EQ(SECSuccess, cache.Put(certID, SEC_ERROR_OCSP_UNKNOWN_CERT, 100,
-                                  100));
-  PRErrorCode errorOut;
+  ASSERT_EQ(Success,
+            cache.Put(certID, Result::ERROR_OCSP_UNKNOWN_CERT, 100, 100));
+  Result resultOut;
   PRTime timeOut;
-  ASSERT_TRUE(cache.Get(certID, errorOut, timeOut));
+  ASSERT_TRUE(cache.Get(certID, resultOut, timeOut));
   // Here we see the more recent time.
-  ASSERT_TRUE(errorOut == 0 && timeOut == 200);
+  ASSERT_EQ(Success, resultOut);
+  ASSERT_EQ(200, timeOut);
 
-  // SEC_ERROR_REVOKED_CERTIFICATE overrides everything
-  PutAndGet(cache, certID, SEC_ERROR_REVOKED_CERTIFICATE, 50);
+  // Result::ERROR_REVOKED_CERTIFICATE overrides everything
+  PutAndGet(cache, certID, Result::ERROR_REVOKED_CERTIFICATE, 50);
 }
 
 TEST_F(OCSPCacheTest, NetworkFailure)
 {
   SCOPED_TRACE("");
   CertID certID(fakeIssuer1, fakeKey000, fakeSerial0000);
-  PutAndGet(cache, certID, PR_CONNECT_REFUSED_ERROR, 100);
-  PutAndGet(cache, certID, 0, 200);
+  PutAndGet(cache, certID, Result::ERROR_CONNECT_REFUSED, 100);
+  PutAndGet(cache, certID, Success, 200);
   // This should not override the already present entry.
-  SECStatus rv = cache.Put(certID, PR_CONNECT_REFUSED_ERROR, 300, 350);
-  ASSERT_TRUE(rv == SECSuccess);
-  PRErrorCode errorOut;
+  ASSERT_EQ(Success,
+            cache.Put(certID, Result::ERROR_CONNECT_REFUSED, 300, 350));
+  Result resultOut;
   PRTime timeOut;
-  ASSERT_TRUE(cache.Get(certID, errorOut, timeOut));
-  ASSERT_TRUE(errorOut == 0 && timeOut == 200);
+  ASSERT_TRUE(cache.Get(certID, resultOut, timeOut));
+  ASSERT_EQ(Success, resultOut);
+  ASSERT_EQ(200, timeOut);
 
-  PutAndGet(cache, certID, SEC_ERROR_OCSP_UNKNOWN_CERT, 400);
+  PutAndGet(cache, certID, Result::ERROR_OCSP_UNKNOWN_CERT, 400);
   // This should not override the already present entry.
-  rv = cache.Put(certID, PR_CONNECT_REFUSED_ERROR, 500, 550);
-  ASSERT_TRUE(rv == SECSuccess);
-  ASSERT_TRUE(cache.Get(certID, errorOut, timeOut));
-  ASSERT_TRUE(errorOut == SEC_ERROR_OCSP_UNKNOWN_CERT && timeOut == 400);
+  ASSERT_EQ(Success,
+            cache.Put(certID, Result::ERROR_CONNECT_REFUSED, 500, 550));
+  ASSERT_TRUE(cache.Get(certID, resultOut, timeOut));
+  ASSERT_EQ(Result::ERROR_OCSP_UNKNOWN_CERT, resultOut);
+  ASSERT_EQ(400, timeOut);
 
-  PutAndGet(cache, certID, SEC_ERROR_REVOKED_CERTIFICATE, 600);
+  PutAndGet(cache, certID, Result::ERROR_REVOKED_CERTIFICATE, 600);
   // This should not override the already present entry.
-  rv = cache.Put(certID, PR_CONNECT_REFUSED_ERROR, 700, 750);
-  ASSERT_TRUE(rv == SECSuccess);
-  ASSERT_TRUE(cache.Get(certID, errorOut, timeOut));
-  ASSERT_TRUE(errorOut == SEC_ERROR_REVOKED_CERTIFICATE && timeOut == 600);
+  ASSERT_EQ(Success,
+            cache.Put(certID, Result::ERROR_CONNECT_REFUSED, 700, 750));
+  ASSERT_TRUE(cache.Get(certID, resultOut, timeOut));
+  ASSERT_EQ(Result::ERROR_REVOKED_CERTIFICATE, resultOut);
+  ASSERT_EQ(600, timeOut);
 }

--- a/security/manager/ssl/tests/unit/head_psm.js
+++ b/security/manager/ssl/tests/unit/head_psm.js
@@ -15,17 +15,17 @@ let { ctypes } = Cu.import("resource://g
 
 let gIsWindows = ("@mozilla.org/windows-registry-key;1" in Cc);
 
 const isDebugBuild = Cc["@mozilla.org/xpcom/debug;1"]
                        .getService(Ci.nsIDebug2).isDebugBuild;
 
 const SEC_ERROR_BASE = Ci.nsINSSErrorsService.NSS_SEC_ERROR_BASE;
 const SSL_ERROR_BASE = Ci.nsINSSErrorsService.NSS_SSL_ERROR_BASE;
-const PSM_ERROR_BASE = Ci.nsINSSErrorsService.PSM_ERROR_BASE;
+const MOZILLA_PKIX_ERROR_BASE = Ci.nsINSSErrorsService.MOZILLA_PKIX_ERROR_BASE;
 
 // Sort in numerical order
 const SEC_ERROR_INVALID_ARGS                            = SEC_ERROR_BASE +   5; // -8187
 const SEC_ERROR_BAD_DER                                 = SEC_ERROR_BASE +   9;
 const SEC_ERROR_EXPIRED_CERTIFICATE                     = SEC_ERROR_BASE +  11;
 const SEC_ERROR_REVOKED_CERTIFICATE                     = SEC_ERROR_BASE +  12; // -8180
 const SEC_ERROR_UNKNOWN_ISSUER                          = SEC_ERROR_BASE +  13;
 const SEC_ERROR_BAD_DATABASE                            = SEC_ERROR_BASE +  18;
@@ -53,17 +53,17 @@ const SEC_ERROR_OCSP_OLD_RESPONSE       
 const SEC_ERROR_OCSP_INVALID_SIGNING_CERT               = SEC_ERROR_BASE + 144;
 const SEC_ERROR_POLICY_VALIDATION_FAILED                = SEC_ERROR_BASE + 160; // -8032
 const SEC_ERROR_OCSP_BAD_SIGNATURE                      = SEC_ERROR_BASE + 157;
 const SEC_ERROR_CERT_SIGNATURE_ALGORITHM_DISABLED       = SEC_ERROR_BASE + 176;
 const SEC_ERROR_APPLICATION_CALLBACK_ERROR              = SEC_ERROR_BASE + 178;
 
 const SSL_ERROR_BAD_CERT_DOMAIN                         = SSL_ERROR_BASE +  12;
 
-const PSM_ERROR_KEY_PINNING_FAILURE                     = PSM_ERROR_BASE +   0;
+const MOZILLA_PKIX_ERROR_KEY_PINNING_FAILURE            = MOZILLA_PKIX_ERROR_BASE +   0;
 
 // Supported Certificate Usages
 const certificateUsageSSLClient              = 0x0001;
 const certificateUsageSSLServer              = 0x0002;
 const certificateUsageSSLCA                  = 0x0008;
 const certificateUsageEmailSigner            = 0x0010;
 const certificateUsageEmailRecipient         = 0x0020;
 const certificateUsageObjectSigner           = 0x0040;

--- a/security/manager/ssl/tests/unit/test_pinning.js
+++ b/security/manager/ssl/tests/unit/test_pinning.js
@@ -34,17 +34,17 @@ function test_strict() {
   // test mode.
   add_test(function() {
     Services.prefs.setIntPref("security.cert_pinning.enforcement_level", 2);
     run_next_test();
   });
 
   // Issued by otherCA, which is not in the pinset for pinning.example.com.
   add_connection_test("bad.include-subdomains.pinning.example.com",
-    getXPCOMStatusFromNSS(PSM_ERROR_KEY_PINNING_FAILURE));
+    getXPCOMStatusFromNSS(MOZILLA_PKIX_ERROR_KEY_PINNING_FAILURE));
 
   // These domains serve certs that match the pinset.
   add_connection_test("include-subdomains.pinning.example.com", Cr.NS_OK);
   add_connection_test("good.include-subdomains.pinning.example.com", Cr.NS_OK);
   add_connection_test("exclude-subdomains.pinning.example.com", Cr.NS_OK);
 
   // This domain serves a cert that doesn't match the pinset, but subdomains
   // are excluded.
@@ -96,33 +96,33 @@ function test_enforce_test_mode() {
   // In enforce test mode, we always enforce all pins, even test pins.
   add_test(function() {
     Services.prefs.setIntPref("security.cert_pinning.enforcement_level", 3);
     run_next_test();
   });
 
   // Issued by otherCA, which is not in the pinset for pinning.example.com.
   add_connection_test("bad.include-subdomains.pinning.example.com",
-    getXPCOMStatusFromNSS(PSM_ERROR_KEY_PINNING_FAILURE));
+    getXPCOMStatusFromNSS(MOZILLA_PKIX_ERROR_KEY_PINNING_FAILURE));
 
   // These domains serve certs that match the pinset.
   add_connection_test("include-subdomains.pinning.example.com", Cr.NS_OK);
   add_connection_test("good.include-subdomains.pinning.example.com", Cr.NS_OK);
   add_connection_test("exclude-subdomains.pinning.example.com", Cr.NS_OK);
 
   // This domain serves a cert that doesn't match the pinset, but subdomains
   // are excluded.
   add_connection_test("sub.exclude-subdomains.pinning.example.com", Cr.NS_OK);
 
   // This domain's pinset is exactly the same as
   // include-subdomains.pinning.example.com, serves the same cert as
   // bad.include-subdomains.pinning.example.com, is in test-mode, but we are
   // enforcing test mode pins.
   add_connection_test("test-mode.pinning.example.com",
-    getXPCOMStatusFromNSS(PSM_ERROR_KEY_PINNING_FAILURE));
+    getXPCOMStatusFromNSS(MOZILLA_PKIX_ERROR_KEY_PINNING_FAILURE));
 }
 
 function check_pinning_telemetry() {
   let service = Cc["@mozilla.org/base/telemetry;1"].getService(Ci.nsITelemetry);
   let prod_histogram = service.getHistogramById("CERT_PINNING_RESULTS")
                          .snapshot();
   let test_histogram = service.getHistogramById("CERT_PINNING_TEST_RESULTS")
                          .snapshot();

--- a/security/pkix/include/pkix/Input.h
+++ b/security/pkix/include/pkix/Input.h
@@ -22,16 +22,17 @@
  * limitations under the License.
  */
 
 #ifndef mozilla_pkix__Input_h
 #define mozilla_pkix__Input_h
 
 #include "pkix/nullptr.h"
 #include "pkix/Result.h"
+#include "seccomon.h"
 #include "stdint.h"
 
 namespace mozilla { namespace pkix {
 
 // Expect* functions advance the input mark and return Success if the input
 // matches the given criteria; they fail with the input mark in an undefined
 // state if the input does not match the criteria.
 //
@@ -50,21 +51,21 @@ public:
     , end(nullptr)
   {
   }
 
   Result Init(const uint8_t* data, size_t len)
   {
     if (input) {
       // already initialized
-      return Fail(SEC_ERROR_INVALID_ARGS);
+      return Result::FATAL_ERROR_INVALID_ARGS;
     }
     if (!data || len > 0xffffu) {
       // input too large
-      return Fail(SEC_ERROR_BAD_DER);
+      return Result::ERROR_BAD_DER;
     }
 
     // XXX: this->input = input bug was not caught by tests! Why not?
     //      this->end = end bug was not caught by tests! Why not?
     this->input = data;
     this->end = data + len;
 
     return Success;
@@ -72,17 +73,17 @@ public:
 
   Result Expect(const uint8_t* expected, uint16_t expectedLen)
   {
     Result rv = EnsureLength(expectedLen);
     if (rv != Success) {
       return rv;
     }
     if (memcmp(input, expected, expectedLen)) {
-      return Fail(SEC_ERROR_BAD_DER);
+      return Result::ERROR_BAD_DER;
     }
     input += expectedLen;
     return Success;
   }
 
   bool Peek(uint8_t expectedByte) const
   {
     return input < end && *input == expectedByte;
@@ -191,17 +192,17 @@ public:
   void SkipToEnd()
   {
     input = end;
   }
 
   Result EnsureLength(uint16_t len)
   {
     if (static_cast<size_t>(end - input) < len) {
-      return Fail(SEC_ERROR_BAD_DER);
+      return Result::ERROR_BAD_DER;
     }
     return Success;
   }
 
   bool AtEnd() const { return input == end; }
 
   class Mark
   {
@@ -214,17 +215,17 @@ public:
   };
 
   Mark GetMark() const { return Mark(*this, input); }
 
   Result GetSECItem(SECItemType type, const Mark& mark, /*out*/ SECItem& item)
   {
     if (&mark.input != this || mark.mark > input) {
       PR_NOT_REACHED("invalid mark");
-      return Fail(SEC_ERROR_INVALID_ARGS);
+      return Result::FATAL_ERROR_INVALID_ARGS;
     }
     item.type = type;
     item.data = const_cast<uint8_t*>(mark.mark);
     item.len = static_cast<decltype(item.len)>(input - mark.mark);
     return Success;
   }
 
 private:

--- a/security/pkix/include/pkix/Result.h
+++ b/security/pkix/include/pkix/Result.h
@@ -20,70 +20,89 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 #ifndef mozilla_pkix__Result_h
 #define mozilla_pkix__Result_h
 
-#include "prerror.h"
-#include "seccomon.h"
-#include "secerr.h"
+#include "pkix/enumclass.h"
 
 namespace mozilla { namespace pkix {
 
-enum Result
+static const unsigned int FATAL_ERROR_FLAG = 0x800;
+
+MOZILLA_PKIX_ENUM_CLASS Result
 {
   Success = 0,
-  FatalError = -1,      // An error was encountered that caused path building
-                        // to stop immediately. example: out-of-memory.
-  RecoverableError = -2 // an error that will cause path building to continue
-                        // searching for alternative paths. example: expired
-                        // certificate.
+
+  ERROR_BAD_DER = 1,
+  ERROR_CA_CERT_INVALID = 2,
+  ERROR_BAD_SIGNATURE = 3,
+  ERROR_CERT_BAD_ACCESS_LOCATION = 4,
+  ERROR_CERT_NOT_IN_NAME_SPACE = 5,
+  ERROR_CERT_SIGNATURE_ALGORITHM_DISABLED = 6,
+  ERROR_CONNECT_REFUSED = 7,
+  ERROR_EXPIRED_CERTIFICATE = 8,
+  ERROR_EXTENSION_VALUE_INVALID = 9,
+  ERROR_INADEQUATE_CERT_TYPE = 10,
+  ERROR_INADEQUATE_KEY_USAGE = 11,
+  ERROR_INVALID_ALGORITHM = 12,
+  ERROR_INVALID_TIME = 13,
+  ERROR_KEY_PINNING_FAILURE = 14,
+  ERROR_PATH_LEN_CONSTRAINT_INVALID = 15,
+  ERROR_POLICY_VALIDATION_FAILED = 16,
+  ERROR_REVOKED_CERTIFICATE = 17,
+  ERROR_UNKNOWN_CRITICAL_EXTENSION = 18,
+  ERROR_UNKNOWN_ISSUER = 19,
+  ERROR_UNTRUSTED_CERT = 20,
+  ERROR_UNTRUSTED_ISSUER = 21,
+
+  ERROR_OCSP_BAD_SIGNATURE = 22,
+  ERROR_OCSP_INVALID_SIGNING_CERT = 23,
+  ERROR_OCSP_MALFORMED_REQUEST = 24,
+  ERROR_OCSP_MALFORMED_RESPONSE = 25,
+  ERROR_OCSP_OLD_RESPONSE = 26,
+  ERROR_OCSP_REQUEST_NEEDS_SIG = 27,
+  ERROR_OCSP_RESPONDER_CERT_INVALID = 28,
+  ERROR_OCSP_SERVER_ERROR = 29,
+  ERROR_OCSP_TRY_SERVER_LATER = 30,
+  ERROR_OCSP_UNAUTHORIZED_REQUEST = 31,
+  ERROR_OCSP_UNKNOWN_RESPONSE_STATUS = 32,
+  ERROR_OCSP_UNKNOWN_CERT = 33,
+  ERROR_OCSP_FUTURE_RESPONSE = 34,
+
+  ERROR_UNKNOWN_ERROR = 35,
+
+  ERROR_INVALID_KEY = 36,
+  ERROR_UNSUPPORTED_KEYALG = 37,
+
+  // Keep this in sync with MAP_LIST in pkixnss.cpp
+
+  FATAL_ERROR_INVALID_ARGS = FATAL_ERROR_FLAG | 1,
+  FATAL_ERROR_INVALID_STATE = FATAL_ERROR_FLAG | 2,
+  FATAL_ERROR_LIBRARY_FAILURE = FATAL_ERROR_FLAG | 3,
+  FATAL_ERROR_NO_MEMORY = FATAL_ERROR_FLAG | 4,
+
+  // Keep this in sync with MAP_LIST in pkixnss.cpp
 };
 
-// When returning errors, use this function instead of calling PR_SetError
-// directly. This helps ensure that we always call PR_SetError when we return
-// an error code. This is a useful place to set a breakpoint when a debugging
-// a certificate verification failure.
-inline Result
-Fail(Result result, PRErrorCode errorCode)
-{
-  PR_ASSERT(result != Success);
-  PR_SetError(errorCode, 0);
-  return result;
-}
-
-inline Result
-MapSECStatus(SECStatus srv)
-{
-  if (srv == SECSuccess) {
-    return Success;
-  }
+// We write many comparisons as (x != Success), and this shortened name makes
+// those comparisons clearer, especially because the shortened name often
+// results in less line wrapping.
+//
+// Visual Studio before VS2013 does not support "enum class," so
+// Result::Success will already be visible in this scope, and compilation will
+// fail if we try to define a variable with that name here.
+#if !defined(_MSC_VER) || (_MSC_VER >= 1700)
+static const Result Success = Result::Success;
+#endif
 
-  PRErrorCode error = PORT_GetError();
-  switch (error) {
-    case SEC_ERROR_EXTENSION_NOT_FOUND:
-      return RecoverableError;
-
-    case PR_INVALID_STATE_ERROR:
-    case SEC_ERROR_INVALID_ARGS:
-    case SEC_ERROR_LIBRARY_FAILURE:
-    case SEC_ERROR_NO_MEMORY:
-      return FatalError;
-  }
-
-  // TODO: PORT_Assert(false); // we haven't classified the error yet
-  return RecoverableError;
-}
-
-inline Result
-Fail(PRErrorCode errorCode)
+inline bool
+IsFatalError(Result rv)
 {
-  PR_ASSERT(errorCode != 0);
-  PR_SetError(errorCode, 0);
-  return mozilla::pkix::MapSECStatus(SECFailure);
+  return static_cast<unsigned int>(rv) & FATAL_ERROR_FLAG;
 }
 
 } } // namespace mozilla::pkix
 
 #endif // mozilla_pkix__Result_h

--- a/security/pkix/include/pkix/pkix.h
+++ b/security/pkix/include/pkix/pkix.h
@@ -20,19 +20,17 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 #ifndef mozilla_pkix__pkix_h
 #define mozilla_pkix__pkix_h
 
-#include "pkix/nullptr.h"
 #include "pkixtypes.h"
-#include "prtime.h"
 
 namespace mozilla { namespace pkix {
 
 // ----------------------------------------------------------------------------
 // LIMITED SUPPORT FOR CERTIFICATE POLICIES
 //
 // If SEC_OID_X509_ANY_POLICY is passed as the value of the requiredPolicy
 // parameter then all policy validation will be skipped. Otherwise, path
@@ -55,93 +53,74 @@ namespace mozilla { namespace pkix {
 //
 // BuildCertChain prioritizes certain checks ahead of others so that when a
 // certificate chain has multiple errors, the "most serious" error is
 // returned. In practice, this ranking of seriousness is tied directly to how
 // Firefox's certificate error override mechanism.
 //
 // The ranking is:
 //
-//    1. Active distrust (SEC_ERROR_UNTRUSTED_CERT).
+//    1. Active distrust (Result::ERROR_UNTRUSTED_CERT).
 //    2. Problems with issuer-independent properties for CA certificates.
-//    3. Unknown issuer (SEC_ERROR_UNKNOWN_ISSUER).
+//    3. Unknown issuer (Result::ERROR_UNKNOWN_ISSUER).
 //    4. Problems with issuer-independent properties for EE certificates.
 //    5. Revocation.
 //
-// In particular, if BuildCertChain returns SEC_ERROR_UNKNOWN_ISSUER then the
-// caller can call CERT_CheckCertValidTimes to determine if the certificate is
-// ALSO expired.
+// In particular, if BuildCertChain returns Result::ERROR_UNKNOWN_ISSUER then
+// the caller can call CERT_CheckCertValidTimes to determine if the certificate
+// is ALSO expired.
 //
 // It would be better if revocation were prioritized above expiration and
 // unknown issuer. However, it is impossible to do revocation checking without
 // knowing the issuer, since the issuer information is needed to validate the
 // revocation information. Also, generally revocation checking only works
 // during the validity period of the certificate.
 //
 // In general, when path building fails, BuildCertChain will return
-// SEC_ERROR_UNKNOWN_ISSUER. However, if all attempted paths resulted in the
-// same error (which is trivially true when there is only one potential path),
-// more specific errors will be returned.
+// Result::ERROR_UNKNOWN_ISSUER. However, if all attempted paths resulted in
+// the same error (which is trivially true when there is only one potential
+// path), more specific errors will be returned.
 //
 // ----------------------------------------------------------------------------
 // Meaning of specific error codes
 //
-// SEC_ERROR_UNTRUSTED_CERT means that the end-entity certificate was actively
-//                          distrusted.
-// SEC_ERROR_UNTRUSTED_ISSUER means that path building failed because of active
-//                            distrust.
+// Result::ERROR_UNTRUSTED_CERT means that the end-entity certificate was
+//                              actively distrusted.
+// Result::SEC_ERROR_UNTRUSTED_ISSUER means that path building failed because
+//                                    of active distrust.
 // TODO(bug 968451): Document more of these.
 
-SECStatus BuildCertChain(TrustDomain& trustDomain, const SECItem& cert,
-                         PRTime time, EndEntityOrCA endEntityOrCA,
-                         KeyUsage requiredKeyUsageIfPresent,
-                         KeyPurposeId requiredEKUIfPresent,
-                         const CertPolicyId& requiredPolicy,
-            /*optional*/ const SECItem* stapledOCSPResponse);
+Result BuildCertChain(TrustDomain& trustDomain, const SECItem& cert,
+                      PRTime time, EndEntityOrCA endEntityOrCA,
+                      KeyUsage requiredKeyUsageIfPresent,
+                      KeyPurposeId requiredEKUIfPresent,
+                      const CertPolicyId& requiredPolicy,
+                      /*optional*/ const SECItem* stapledOCSPResponse);
 
-// Verify the given signed data using the given public key.
-SECStatus VerifySignedData(const SignedDataWithSignature& sd,
-                           const SECItem& subjectPublicKeyInfo,
-                           void* pkcs11PinArg);
-
-// The return value, if non-null, is owned by the arena and MUST NOT be freed.
-SECItem* CreateEncodedOCSPRequest(TrustDomain& trustDomain, PLArenaPool* arena,
-                                  const CertID& certID);
+static const size_t OCSP_REQUEST_MAX_LENGTH = 127;
+Result CreateEncodedOCSPRequest(TrustDomain& trustDomain,
+                                const struct CertID& certID,
+                                /*out*/ uint8_t (&out)[OCSP_REQUEST_MAX_LENGTH],
+                                /*out*/ size_t& outLen);
 
 // The out parameter expired will be true if the response has expired. If the
 // response also indicates a revoked or unknown certificate, that error
-// will be returned by PR_GetError(). Otherwise, SEC_ERROR_OCSP_OLD_RESPONSE
-// will be returned by PR_GetError() for an expired response.
+// will be returned. Otherwise, REsult::ERROR_OCSP_OLD_RESPONSE will be
+// returned for an expired response.
+//
 // The optional parameter thisUpdate will be the thisUpdate value of
 // the encoded response if it is considered trustworthy. Only
 // good, unknown, or revoked responses that verify correctly are considered
 // trustworthy. If the response is not trustworthy, thisUpdate will be 0.
 // Similarly, the optional parameter validThrough will be the time through
 // which the encoded response is considered trustworthy (that is, if a response had a
 // thisUpdate time of validThrough, it would be considered trustworthy).
-SECStatus VerifyEncodedOCSPResponse(TrustDomain& trustDomain,
-                                    const CertID& certID, PRTime time,
-                                    uint16_t maxLifetimeInDays,
-                                    const SECItem& encodedResponse,
-                          /* out */ bool& expired,
-                 /* optional out */ PRTime* thisUpdate = nullptr,
-                 /* optional out */ PRTime* validThrough = nullptr);
-
-// Computes the SHA-1 hash of the data in the current item.
-//
-// item contains the data to hash.
-// digestBuf must point to a buffer to where the SHA-1 hash will be written.
-// digestBufLen must be 20 (the length of a SHA-1 hash,
-//              TrustDomain::DIGEST_LENGTH).
-//
-// TODO(bug 966856): Add SHA-2 support
-// TODO: Taking the output buffer as (uint8_t*, size_t) is counter to our
-// other, extensive, memory safety efforts in mozilla::pkix, and we should find
-// a way to provide a more-obviously-safe interface.
-SECStatus DigestBuf(const SECItem& item, /*out*/ uint8_t* digestBuf,
-                    size_t digestBufLen);
-
-// Checks, for RSA keys and DSA keys, that the modulus is at least 1024 bits.
-SECStatus CheckPublicKey(const SECItem& subjectPublicKeyInfo);
+Result VerifyEncodedOCSPResponse(TrustDomain& trustDomain,
+                                 const CertID& certID, PRTime time,
+                                 uint16_t maxLifetimeInDays,
+                                 const SECItem& encodedResponse,
+                       /* out */ bool& expired,
+              /* optional out */ PRTime* thisUpdate = nullptr,
+              /* optional out */ PRTime* validThrough = nullptr);
 
 } } // namespace mozilla::pkix
 
 #endif // mozilla_pkix__pkix_h

new file mode 100644
--- /dev/null
+++ b/security/pkix/include/pkix/pkixnss.h
@@ -0,0 +1,81 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This code is made available to you under your choice of the following sets
+ * of licensing terms:
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+/* Copyright 2013 Mozilla Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef mozilla_pkix__pkixnss_h
+#define mozilla_pkix__pkixnss_h
+
+#include "pkixtypes.h"
+#include "prerror.h"
+#include "seccomon.h"
+
+namespace mozilla { namespace pkix {
+
+// Verify the given signed data using the given public key.
+Result VerifySignedData(const SignedDataWithSignature& sd,
+                        const SECItem& subjectPublicKeyInfo,
+                        void* pkcs11PinArg);
+
+// Computes the SHA-1 hash of the data in the current item.
+//
+// item contains the data to hash.
+// digestBuf must point to a buffer to where the SHA-1 hash will be written.
+// digestBufLen must be 20 (the length of a SHA-1 hash,
+//              TrustDomain::DIGEST_LENGTH).
+//
+// TODO(bug 966856): Add SHA-2 support
+// TODO: Taking the output buffer as (uint8_t*, size_t) is counter to our
+// other, extensive, memory safety efforts in mozilla::pkix, and we should find
+// a way to provide a more-obviously-safe interface.
+Result DigestBuf(const SECItem& item, /*out*/ uint8_t* digestBuf,
+                 size_t digestBufLen);
+
+// Checks, for RSA keys and DSA keys, that the modulus is at least 1024 bits.
+Result CheckPublicKey(const SECItem& subjectPublicKeyInfo);
+
+Result MapPRErrorCodeToResult(PRErrorCode errorCode);
+PRErrorCode MapResultToPRErrorCode(Result result);
+
+// Returns the stringified name of the given result, e.g. "Result::Success",
+// or nullptr if result is unknown (invalid).
+const char* MapResultToName(Result result);
+
+// The error codes within each module must fit in 16 bits. We want these
+// errors to fit in the same module as the NSS errors but not overlap with
+// any of them. Converting an NSS SEC, NSS SSL, or PSM error to an NS error
+// involves negating the value of the error and then synthesizing an error
+// in the NS_ERROR_MODULE_SECURITY module. Hence, PSM errors will start at
+// a negative value that both doesn't overlap with the current value
+// ranges for NSS errors and that will fit in 16 bits when negated.
+static const PRErrorCode ERROR_BASE = -0x4000;
+static const PRErrorCode ERROR_LIMIT = ERROR_BASE + 1000;
+
+enum ErrorCode {
+  MOZILLA_PKIX_ERROR_KEY_PINNING_FAILURE = ERROR_BASE + 0
+};
+
+void RegisterErrorTable();
+
+} } // namespace mozilla::pkix
+
+#endif // mozilla_pkix__pkixnss_h

--- a/security/pkix/include/pkix/pkixtypes.h
+++ b/security/pkix/include/pkix/pkixtypes.h
@@ -20,17 +20,17 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 #ifndef mozilla_pkix__pkixtypes_h
 #define mozilla_pkix__pkixtypes_h
 
-#include "pkix/enumclass.h"
+#include "pkix/Result.h"
 #include "pkix/nullptr.h"
 #include "prtime.h"
 #include "seccomon.h"
 #include "stdint.h"
 
 namespace mozilla { namespace pkix {
 
 MOZILLA_PKIX_ENUM_CLASS DigestAlgorithm
@@ -193,34 +193,34 @@ public:
   // When policy.IsAnyPolicy(), then no policy-related checking should be done.
   // When !policy.IsAnyPolicy(), then GetCertTrust MUST NOT return with
   // *trustLevel == TrustAnchor unless the given cert is considered a trust
   // anchor *for that policy*. In particular, if the user has marked an
   // intermediate certificate as trusted, but that intermediate isn't in the
   // list of EV roots, then GetCertTrust must result in
   // *trustLevel == InheritsTrust instead of *trustLevel == TrustAnchor
   // (assuming the candidate cert is not actively distrusted).
-  virtual SECStatus GetCertTrust(EndEntityOrCA endEntityOrCA,
-                                 const CertPolicyId& policy,
-                                 const SECItem& candidateCertDER,
-                         /*out*/ TrustLevel* trustLevel) = 0;
+  virtual Result GetCertTrust(EndEntityOrCA endEntityOrCA,
+                              const CertPolicyId& policy,
+                              const SECItem& candidateCertDER,
+                              /*out*/ TrustLevel* trustLevel) = 0;
 
   class IssuerChecker
   {
   public:
     // potentialIssuerDER is the complete DER encoding of the certificate to
     // be checked as a potential issuer.
     //
     // If additionalNameConstraints is not nullptr then it must point to an
     // encoded NameConstraints extension value; in that case, those name
     // constraints will be checked in addition to any any name constraints
     // contained in potentialIssuerDER.
-    virtual SECStatus Check(const SECItem& potentialIssuerDER,
-               /*optional*/ const SECItem* additionalNameConstraints,
-                    /*out*/ bool& keepGoing) = 0;
+    virtual Result Check(const SECItem& potentialIssuerDER,
+                         /*optional*/ const SECItem* additionalNameConstraints,
+                         /*out*/ bool& keepGoing) = 0;
   protected:
     IssuerChecker();
     virtual ~IssuerChecker();
   private:
     IssuerChecker(const IssuerChecker&) /*= delete*/;
     void operator=(const IssuerChecker&) /*= delete*/;
   };
 
@@ -260,18 +260,18 @@ public:
   //              [...]
   //                TrustDomain::FindIssuer
   //                  [...]
   //                    IssuerChecker::Check
   //                      [...]
   //
   // checker.Check is responsible for limiting the recursion to a reasonable
   // limit.
-  virtual SECStatus FindIssuer(const SECItem& encodedIssuerName,
-                               IssuerChecker& checker, PRTime time) = 0;
+  virtual Result FindIssuer(const SECItem& encodedIssuerName,
+                            IssuerChecker& checker, PRTime time) = 0;
 
   // Called as soon as we think we have a valid chain but before revocation
   // checks are done. This function can be used to compute additional checks,
   // especilaly checks that require the entire certificate chain. This callback
   // can also be used to save a copy of the built certificate chain for later
   // use.
   //
   // This function may be called multiple times, regardless of whether it
@@ -284,57 +284,56 @@ public:
   // Keep in mind, in particular, that if the application saves a copy of the
   // certificate chain the last invocation of IsChainValid during a validation,
   // it is still possible for BuildCertChain to fail (return SECFailure), in
   // which case the application must not assume anything about the validity of
   // the last certificate chain passed to IsChainValid; especially, it would be
   // very wrong to assume that the certificate chain is valid.
   //
   // certChain.GetDER(0) is the trust anchor.
-  virtual SECStatus IsChainValid(const DERArray& certChain) = 0;
+  virtual Result IsChainValid(const DERArray& certChain) = 0;
 
   // issuerCertToDup is only non-const so CERT_DupCertificate can be called on
   // it.
-  virtual SECStatus CheckRevocation(EndEntityOrCA endEntityOrCA,
-                                    const CertID& certID, PRTime time,
-                       /*optional*/ const SECItem* stapledOCSPresponse,
-                       /*optional*/ const SECItem* aiaExtension) = 0;
+  virtual Result CheckRevocation(EndEntityOrCA endEntityOrCA,
+                                 const CertID& certID, PRTime time,
+                    /*optional*/ const SECItem* stapledOCSPresponse,
+                    /*optional*/ const SECItem* aiaExtension) = 0;
+
+  // Check that the key size, algorithm, and parameters of the given public key
+  // are acceptable.
+  //
+  // VerifySignedData() should do the same checks that this function does, but
+  // mainly for efficiency, some keys are not passed to VerifySignedData().
+  // This function is called instead for those keys.
+  virtual Result CheckPublicKey(const SECItem& subjectPublicKeyInfo) = 0;
 
   // Verify the given signature using the given public key.
   //
   // Most implementations of this function should probably forward the call
   // directly to mozilla::pkix::VerifySignedData.
   //
   // In any case, the implementation must perform checks on the public key
   // similar to how mozilla::pkix::CheckPublicKey() does.
-  virtual SECStatus VerifySignedData(const SignedDataWithSignature& signedData,
-                                     const SECItem& subjectPublicKeyInfo) = 0;
+  virtual Result VerifySignedData(const SignedDataWithSignature& signedData,
+                                  const SECItem& subjectPublicKeyInfo) = 0;
 
   // Compute the SHA-1 hash of the data in the current item.
   //
   // item contains the data to hash.
   // digestBuf must point to a buffer to where the SHA-1 hash will be written.
   // digestBufLen must be DIGEST_LENGTH (20, the length of a SHA-1 hash).
   //
   // TODO(bug 966856): Add SHA-2 support
   // TODO: Taking the output buffer as (uint8_t*, size_t) is counter to our
   // other, extensive, memory safety efforts in mozilla::pkix, and we should
   // find a way to provide a more-obviously-safe interface.
   static const size_t DIGEST_LENGTH = 20; // length of SHA-1 digest
-  virtual SECStatus DigestBuf(const SECItem& item, /*out*/ uint8_t* digestBuf,
-                              size_t digestBufLen) = 0;
-
-  // Check that the key size, algorithm, and parameters of the given public key
-  // are acceptable.
-  //
-  // VerifySignedData() should do the same checks that this function does, but
-  // mainly for efficiency, some keys are not passed to VerifySignedData().
-  // This function is called instead for those keys.
-  virtual SECStatus CheckPublicKey(const SECItem& subjectPublicKeyInfo) = 0;
-
+  virtual Result DigestBuf(const SECItem& item, /*out*/ uint8_t* digestBuf,
+                           size_t digestBufLen) = 0;
 protected:
   TrustDomain() { }
 
 private:
   TrustDomain(const TrustDomain&) /* = delete */;
   void operator=(const TrustDomain&) /* = delete */;
 };
 

--- a/security/pkix/lib/pkixbuild.cpp
+++ b/security/pkix/lib/pkixbuild.cpp
@@ -54,158 +54,152 @@ public:
                    unsigned int subCACount)
     : trustDomain(trustDomain)
     , subject(subject)
     , time(time)
     , requiredEKUIfPresent(requiredEKUIfPresent)
     , requiredPolicy(requiredPolicy)
     , stapledOCSPResponse(stapledOCSPResponse)
     , subCACount(subCACount)
-    , result(SEC_ERROR_LIBRARY_FAILURE)
+    , result(Result::FATAL_ERROR_LIBRARY_FAILURE)
     , resultWasSet(false)
   {
   }
 
-  SECStatus Check(const SECItem& potentialIssuerDER,
-                  /*optional*/ const SECItem* additionalNameConstraints,
-                  /*out*/ bool& keepGoing);
+  Result Check(const SECItem& potentialIssuerDER,
+               /*optional*/ const SECItem* additionalNameConstraints,
+               /*out*/ bool& keepGoing);
 
   Result CheckResult() const;
 
 private:
   TrustDomain& trustDomain;
   const BackCert& subject;
   const PRTime time;
   const KeyPurposeId requiredEKUIfPresent;
   const CertPolicyId& requiredPolicy;
   /*optional*/ SECItem const* const stapledOCSPResponse;
   const unsigned int subCACount;
 
-  SECStatus RecordResult(PRErrorCode currentResult, /*out*/ bool& keepGoing);
-  PRErrorCode result;
+  Result RecordResult(Result currentResult, /*out*/ bool& keepGoing);
+  Result result;
   bool resultWasSet;
 
   PathBuildingStep(const PathBuildingStep&) /*= delete*/;
   void operator=(const PathBuildingStep&) /*= delete*/;
 };
 
-SECStatus
-PathBuildingStep::RecordResult(PRErrorCode newResult,
-                               /*out*/ bool& keepGoing)
+Result
+PathBuildingStep::RecordResult(Result newResult, /*out*/ bool& keepGoing)
 {
-  if (newResult == SEC_ERROR_UNTRUSTED_CERT) {
-    newResult = SEC_ERROR_UNTRUSTED_ISSUER;
+  if (newResult == Result::ERROR_UNTRUSTED_CERT) {
+    newResult = Result::ERROR_UNTRUSTED_ISSUER;
   }
+
   if (resultWasSet) {
-    if (result == 0) {
+    if (result == Success) {
       PR_NOT_REACHED("RecordResult called after finding a chain");
-      PR_SetError(SEC_ERROR_LIBRARY_FAILURE, 0);
-      return SECFailure;
+      return Result::FATAL_ERROR_INVALID_STATE;
     }
     // If every potential issuer has the same problem (e.g. expired) and/or if
     // there is only one bad potential issuer, then return a more specific
     // error. Otherwise, punt on trying to decide which error should be
-    // returned by returning the generic SEC_ERROR_UNKNOWN_ISSUER error.
-    if (newResult != 0 && newResult != result) {
-      newResult = SEC_ERROR_UNKNOWN_ISSUER;
+    // returned by returning the generic Result::ERROR_UNKNOWN_ISSUER error.
+    if (newResult != Success && newResult != result) {
+      newResult = Result::ERROR_UNKNOWN_ISSUER;
     }
   }
 
   result = newResult;
   resultWasSet = true;
-  keepGoing = result != 0;
-  return SECSuccess;
+  keepGoing = result != Success;
+  return Success;
 }
 
 Result
 PathBuildingStep::CheckResult() const
 {
   if (!resultWasSet) {
-    return Fail(RecoverableError, SEC_ERROR_UNKNOWN_ISSUER);
+    return Result::ERROR_UNKNOWN_ISSUER;
   }
-  if (result == 0) {
-    return Success;
-  }
-  PR_SetError(result, 0);
-  return MapSECStatus(SECFailure);
+  return result;
 }
 
 // The code that executes in the inner loop of BuildForward
-SECStatus
+Result
 PathBuildingStep::Check(const SECItem& potentialIssuerDER,
                         /*optional*/ const SECItem* additionalNameConstraints,
                         /*out*/ bool& keepGoing)
 {
   BackCert potentialIssuer(potentialIssuerDER, EndEntityOrCA::MustBeCA,
                            &subject);
   Result rv = potentialIssuer.Init();
   if (rv != Success) {
-    return RecordResult(PR_GetError(), keepGoing);
+    return RecordResult(rv, keepGoing);
   }
 
   // RFC5280 4.2.1.1. Authority Key Identifier
   // RFC5280 4.2.1.2. Subject Key Identifier
 
   // Loop prevention, done as recommended by RFC4158 Section 5.2
   // TODO: this doesn't account for subjectAltNames!
   // TODO(perf): This probably can and should be optimized in some way.
   bool loopDetected = false;
   for (const BackCert* prev = potentialIssuer.childCert;
        !loopDetected && prev != nullptr; prev = prev->childCert) {
     if (SECITEM_ItemsAreEqual(&potentialIssuer.GetSubjectPublicKeyInfo(),
                               &prev->GetSubjectPublicKeyInfo()) &&
         SECITEM_ItemsAreEqual(&potentialIssuer.GetSubject(),
                               &prev->GetSubject())) {
       // XXX: error code
-      return RecordResult(SEC_ERROR_UNKNOWN_ISSUER, keepGoing);
+      return RecordResult(Result::ERROR_UNKNOWN_ISSUER, keepGoing);
     }
   }
 
   if (potentialIssuer.GetNameConstraints()) {
     rv = CheckNameConstraints(*potentialIssuer.GetNameConstraints(),
                               subject, requiredEKUIfPresent);
     if (rv != Success) {
-       return RecordResult(PR_GetError(), keepGoing);
+       return RecordResult(rv, keepGoing);
     }
   }
 
   if (additionalNameConstraints) {
     rv = CheckNameConstraints(*additionalNameConstraints, subject,
                               requiredEKUIfPresent);
     if (rv != Success) {
-       return RecordResult(PR_GetError(), keepGoing);
+       return RecordResult(rv, keepGoing);
     }
   }
 
   // RFC 5280, Section 4.2.1.3: "If the keyUsage extension is present, then the
   // subject public key MUST NOT be used to verify signatures on certificates
   // or CRLs unless the corresponding keyCertSign or cRLSign bit is set."
   rv = BuildForward(trustDomain, potentialIssuer, time, KeyUsage::keyCertSign,
                     requiredEKUIfPresent, requiredPolicy, nullptr, subCACount);
   if (rv != Success) {
-    return RecordResult(PR_GetError(), keepGoing);
+    return RecordResult(rv, keepGoing);
   }
 
-  SECStatus srv = trustDomain.VerifySignedData(
-                                subject.GetSignedData(),
-                                potentialIssuer.GetSubjectPublicKeyInfo());
-  if (srv != SECSuccess) {
-    return RecordResult(PR_GetError(), keepGoing);
+  rv = trustDomain.VerifySignedData(subject.GetSignedData(),
+                                    potentialIssuer.GetSubjectPublicKeyInfo());
+  if (rv != Success) {
+    return RecordResult(rv, keepGoing);
   }
 
   CertID certID(subject.GetIssuer(), potentialIssuer.GetSubjectPublicKeyInfo(),
                 subject.GetSerialNumber());
-  srv = trustDomain.CheckRevocation(subject.endEntityOrCA, certID, time,
-                                    stapledOCSPResponse,
-                                    subject.GetAuthorityInfoAccess());
-  if (srv != SECSuccess) {
-    return RecordResult(PR_GetError(), keepGoing);
+  rv = trustDomain.CheckRevocation(subject.endEntityOrCA, certID, time,
+                                   stapledOCSPResponse,
+                                   subject.GetAuthorityInfoAccess());
+  if (rv != Success) {
+    return RecordResult(rv, keepGoing);
   }
 
-  return RecordResult(0/*PRErrorCode::success*/, keepGoing);
+  return RecordResult(Success, keepGoing);
 }
 
 // Recursively build the path from the given subject certificate to the root.
 //
 // Be very careful about changing the order of checks. The order is significant
 // because it affects which error we return when a certificate or certificate
 // chain has multiple problems. See the error ranking documentation in
 // pkix/pkix.h.
@@ -224,116 +218,107 @@ BuildForward(TrustDomain& trustDomain,
   TrustLevel trustLevel;
   // If this is an end-entity and not a trust anchor, we defer reporting
   // any error found here until after attempting to find a valid chain.
   // See the explanation of error prioritization in pkix.h.
   rv = CheckIssuerIndependentProperties(trustDomain, subject, time,
                                         requiredKeyUsageIfPresent,
                                         requiredEKUIfPresent, requiredPolicy,
                                         subCACount, &trustLevel);
-  PRErrorCode deferredEndEntityError = 0;
+  Result deferredEndEntityError = Success;
   if (rv != Success) {
     if (subject.endEntityOrCA == EndEntityOrCA::MustBeEndEntity &&
         trustLevel != TrustLevel::TrustAnchor) {
-      deferredEndEntityError = PR_GetError();
+      deferredEndEntityError = rv;
     } else {
       return rv;
     }
   }
 
   if (trustLevel == TrustLevel::TrustAnchor) {
     // End of the recursion.
 
     NonOwningDERArray chain;
     for (const BackCert* cert = &subject; cert; cert = cert->childCert) {
-      Result rv = chain.Append(cert->GetDER());
+      rv = chain.Append(cert->GetDER());
       if (rv != Success) {
         PR_NOT_REACHED("NonOwningDERArray::SetItem failed.");
         return rv;
       }
     }
 
     // This must be done here, after the chain is built but before any
     // revocation checks have been done.
-    SECStatus srv = trustDomain.IsChainValid(chain);
-    if (srv != SECSuccess) {
-      return MapSECStatus(srv);
-    }
-
-    return Success;
+    return trustDomain.IsChainValid(chain);
   }
 
   if (subject.endEntityOrCA == EndEntityOrCA::MustBeCA) {
     // Avoid stack overflows and poor performance by limiting cert chain
     // length.
     static const unsigned int MAX_SUBCA_COUNT = 6;
     static_assert(1/*end-entity*/ + MAX_SUBCA_COUNT + 1/*root*/ ==
                   NonOwningDERArray::MAX_LENGTH,
                   "MAX_SUBCA_COUNT and NonOwningDERArray::MAX_LENGTH mismatch.");
     if (subCACount >= MAX_SUBCA_COUNT) {
-      return Fail(RecoverableError, SEC_ERROR_UNKNOWN_ISSUER);
+      return Result::ERROR_UNKNOWN_ISSUER;
     }
     ++subCACount;
   } else {
     PR_ASSERT(subCACount == 0);
   }
 
   // Find a trusted issuer.
 
   PathBuildingStep pathBuilder(trustDomain, subject, time,
                                requiredEKUIfPresent, requiredPolicy,
                                stapledOCSPResponse, subCACount);
 
   // TODO(bug 965136): Add SKI/AKI matching optimizations
-  if (trustDomain.FindIssuer(subject.GetIssuer(), pathBuilder, time)
-        != SECSuccess) {
-    return MapSECStatus(SECFailure);
+  rv = trustDomain.FindIssuer(subject.GetIssuer(), pathBuilder, time);
+  if (rv != Success) {
+    return rv;
   }
 
   rv = pathBuilder.CheckResult();
   if (rv != Success) {
     return rv;
   }
 
   // If we found a valid chain but deferred reporting an error with the
   // end-entity certificate, report it now.
-  if (deferredEndEntityError != 0) {
-    return Fail(RecoverableError, deferredEndEntityError);
+  if (deferredEndEntityError != Success) {
+    return deferredEndEntityError;
   }
 
   // We've built a valid chain from the subject cert up to a trusted root.
   return Success;
 }
 
-SECStatus
+Result
 BuildCertChain(TrustDomain& trustDomain, const SECItem& certDER,
                PRTime time, EndEntityOrCA endEntityOrCA,
                KeyUsage requiredKeyUsageIfPresent,
                KeyPurposeId requiredEKUIfPresent,
                const CertPolicyId& requiredPolicy,
                /*optional*/ const SECItem* stapledOCSPResponse)
 {
   // XXX: Support the legacy use of the subject CN field for indicating the
   // domain name the certificate is valid for.
   BackCert cert(certDER, endEntityOrCA, nullptr);
   Result rv = cert.Init();
   if (rv != Success) {
-    return SECFailure;
+    return rv;
   }
 
   // See documentation for CheckPublicKey() in pkixtypes.h for why the public
   // key also needs to be checked here when trustDomain.VerifySignedData()
   // should already be doing it.
-  if (trustDomain.CheckPublicKey(cert.GetSubjectPublicKeyInfo()) != SECSuccess) {
-    return SECFailure;
+  rv = trustDomain.CheckPublicKey(cert.GetSubjectPublicKeyInfo());
+  if (rv != Success) {
+    return rv;
   }
 
-  rv = BuildForward(trustDomain, cert, time, requiredKeyUsageIfPresent,
-                    requiredEKUIfPresent, requiredPolicy, stapledOCSPResponse,
-                    0/*subCACount*/);
-  if (rv != Success) {
-    return SECFailure;
-  }
-
-  return SECSuccess;
+  return BuildForward(trustDomain, cert, time, requiredKeyUsageIfPresent,
+                      requiredEKUIfPresent, requiredPolicy, stapledOCSPResponse,
+                      0/*subCACount*/);
 }
 
 } } // namespace mozilla::pkix

--- a/security/pkix/lib/pkixcert.cpp
+++ b/security/pkix/lib/pkixcert.cpp
@@ -238,21 +238,21 @@ BackCert::RememberExtension(Input& extnI
   } else if (extnID.MatchRest(id_pe_authorityInfoAccess)) {
     out = &authorityInfoAccess;
   }
 
   if (out) {
     // Don't allow an empty value for any extension we understand. This way, we
     // can test out->len to check for duplicates.
     if (extnValue.len == 0) {
-      return Fail(SEC_ERROR_EXTENSION_VALUE_INVALID);
+      return Result::ERROR_EXTENSION_VALUE_INVALID;
     }
     if (out->len != 0) {
       // Duplicate extension
-      return Fail(SEC_ERROR_EXTENSION_VALUE_INVALID);
+      return Result::ERROR_EXTENSION_VALUE_INVALID;
     }
     *out = extnValue;
     understood = true;
   }
 
   return Success;
 }
 

--- a/security/pkix/lib/pkixcheck.cpp
+++ b/security/pkix/lib/pkixcheck.cpp
@@ -23,41 +23,42 @@
  */
 
 #include "cert.h"
 #include "pkix/bind.h"
 #include "pkix/pkix.h"
 #include "pkix/ScopedPtr.h"
 #include "pkixcheck.h"
 #include "pkixder.h"
+#include "pkix/pkixnss.h"
 #include "pkixutil.h"
 
 namespace mozilla { namespace pkix {
 
 Result
 CheckValidity(const SECItem& encodedValidity, PRTime time)
 {
   Input validity;
   if (validity.Init(encodedValidity.data, encodedValidity.len) != Success) {
-    return Fail(RecoverableError, SEC_ERROR_EXPIRED_CERTIFICATE);
+    return Result::ERROR_EXPIRED_CERTIFICATE;
   }
   PRTime notBefore;
   if (der::TimeChoice(validity, notBefore) != Success) {
-    return Fail(RecoverableError, SEC_ERROR_EXPIRED_CERTIFICATE);
+    return Result::ERROR_EXPIRED_CERTIFICATE;
   }
   if (time < notBefore) {
-    return Fail(RecoverableError, SEC_ERROR_EXPIRED_CERTIFICATE);
+    return Result::ERROR_EXPIRED_CERTIFICATE;
   }
 
   PRTime notAfter;
   if (der::TimeChoice(validity, notAfter) != Success) {
-    return Fail(RecoverableError, SEC_ERROR_EXPIRED_CERTIFICATE);
+    return Result::ERROR_EXPIRED_CERTIFICATE;
   }
   if (time > notAfter) {
-    return Fail(RecoverableError, SEC_ERROR_EXPIRED_CERTIFICATE);
+    return Result::ERROR_EXPIRED_CERTIFICATE;
   }
 
   return der::End(validity);
 }
 
 // 4.2.1.3. Key Usage (id-ce-keyUsage)
 
 // As explained in the comment in CheckKeyUsage, bit 0 is the most significant
@@ -73,46 +74,46 @@ CheckKeyUsage(EndEntityOrCA endEntityOrC
               KeyUsage requiredKeyUsageIfPresent)
 {
   if (!encodedKeyUsage) {
     // TODO(bug 970196): Reject certificates that are being used to verify
     // certificate signatures unless the certificate is a trust anchor, to
     // reduce the chances of an end-entity certificate being abused as a CA
     // certificate.
     // if (endEntityOrCA == EndEntityOrCA::MustBeCA && !isTrustAnchor) {
-    //   return Fail(RecoverableError, SEC_ERROR_INADEQUATE_KEY_USAGE);
+    //   return Result::ERROR_INADEQUATE_KEY_USAGE;
     // }
     //
     // TODO: Users may configure arbitrary certificates as trust anchors, not
     // just roots. We should only allow a certificate without a key usage to be
     // used as a CA when it is self-issued and self-signed.
     return Success;
   }
 
   Input input;
   if (input.Init(encodedKeyUsage->data, encodedKeyUsage->len) != Success) {
-    return Fail(RecoverableError, SEC_ERROR_INADEQUATE_KEY_USAGE);
+    return Result::ERROR_INADEQUATE_KEY_USAGE;
   }
   Input value;
   if (der::ExpectTagAndGetValue(input, der::BIT_STRING, value) != Success) {
-    return Fail(RecoverableError, SEC_ERROR_INADEQUATE_KEY_USAGE);
+    return Result::ERROR_INADEQUATE_KEY_USAGE;
   }
 
   uint8_t numberOfPaddingBits;
   if (value.Read(numberOfPaddingBits) != Success) {
-    return Fail(RecoverableError, SEC_ERROR_INADEQUATE_KEY_USAGE);
+    return Result::ERROR_INADEQUATE_KEY_USAGE;
   }
   if (numberOfPaddingBits > 7) {
-    return Fail(RecoverableError, SEC_ERROR_INADEQUATE_KEY_USAGE);
+    return Result::ERROR_INADEQUATE_KEY_USAGE;
   }
 
   uint8_t bits;
   if (value.Read(bits) != Success) {
     // Reject empty bit masks.
-    return Fail(RecoverableError, SEC_ERROR_INADEQUATE_KEY_USAGE);
+    return Result::ERROR_INADEQUATE_KEY_USAGE;
   }
 
   // The most significant bit is numbered 0 (digitalSignature) and the least
   // significant bit is numbered 7 (encipherOnly), and the padding is in the
   // least significant bits of the last byte. The numbering of bits in a byte
   // is backwards from how we usually interpret them.
   //
   // For example, let's say bits is encoded in one byte with of value 0xB0 and
@@ -143,41 +144,41 @@ CheckKeyUsage(EndEntityOrCA endEntityOrC
   //
   // Note that since the KeyUsage enumeration is limited to values 0-7, we
   // only ever need to examine the first byte test for
   // requiredKeyUsageIfPresent.
 
   if (requiredKeyUsageIfPresent != KeyUsage::noParticularKeyUsageRequired) {
     // Check that the required key usage bit is set.
     if ((bits & KeyUsageToBitMask(requiredKeyUsageIfPresent)) == 0) {
-      return Fail(RecoverableError, SEC_ERROR_INADEQUATE_KEY_USAGE);
+      return Result::ERROR_INADEQUATE_KEY_USAGE;
     }
   }
 
   if (endEntityOrCA != EndEntityOrCA::MustBeCA) {
     // RFC 5280 says "The keyCertSign bit is asserted when the subject public
     // key is used for verifying signatures on public key certificates. If the
     // keyCertSign bit is asserted, then the cA bit in the basic constraints
     // extension (Section 4.2.1.9) MUST also be asserted."
     if ((bits & KeyUsageToBitMask(KeyUsage::keyCertSign)) != 0) {
-      return Fail(RecoverableError, SEC_ERROR_INADEQUATE_KEY_USAGE);
+      return Result::ERROR_INADEQUATE_KEY_USAGE;
     }
   }
 
   // The padding applies to the last byte, so skip to the last byte.
   while (!value.AtEnd()) {
     if (value.Read(bits) != Success) {
-      return Fail(RecoverableError, SEC_ERROR_INADEQUATE_KEY_USAGE);
+      return Result::ERROR_INADEQUATE_KEY_USAGE;
     }
   }
 
   // All of the padding bits must be zero, according to DER rules.
   uint8_t paddingMask = static_cast<uint8_t>((1 << numberOfPaddingBits) - 1);
   if ((bits & paddingMask) != 0) {
-    return Fail(RecoverableError, SEC_ERROR_INADEQUATE_KEY_USAGE);
+    return Result::ERROR_INADEQUATE_KEY_USAGE;
   }
 
   return Success;
 }
 
 // RFC5820 4.2.1.4. Certificate Policies
 
 // "The user-initial-policy-set contains the special value any-policy if the
@@ -234,63 +235,63 @@ Result
 CheckCertificatePolicies(EndEntityOrCA endEntityOrCA,
                          const SECItem* encodedCertificatePolicies,
                          const SECItem* encodedInhibitAnyPolicy,
                          TrustLevel trustLevel,
                          const CertPolicyId& requiredPolicy)
 {
   if (requiredPolicy.numBytes == 0 ||
       requiredPolicy.numBytes > sizeof requiredPolicy.bytes) {
-    return Fail(FatalError, SEC_ERROR_INVALID_ARGS);
+    return Result::FATAL_ERROR_INVALID_ARGS;
   }
 
   // Ignore all policy information if the caller indicates any policy is
   // acceptable. See TrustDomain::GetCertTrust and the policy part of
   // BuildCertChain's documentation.
   if (requiredPolicy.IsAnyPolicy()) {
     return Success;
   }
 
   // Bug 989051. Until we handle inhibitAnyPolicy we will fail close when
   // inhibitAnyPolicy extension is present and we need to evaluate certificate
   // policies.
   if (encodedInhibitAnyPolicy) {
-    return Fail(RecoverableError, SEC_ERROR_POLICY_VALIDATION_FAILED);
+    return Result::ERROR_POLICY_VALIDATION_FAILED;
   }
 
   // The root CA certificate may omit the policies that it has been
   // trusted for, so we cannot require the policies to be present in those
   // certificates. Instead, the determination of which roots are trusted for
   // which policies is made by the TrustDomain's GetCertTrust method.
   if (trustLevel == TrustLevel::TrustAnchor &&
       endEntityOrCA == EndEntityOrCA::MustBeCA) {
     return Success;
   }
 
   if (!encodedCertificatePolicies) {
-    return Fail(RecoverableError, SEC_ERROR_POLICY_VALIDATION_FAILED);
+    return Result::ERROR_POLICY_VALIDATION_FAILED;
   }
 
   bool found = false;
 
   Input input;
   if (input.Init(encodedCertificatePolicies->data,
                  encodedCertificatePolicies->len) != Success) {
-    return Fail(RecoverableError, SEC_ERROR_POLICY_VALIDATION_FAILED);
+    return Result::ERROR_POLICY_VALIDATION_FAILED;
   }
   if (der::NestedOf(input, der::SEQUENCE, der::SEQUENCE, der::EmptyAllowed::No,
                     bind(CheckPolicyInformation, _1, endEntityOrCA,
                          requiredPolicy, ref(found))) != Success) {
-    return Fail(RecoverableError, SEC_ERROR_POLICY_VALIDATION_FAILED);
+    return Result::ERROR_POLICY_VALIDATION_FAILED;
   }
   if (der::End(input) != Success) {
-    return Fail(RecoverableError, SEC_ERROR_POLICY_VALIDATION_FAILED);
+    return Result::ERROR_POLICY_VALIDATION_FAILED;
   }
   if (!found) {
-    return Fail(RecoverableError, SEC_ERROR_POLICY_VALIDATION_FAILED);
+    return Result::ERROR_POLICY_VALIDATION_FAILED;
   }
 
   return Success;
 }
 
 static const long UNLIMITED_PATH_LEN = -1; // must be less than zero
 
 //  BasicConstraints ::= SEQUENCE {
@@ -302,25 +303,25 @@ DecodeBasicConstraints(Input& input, /*o
 {
   // TODO(bug 989518): cA is by default false. According to DER, default
   // values must not be explicitly encoded in a SEQUENCE. So, if this
   // value is present and false, it is an encoding error. However, Go Daddy
   // has issued many certificates with this improper encoding, so we can't
   // enforce this yet (hence passing true for allowInvalidExplicitEncoding
   // to der::OptionalBoolean).
   if (der::OptionalBoolean(input, true, isCA) != Success) {
-    return Fail(SEC_ERROR_EXTENSION_VALUE_INVALID);
+    return Result::ERROR_EXTENSION_VALUE_INVALID;
   }
 
   // TODO(bug 985025): If isCA is false, pathLenConstraint MUST NOT
   // be included (as per RFC 5280 section 4.2.1.9), but for compatibility
   // reasons, we don't check this for now.
   if (der::OptionalInteger(input, UNLIMITED_PATH_LEN, pathLenConstraint)
         != Success) {
-    return Fail(SEC_ERROR_EXTENSION_VALUE_INVALID);
+    return Result::ERROR_EXTENSION_VALUE_INVALID;
   }
 
   return Success;
 }
 
 // RFC5280 4.2.1.9. Basic Constraints (id-ce-basicConstraints)
 Result
 CheckBasicConstraints(EndEntityOrCA endEntityOrCA,
@@ -330,25 +331,25 @@ CheckBasicConstraints(EndEntityOrCA endE
 {
   bool isCA = false;
   long pathLenConstraint = UNLIMITED_PATH_LEN;
 
   if (encodedBasicConstraints) {
     Input input;
     if (input.Init(encodedBasicConstraints->data,
                    encodedBasicConstraints->len) != Success) {
-      return Fail(RecoverableError, SEC_ERROR_EXTENSION_VALUE_INVALID);
+      return Result::ERROR_EXTENSION_VALUE_INVALID;
     }
     if (der::Nested(input, der::SEQUENCE,
                     bind(DecodeBasicConstraints, _1, ref(isCA),
                          ref(pathLenConstraint))) != Success) {
-      return Fail(RecoverableError, SEC_ERROR_EXTENSION_VALUE_INVALID);
+      return Result::ERROR_EXTENSION_VALUE_INVALID;
     }
     if (der::End(input) != Success) {
-      return Fail(RecoverableError, SEC_ERROR_EXTENSION_VALUE_INVALID);
+      return Result::ERROR_EXTENSION_VALUE_INVALID;
     }
   } else {
     // "If the basic constraints extension is not present in a version 3
     //  certificate, or the extension is present but the cA boolean is not
     //  asserted, then the certified public key MUST NOT be used to verify
     //  certificate signatures."
     //
     // For compatibility, we must accept v1 trust anchors without basic
@@ -360,102 +361,103 @@ CheckBasicConstraints(EndEntityOrCA endE
       isCA = true;
     }
   }
 
   if (endEntityOrCA == EndEntityOrCA::MustBeEndEntity) {
     // CA certificates are not trusted as EE certs.
 
     if (isCA) {
-      // XXX: We use SEC_ERROR_CA_CERT_INVALID here so we can distinguish
-      // this error from other errors, given that NSS does not have a "CA cert
-      // used as end-entity" error code since it doesn't have such a
+      // TODO(bug 1040446): We use Result::ERROR_CA_CERT_INVALID here so we can
+      // distinguish this error from other errors, given that NSS does not have
+      // a "CA cert used as end-entity" error code since it doesn't have such a
       // prohibition. We should add such an error code and stop abusing
-      // SEC_ERROR_CA_CERT_INVALID this way.
+      // Result::ERROR_CA_CERT_INVALID this way.
       //
       // Note, in particular, that this check prevents a delegated OCSP
       // response signing certificate with the CA bit from successfully
       // validating when we check it from pkixocsp.cpp, which is a good thing.
       //
-      return Fail(RecoverableError, SEC_ERROR_CA_CERT_INVALID);
+      return Result::ERROR_CA_CERT_INVALID;
     }
 
     return Success;
   }
 
   PORT_Assert(endEntityOrCA == EndEntityOrCA::MustBeCA);
 
   // End-entity certificates are not allowed to act as CA certs.
   if (!isCA) {
-    return Fail(RecoverableError, SEC_ERROR_CA_CERT_INVALID);
+    return Result::ERROR_CA_CERT_INVALID;
   }
 
   if (pathLenConstraint >= 0 &&
       static_cast<long>(subCACount) > pathLenConstraint) {
-    return Fail(RecoverableError, SEC_ERROR_PATH_LEN_CONSTRAINT_INVALID);
+    return Result::ERROR_PATH_LEN_CONSTRAINT_INVALID;
   }
 
   return Success;
 }
 
 // 4.2.1.10. Name Constraints
 
 inline void
 PORT_FreeArena_false(PLArenaPool* arena) {
   // PL_FreeArenaPool can't be used because it doesn't actually free the
   // memory, which doesn't work well with memory analysis tools
   return PORT_FreeArena(arena, PR_FALSE);
 }
 
+// TODO: remove #include "pkix/pkixnss.h" when this is rewritten to be
+// independent of NSS.
 Result
 CheckNameConstraints(const SECItem& encodedNameConstraints,
                      const BackCert& firstChild,
                      KeyPurposeId requiredEKUIfPresent)
 {
   ScopedPtr<PLArenaPool, PORT_FreeArena_false>
     arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
   if (!arena) {
-    return MapSECStatus(SECFailure);
+    return Result::FATAL_ERROR_NO_MEMORY;
   }
 
   // Owned by arena
   const CERTNameConstraints* constraints =
     CERT_DecodeNameConstraintsExtension(arena.get(), &encodedNameConstraints);
   if (!constraints) {
-    return MapSECStatus(SECFailure);
+    return MapPRErrorCodeToResult(PR_GetError());
   }
 
   for (const BackCert* child = &firstChild; child; child = child->childCert) {
     ScopedPtr<CERTCertificate, CERT_DestroyCertificate>
       nssCert(CERT_NewTempCertificate(CERT_GetDefaultCertDB(),
                                       const_cast<SECItem*>(&child->GetDER()),
                                       nullptr, false, true));
     if (!nssCert) {
-      return MapSECStatus(SECFailure);
+      return MapPRErrorCodeToResult(PR_GetError());
     }
 
     bool includeCN = child->endEntityOrCA == EndEntityOrCA::MustBeEndEntity &&
                      requiredEKUIfPresent == KeyPurposeId::id_kp_serverAuth;
     // owned by arena
     const CERTGeneralName*
       names(CERT_GetConstrainedCertificateNames(nssCert.get(), arena.get(),
                                                 includeCN));
     if (!names) {
-      return MapSECStatus(SECFailure);
+      return MapPRErrorCodeToResult(PR_GetError());
     }
 
     CERTGeneralName* currentName = const_cast<CERTGeneralName*>(names);
     do {
       if (CERT_CheckNameSpace(arena.get(), constraints, currentName)
             != SECSuccess) {
         // XXX: It seems like CERT_CheckNameSpace doesn't always call
-        // PR_SetError when it fails. We set the error code here, though this
-        // may be papering over some fatal errors. NSS's
-        // cert_VerifyCertChainOld does something similar.
-        return Fail(RecoverableError, SEC_ERROR_CERT_NOT_IN_NAME_SPACE);
+        // PR_SetError when it fails, so we ignore what PR_GetError would
+        // return. NSS's cert_VerifyCertChainOld does something similar.
+        return Result::ERROR_CERT_NOT_IN_NAME_SPACE;
       }
       currentName = CERT_GetNextGeneralName(currentName);
     } while (currentName != names);
   }
 
   return Success;
 }
 
@@ -517,21 +519,21 @@ MatchEKU(Input& value, KeyPurposeId requ
         break;
 
       case KeyPurposeId::id_kp_OCSPSigning:
         match = value.MatchRest(ocsp);
         break;
 
       case KeyPurposeId::anyExtendedKeyUsage:
         PR_NOT_REACHED("anyExtendedKeyUsage should start with found==true");
-        return Fail(SEC_ERROR_LIBRARY_FAILURE);
+        return Result::FATAL_ERROR_LIBRARY_FAILURE;
 
       default:
         PR_NOT_REACHED("unrecognized EKU");
-        return Fail(SEC_ERROR_LIBRARY_FAILURE);
+        return Result::FATAL_ERROR_LIBRARY_FAILURE;
     }
   }
 
   if (match) {
     found = true;
     if (requiredEKU == KeyPurposeId::id_kp_OCSPSigning) {
       foundOCSPSigning = true;
     }
@@ -544,45 +546,45 @@ MatchEKU(Input& value, KeyPurposeId requ
   return Success;
 }
 
 Result
 CheckExtendedKeyUsage(EndEntityOrCA endEntityOrCA,
                       const SECItem* encodedExtendedKeyUsage,
                       KeyPurposeId requiredEKU)
 {
-  // XXX: We're using SEC_ERROR_INADEQUATE_CERT_TYPE here so that callers can
-  // distinguish EKU mismatch from KU mismatch from basic constraints mismatch.
-  // We should probably add a new error code that is more clear for this type
-  // of problem.
+  // XXX: We're using Result::ERROR_INADEQUATE_CERT_TYPE here so that callers
+  // can distinguish EKU mismatch from KU mismatch from basic constraints
+  // mismatch. We should probably add a new error code that is more clear for
+  // this type of problem.
 
   bool foundOCSPSigning = false;
 
   if (encodedExtendedKeyUsage) {
     bool found = requiredEKU == KeyPurposeId::anyExtendedKeyUsage;
 
     Input input;
     if (input.Init(encodedExtendedKeyUsage->data,
                    encodedExtendedKeyUsage->len) != Success) {
-      return Fail(RecoverableError, SEC_ERROR_INADEQUATE_CERT_TYPE);
+      return Result::ERROR_INADEQUATE_CERT_TYPE;
     }
     if (der::NestedOf(input, der::SEQUENCE, der::OIDTag, der::EmptyAllowed::No,
                       bind(MatchEKU, _1, requiredEKU, endEntityOrCA,
                            ref(found), ref(foundOCSPSigning)))
           != Success) {
-      return Fail(RecoverableError, SEC_ERROR_INADEQUATE_CERT_TYPE);
+      return Result::ERROR_INADEQUATE_CERT_TYPE;
     }
     if (der::End(input) != Success) {
-      return Fail(RecoverableError, SEC_ERROR_INADEQUATE_CERT_TYPE);
+      return Result::ERROR_INADEQUATE_CERT_TYPE;
     }
 
     // If the EKU extension was included, then the required EKU must be in the
     // list.
     if (!found) {
-      return Fail(RecoverableError, SEC_ERROR_INADEQUATE_CERT_TYPE);
+      return Result::ERROR_INADEQUATE_CERT_TYPE;
     }
   }
 
   // pkixocsp.cpp depends on the following additional checks.
 
   if (endEntityOrCA == EndEntityOrCA::MustBeEndEntity) {
     // When validating anything other than an delegated OCSP signing cert,
     // reject any cert that also claims to be an OCSP responder, because such
@@ -592,29 +594,29 @@ CheckExtendedKeyUsage(EndEntityOrCA endE
     // That said, we accept CA certificates with id-kp-OCSPSigning because
     // some CAs in Mozilla's CA program have issued such intermediate
     // certificates, and because some CAs have reported some Microsoft server
     // software wrongly requires CA certificates to have id-kp-OCSPSigning.
     // Allowing this exception does not cause any security issues because we
     // require delegated OCSP response signing certificates to be end-entity
     // certificates.
     if (foundOCSPSigning && requiredEKU != KeyPurposeId::id_kp_OCSPSigning) {
-      return Fail(RecoverableError, SEC_ERROR_INADEQUATE_CERT_TYPE);
+      return Result::ERROR_INADEQUATE_CERT_TYPE;
     }
     // http://tools.ietf.org/html/rfc6960#section-4.2.2.2:
     // "OCSP signing delegation SHALL be designated by the inclusion of
     // id-kp-OCSPSigning in an extended key usage certificate extension
     // included in the OCSP response signer's certificate."
     //
     // id-kp-OCSPSigning is the only EKU that isn't implicitly assumed when the
     // EKU extension is missing from an end-entity certificate. However, any CA
     // certificate can issue a delegated OCSP response signing certificate, so
     // we can't require the EKU be explicitly included for CA certificates.
     if (!foundOCSPSigning && requiredEKU == KeyPurposeId::id_kp_OCSPSigning) {
-      return Fail(RecoverableError, SEC_ERROR_INADEQUATE_CERT_TYPE);
+      return Result::ERROR_INADEQUATE_CERT_TYPE;
     }
   }
 
   return Success;
 }
 
 Result
 CheckIssuerIndependentProperties(TrustDomain& trustDomain,
@@ -626,29 +628,28 @@ CheckIssuerIndependentProperties(TrustDo
                                  unsigned int subCACount,
                 /*optional out*/ TrustLevel* trustLevelOut)
 {
   Result rv;
 
   const EndEntityOrCA endEntityOrCA = cert.endEntityOrCA;
 
   TrustLevel trustLevel;
-  rv = MapSECStatus(trustDomain.GetCertTrust(endEntityOrCA, requiredPolicy,
-                                             cert.GetDER(), &trustLevel));
+  rv = trustDomain.GetCertTrust(endEntityOrCA, requiredPolicy, cert.GetDER(),
+                                &trustLevel);
   if (rv != Success) {
     return rv;
   }
   if (trustLevel == TrustLevel::ActivelyDistrusted) {
-    return Fail(RecoverableError, SEC_ERROR_UNTRUSTED_CERT);
+    return Result::ERROR_UNTRUSTED_CERT;
   }
   if (trustLevel != TrustLevel::TrustAnchor &&
       trustLevel != TrustLevel::InheritsTrust) {
     // The TrustDomain returned a trust level that we weren't expecting.
-    PORT_SetError(PR_INVALID_STATE_ERROR);
-    return FatalError;
+    return Result::FATAL_ERROR_INVALID_STATE;
   }
   if (trustLevelOut) {
     *trustLevelOut = trustLevel;
   }
 
   // 4.2.1.1. Authority Key Identifier is ignored (see bug 965136).
 
   // 4.2.1.2. Subject Key Identifier is ignored (see bug 965136).