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

net/quic/test_tools/crypto_test_utils_chromium.cc

Index: net/quic/test_tools/crypto_test_utils_chromium.cc
===================================================================
--- net/quic/test_tools/crypto_test_utils_chromium.cc	(revision 279242)
+++ net/quic/test_tools/crypto_test_utils_chromium.cc	(working copy)
@@ -18,6 +18,8 @@
 
 namespace test {
 
+namespace {
+
 class TestProofVerifierChromium : public ProofVerifierChromium {
  public:
   TestProofVerifierChromium(CertVerifier* cert_verifier,
@@ -36,6 +38,70 @@
   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();
@@ -53,6 +119,21 @@
   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