Land Recent QUIC changes.

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 "net/quic/crypto/common_cert_set.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/crypto/crypto_server_config.h"
 #include "net/quic/crypto/quic_decrypter.h"
@@ skipping 84 matching lines @@
 
   for (vector<CryptoHandshakeMessage>::const_iterator
        i = crypto_visitor.messages().begin();
        i != crypto_visitor.messages().end(); ++i) {
     dest_stream->OnHandshakeMessage(*i);
   }
 }
 
 }  // anonymous namespace
 
+CryptoTestUtils::FakeClientOptions::FakeClientOptions()
+    : dont_verify_certs(false) {
+}
+
 // static
 void CryptoTestUtils::CommunicateHandshakeMessages(
     PacketSavingConnection* a_conn,
     QuicCryptoStream* a,
     PacketSavingConnection* b_conn,
     QuicCryptoStream* b) {
   size_t a_i = 0, b_i = 0;
   while (!a->handshake_confirmed()) {
     ASSERT_GT(a_conn->packets_.size(), a_i);
     LOG(INFO) << "Processing " << a_conn->packets_.size() - a_i
@@ skipping 13 matching lines @@
 // static
 int CryptoTestUtils::HandshakeWithFakeServer(
     PacketSavingConnection* client_conn,
     QuicCryptoClientStream* client) {
   QuicGuid guid(1);
   IPAddressNumber ip;
   CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip));
   IPEndPoint addr = IPEndPoint(ip, 1);
   PacketSavingConnection* server_conn =
       new PacketSavingConnection(guid, addr, true);
-  TestSession server_session(server_conn, true);
+  TestSession server_session(server_conn, QuicConfig(), true);
 
-  QuicConfig config;
   QuicCryptoServerConfig crypto_config(QuicCryptoServerConfig::TESTING);
   SetupCryptoServerConfigForTest(
       server_session.connection()->clock(),
       server_session.connection()->random_generator(),
-      &config, &crypto_config);
+      server_session.config(), &crypto_config);
 
-  QuicCryptoServerStream server(config, crypto_config, &server_session);
+  QuicCryptoServerStream server(crypto_config, &server_session);
   server_session.SetCryptoStream(&server);
 
   // The client's handshake must have been started already.
   CHECK_NE(0u, client_conn->packets_.size());
 
   CommunicateHandshakeMessages(client_conn, client, server_conn, &server);
 
   CompareClientAndServerKeys(client, &server);
 
   return client->num_sent_client_hellos();
 }
 
 // static
 int CryptoTestUtils::HandshakeWithFakeClient(
     PacketSavingConnection* server_conn,
-    QuicCryptoServerStream* server) {
+    QuicCryptoServerStream* server,
+    const FakeClientOptions& options) {
   QuicGuid guid(1);
   IPAddressNumber ip;
   CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip));
   IPEndPoint addr = IPEndPoint(ip, 1);
   PacketSavingConnection* client_conn =
       new PacketSavingConnection(guid, addr, false);
-  TestSession client_session(client_conn, true);
-  QuicConfig config;
+  TestSession client_session(client_conn, QuicConfig(), false);
   QuicCryptoClientConfig crypto_config;
 
-  config.SetDefaults();
+  client_session.config()->SetDefaults();
   crypto_config.SetDefaults();
   // TODO(rtenneti): Enable testing of ProofVerifier.
-  // crypto_config.SetProofVerifier(ProofVerifierForTesting());
-  QuicCryptoClientStream client("test.example.com", config, &client_session,
+  // if (!options.dont_verify_certs) {
+  //  crypto_config.SetProofVerifier(ProofVerifierForTesting());
+  // }
+  QuicCryptoClientStream client("test.example.com", &client_session,
                                 &crypto_config);
   client_session.SetCryptoStream(&client);
 
   CHECK(client.CryptoConnect());
   CHECK_EQ(1u, client_conn->packets_.size());
 
   CommunicateHandshakeMessages(client_conn, &client, server_conn, server);
 
   CompareClientAndServerKeys(&client, server);
 
   return client.num_sent_client_hellos();
 }
 
 // static
 void CryptoTestUtils::SetupCryptoServerConfigForTest(
     const QuicClock* clock,
     QuicRandom* rand,
     QuicConfig* config,
     QuicCryptoServerConfig* crypto_config) {
   config->SetDefaults();
-  CryptoHandshakeMessage extra_tags;
-  config->ToHandshakeMessage(&extra_tags);
-
   scoped_ptr<CryptoHandshakeMessage> scfg(
       crypto_config->AddDefaultConfig(
-          rand, clock, extra_tags, QuicCryptoServerConfig::kDefaultExpiry));
-  if (!config->SetFromHandshakeMessage(*scfg)) {
-    CHECK(false) << "Crypto config could not be parsed by QuicConfig.";
-  }
+          rand, clock, QuicCryptoServerConfig::kDefaultExpiry));
 }
 
 // static
 string CryptoTestUtils::GetValueForTag(const CryptoHandshakeMessage& message,
                                        QuicTag tag) {
   QuicTagValueMap::const_iterator it = message.tag_value_map().find(tag);
   if (it == message.tag_value_map().end()) {
     return string();
   }
   return it->second;
@@ skipping 49 matching lines @@
     return true;
   }
 
  private:
   const string cert_;
   const uint64 hash_;
   const uint32 index_;
 };
 
 CommonCertSets* CryptoTestUtils::MockCommonCertSets(StringPiece cert,
-                                                   uint64 hash,
-                                                   uint32 index) {
+                                                    uint64 hash,
+                                                    uint32 index) {
   return new class MockCommonCertSets(cert, hash, index);
 }
 
 void CryptoTestUtils::CompareClientAndServerKeys(
     QuicCryptoClientStream* client,
     QuicCryptoServerStream* server) {
   const QuicEncrypter* client_encrypter(
       client->session()->connection()->encrypter(ENCRYPTION_INITIAL));
   const QuicDecrypter* client_decrypter(
       client->session()->connection()->decrypter());
@@ skipping 71 matching lines @@
                                 client_forward_secure_decrypter_key.data(),
                                 client_forward_secure_decrypter_key.length());
   CompareCharArraysWithHexError("server forward secure write IV",
                                 server_forward_secure_encrypter_iv.data(),
                                 server_forward_secure_encrypter_iv.length(),
                                 client_forward_secure_decrypter_iv.data(),
                                 client_forward_secure_decrypter_iv.length());
 }
 }  // namespace test
 }  // namespace net