Remove insecure QUIC support

net/tools/quic/test_tools/quic_test_server.cc

 // Copyright (c) 2015 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/test_tools/quic_test_server.h"
 
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/ip_endpoint.h"
@@ skipping 43 matching lines @@
                      const QuicCryptoServerConfig* crypto_config,
                      const QuicVersionVector& versions,
                      PacketWriterFactory* factory,
                      QuicConnectionHelperInterface* helper)
       : QuicDispatcher(config, crypto_config, versions, factory, helper) {}
   QuicServerSession* CreateQuicSession(QuicConnectionId id,
                                        const IPEndPoint& client) override {
     if (session_creator_ == nullptr && stream_creator_ == nullptr) {
       return QuicDispatcher::CreateQuicSession(id, client);
     }
-    QuicConnection* connection =
-        new QuicConnection(id, client, helper(), connection_writer_factory(),
-                           /* owns_writer= */ true, Perspective::IS_SERVER,
-                           /* is_secure */ true, supported_versions());
+    QuicConnection* connection = new QuicConnection(
+        id, client, helper(), connection_writer_factory(),
+        /* owns_writer= */ true, Perspective::IS_SERVER, supported_versions());
 
     QuicServerSession* session = nullptr;
     if (stream_creator_ != nullptr) {
       session = new CustomStreamSession(config(), connection, this,
                                         crypto_config(), stream_creator_);
     } else {
       session = session_creator_(config(), connection, this, crypto_config());
     }
     session->Initialize();
     return session;
@@ skipping 21 matching lines @@
 
   QuicTestServer::StreamCreationFunction stream_creator() {
     return stream_creator_;
   }
 
  private:
   QuicTestServer::SessionCreationFunction session_creator_;
   QuicTestServer::StreamCreationFunction stream_creator_;
 };
 
-QuicTestServer::QuicTestServer() : QuicServer() {}
+QuicTestServer::QuicTestServer(ProofSource* proof_source)
+    : QuicServer(proof_source) {}
 
-QuicTestServer::QuicTestServer(const QuicConfig& config,
+QuicTestServer::QuicTestServer(ProofSource* proof_source,
+                               const QuicConfig& config,
                                const QuicVersionVector& supported_versions)
-    : QuicServer(config, supported_versions) {}
+    : QuicServer(proof_source, config, supported_versions) {}
 
 QuicDispatcher* QuicTestServer::CreateQuicDispatcher() {
   return new QuicTestDispatcher(
       config(), &crypto_config(), supported_versions(),
       new QuicDispatcher::DefaultPacketWriterFactory(),
       new QuicEpollConnectionHelper(epoll_server()));
 }
 
 void QuicTestServer::SetSessionCreator(SessionCreationFunction function) {
   static_cast<QuicTestDispatcher*>(dispatcher())
@@ skipping 13 matching lines @@
     QuicConnection* connection,
     QuicServerSessionVisitor* visitor,
     const QuicCryptoServerConfig* crypto_config)
     : QuicServerSession(config, connection, visitor, crypto_config) {
   SendGoAway(QUIC_PEER_GOING_AWAY, "");
 }
 
 }  // namespace test
 }  // namespace tools
 }  // namespace net