Landing Recent QUIC changes until Sat Oct 29 14:59:35.

net/quic/test_tools/crypto_test_utils.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/quic/test_tools/crypto_test_utils.h"
 
 #include <memory>
 
 #include "base/strings/string_util.h"
 #include "crypto/openssl_util.h"
@@ skipping 312 matching lines @@
   }
 
   class ProcessClientHelloCallback : public ProcessClientHelloResultCallback {
    public:
     explicit ProcessClientHelloCallback(FullChloGenerator* generator)
         : generator_(generator) {}
     void Run(
         QuicErrorCode error,
         const string& error_details,
         std::unique_ptr<CryptoHandshakeMessage> message,
-        std::unique_ptr<DiversificationNonce> diversification_nonce) override {
+        std::unique_ptr<DiversificationNonce> diversification_nonce,
+        std::unique_ptr<ProofSource::Details> proof_source_details) override {
       generator_->ProcessClientHelloDone(std::move(message));
     }
 
    private:
     FullChloGenerator* generator_;
   };
 
   std::unique_ptr<ProcessClientHelloCallback> GetProcessClientHelloCallback() {
     return std::unique_ptr<ProcessClientHelloCallback>(
         new ProcessClientHelloCallback(this));
@@ skipping 50 matching lines @@
       new PacketSavingConnection(helper, alarm_factory, Perspective::IS_SERVER,
                                  client_conn->supported_versions());
 
   QuicCryptoServerConfig crypto_config(QuicCryptoServerConfig::TESTING,
                                        QuicRandom::GetInstance(),
                                        ProofSourceForTesting());
   QuicCompressedCertsCache compressed_certs_cache(
       QuicCompressedCertsCache::kQuicCompressedCertsCacheSize);
   SetupCryptoServerConfigForTest(server_conn->clock(),
                                  server_conn->random_generator(),
-                                 server_quic_config, &crypto_config, options);
+                                 &crypto_config, options);
 
   TestQuicSpdyServerSession server_session(server_conn, *server_quic_config,
                                            &crypto_config,
                                            &compressed_certs_cache);
 
   // The client's handshake must have been started already.
   CHECK_NE(0u, client_conn->encrypted_packets_.size());
 
   CommunicateHandshakeMessages(client_conn, client, server_conn,
                                server_session.GetCryptoStream());
@@ skipping 57 matching lines @@
     }
   }
 
   return client_session.GetCryptoStream()->num_sent_client_hellos();
 }
 
 // static
 void CryptoTestUtils::SetupCryptoServerConfigForTest(
     const QuicClock* clock,
     QuicRandom* rand,
-    QuicConfig* config,
     QuicCryptoServerConfig* crypto_config,
     const FakeServerOptions& fake_options) {
   QuicCryptoServerConfig::ConfigOptions options;
   options.channel_id_enabled = true;
   options.token_binding_params = fake_options.token_binding_params;
   std::unique_ptr<CryptoHandshakeMessage> scfg(
       crypto_config->AddDefaultConfig(rand, clock, options));
 }
 
 // static
@@ skipping 72 matching lines @@
 }
 
 uint64_t CryptoTestUtils::LeafCertHashForTesting() {
   scoped_refptr<ProofSource::Chain> chain;
   IPAddress server_ip;
   string sig;
   string cert_sct;
   std::unique_ptr<ProofSource> proof_source(
       CryptoTestUtils::ProofSourceForTesting());
   if (!proof_source->GetProof(server_ip, "", "", AllSupportedVersions().front(),
-                              "", &chain, &sig, &cert_sct) ||
+                              "", QuicTagVector(), &chain, &sig, &cert_sct) ||
       chain->certs.empty()) {
     DCHECK(false) << "Proof generation failed";
     return 0;
   }
 
   return QuicUtils::FNV1a_64_Hash(chain->certs.at(0).c_str(),
                                   chain->certs.at(0).length());
 }
 
 class MockCommonCertSets : public CommonCertSets {
@@ skipping 426 matching lines @@
   // Pass a inchoate CHLO.
   FullChloGenerator generator(crypto_config, server_ip, client_addr, clock,
                               proof, compressed_certs_cache, out);
   crypto_config->ValidateClientHello(
       inchoate_chlo, client_addr.address(), server_ip, version, clock, proof,
       generator.GetValidateClientHelloCallback());
 }
 
 }  // namespace test
 }  // namespace net