Certificate Transparency: Change CTVerifyResult to have a single list

net/quic/chromium/crypto/proof_verifier_chromium.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/chromium/crypto/proof_verifier_chromium.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 379 matching lines @@
   const CertStatus cert_status = cert_verify_result.cert_status;
   verify_details_->ct_verify_result.ct_policies_applied = result == OK;
   verify_details_->ct_verify_result.ev_policy_compliance =
       ct::EVPolicyCompliance::EV_POLICY_DOES_NOT_APPLY;
 
   // If the connection was good, check HPKP and CT status simultaneously,
   // but prefer to treat the HPKP error as more serious, if there was one.
   if (enforce_policy_checking_ &&
       (result == OK ||
        (IsCertificateError(result) && IsCertStatusMinorError(cert_status)))) {
+    SCTList verified_scts = ct::SCTsMatchingStatus(
+        verify_details_->ct_verify_result.scts, ct::SCT_STATUS_OK);
     if ((cert_verify_result.cert_status & CERT_STATUS_IS_EV)) {
       ct::EVPolicyCompliance ev_policy_compliance =
           policy_enforcer_->DoesConformToCTEVPolicy(
               cert_verify_result.verified_cert.get(),
-              SSLConfigService::GetEVCertsWhitelist().get(),
-              verify_details_->ct_verify_result.verified_scts, net_log_);
+              SSLConfigService::GetEVCertsWhitelist().get(), verified_scts,
+              net_log_);
       verify_details_->ct_verify_result.ev_policy_compliance =
           ev_policy_compliance;
       if (ev_policy_compliance !=
               ct::EVPolicyCompliance::EV_POLICY_DOES_NOT_APPLY &&
           ev_policy_compliance !=
               ct::EVPolicyCompliance::EV_POLICY_COMPLIES_VIA_WHITELIST &&
           ev_policy_compliance !=
               ct::EVPolicyCompliance::EV_POLICY_COMPLIES_VIA_SCTS) {
         verify_details_->cert_verify_result.cert_status |=
             CERT_STATUS_CT_COMPLIANCE_FAILED;
         verify_details_->cert_verify_result.cert_status &= ~CERT_STATUS_IS_EV;
       }
     }
 
     verify_details_->ct_verify_result.cert_policy_compliance =
         policy_enforcer_->DoesConformToCertPolicy(
-            cert_verify_result.verified_cert.get(),
-            verify_details_->ct_verify_result.verified_scts, net_log_);
+            cert_verify_result.verified_cert.get(), verified_scts, net_log_);
 
     int ct_result = OK;
     if (verify_details_->ct_verify_result.cert_policy_compliance !=
             ct::CertPolicyCompliance::CERT_POLICY_COMPLIES_VIA_SCTS &&
         transport_security_state_->ShouldRequireCT(
             hostname_, cert_verify_result.verified_cert.get(),
             cert_verify_result.public_key_hashes)) {
       verify_details_->cert_verify_result.cert_status |=
           CERT_STATUS_CERTIFICATE_TRANSPARENCY_REQUIRED;
       ct_result = ERR_CERTIFICATE_TRANSPARENCY_REQUIRED;
@@ skipping 179 matching lines @@
     active_jobs_.insert(job.release());
   return status;
 }
 
 void ProofVerifierChromium::OnJobComplete(Job* job) {
   active_jobs_.erase(job);
   delete job;
 }
 
 }  // namespace net