Landing Recent QUIC changes until 2015-11-09 20:32 UTC

net/tools/quic/test_tools/quic_test_client.cc

 // 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.
 
 #include "net/tools/quic/test_tools/quic_test_client.h"
 
 #include "base/time/time.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_verify_result.h"
@@ skipping 28 matching lines @@
 namespace {
 
 // RecordingProofVerifier accepts any certificate chain and records the common
 // name of the leaf.
 class RecordingProofVerifier : public ProofVerifier {
  public:
   // ProofVerifier interface.
   QuicAsyncStatus VerifyProof(const string& hostname,
                               const string& server_config,
                               const vector<string>& certs,
+                              const string& cert_sct,
                               const string& signature,
                               const ProofVerifyContext* context,
                               string* error_details,
                               scoped_ptr<ProofVerifyDetails>* details,
                               ProofVerifierCallback* callback) override {
     common_name_.clear();
     if (certs.empty()) {
       return QUIC_FAILURE;
     }
 
     // Convert certs to X509Certificate.
     vector<StringPiece> cert_pieces(certs.size());
     for (unsigned i = 0; i < certs.size(); i++) {
       cert_pieces[i] = StringPiece(certs[i]);
     }
     // TODO(rtenneti): Fix after adding support for real certs. Currently,
     // cert_pieces are "leaf" and "intermediate" and CreateFromDERCertChain
     // fails to return cert from these cert_pieces.
     //    scoped_refptr<net::X509Certificate> cert =
     //        net::X509Certificate::CreateFromDERCertChain(cert_pieces);
     //    if (!cert.get()) {
     //      return QUIC_FAILURE;
     //    }
     //
     //    common_name_ = cert->subject().GetDisplayName();
+    cert_sct_ = cert_sct;
+
     return QUIC_SUCCESS;
   }
 
   const string& common_name() const { return common_name_; }
 
+  const string& cert_sct() const { return cert_sct_; }
+
  private:
   string common_name_;
+  string cert_sct_;
 };
 
 }  // anonymous namespace
 
 BalsaHeaders* MungeHeaders(const BalsaHeaders* const_headers) {
   StringPiece uri = const_headers->request_uri();
   if (uri.empty()) {
     return nullptr;
   }
   if (const_headers->request_method() == "CONNECT") {
@@ skipping 289 matching lines @@
   return client()->connection_error();
 }
 
 MockableQuicClient* QuicTestClient::client() { return client_.get(); }
 
 const string& QuicTestClient::cert_common_name() const {
   return reinterpret_cast<RecordingProofVerifier*>(client_->proof_verifier())
       ->common_name();
 }
 
+const string& QuicTestClient::cert_sct() const {
+  return reinterpret_cast<RecordingProofVerifier*>(client_->proof_verifier())
+      ->cert_sct();
+}
+
 QuicTagValueMap QuicTestClient::GetServerConfig() const {
   QuicCryptoClientConfig* config = client_->crypto_config();
   QuicCryptoClientConfig::CachedState* state =
       config->LookupOrCreate(client_->server_id());
   const CryptoHandshakeMessage* handshake_msg = state->GetServerConfig();
   if (handshake_msg != nullptr) {
     return handshake_msg->tag_value_map();
   } else {
     return QuicTagValueMap();
   }
@@ skipping 215 matching lines @@
   message->headers()->SetRequestVersion(
       HTTPMessage::VersionToString(HttpConstants::HTTP_1_1));
   message->headers()->SetRequestMethod(
       HTTPMessage::MethodToString(HttpConstants::GET));
   message->headers()->SetRequestUri(uri);
 }
 
 }  // namespace test
 }  // namespace tools
 }  // namespace net