Landing Recent QUIC changes until 4/22/2016 14:55 UTC

net/quic/crypto/quic_crypto_server_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_server_config.h"
 
 #include <stdarg.h>
 
 #include <memory>
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
 #include "net/quic/crypto/cert_compressor.h"
-#include "net/quic/crypto/chacha20_poly1305_rfc7539_encrypter.h"
+#include "net/quic/crypto/chacha20_poly1305_encrypter.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
 #include "net/quic/crypto/crypto_secret_boxer.h"
 #include "net/quic/crypto/crypto_server_config_protobuf.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/crypto/strike_register_client.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_time.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/quic_test_utils.h"
@@ skipping 214 matching lines @@
   std::unique_ptr<CryptoHandshakeMessage> message(server.AddDefaultConfig(
       rand, &clock, QuicCryptoServerConfig::ConfigOptions()));
 
   // The default configuration should have AES-GCM and at least one ChaCha20
   // cipher.
   const QuicTag* aead_tags;
   size_t aead_len;
   ASSERT_EQ(QUIC_NO_ERROR, message->GetTaglist(kAEAD, &aead_tags, &aead_len));
   vector<QuicTag> aead(aead_tags, aead_tags + aead_len);
   EXPECT_THAT(aead, ::testing::Contains(kAESG));
-  if (ChaCha20Poly1305Rfc7539Encrypter::IsSupported()) {
-    EXPECT_LE(2u, aead.size());
-  } else {
-    EXPECT_LE(1u, aead.size());
-  }
+  EXPECT_LE(1u, aead.size());
 }
 
 TEST(QuicCryptoServerConfigTest, ServerConfigDisableChaCha) {
   ValueRestore<bool> old_flag(
       &FLAGS_quic_crypto_server_config_default_has_chacha20, false);
   QuicRandom* rand = QuicRandom::GetInstance();
   QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand,
                                 CryptoTestUtils::ProofSourceForTesting());
   MockClock clock;
 
@@ skipping 33 matching lines @@
   QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand,
                                 CryptoTestUtils::ProofSourceForTesting());
   QuicCryptoServerConfigPeer peer(&server);
 
   vector<string> certs = {"testcert"};
   scoped_refptr<ProofSource::Chain> chain(new ProofSource::Chain(certs));
 
   string compressed =
       peer.CompressChain(&compressed_certs_cache, chain, "", "", nullptr);
 
-  if (FLAGS_quic_use_cached_compressed_certs) {
-    EXPECT_EQ(compressed_certs_cache.Size(), 1u);
-  } else {
-    EXPECT_EQ(compressed_certs_cache.Size(), 0u);
-  }
+  EXPECT_EQ(compressed_certs_cache.Size(), 1u);
 }
 
 TEST(QuicCryptoServerConfigTest, CompressSameCertsTwice) {
   QuicCompressedCertsCache compressed_certs_cache(
       QuicCompressedCertsCache::kQuicCompressedCertsCacheSize);
 
   QuicRandom* rand = QuicRandom::GetInstance();
   QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand,
                                 CryptoTestUtils::ProofSourceForTesting());
   QuicCryptoServerConfigPeer peer(&server);
 
   // Compress the certs for the first time.
   vector<string> certs = {"testcert"};
   scoped_refptr<ProofSource::Chain> chain(new ProofSource::Chain(certs));
   string common_certs = "";
   string cached_certs = "";
 
   string compressed = peer.CompressChain(&compressed_certs_cache, chain,
                                          common_certs, cached_certs, nullptr);
-  if (FLAGS_quic_use_cached_compressed_certs) {
-    EXPECT_EQ(compressed_certs_cache.Size(), 1u);
-  }
+  EXPECT_EQ(compressed_certs_cache.Size(), 1u);
 
   // Compress the same certs, should use cache if available.
   string compressed2 = peer.CompressChain(&compressed_certs_cache, chain,
                                           common_certs, cached_certs, nullptr);
   EXPECT_EQ(compressed, compressed2);
-  if (FLAGS_quic_use_cached_compressed_certs) {
-    EXPECT_EQ(compressed_certs_cache.Size(), 1u);
-  }
+  EXPECT_EQ(compressed_certs_cache.Size(), 1u);
 }
 
 TEST(QuicCryptoServerConfigTest, CompressDifferentCerts) {
   // This test compresses a set of similar but not identical certs. Cache if
   // used should return cache miss and add all the compressed certs.
   QuicCompressedCertsCache compressed_certs_cache(
       QuicCompressedCertsCache::kQuicCompressedCertsCacheSize);
 
   QuicRandom* rand = QuicRandom::GetInstance();
   QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand,
                                 CryptoTestUtils::ProofSourceForTesting());
   QuicCryptoServerConfigPeer peer(&server);
 
   vector<string> certs = {"testcert"};
   scoped_refptr<ProofSource::Chain> chain(new ProofSource::Chain(certs));
   string common_certs = "";
   string cached_certs = "";
 
   string compressed = peer.CompressChain(&compressed_certs_cache, chain,
                                          common_certs, cached_certs, nullptr);
-  if (FLAGS_quic_use_cached_compressed_certs) {
-    EXPECT_EQ(compressed_certs_cache.Size(), 1u);
-  }
+  EXPECT_EQ(compressed_certs_cache.Size(), 1u);
 
   // Compress a similar certs which only differs in the chain.
   scoped_refptr<ProofSource::Chain> chain2(new ProofSource::Chain(certs));
 
   string compressed2 = peer.CompressChain(&compressed_certs_cache, chain2,
                                           common_certs, cached_certs, nullptr);
-  if (FLAGS_quic_use_cached_compressed_certs) {
-    EXPECT_EQ(compressed_certs_cache.Size(), 2u);
-  }
+  EXPECT_EQ(compressed_certs_cache.Size(), 2u);
 
   // Compress a similar certs which only differs in common certs field.
   static const uint64_t set_hash = 42;
   std::unique_ptr<CommonCertSets> common_sets(
       CryptoTestUtils::MockCommonCertSets(certs[0], set_hash, 1));
   StringPiece different_common_certs(reinterpret_cast<const char*>(&set_hash),
                                      sizeof(set_hash));
   string compressed3 = peer.CompressChain(&compressed_certs_cache, chain,
                                           different_common_certs.as_string(),
                                           cached_certs, common_sets.get());
-  if (FLAGS_quic_use_cached_compressed_certs) {
-    EXPECT_EQ(compressed_certs_cache.Size(), 3u);
-  }
+  EXPECT_EQ(compressed_certs_cache.Size(), 3u);
 }
 
 class SourceAddressTokenTest : public ::testing::Test {
  public:
   SourceAddressTokenTest()
       : ip4_(Loopback4()),
         ip4_dual_(ConvertIPv4ToIPv4MappedIPv6(ip4_)),
         ip6_(Loopback6()),
         original_time_(QuicWallTime::Zero()),
         rand_(QuicRandom::GetInstance()),
@@ skipping 379 matching lines @@
 TEST_F(CryptoServerConfigsTest, InvalidConfigs) {
   // Ensure that invalid configs don't change anything.
   SetConfigs("a", 800, 1, "b", 900, 1, "c", 1100, 1, nullptr);
   test_peer_.CheckConfigs("a", false, "b", true, "c", false, nullptr);
   SetConfigs("a", 800, 1, "c", 1100, 1, "INVALID1", 1000, 1, nullptr);
   test_peer_.CheckConfigs("a", false, "b", true, "c", false, nullptr);
 }
 
 }  // namespace test
 }  // namespace net