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

net/quic/crypto/quic_crypto_client_config_test.cc

 // Copyright 2013 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/crypto/quic_crypto_client_config.h"
 
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/quic_server_id.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/mock_random.h"
@@ skipping 301 matching lines @@
   EXPECT_TRUE(config.LookupOrCreate(canonical_id2)->IsEmpty());
 }
 
 TEST(QuicCryptoClientConfigTest, ClearCachedStates) {
   QuicCryptoClientConfig config(CryptoTestUtils::ProofVerifierForTesting());
   QuicServerId server_id("www.google.com", 80, PRIVACY_MODE_DISABLED);
   QuicCryptoClientConfig::CachedState* state = config.LookupOrCreate(server_id);
   // TODO(rch): Populate other fields of |state|.
   vector<string> certs(1);
   certs[0] = "Hello Cert";
-  state->SetProof(certs, "signature");
+  state->SetProof(certs, "cert_sct", "signature");
   state->set_source_address_token("TOKEN");
   state->SetProofValid();
   EXPECT_EQ(1u, state->generation_counter());
 
   // Verify LookupOrCreate returns the same data.
   QuicCryptoClientConfig::CachedState* other = config.LookupOrCreate(server_id);
 
   EXPECT_EQ(state, other);
   EXPECT_EQ(1u, other->generation_counter());
 
   // Clear the cached states.
   config.ClearCachedStates();
 
   // Verify LookupOrCreate doesn't have any data.
   QuicCryptoClientConfig::CachedState* cleared_cache =
       config.LookupOrCreate(server_id);
 
   EXPECT_EQ(state, cleared_cache);
   EXPECT_FALSE(cleared_cache->proof_valid());
   EXPECT_TRUE(cleared_cache->server_config().empty());
   EXPECT_TRUE(cleared_cache->certs().empty());
+  EXPECT_TRUE(cleared_cache->cert_sct().empty());
   EXPECT_TRUE(cleared_cache->signature().empty());
   EXPECT_EQ(2u, cleared_cache->generation_counter());
 }
 
 // Creates a minimal dummy reject message that will pass the client-config
 // validation tests.
 void FillInDummyReject(CryptoHandshakeMessage* rej, bool reject_is_stateless) {
   if (reject_is_stateless) {
     rej->set_tag(kSREJ);
   } else {
@@ skipping 27 matching lines @@
 
 TEST(QuicCryptoClientConfigTest, ProcessReject) {
   CryptoHandshakeMessage rej;
   FillInDummyReject(&rej, /* stateless */ false);
 
   // Now process the rejection.
   QuicCryptoClientConfig::CachedState cached;
   QuicCryptoNegotiatedParameters out_params;
   string error;
   QuicCryptoClientConfig config(CryptoTestUtils::ProofVerifierForTesting());
-  EXPECT_EQ(QUIC_NO_ERROR, config.ProcessRejection(
-                               rej, QuicWallTime::FromUNIXSeconds(0), &cached,
-                               &out_params, &error));
+  EXPECT_EQ(QUIC_NO_ERROR,
+            config.ProcessRejection(rej, QuicWallTime::FromUNIXSeconds(0),
+                                    QuicSupportedVersions().front(), &cached,
+                                    &out_params, &error));
   EXPECT_FALSE(cached.has_server_designated_connection_id());
   EXPECT_FALSE(cached.has_server_nonce());
 }
 
 TEST(QuicCryptoClientConfigTest, ProcessStatelessReject) {
   // Create a dummy reject message and mark it as stateless.
   CryptoHandshakeMessage rej;
   FillInDummyReject(&rej, /* stateless */ true);
   const QuicConnectionId kConnectionId = 0xdeadbeef;
   const string server_nonce = "SERVER_NONCE";
   rej.SetValue(kRCID, kConnectionId);
   rej.SetStringPiece(kServerNonceTag, server_nonce);
 
   // Now process the rejection.
   QuicCryptoClientConfig::CachedState cached;
   QuicCryptoNegotiatedParameters out_params;
   string error;
   QuicCryptoClientConfig config(CryptoTestUtils::ProofVerifierForTesting());
-  EXPECT_EQ(QUIC_NO_ERROR, config.ProcessRejection(
-                               rej, QuicWallTime::FromUNIXSeconds(0), &cached,
-                               &out_params, &error));
+  EXPECT_EQ(QUIC_NO_ERROR,
+            config.ProcessRejection(rej, QuicWallTime::FromUNIXSeconds(0),
+                                    QuicSupportedVersions().front(), &cached,
+                                    &out_params, &error));
   EXPECT_TRUE(cached.has_server_designated_connection_id());
   EXPECT_EQ(kConnectionId, cached.GetNextServerDesignatedConnectionId());
   EXPECT_EQ(server_nonce, cached.GetNextServerNonce());
 }
 
 TEST(QuicCryptoClientConfigTest, BadlyFormattedStatelessReject) {
   // Create a dummy reject message and mark it as stateless.  Do not
   // add an server-designated connection-id.
   CryptoHandshakeMessage rej;
   FillInDummyReject(&rej, /* stateless */ true);
 
   // Now process the rejection.
   QuicCryptoClientConfig::CachedState cached;
   QuicCryptoNegotiatedParameters out_params;
   string error;
   QuicCryptoClientConfig config(CryptoTestUtils::ProofVerifierForTesting());
-  EXPECT_EQ(
-      QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND,
-      config.ProcessRejection(rej, QuicWallTime::FromUNIXSeconds(0), &cached,
-                              &out_params, &error));
+  EXPECT_EQ(QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND,
+            config.ProcessRejection(rej, QuicWallTime::FromUNIXSeconds(0),
+                                    QuicSupportedVersions().front(), &cached,
+                                    &out_params, &error));
   EXPECT_FALSE(cached.has_server_designated_connection_id());
   EXPECT_EQ("Missing kRCID", error);
 }
 
 TEST(QuicCryptoClientConfigTest, ServerNonceinSHLO_BeforeQ027) {
   // Test that in QUIC_VERSION_26 and lower, the the server does not need to
   // include a nonce in the SHLO.
   CryptoHandshakeMessage msg;
   msg.set_tag(kSHLO);
   // Choose the lowest version.
@@ skipping 33 matching lines @@
   QuicCryptoNegotiatedParameters out_params;
   string error_details;
   EXPECT_EQ(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER,
             config.ProcessServerHello(msg, 0, version, supported_versions,
                                       &cached, &out_params, &error_details));
   EXPECT_EQ("server hello missing server nonce", error_details);
 }
 
 }  // namespace test
 }  // namespace net