relnote: remove insecure QUIC support

net/quic/quic_crypto_server_stream_test.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/quic_crypto_server_stream.h"
 
 #include <map>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 49 matching lines @@
 
 namespace {
 
 const char kServerHostname[] = "test.example.com";
 const uint16 kServerPort = 443;
 
 class QuicCryptoServerStreamTest : public ::testing::TestWithParam<bool> {
  public:
   QuicCryptoServerStreamTest()
       : server_crypto_config_(QuicCryptoServerConfig::TESTING,
-                              QuicRandom::GetInstance()),
-        server_id_(kServerHostname, kServerPort, true, PRIVACY_MODE_DISABLED) {
-#if defined(USE_OPENSSL)
-    server_crypto_config_.SetProofSource(
-        CryptoTestUtils::ProofSourceForTesting());
-#else
-    // TODO(rch): Implement a NSS proof source.
-    server_crypto_config_.SetProofSource(
-        CryptoTestUtils::FakeProofSourceForTesting());
-#endif
+                              QuicRandom::GetInstance(),
+                              CryptoTestUtils::ProofSourceForTesting()),
+        server_id_(kServerHostname, kServerPort, PRIVACY_MODE_DISABLED),
+        client_crypto_config_(CryptoTestUtils::ProofVerifierForTesting()) {
     server_crypto_config_.set_strike_register_no_startup_period();
 
     InitializeServer();
 
     if (AsyncStrikeRegisterVerification()) {
       string orbit =
           QuicCryptoServerConfigPeer::GetPrimaryOrbit(server_crypto_config_);
       strike_register_client_ = new DelayedVerifyStrikeRegisterClient(
           10000,  // strike_register_max_entries
           static_cast<uint32>(
@@ skipping 31 matching lines @@
   // Initializes a fake client, and all its associated state, for
   // testing.  May be called multiple times.
   void InitializeFakeClient(bool supports_stateless_rejects) {
     TestQuicSpdyClientSession* client_session = nullptr;
     CreateClientSessionForTest(server_id_, supports_stateless_rejects,
                                QuicTime::Delta::FromSeconds(100000),
                                &client_crypto_config_, &client_connection_,
                                &client_session);
     CHECK(client_session);
     client_session_.reset(client_session);
-    if (!client_options_.dont_verify_certs) {
-#if defined(USE_OPENSSL)
-      client_crypto_config_.SetProofVerifier(
-          CryptoTestUtils::ProofVerifierForTesting());
-#else
-      // TODO(rch): Implement a NSS proof source.
-      client_crypto_config_.SetProofVerifier(
-          CryptoTestUtils::FakeProofVerifierForTesting());
-#endif
-    }
   }
 
   bool AsyncStrikeRegisterVerification() {
     return GetParam();
   }
 
   void ConstructHandshakeMessage() {
     CryptoFramer framer;
     message_data_.reset(framer.ConstructHandshakeMessage(message_));
   }
@@ skipping 226 matching lines @@
 TEST_P(QuicCryptoServerStreamTest, BadMessageType) {
   message_.set_tag(kSHLO);
   ConstructHandshakeMessage();
   EXPECT_CALL(*server_connection_,
               SendConnectionClose(QUIC_INVALID_CRYPTO_MESSAGE_TYPE));
   server_stream()->OnStreamFrame(
       QuicStreamFrame(kCryptoStreamId, /*fin=*/false, /*offset=*/0,
                       message_data_->AsStringPiece()));
 }
 
-TEST_P(QuicCryptoServerStreamTest, WithoutCertificates) {
-  server_crypto_config_.SetProofSource(nullptr);
-  server_id_ =
-      QuicServerId(kServerHostname, kServerPort, false, PRIVACY_MODE_DISABLED);
-  client_options_.dont_verify_certs = true;
-
-  // Only 2 client hellos need to be sent in the no-certs case: one to get the
-  // source-address token and the second to finish.
-  EXPECT_EQ(2, CompleteCryptoHandshake());
-  EXPECT_TRUE(server_stream()->encryption_established());
-  EXPECT_TRUE(server_stream()->handshake_confirmed());
-}
-
 TEST_P(QuicCryptoServerStreamTest, ChannelID) {
   client_options_.channel_id_enabled = true;
   client_options_.channel_id_source_async = false;
   // CompleteCryptoHandshake verifies
   // server_stream()->crypto_negotiated_params().channel_id is correct.
   EXPECT_EQ(2, CompleteCryptoHandshake());
   EXPECT_TRUE(server_stream()->encryption_established());
   EXPECT_TRUE(server_stream()->handshake_confirmed());
 }
 
@@ skipping 23 matching lines @@
   message_.Clear();
   QuicConfig stateful_reject_config = DefaultQuicConfig();
   stateful_reject_config.ToHandshakeMessage(&message_);
   EXPECT_FALSE(
       QuicCryptoServerStreamPeer::DoesPeerSupportStatelessRejects(message_));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net