net: make QUIC ProofVerifier more generic.

net/quic/crypto/proof_test.cc

 // Copyright (c) 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 "base/files/file_path.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/cert_status_flags.h"
 #include "net/cert/cert_verify_result.h"
@@ skipping 70 matching lines @@
   }
   rv = verifier->VerifyProof("foo.com", server_config, wrong_certs, signature,
                              &error_details, &cert_verify_result,
                              callback.callback());
   rv = callback.GetResult(rv);
   ASSERT_EQ(ERR_FAILED, rv);
   ASSERT_NE("", error_details);
 #endif  // 0
 }
 
+// TestProofVerifierCallback is a simple callback for a ProofVerifier that
+// signals a TestCompletionCallback when called and stores the results from the
+// ProofVerifier in pointers passed to the constructor.
+class TestProofVerifierCallback : public ProofVerifierCallback {
+ public:
+  TestProofVerifierCallback(TestCompletionCallback* comp_callback,
+                            bool* ok,
+                            std::string* error_details)
+      : comp_callback_(comp_callback),
+        ok_(ok),
+        error_details_(error_details) {}
+
+  virtual void Run(bool ok,
+                   const std::string& error_details,
+                   scoped_ptr<ProofVerifyDetails>* details) OVERRIDE {
+    *ok_ = ok;
+    *error_details_ = error_details;
+
+    comp_callback_->callback().Run(0);
+  }
+
+ private:
+  TestCompletionCallback* const comp_callback_;
+  bool* const ok_;
+  std::string* const error_details_;
+};
+
+// RunVerification runs |verifier->VerifyProof| and asserts that the result
+// matches |expected_ok|.
+static void RunVerification(ProofVerifier* verifier,
+                            const std::string& hostname,
+                            const std::string& server_config,
+                            const vector<std::string>& certs,
+                            const std::string& proof,
+                            bool expected_ok) {
+  scoped_ptr<ProofVerifyDetails> details;
+  TestCompletionCallback comp_callback;
+  bool ok;
+  std::string error_details;
+  TestProofVerifierCallback* callback =
+      new TestProofVerifierCallback(&comp_callback, &ok, &error_details);
+
+  ProofVerifier::Status status = verifier->VerifyProof(
+      hostname, server_config, certs, proof, &error_details, &details,
+      callback);
+
+  switch (status) {
+    case ProofVerifier::FAILURE:
+      ASSERT_FALSE(expected_ok);
+      ASSERT_NE("", error_details);
+      return;
+    case ProofVerifier::SUCCESS:
+      ASSERT_TRUE(expected_ok);
+      ASSERT_EQ("", error_details);
+      return;
+    case ProofVerifier::PENDING:
+      comp_callback.WaitForResult();
+      ASSERT_EQ(expected_ok, ok);
+      break;
+  }
+}
+
 static string PEMCertFileToDER(const string& file_name) {
   base::FilePath certs_dir = GetTestCertsDirectory();
   scoped_refptr<X509Certificate> cert =
       ImportCertFromFile(certs_dir, file_name);
   CHECK_NE(static_cast<X509Certificate*>(NULL), cert);
 
   string der_bytes;
   CHECK(X509Certificate::GetDEREncoded(cert->os_cert_handle(), &der_bytes));
   return der_bytes;
 }
@@ skipping 118 matching lines @@
   vector<string> signatures(3);
   signatures[0].assign(reinterpret_cast<const char*>(signature_data_0),
                        sizeof(signature_data_0));
   signatures[1].assign(reinterpret_cast<const char*>(signature_data_1),
                        sizeof(signature_data_1));
   signatures[2].assign(reinterpret_cast<const char*>(signature_data_2),
                        sizeof(signature_data_2));
 
   for (size_t i = 0; i < signatures.size(); i++) {
     const string& signature = signatures[i];
-    int rv;
-    TestCompletionCallback callback;
-    rv = verifier->VerifyProof(hostname, server_config, certs, signature,
-                               &error_details, &cert_verify_result,
-                               callback.callback());
-    rv = callback.GetResult(rv);
-    ASSERT_EQ(OK, rv);
-    ASSERT_EQ("", error_details);
-    ASSERT_FALSE(IsCertStatusError(cert_verify_result.cert_status));
 
-    rv = verifier->VerifyProof("foo.com", server_config, certs, signature,
-                               &error_details, &cert_verify_result,
-                               callback.callback());
-    rv = callback.GetResult(rv);
-    ASSERT_EQ(ERR_FAILED, rv);
-    ASSERT_NE("", error_details);
-
-    rv = verifier->VerifyProof(hostname, server_config.substr(1, string::npos),
-                               certs, signature, &error_details,
-                               &cert_verify_result, callback.callback());
-    rv = callback.GetResult(rv);
-    ASSERT_EQ(ERR_FAILED, rv);
-    ASSERT_NE("", error_details);
+    RunVerification(
+        verifier.get(), hostname, server_config, certs, signature, true);

[ramant (doing other things), 2013/07/29 17:04:24]

nit: I was shy to ask this before. Is it good to test cert_verify_result in
these tests?

IMO, these unit tests cover getting the data from cache (synchronously),
asynchronously.

 ASSERT_FALSE(IsCertStatusError(cert_verify_result.cert_status));

+    RunVerification(
+        verifier.get(), "foo.com", server_config, certs, signature, false);
+    RunVerification(
+        verifier.get(), hostname, server_config.substr(1, string::npos),
+        certs, signature, false);
 
     const string corrupt_signature = "1" + signature;
-    rv = verifier->VerifyProof(hostname, server_config, certs,
-                               corrupt_signature, &error_details,
-                               &cert_verify_result, callback.callback());
-    rv = callback.GetResult(rv);
-    ASSERT_EQ(ERR_FAILED, rv);
-    ASSERT_NE("", error_details);
+    RunVerification(
+        verifier.get(), hostname, server_config, certs, corrupt_signature,
+        false);
 
     vector<string> wrong_certs;
     for (size_t i = 1; i < certs.size(); i++) {
       wrong_certs.push_back(certs[i]);
     }
-    rv = verifier->VerifyProof("foo.com", server_config, wrong_certs, signature,
-                               &error_details, &cert_verify_result,
-                               callback.callback());
-    rv = callback.GetResult(rv);
-    ASSERT_EQ(ERR_FAILED, rv);
-    ASSERT_NE("", error_details);
+    RunVerification(verifier.get(), hostname, server_config, wrong_certs,
+                    signature, false);
   }
 }
 
 // A known answer test that allows us to test ProofVerifier without a working
 // ProofSource.
 // TODO(rtenneti): Enable VerifyECDSAKnownAnswerTest on Windows. Disabled this
 // test because X509Certificate::GetPublicKeyInfo is not returning the correct
 // type for ECDSA certificates.
 #if defined(OS_WIN)
 #define MAYBE_VerifyECDSAKnownAnswerTest DISABLED_VerifyECDSAKnownAnswerTest
