WKWebView: Added cert verification API to web controller.

ios/web/net/cert_verifier_block_adapter.h

 // 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.
 
 #ifndef IOS_WEB_NET_CERT_VERIFIER_BLOCK_ADAPTER_H_
 #define IOS_WEB_NET_CERT_VERIFIER_BLOCK_ADAPTER_H_
 
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
 #include "net/cert/cert_verifier.h"
+#include "net/cert/cert_verify_result.h"
 #include "net/log/net_log.h"
 
 namespace net {
 
-class CertVerifyResult;
 class CRLSet;
 class X509Certificate;
 
 // Provides block-based interface for net::CertVerifier.
 class CertVerifierBlockAdapter {
  public:
-  CertVerifierBlockAdapter();
-  // Constructs adapter with given |CertVerifier| which can not be null.
-  CertVerifierBlockAdapter(scoped_ptr<CertVerifier> cert_verifier);
+  // Constructs adapter with given |CertVerifier| and |NetLog| which can not be
+  // null. CertVerifierBlockAdapter does NOT take ownership over |cert_verifier|
+  // and |net_log|.
+  CertVerifierBlockAdapter(CertVerifier* cert_verifier, NetLog* net_log);
 
   // When the verifier is destroyed, all certificate verification requests are
   // canceled, and their completion handlers will not be called.
   ~CertVerifierBlockAdapter();
 
-  // Encapsulates verification parms. |cert| and |hostname| are mandatory, the
+  // Encapsulates verification params. |cert| and |hostname| are mandatory, the
   // other params are optional. If either of mandatory arguments is null or
   // empty then verification |CompletionHandler| will be called with
   // ERR_INVALID_ARGUMENT status.
   struct Params {
     // Constructs Params from X509 cert and hostname, which are mandatory for
     // verification.
     Params(scoped_refptr<net::X509Certificate> cert,
            const std::string& hostname);
     ~Params();
 
     // Certificate to verify, can not be null.
     scoped_refptr<net::X509Certificate> cert;
 
     // Hostname as an SSL server, can not be empty.
     std::string hostname;
 
     // If non-empty, is a stapled OCSP response to use.
     std::string ocsp_response;
 
     // Bitwise OR of CertVerifier::VerifyFlags.
-    CertVerifier::VerifyFlags flags;
+    int flags;
 
     // An optional CRLSet structure which can be used to avoid revocation checks
     // over the network.
     scoped_refptr<CRLSet> crl_set;
   };
 
-  // Type of verification completion block. On success CertVerifyResult is not
-  // null and status is OK, otherwise CertVerifyResult is null and status is a
-  // net error code.
-  typedef void (^CompletionHandler)(scoped_ptr<CertVerifyResult>, int status);
+  // Type of verification completion block. On success status is OK, otherwise
+  // status is a net error code and CertVerifyResult is not a valid object.
+  typedef void (^CompletionHandler)(CertVerifyResult, int status);
 
   // Verifies certificate with given |params|. |completion_handler| must not be
-  // null and call be called either syncronously (in the same runloop) or
-  // asyncronously.
+  // null and call be called either synchronously (in the same runloop) or
+  // asynchronously.

[Ryan Sleevi, 2015/08/07 21:52:12]

Does this API requirement match SecTrust's?

If the goal is to have these APIs be easily convertable between the two, then it
seems you should try to go for the same guarantees. For example, if
SecTrustEvaluateAsync is always going to return asynchronously, perhaps your
Adapter should handle converting the synchronous results from the CertVerifier
into asynchronous dispatches for consistency.

[Eugene But (OOO till 7-30), 2015/08/12 22:00:38]

SecTrustEvaluateAsync always calls block asynchronously on GCD queue (similar to
thread concept) provided by the caller. Verify always calls block on the same
thread where it was called, however it calls it synchronously in case if result
is retrieved from caches.

In that sense Adapter behavior is different from SecTrustEvaluateAsync. However
I believe it's acceptable tradeoff, because calling Adapter::Verify completion
handler asynchronously on the same thread would add additional performance
overhead and will make code a little bit more complex. WDYT?

   void Verify(const Params& params, CompletionHandler completion_handler);
 
  private:
-  // Underlying CertVerifier.
-  scoped_ptr<CertVerifier> cert_verifier_;
-  // Net Log required by CertVerifier.
+  // Pending verification requests. Request must be alive until verification is
+  // completed, otherwise verification operation will be cancelled.
+  ScopedVector<CertVerifier::Request> pending_requests_;
+  // Underlying unowned CertVerifier.
+  CertVerifier* cert_verifier_;
+  // BoundNetLog required by CertVerifier.
   BoundNetLog net_log_;
 };
 
 }  // net
 
 #endif  // IOS_WEB_NET_CERT_VERIFIER_BLOCK_ADAPTER_H_