Landing Recent QUIC changes until 5:30 PM, Feb 3, 2017 UTC-5

net/tools/quic/stateless_rejector_test.cc

 // Copyright 2016 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/tools/quic/stateless_rejector.h"
 
 #include <memory>
 #include <vector>
 
 #include "net/quic/core/crypto/crypto_handshake_message.h"
@@ skipping 56 matching lines @@
       param.flags = flags;
       params.push_back(param);
     }
   }
   return params;
 }
 
 class StatelessRejectorTest : public ::testing::TestWithParam<TestParams> {
  public:
   StatelessRejectorTest()
-      : proof_source_(CryptoTestUtils::ProofSourceForTesting()),
+      : proof_source_(crypto_test_utils::ProofSourceForTesting()),
         config_(QuicCryptoServerConfig::TESTING,
                 QuicRandom::GetInstance(),
-                CryptoTestUtils::ProofSourceForTesting()),
+                crypto_test_utils::ProofSourceForTesting()),
         config_peer_(&config_),
         compressed_certs_cache_(
             QuicCompressedCertsCache::kQuicCompressedCertsCacheSize),
         rejector_(QuicMakeUnique<StatelessRejector>(
             GetParam().version,
             AllSupportedVersions(),
             &config_,
             &compressed_certs_cache_,
             &clock_,
             QuicRandom::GetInstance(),
@@ skipping 72 matching lines @@
   string stk_hex_;
 };
 
 INSTANTIATE_TEST_CASE_P(Flags,
                         StatelessRejectorTest,
                         ::testing::ValuesIn(GetTestParams()),
                         TestParamToString);
 
 TEST_P(StatelessRejectorTest, InvalidChlo) {
   // clang-format off
-  const CryptoHandshakeMessage client_hello = CryptoTestUtils::Message(
-      "CHLO",
-      "PDMD", "X509",
-      "COPT", "SREJ",
-      nullptr);
+  const CryptoHandshakeMessage client_hello = crypto_test_utils::CreateCHLO(
+      {{"PDMD", "X509"},
+       {"COPT", "SREJ"}});
   // clang-format on
   rejector_->OnChlo(GetParam().version, kConnectionId,
                     kServerDesignateConnectionId, client_hello);
 
   if (GetParam().flags != ENABLED) {
     EXPECT_EQ(StatelessRejector::UNSUPPORTED, rejector_->state());
     return;
   }
 
   // The StatelessRejector is undecided - proceed with async processing
   ASSERT_EQ(StatelessRejector::UNKNOWN, rejector_->state());
   StatelessRejector::Process(std::move(rejector_),
                              QuicMakeUnique<ProcessDoneCallback>(this));
 
   EXPECT_EQ(StatelessRejector::FAILED, rejector_->state());
   EXPECT_EQ(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER, rejector_->error());
 }
 
 TEST_P(StatelessRejectorTest, ValidChloWithoutSrejSupport) {
   // clang-format off
-  const CryptoHandshakeMessage client_hello = CryptoTestUtils::Message(
-      "CHLO",
-      "PDMD", "X509",
-      "AEAD", "AESG",
-      "KEXS", "C255",
-      "PUBS", pubs_hex_.c_str(),
-      "NONC", nonc_hex_.c_str(),
-      "VER\0", ver_hex_.c_str(),
-      "$padding", static_cast<int>(kClientHelloMinimumSize),
-      nullptr);
+  const CryptoHandshakeMessage client_hello = crypto_test_utils::CreateCHLO(
+      {{"PDMD", "X509"},
+       {"AEAD", "AESG"},
+       {"KEXS", "C255"},
+       {"PUBS", pubs_hex_},
+       {"NONC", nonc_hex_},
+       {"VER\0", ver_hex_}},
+      kClientHelloMinimumSize);
   // clang-format on
 
   rejector_->OnChlo(GetParam().version, kConnectionId,
                     kServerDesignateConnectionId, client_hello);
   EXPECT_EQ(StatelessRejector::UNSUPPORTED, rejector_->state());
 }
 
 TEST_P(StatelessRejectorTest, RejectChlo) {
   // clang-format off
-  const CryptoHandshakeMessage client_hello = CryptoTestUtils::Message(
-      "CHLO",
-      "PDMD", "X509",
-      "AEAD", "AESG",
-      "KEXS", "C255",
-      "COPT", "SREJ",
-      "SCID", scid_hex_.c_str(),
-      "PUBS", pubs_hex_.c_str(),
-      "NONC", nonc_hex_.c_str(),
-      "#004b5453", stk_hex_.c_str(),
-      "VER\0", ver_hex_.c_str(),
-      "$padding", static_cast<int>(kClientHelloMinimumSize),
-      nullptr);
+  const CryptoHandshakeMessage client_hello = crypto_test_utils::CreateCHLO(
+      {{"PDMD", "X509"},
+       {"AEAD", "AESG"},
+       {"KEXS", "C255"},
+       {"COPT", "SREJ"},
+       {"SCID", scid_hex_},
+       {"PUBS", pubs_hex_},
+       {"NONC", nonc_hex_},
+       {"#004b5453", stk_hex_},
+       {"VER\0", ver_hex_}},
+      kClientHelloMinimumSize);
   // clang-format on
 
   rejector_->OnChlo(GetParam().version, kConnectionId,
                     kServerDesignateConnectionId, client_hello);
   if (GetParam().flags != ENABLED) {
     EXPECT_EQ(StatelessRejector::UNSUPPORTED, rejector_->state());
     return;
   }
 
   // The StatelessRejector is undecided - proceed with async processing
   ASSERT_EQ(StatelessRejector::UNKNOWN, rejector_->state());
   StatelessRejector::Process(std::move(rejector_),
                              QuicMakeUnique<ProcessDoneCallback>(this));
 
   ASSERT_EQ(StatelessRejector::REJECTED, rejector_->state());
   const CryptoHandshakeMessage& reply = rejector_->reply();
   EXPECT_EQ(kSREJ, reply.tag());
   const uint32_t* reject_reasons;
   size_t num_reject_reasons;
   EXPECT_EQ(QUIC_NO_ERROR,
             reply.GetTaglist(kRREJ, &reject_reasons, &num_reject_reasons));
   EXPECT_EQ(1u, num_reject_reasons);
   EXPECT_EQ(INVALID_EXPECTED_LEAF_CERTIFICATE,
             static_cast<HandshakeFailureReason>(reject_reasons[0]));
 }
 
 TEST_P(StatelessRejectorTest, AcceptChlo) {
-  const uint64_t xlct = CryptoTestUtils::LeafCertHashForTesting();
+  const uint64_t xlct = crypto_test_utils::LeafCertHashForTesting();
   const string xlct_hex =
       "#" + QuicTextUtils::HexEncode(reinterpret_cast<const char*>(&xlct),
                                      sizeof(xlct));
   // clang-format off
-  const CryptoHandshakeMessage client_hello = CryptoTestUtils::Message(
-      "CHLO",
-      "PDMD", "X509",
-      "AEAD", "AESG",
-      "KEXS", "C255",
-      "COPT", "SREJ",
-      "SCID", scid_hex_.c_str(),
-      "PUBS", pubs_hex_.c_str(),
-      "NONC", nonc_hex_.c_str(),
-      "#004b5453", stk_hex_.c_str(),
-      "VER\0", ver_hex_.c_str(),
-      "XLCT", xlct_hex.c_str(),
-      "$padding", static_cast<int>(kClientHelloMinimumSize),
-      nullptr);
+  const CryptoHandshakeMessage client_hello = crypto_test_utils::CreateCHLO(
+      {{"PDMD", "X509"},
+       {"AEAD", "AESG"},
+       {"KEXS", "C255"},
+       {"COPT", "SREJ"},
+       {"SCID", scid_hex_},
+       {"PUBS", pubs_hex_},
+       {"NONC", nonc_hex_},
+       {"#004b5453", stk_hex_},
+       {"VER\0", ver_hex_},
+       {"XLCT", xlct_hex}},
+      kClientHelloMinimumSize);
   // clang-format on
 
   rejector_->OnChlo(GetParam().version, kConnectionId,
                     kServerDesignateConnectionId, client_hello);
   if (GetParam().flags != ENABLED) {
     EXPECT_EQ(StatelessRejector::UNSUPPORTED, rejector_->state());
     return;
   }
 
   // The StatelessRejector is undecided - proceed with async processing
   ASSERT_EQ(StatelessRejector::UNKNOWN, rejector_->state());
   StatelessRejector::Process(std::move(rejector_),
                              QuicMakeUnique<ProcessDoneCallback>(this));
 
   EXPECT_EQ(StatelessRejector::ACCEPTED, rejector_->state());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net