Remove insecure QUIC support

net/quic/crypto/quic_crypto_client_config.h

 // Copyright 2013 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_QUIC_CRYPTO_QUIC_CRYPTO_CLIENT_CONFIG_H_
 #define NET_QUIC_CRYPTO_QUIC_CRYPTO_CLIENT_CONFIG_H_
 
 #include <map>
 #include <queue>
 #include <string>
@@ skipping 163 matching lines @@
 
     // TODO(jokulik): Consider using a hash-set as extra book-keeping to ensure
     // that no connection-id is added twice.  Also, consider keeping the server
     // nonces and connection_ids together in one queue.
     std::queue<QuicConnectionId> server_designated_connection_ids_;
     std::queue<std::string> server_nonces_;
 
     DISALLOW_COPY_AND_ASSIGN(CachedState);
   };
 
-  QuicCryptoClientConfig();
+  explicit QuicCryptoClientConfig(ProofVerifier* proof_verifier);
   ~QuicCryptoClientConfig();
 
   // LookupOrCreate returns a CachedState for the given |server_id|. If no such
   // CachedState currently exists, it will be created and cached.
   CachedState* LookupOrCreate(const QuicServerId& server_id);
 
   // Delete all CachedState objects from cached_states_.
   void ClearCachedStates();
 
   // FillInchoateClientHello sets |out| to be a CHLO message that elicits a
@@ skipping 37 matching lines @@
   // ProcessRejection processes a REJ message from a server and updates the
   // cached information about that server. After this, |IsComplete| may return
   // true for that server's CachedState. If the rejection message contains state
   // about a future handshake (i.e. an nonce value from the server), then it
   // will be saved in |out_params|. |now| is used to judge whether the server
   // config in the rejection message has expired. |is_https| is used to track
   // reject reason for secure vs insecure QUIC.
   QuicErrorCode ProcessRejection(const CryptoHandshakeMessage& rej,
                                  QuicWallTime now,
                                  CachedState* cached,
-                                 bool is_https,
                                  QuicCryptoNegotiatedParameters* out_params,
                                  std::string* error_details);
 
   // ProcessServerHello processes the message in |server_hello|, updates the
   // cached information about that server, writes the negotiated parameters to
   // |out_params| and returns QUIC_NO_ERROR. If |server_hello| is unacceptable
   // then it puts an error message in |error_details| and returns an error
   // code. |version| is the QUIC version for the current connection.
   // |negotiated_versions| contains the list of version, if any, that were
   // present in a version negotiation packet previously recevied from the
@@ skipping 14 matching lines @@
   // QUIC_NO_ERROR is returned.
   QuicErrorCode ProcessServerConfigUpdate(
       const CryptoHandshakeMessage& server_update,
       QuicWallTime now,
       CachedState* cached,
       QuicCryptoNegotiatedParameters* out_params,
       std::string* error_details);
 
   ProofVerifier* proof_verifier() const;
 
-  // SetProofVerifier takes ownership of a |ProofVerifier| that clients are
-  // free to use in order to verify certificate chains from servers. If a
-  // ProofVerifier is set then the client will request a certificate chain from
-  // the server.
-  void SetProofVerifier(ProofVerifier* verifier);
-
   ChannelIDSource* channel_id_source() const;
 
   // SetChannelIDSource sets a ChannelIDSource that will be called, when the
   // server supports channel IDs, to obtain a channel ID for signing a message
   // proving possession of the channel ID. This object takes ownership of
   // |source|.
   void SetChannelIDSource(ChannelIDSource* source);
 
   // Initialize the CachedState from |canonical_crypto_config| for the
   // |canonical_server_id| as the initial CachedState for |server_id|. We will
@@ skipping 69 matching lines @@
 
   // The |user_agent_id_| passed in QUIC's CHLO message.
   std::string user_agent_id_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicCryptoClientConfig);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CRYPTO_QUIC_CRYPTO_CLIENT_CONFIG_H_