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 22 matching lines @@
 class ReliableQuicStream;
 }  // namespace net
 
 using std::pair;
 using std::string;
 using testing::_;
 
 namespace net {
 namespace test {
 
+#if defined(USE_OPENSSL)
+
 class QuicCryptoServerConfigPeer {
  public:
   static string GetPrimaryOrbit(const QuicCryptoServerConfig& config) {
     base::AutoLock lock(config.configs_lock_);
     CHECK(config.primary_config_.get() != nullptr);
     return string(reinterpret_cast<const char*>(config.primary_config_->orbit),
                   kOrbitSize);
   }
 };
 
 class QuicCryptoServerStreamPeer {
  public:
   static bool DoesPeerSupportStatelessRejects(
       const CryptoHandshakeMessage& message) {
     return net::QuicCryptoServerStream::DoesPeerSupportStatelessRejects(
         message);
   }
 };
 
 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 35 matching lines @@
   // testing.  May be called multiple times.
   void InitializeFakeClient(bool supports_stateless_rejects) {
     TestQuicSpdyClientSession* client_session = nullptr;
     helpers_.push_back(new MockHelper);
     CreateClientSessionForTest(server_id_, supports_stateless_rejects,
                                QuicTime::Delta::FromSeconds(100000),
                                helpers_.back(), &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() {
     if (server_connection_->version() > QUIC_VERSION_26) {
       return false;
     }
     return GetParam();
   }
 
   void ConstructHandshakeMessage() {
@@ skipping 232 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 21 matching lines @@
       QuicCryptoServerStreamPeer::DoesPeerSupportStatelessRejects(message_));
 
   message_.Clear();
   QuicConfig stateful_reject_config = DefaultQuicConfig();
   stateful_reject_config.ToHandshakeMessage(&message_);
   EXPECT_FALSE(
       QuicCryptoServerStreamPeer::DoesPeerSupportStatelessRejects(message_));
 }
 
 }  // namespace
+
+#endif
+
 }  // namespace test
 }  // namespace net