net: Implement ChannelIDSourceChromium, which is based on Chromium's

net/quic/test_tools/crypto_test_utils_chromium.cc

 // Copyright 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 "net/quic/test_tools/crypto_test_utils.h"
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert/test_root_certs.h"
 #include "net/cert/x509_certificate.h"
 #include "net/quic/crypto/proof_source_chromium.h"
 #include "net/quic/crypto/proof_verifier_chromium.h"
 #include "net/test/cert_test_util.h"
 
 namespace net {
 
 namespace test {
 
+namespace {
+
 class TestProofVerifierChromium : public ProofVerifierChromium {
  public:
   TestProofVerifierChromium(CertVerifier* cert_verifier,
                             const std::string& cert_file)
       : ProofVerifierChromium(cert_verifier),
         cert_verifier_(cert_verifier) {
     // Load and install the root for the validated chain.
     scoped_refptr<X509Certificate> root_cert =
         ImportCertFromFile(GetTestCertsDirectory(), cert_file);
     scoped_root_.Reset(root_cert.get());
   }
   virtual ~TestProofVerifierChromium() {}
 
  private:
   ScopedTestRoot scoped_root_;
   scoped_ptr<CertVerifier> cert_verifier_;
 };
 
+const char kLeafCert[] = "leaf";
+const char kIntermediateCert[] = "intermediate";
+const char kSignature[] = "signature";
+
+class MockProofSource : public ProofSource {

[Ryan Hamilton, 2014/06/25 18:55:15]

Consider naming these classes "TestFoo" instead of "MockFoo" because when I see
"Mock" I think gmock and expect to be able to say EXPECT_CALL(...). Of course,
these are temporary classes so this is not a terribly big deal.

[wtc, 2014/06/28 16:03:30]

There are many MockFoo classes in src/net that don't use gmock. However, I am
also unhappy with the MockProofSource and MockProofVerifier names. I didn't name
them TestProofSource and TestProofVerifier because those names are reserved for
the full implementation. See the TestProofVerifierChromium class on line 23.

Maybe I can name these HardcodedProofSource and HardcodedProofVerifier? Would
that be too wordy? Perhaps FixedProofSource and FixedProofVerifier? 

[Ryan Hamilton, 2014/06/30 17:47:03]

Fixed sounds great to me!

[wtc, 2014/06/30 19:35:14]

I decided to use "Fake".

+ public:
+  MockProofSource() : certs_(2) {
+    certs_[0] = kLeafCert;
+    certs_[1] = kIntermediateCert;
+  }
+  virtual ~MockProofSource() {}
+
+  // ProofSource interface
+  virtual bool GetProof(const std::string& hostname,
+                        const std::string& server_config,
+                        bool ecdsa_ok,
+                        const std::vector<std::string>** out_certs,
+                        std::string* out_signature) OVERRIDE {
+    *out_certs = &certs_;
+    *out_signature = kSignature;
+    return true;
+  }
+
+ private:
+  std::vector<std::string> certs_;
+  DISALLOW_COPY_AND_ASSIGN(MockProofSource);
+};
+
+class MockProofVerifier : public ProofVerifier {
+ public:
+  MockProofVerifier() {}
+  virtual ~MockProofVerifier() {}
+
+  // ProofVerifier interface
+  virtual QuicAsyncStatus VerifyProof(
+      const std::string& hostname,
+      const std::string& server_config,
+      const std::vector<std::string>& certs,
+      const std::string& signature,
+      const ProofVerifyContext* verify_context,
+      std::string* error_details,
+      scoped_ptr<ProofVerifyDetails>* verify_details,
+      ProofVerifierCallback* callback) OVERRIDE {
+    error_details->clear();
+    scoped_ptr<ProofVerifyDetailsChromium> verify_details_chromium(
+        new ProofVerifyDetailsChromium);
+    if (certs.size() != 2 || certs[0] != kLeafCert ||
+        certs[1] != kIntermediateCert || signature != kSignature) {
+      *error_details = "Invalid proof";
+      verify_details_chromium->cert_verify_result.cert_status =
+          CERT_STATUS_INVALID;
+      *verify_details = verify_details_chromium.Pass();
+      return QUIC_FAILURE;
+    }
+    *verify_details = verify_details_chromium.Pass();
+    return QUIC_SUCCESS;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockProofVerifier);
+};
+
+}  // namespace
+
 // static
 ProofSource* CryptoTestUtils::ProofSourceForTesting() {
   return new ProofSourceChromium();
 }
 
 // static
 ProofVerifier* CryptoTestUtils::ProofVerifierForTesting() {
   TestProofVerifierChromium* proof_verifier = new TestProofVerifierChromium(
       CertVerifier::CreateDefault(), "quic_root.crt");
   return proof_verifier;
 }
 
 // static
 ProofVerifyContext* CryptoTestUtils::ProofVerifyContextForTesting() {
   return new ProofVerifyContextChromium(BoundNetLog());
 }
 
+// static
+ProofSource* CryptoTestUtils::MockProofSourceForTesting() {
+  return new MockProofSource();
+}
+
+// static
+ProofVerifier* CryptoTestUtils::MockProofVerifierForTesting() {
+  return new MockProofVerifier();
+}
+
+// static
+ProofVerifyContext* CryptoTestUtils::MockProofVerifyContextForTesting() {
+  return NULL;
+}
+
 }  // namespace test
 
 }  // namespace net