Allow browser tests to use a MockCertVerifier

net/cert/cert_verifier.h

 // 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.
 
 #ifndef NET_CERT_CERT_VERIFIER_H_
 #define NET_CERT_CERT_VERIFIER_H_
 
 #include <string>
 
 #include "base/macros.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
 
 namespace net {
 
 class BoundNetLog;
+class CertVerifyProc;
 class CertVerifyResult;
 class CRLSet;
 class X509Certificate;
 
 // CertVerifier represents a service for verifying certificates.
 //
 // CertVerifiers can handle multiple requests at a time.
 class NET_EXPORT CertVerifier {
  public:
   class Request {
@@ skipping 41 matching lines @@
     // Note: If VERIFY_CERT_IO_ENABLE is not also supplied, certificates
     // that chain to local trust anchors will likely fail - for example, due to
     // lacking fresh cached revocation issue (Windows) or because OCSP stapling
     // can only provide information for the leaf, and not for any
     // intermediates.
     VERIFY_REV_CHECKING_REQUIRED_LOCAL_ANCHORS = 1 << 4,
   };
 
   // When the verifier is destroyed, all certificate verification requests are
   // canceled, and their completion callbacks will not be called.
-  virtual ~CertVerifier() {}
+  virtual ~CertVerifier();
 
   // Verifies the given certificate against the given hostname as an SSL server.
   // Returns OK if successful or an error code upon failure.
   //
   // The |*verify_result| structure, including the |verify_result->cert_status|
   // bitmask, is always filled out regardless of the return value.  If the
   // certificate has multiple errors, the corresponding status flags are set in
   // |verify_result->cert_status|, and the error code for the most serious
   // error is returned.
   //
@@ skipping 33 matching lines @@
                      const CompletionCallback& callback,
                      scoped_ptr<Request>* out_req,
                      const BoundNetLog& net_log) = 0;
 
   // Returns true if this CertVerifier supports stapled OCSP responses.
   virtual bool SupportsOCSPStapling();
 
   // Creates a CertVerifier implementation that verifies certificates using
   // the preferred underlying cryptographic libraries.
   static CertVerifier* CreateDefault();
+
+  static CertVerifier* CreateWithVerifyProc(CertVerifyProc* cert_verify_proc);

[Ryan Sleevi, 2015/07/09 19:35:28]

Why the need to expose this interface?

I really didn't want CertVerifyProc to be part of the public API people are
fiddling with.

[estark, 2015/07/09 20:14:24]

So I'm trying to use this instead of places where people are constructing new
MultithreadedCertVerifiers themselves (namely
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/io_...,
which already knows about CertVerifyProcs because it's creating one to pass to
the MultithreadedCertVerifier constructor).

+};
+
+// CertVerifierFactory creates CertVerifiers. There is a single global
+// CertVerifierFactory, which allows tests to inject mock verifiers.
+class NET_EXPORT CertVerifierFactory {

[Ryan Sleevi, 2015/07/09 19:35:27]

This is a design I intentionally wanted to avoid as much as possible. Even the
CertVerifier::CreateDefault() is an anti-pattern that I left in because I
couldn't get to all the callsites reasonably to sort this out.

That is, I really don't want us to go the HostResolverProc path, and the factory
is also somewhat squicky.

Is there a thread with the design motivations? Have I just forgotten all
context?

[estark, 2015/07/09 20:11:50]

Email thread with you me and Matt titled "MockCertVerifier". Maybe I
misunderstood what you were suggesting?

+ public:
+  CertVerifierFactory();
+  virtual ~CertVerifierFactory();
+
+  // Creates a new CertVerifier which will use the given
+  // |cert_verify_proc|. Ownership of the returned CertVerifier is
+  // assumed by the caller. The CertVerifier will own the given
+  // |cert_verify_proc|.
+  virtual CertVerifier* CreateCertVerifier(CertVerifyProc* cert_verify_proc);
+
+  // Gets and sets the the global CertVerifierFactory.
+  static CertVerifierFactory* GetCertVerifierFactory();
+  static void SetCertVerifierFactory(CertVerifierFactory* factory);
+
+ private:
+  static CertVerifierFactory* cert_verifier_factory_;

[Ryan Sleevi, 2015/07/09 19:40:26]

There's (generally) no need for such private statics - you can leave them in the
unname namespace of the .cc

+
+  DISALLOW_COPY_AND_ASSIGN(CertVerifierFactory);
 };
 
 }  // namespace net
 
 #endif  // NET_CERT_CERT_VERIFIER_H_