Rename CertPolicyEnforcer to CTPolicyEnforcer

net/quic/crypto/proof_verifier_chromium_test.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/crypto/proof_verifier_chromium.h"
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_data_directory.h"
-#include "net/cert/cert_policy_enforcer.h"
 #include "net/cert/cert_status_flags.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert/ct_log_verifier.h"
+#include "net/cert/ct_policy_enforcer.h"
 #include "net/cert/ct_serialization.h"
 #include "net/cert/ct_verify_result.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/cert/multi_log_ct_verifier.h"
 #include "net/cert/x509_certificate.h"
 #include "net/http/transport_security_state.h"
 #include "net/log/net_log.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/ct_test_util.h"
@@ skipping 18 matching lines @@
              CRLSet* crl_set,
              CertVerifyResult* verify_result,
              const CompletionCallback& callback,
              scoped_ptr<CertVerifier::Request>* out_req,
              const BoundNetLog& net_log) override {
     ADD_FAILURE() << "CertVerifier::Verify() should not be called";
     return ERR_FAILED;
   }
 };
 
-// CertPolicyEnforcer that will fail the test if it is ever called.
-class FailsTestCertPolicyEnforcer : public CertPolicyEnforcer {
+// CTPolicyEnforcer that will fail the test if it is ever called.
+class FailsTestCTPolicyEnforcer : public CTPolicyEnforcer {
  public:
-  FailsTestCertPolicyEnforcer() {}
-  ~FailsTestCertPolicyEnforcer() override {}
+  FailsTestCTPolicyEnforcer() {}
+  ~FailsTestCTPolicyEnforcer() override {}
 
   bool DoesConformToCTEVPolicy(X509Certificate* cert,
                                const ct::EVCertsWhitelist* ev_whitelist,
                                const ct::CTVerifyResult& ct_result,
                                const BoundNetLog& net_log) override {
-    ADD_FAILURE() << "CertPolicyEnforcer::DoesConformToCTEVPolicy() should "
+    ADD_FAILURE() << "CTPolicyEnforcer::DoesConformToCTEVPolicy() should "
                   << "not be called";
     return false;
   }
 };
 
-// CertPolicyEnforcer that can simulate whether or not a given certificate
+// CTPolicyEnforcer that can simulate whether or not a given certificate
 // conforms to the CT/EV policy.
-class MockCertPolicyEnforcer : public CertPolicyEnforcer {
+class MockCTPolicyEnforcer : public CTPolicyEnforcer {
  public:
-  MockCertPolicyEnforcer(bool is_ev) : is_ev_(is_ev) {}
-  ~MockCertPolicyEnforcer() override {}
+  MockCTPolicyEnforcer(bool is_ev) : is_ev_(is_ev) {}
+  ~MockCTPolicyEnforcer() override {}
 
   bool DoesConformToCTEVPolicy(X509Certificate* cert,
                                const ct::EVCertsWhitelist* ev_whitelist,
                                const ct::CTVerifyResult& ct_result,
                                const BoundNetLog& net_log) override {
     return is_ev_;
   }
 
  private:
   bool is_ev_;
@@ skipping 251 matching lines @@
   scoped_refptr<X509Certificate> test_cert = GetTestServerCertificate();
   ASSERT_TRUE(test_cert);
 
   CertVerifyResult dummy_result;
   dummy_result.verified_cert = test_cert;
   dummy_result.cert_status = CERT_STATUS_IS_EV;
 
   MockCertVerifier dummy_verifier;
   dummy_verifier.AddResultForCert(test_cert.get(), dummy_result, OK);
 
-  MockCertPolicyEnforcer policy_enforcer(true /*is_ev*/);
+  MockCTPolicyEnforcer policy_enforcer(true /*is_ev*/);
 
   ProofVerifierChromium proof_verifier(&dummy_verifier, &policy_enforcer,
                                        nullptr, ct_verifier_.get());
 
   scoped_ptr<DummyProofVerifierCallback> callback(
       new DummyProofVerifierCallback);
   QuicAsyncStatus status = proof_verifier.VerifyProof(
       kTestHostname, kTestConfig, certs_, "", GetTestSignature(),
       verify_context_.get(), &error_details_, &details_, callback.get());
   ASSERT_EQ(QUIC_SUCCESS, status);
@@ skipping 11 matching lines @@
   scoped_refptr<X509Certificate> test_cert = GetTestServerCertificate();
   ASSERT_TRUE(test_cert);
 
   CertVerifyResult dummy_result;
   dummy_result.verified_cert = test_cert;
   dummy_result.cert_status = CERT_STATUS_IS_EV;
 
   MockCertVerifier dummy_verifier;
   dummy_verifier.AddResultForCert(test_cert.get(), dummy_result, OK);
 
-  MockCertPolicyEnforcer policy_enforcer(false /*is_ev*/);
+  MockCTPolicyEnforcer policy_enforcer(false /*is_ev*/);
 
   ProofVerifierChromium proof_verifier(&dummy_verifier, &policy_enforcer,
                                        nullptr, ct_verifier_.get());
 
   scoped_ptr<DummyProofVerifierCallback> callback(
       new DummyProofVerifierCallback);
   QuicAsyncStatus status = proof_verifier.VerifyProof(
       kTestHostname, kTestConfig, certs_, "", GetTestSignature(),
       verify_context_.get(), &error_details_, &details_, callback.get());
   ASSERT_EQ(QUIC_SUCCESS, status);
@@ skipping 12 matching lines @@
   scoped_refptr<X509Certificate> test_cert = GetTestServerCertificate();
   ASSERT_TRUE(test_cert);
 
   CertVerifyResult dummy_result;
   dummy_result.verified_cert = test_cert;
   dummy_result.cert_status = 0;
 
   MockCertVerifier dummy_verifier;
   dummy_verifier.AddResultForCert(test_cert.get(), dummy_result, OK);
 
-  FailsTestCertPolicyEnforcer policy_enforcer;
+  FailsTestCTPolicyEnforcer policy_enforcer;
 
   ProofVerifierChromium proof_verifier(&dummy_verifier, &policy_enforcer,
                                        nullptr, ct_verifier_.get());
 
   scoped_ptr<DummyProofVerifierCallback> callback(
       new DummyProofVerifierCallback);
   QuicAsyncStatus status = proof_verifier.VerifyProof(
       kTestHostname, kTestConfig, certs_, "", GetTestSignature(),
       verify_context_.get(), &error_details_, &details_, callback.get());
   ASSERT_EQ(QUIC_SUCCESS, status);
 
   ASSERT_TRUE(details_.get());
   ProofVerifyDetailsChromium* verify_details =
       static_cast<ProofVerifyDetailsChromium*>(details_.get());
   EXPECT_EQ(0u, verify_details->cert_verify_result.cert_status);
 }
 
 }  // namespace test
 }  // namespace net