Remove insecure QUIC support

net/quic/test_tools/crypto_test_utils.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/test_tools/crypto_test_utils.h"
 
 #include "net/quic/crypto/channel_id.h"
 #include "net/quic/crypto/common_cert_set.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/crypto/quic_crypto_server_config.h"
@@ skipping 149 matching lines @@
 
  private:
   scoped_ptr<ChannelIDSource> sync_source_;
   scoped_ptr<ChannelIDSourceCallback> callback_;
   scoped_ptr<ChannelIDKey> channel_id_key_;
 };
 
 }  // anonymous namespace
 
 CryptoTestUtils::FakeClientOptions::FakeClientOptions()
-    : dont_verify_certs(false),
-      channel_id_enabled(false),
+    : channel_id_enabled(false),
       channel_id_source_async(false) {
 }
 
 // static
 int CryptoTestUtils::HandshakeWithFakeServer(
     MockHelper* helper,
     PacketSavingConnection* client_conn,
     QuicCryptoClientStream* client) {
   PacketSavingConnection* server_conn = new PacketSavingConnection(
       helper, Perspective::IS_SERVER, client_conn->supported_versions());
 
   QuicConfig config = DefaultQuicConfig();
   QuicCryptoServerConfig crypto_config(QuicCryptoServerConfig::TESTING,
-                                       QuicRandom::GetInstance());
+                                       QuicRandom::GetInstance(),
+                                       ProofSourceForTesting());
   SetupCryptoServerConfigForTest(server_conn->clock(),
                                  server_conn->random_generator(), &config,
                                  &crypto_config);
 
   TestQuicSpdyServerSession server_session(server_conn, config, &crypto_config);
 
   // The client's handshake must have been started already.
   CHECK_NE(0u, client_conn->encrypted_packets_.size());
 
   CommunicateHandshakeMessages(client_conn, client, server_conn,
                                server_session.GetCryptoStream());
-
   CompareClientAndServerKeys(client, server_session.GetCryptoStream());
 
   return client->num_sent_client_hellos();
 }
 
 // static
 int CryptoTestUtils::HandshakeWithFakeClient(
     MockHelper* helper,
     PacketSavingConnection* server_conn,
     QuicCryptoServerStream* server,
     const QuicServerId& server_id,
     const FakeClientOptions& options) {
   PacketSavingConnection* client_conn =
       new PacketSavingConnection(helper, Perspective::IS_CLIENT);
   // Advance the time, because timers do not like uninitialized times.
   client_conn->AdvanceTime(QuicTime::Delta::FromSeconds(1));
 
-  QuicCryptoClientConfig crypto_config;
+  QuicCryptoClientConfig crypto_config(ProofVerifierForTesting());
   AsyncTestChannelIDSource* async_channel_id_source = nullptr;
   if (options.channel_id_enabled) {
 
     ChannelIDSource* source = ChannelIDSourceForTesting();
     if (options.channel_id_source_async) {
       async_channel_id_source = new AsyncTestChannelIDSource(source);
       source = async_channel_id_source;
     }
     crypto_config.SetChannelIDSource(source);
   }
-  if (!options.dont_verify_certs && server_id.is_https()) {
-#if defined(USE_OPENSSL)
-    crypto_config.SetProofVerifier(ProofVerifierForTesting());
-#else
-    // TODO(rch): Implement a NSS proof source.
-    crypto_config.SetProofVerifier(FakeProofVerifierForTesting());
-#endif
-  }
   TestQuicSpdyClientSession client_session(client_conn, DefaultQuicConfig(),
                                            server_id, &crypto_config);
 
   client_session.GetCryptoStream()->CryptoConnect();
   CHECK_EQ(1u, client_conn->encrypted_packets_.size());
 
   CommunicateHandshakeMessagesAndRunCallbacks(
       client_conn, client_session.GetCryptoStream(), server_conn, server,
       async_channel_id_source);
 
@@ skipping 370 matching lines @@
   scoped_ptr<CryptoHandshakeMessage> parsed(
       CryptoFramer::ParseMessage(bytes->AsStringPiece()));
   CHECK(parsed.get());
 
   va_end(ap);
   return *parsed;
 }
 
 }  // namespace test
 }  // namespace net