relnote: remove insecure QUIC support

net/quic/quic_connection.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.
 //
 // The entity that handles framing writes for a Quic client or server.
 // Each QuicSession will have a connection associated with it.
 //
 // On the server side, the Dispatcher handles the raw reads, and hands off
 // packets via ProcessUdpPacket for framing and processing.
 //
@@ skipping 276 matching lines @@
   // Constructs a new QuicConnection for |connection_id| and |address|. Invokes
   // writer_factory->Create() to get a writer; |owns_writer| specifies whether
   // the connection takes ownership of the returned writer. |helper| must
   // outlive this connection.
   QuicConnection(QuicConnectionId connection_id,
                  IPEndPoint address,
                  QuicConnectionHelperInterface* helper,
                  const PacketWriterFactory& writer_factory,
                  bool owns_writer,
                  Perspective perspective,
-                 bool is_secure,
                  const QuicVersionVector& supported_versions);
   ~QuicConnection() override;
 
   // Sets connection parameters from the supplied |config|.
   void SetFromConfig(const QuicConfig& config);
 
   // Called by the session when sending connection state to the client.
   virtual void OnSendConnectionState(
       const CachedNetworkParameters& cached_network_params);
 
@@ skipping 296 matching lines @@
     const bool already_delayed_;
   };
 
   QuicPacketNumber packet_number_of_last_sent_packet() const {
     return packet_number_of_last_sent_packet_;
   }
 
   QuicPacketWriter* writer() { return writer_; }
   const QuicPacketWriter* writer() const { return writer_; }
 
-  bool is_secure() const { return is_secure_; }
-
   // Sends an MTU discovery packet of size |target_mtu|.  If the packet is
   // acknowledged by the peer, the maximum packet size will be increased to
   // |target_mtu|.
   void SendMtuDiscoveryPacket(QuicByteCount target_mtu);
 
   // Sends an MTU discovery packet of size |mtu_discovery_target_| and updates
   // the MTU discovery alarm.
   void DiscoverMtu();
 
   // Return the name of the cipher of the primary decrypter of the framer.
@@ skipping 315 matching lines @@
   bool self_port_changed_;
 
   // Set to false if the connection should not send truncated connection IDs to
   // the peer, even if the peer supports it.
   bool can_truncate_connection_ids_;
 
   // If non-empty this contains the set of versions received in a
   // version negotiation packet.
   QuicVersionVector server_supported_versions_;
 
-  // True if this is a secure QUIC connection.
-  bool is_secure_;
-
   // The size of the packet we are targeting while doing path MTU discovery.
   QuicByteCount mtu_discovery_target_;
 
   // The number of MTU probes already sent.
   size_t mtu_probe_count_;
 
   // The number of packets between MTU probes.
   QuicPacketCount packets_between_mtu_probes_;
 
   // The packet number of the packet after which the next MTU probe will be
   // sent.
   QuicPacketNumber next_mtu_probe_at_;
 
   // The size of the largest packet received from peer.
   QuicByteCount largest_received_packet_size_;
 
   // Whether a GoAway has been sent.
   bool goaway_sent_;
 
   // Whether a GoAway has been received.
   bool goaway_received_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_