@@ skipping 51 matching lines @@
   vector<string> signatures(3);
   signatures[0].assign(reinterpret_cast<const char*>(signature_data_0),
                        sizeof(signature_data_0));
   signatures[1].assign(reinterpret_cast<const char*>(signature_data_1),
                        sizeof(signature_data_1));
   signatures[2].assign(reinterpret_cast<const char*>(signature_data_2),
                        sizeof(signature_data_2));
 
   for (size_t i = 0; i < signatures.size(); i++) {
     const string& signature = signatures[i];
-    int rv;
-    TestCompletionCallback callback;
-    rv = verifier->VerifyProof(hostname, server_config, certs, signature,
-                               &error_details, &cert_verify_result,
-                               callback.callback());
-    rv = callback.GetResult(rv);
-    ASSERT_EQ(OK, rv);
-    ASSERT_EQ("", error_details);
-    ASSERT_FALSE(IsCertStatusError(cert_verify_result.cert_status));
 
-    rv = verifier->VerifyProof("foo.com", server_config, certs, signature,
-                               &error_details, &cert_verify_result,
-                               callback.callback());
-    rv = callback.GetResult(rv);
-    ASSERT_EQ(ERR_FAILED, rv);
-    ASSERT_NE("", error_details);
-
-    rv = verifier->VerifyProof(hostname, server_config.substr(1, string::npos),
-                               certs, signature, &error_details,
-                               &cert_verify_result, callback.callback());
-    rv = callback.GetResult(rv);
-    ASSERT_EQ(ERR_FAILED, rv);
-    ASSERT_NE("", error_details);
+    RunVerification(
+        verifier.get(), hostname, server_config, certs, signature, true);
+    RunVerification(
+        verifier.get(), "foo.com", server_config, certs, signature, false);
+    RunVerification(
+        verifier.get(), hostname, server_config.substr(1, string::npos),
+        certs, signature, false);
 
     // An ECDSA signature is DER-encoded. Corrupt the last byte so that the
     // signature can still be DER-decoded correctly.
     string corrupt_signature = signature;
     corrupt_signature[corrupt_signature.size() - 1] += 1;
-    rv = verifier->VerifyProof(hostname, server_config, certs,
-                               corrupt_signature, &error_details,
-                               &cert_verify_result, callback.callback());
-    rv = callback.GetResult(rv);
-    ASSERT_EQ(ERR_FAILED, rv);
-    ASSERT_NE("", error_details);
+    RunVerification(
+        verifier.get(), hostname, server_config, certs, corrupt_signature,
+        false);
 
     // Prepending a "1" makes the DER invalid.
     const string bad_der_signature1 = "1" + signature;
-    rv = verifier->VerifyProof(hostname, server_config, certs,
-                               bad_der_signature1, &error_details,
-                               &cert_verify_result, callback.callback());
-    rv = callback.GetResult(rv);
-    ASSERT_EQ(ERR_FAILED, rv);
-    ASSERT_NE("", error_details);
+    RunVerification(
+        verifier.get(), hostname, server_config, certs, bad_der_signature1,
+        false);
 
     vector<string> wrong_certs;
     for (size_t i = 1; i < certs.size(); i++) {
       wrong_certs.push_back(certs[i]);
     }
-    rv = verifier->VerifyProof("foo.com", server_config, wrong_certs, signature,
-                               &error_details, &cert_verify_result,
-                               callback.callback());
-    rv = callback.GetResult(rv);
-    ASSERT_EQ(ERR_FAILED, rv);
-    ASSERT_NE("", error_details);
+    RunVerification(
+        verifier.get(), hostname, server_config, wrong_certs, signature, false);
   }
 }
 
 }  // namespace test
 }  // namespace net