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 90 matching lines @@
 }
 
 // HexChar parses |c| as a hex character. If valid, it sets |*value| to the
 // value of the hex character and returns true. Otherwise it returns false.
 bool HexChar(char c, uint8* value) {
   if (c >= '0' && c <= '9') {
     *value = c - '0';
     return true;
   }
   if (c >= 'a' && c <= 'f') {
-    *value = c - 'a';
+    *value = c - 'a' + 10;
     return true;
   }
   if (c >= 'A' && c <= 'F') {
-    *value = c - 'A';
+    *value = c - 'A' + 10;
     return true;
   }
   return false;
 }
 
 }  // anonymous namespace
 
 CryptoTestUtils::FakeClientOptions::FakeClientOptions()
-    : dont_verify_certs(false) {
+    : dont_verify_certs(false),
+      channel_id_enabled(false) {
 }
 
 // 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, QuicConfig(), true);
 
-  QuicCryptoServerConfig crypto_config(QuicCryptoServerConfig::TESTING);
+  QuicCryptoServerConfig crypto_config(QuicCryptoServerConfig::TESTING,
+                                       QuicRandom::GetInstance());
   SetupCryptoServerConfigForTest(
       server_session.connection()->clock(),
       server_session.connection()->random_generator(),
       server_session.config(), &crypto_config);
 
   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());
@@ skipping 16 matching lines @@
   IPEndPoint addr = IPEndPoint(ip, 1);
   PacketSavingConnection* client_conn =
       new PacketSavingConnection(guid, addr, false);
   TestSession client_session(client_conn, QuicConfig(), false);
   QuicCryptoClientConfig crypto_config;
 
   client_session.config()->SetDefaults();
   crypto_config.SetDefaults();
   // TODO(rtenneti): Enable testing of ProofVerifier.
   // if (!options.dont_verify_certs) {
-  //  crypto_config.SetProofVerifier(ProofVerifierForTesting());
+  //   crypto_config.SetProofVerifier(ProofVerifierForTesting());
   // }
+  if (options.channel_id_enabled) {
+    crypto_config.SetChannelIDSigner(ChannelIDSignerForTesting());
+  }
   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();
+  QuicCryptoServerConfig::ConfigOptions options;
+  options.channel_id_enabled = true;
   scoped_ptr<CryptoHandshakeMessage> scfg(
-      crypto_config->AddDefaultConfig(
-          rand, clock, QuicCryptoServerConfig::kDefaultExpiry));
+      crypto_config->AddDefaultConfig(rand, clock, options));
 }
 
 // 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()) {
@@ skipping 251 matching lines @@
     }
 
     msg.SetStringPiece(tag, valuestr);
   }
 
   return msg;
 }
 
 }  // namespace test
 }  // namespace net