Remove insecure QUIC support

net/tools/quic/test_tools/quic_test_client.h

 // 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.
 
 #ifndef NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_
 #define NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 52 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MockableQuicClient);
 };
 
 // A toy QUIC client used for testing, mostly following the SimpleClient APIs.
 class QuicTestClient : public SimpleClient,
                        public QuicDataStream::Visitor {
  public:
   QuicTestClient(IPEndPoint server_address,
                  const std::string& server_hostname,
-                 bool secure,
                  const QuicVersionVector& supported_versions);
   QuicTestClient(IPEndPoint server_address,
                  const std::string& server_hostname,
-                 bool secure,
                  const QuicConfig& config,
                  const QuicVersionVector& supported_versions);
 
   ~QuicTestClient() override;
 
-  // ExpectCertificates controls whether the server is expected to provide
-  // certificates. The certificates, if any, are not verified, but the common
-  // name is recorded and available with |cert_common_name()|.
-  void ExpectCertificates(bool on);
-
   // Sets the |user_agent_id| of the |client_|.
   void SetUserAgentID(const std::string& user_agent_id);
 
   // Wraps data in a quic packet and sends it.
   ssize_t SendData(const std::string& data, bool last_data);
   // As above, but |delegate| will be notified when |data| is ACKed.
   ssize_t SendData(const std::string& data,
                    bool last_data,
                    QuicAckListenerInterface* delegate);
 
@@ skipping 88 matching lines @@
 
   void set_allow_bidirectional_data(bool value) {
     allow_bidirectional_data_ = value;
   }
 
   bool allow_bidirectional_data() const { return allow_bidirectional_data_; }
 
  protected:
   QuicTestClient();
 
-  void Initialize(bool secure);
+  void Initialize();
 
   void set_client(MockableQuicClient* client) { client_.reset(client); }
 
  private:
   class TestClientDataToResend : public QuicClient::QuicDataToResend {
    public:
     TestClientDataToResend(BalsaHeaders* headers,
                            StringPiece body,
                            bool fin,
                            QuicTestClient* test_client,
@@ skipping 26 matching lines @@
   QuicPriority priority_;
   std::string response_;
   uint64 bytes_read_;
   uint64 bytes_written_;
   // The number of uncompressed HTTP header bytes received.
   int response_header_size_;
   // The number of HTTP body bytes received.
   int64 response_body_size_;
   // True if we tried to connect already since the last call to Disconnect().
   bool connect_attempted_;
-  bool secure_;
   // The client will auto-connect exactly once before sending data.  If
   // something causes a connection reset, it will not automatically reconnect
   // unless auto_reconnect_ is true.
   bool auto_reconnect_;
   // Should we buffer the response body? Defaults to true.
   bool buffer_body_;
   // FEC policy for data sent by this client.
   FecPolicy fec_policy_;
   // When true allows the sending of a request to continue while the response is
   // arriving.
   bool allow_bidirectional_data_;
-  // proof_verifier_ points to a RecordingProofVerifier that is owned by
-  // client_.
-  ProofVerifier* proof_verifier_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicTestClient);
 };
 
 }  // namespace test
 
 }  // namespace tools
 }  // namespace net
 
 #endif  // NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_