Route OCSP stapling through CertVerifier.

net/cert/cert_verify_proc_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/cert/cert_verify_proc.h"
 
 #include <vector>
 
 #include "base/callback_helpers.h"
 #include "base/files/file_path.h"
@@ skipping 39 matching lines @@
 // for all certificates that are Verified.
 class WellKnownCaCertVerifyProc : public CertVerifyProc {
  public:
   // Initialize a CertVerifyProc that will set
   // |verify_result->is_issued_by_known_root| to |is_well_known|.
   explicit WellKnownCaCertVerifyProc(bool is_well_known)
       : is_well_known_(is_well_known) {}
 
   // CertVerifyProc implementation:
   bool SupportsAdditionalTrustAnchors() const override { return false; }
+  bool SupportsOCSPStapling() const override { return false; }
 
  protected:
   ~WellKnownCaCertVerifyProc() override {}
 
  private:
   int VerifyInternal(X509Certificate* cert,
                      const std::string& hostname,
+                     const std::string& ocsp_response,
                      int flags,
                      CRLSet* crl_set,
                      const CertificateList& additional_trust_anchors,
                      CertVerifyResult* verify_result) override;
 
   const bool is_well_known_;
 
   DISALLOW_COPY_AND_ASSIGN(WellKnownCaCertVerifyProc);
 };
 
 int WellKnownCaCertVerifyProc::VerifyInternal(
     X509Certificate* cert,
     const std::string& hostname,
+    const std::string& ocsp_response,
     int flags,
     CRLSet* crl_set,
     const CertificateList& additional_trust_anchors,
     CertVerifyResult* verify_result) {
   verify_result->is_issued_by_known_root = is_well_known_;
   return OK;
 }
 
 bool SupportsReturningVerifiedChain() {
 #if defined(OS_ANDROID)
@@ skipping 28 matching lines @@
   bool SupportsAdditionalTrustAnchors() {
     return verify_proc_->SupportsAdditionalTrustAnchors();
   }
 
   int Verify(X509Certificate* cert,
              const std::string& hostname,
              int flags,
              CRLSet* crl_set,
              const CertificateList& additional_trust_anchors,
              CertVerifyResult* verify_result) {
-    return verify_proc_->Verify(cert, hostname, flags, crl_set,
+    return verify_proc_->Verify(cert, hostname, std::string(), flags, crl_set,
                                 additional_trust_anchors, verify_result);
   }
 
   const CertificateList empty_cert_list_;
   scoped_refptr<CertVerifyProc> verify_proc_;
 };
 
 TEST_F(CertVerifyProcTest, DISABLED_WithoutRevocationChecking) {
   // Check that verification without revocation checking works.
   CertificateList certs = CreateCertificateListFromFile(
@@ skipping 1466 matching lines @@
   int flags = 0;
   CertVerifyResult verify_result;
   int error = Verify(cert.get(), "127.0.0.1", flags, NULL, empty_cert_list_,
                      &verify_result);
   EXPECT_EQ(ERR_CERT_INVALID, error);
   EXPECT_EQ(CERT_STATUS_INVALID, verify_result.cert_status);
 }
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
 }  // namespace net