Disable QUIC v29 and earlier. Protected by FLAGS_quic_disable_pre_30.

net/tools/quic/quic_dispatcher.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.
 //
 // A server side dispatcher which dispatches a given client's data to their
 // stream.
 
 #ifndef NET_TOOLS_QUIC_QUIC_DISPATCHER_H_
 #define NET_TOOLS_QUIC_QUIC_DISPATCHER_H_
 
@@ skipping 162 matching lines @@
   virtual QuicPacketFate ValidityChecks(const QuicPacketHeader& header);
 
   // Create and return the time wait list manager for this dispatcher, which
   // will be owned by the dispatcher as time_wait_list_manager_
   virtual QuicTimeWaitListManager* CreateQuicTimeWaitListManager();
 
   QuicTimeWaitListManager* time_wait_list_manager() {
     return time_wait_list_manager_.get();
   }
 
-  const QuicVersionVector& supported_versions() const {
-    return supported_versions_;
-  }
+  const QuicVersionVector& GetSupportedVersions();
 
   const IPEndPoint& current_server_address() { return current_server_address_; }
   const IPEndPoint& current_client_address() { return current_client_address_; }
   const QuicReceivedPacket& current_packet() { return *current_packet_; }
 
   const QuicConfig& config() const { return config_; }
 
   const QuicCryptoServerConfig* crypto_config() const { return crypto_config_; }
 
   QuicCompressedCertsCache* compressed_certs_cache() {
@@ skipping 19 matching lines @@
   // cleaned up for bug 16950226.)
   virtual QuicPacketWriter* CreatePerConnectionWriter();
 
   // Returns true if a session should be created for a connection with an
   // unknown version identified by |version_tag|.
   virtual bool ShouldCreateSessionForUnknownVersion(QuicTag version_tag);
 
   void SetLastError(QuicErrorCode error);
 
   // Called when the public header has been parsed and the session has been
-  // looked up, and the session was not found in the active std::list of
-  // sessions.
+  // looked up, and the session was not found in the active list of sessions.
   // Returns false if processing should stop after this call.
   virtual bool OnUnauthenticatedUnknownPublicHeader(
       const QuicPacketPublicHeader& header);
 
  private:
   friend class net::test::QuicDispatcherPeer;
 
   // Removes the session from the session map and write blocked list, and adds
   // the ConnectionId to the time-wait list.  If |session_closed_statelessly| is
   // true, any future packets for the ConnectionId will be black-holed.
@@ skipping 38 matching lines @@
   // An alarm which deletes closed sessions.
   std::unique_ptr<QuicAlarm> delete_sessions_alarm_;
 
   // The writer to write to the socket with.
   std::unique_ptr<QuicPacketWriter> writer_;
 
   // This vector contains QUIC versions which we currently support.
   // This should be ordered such that the highest supported version is the first
   // element, with subsequent elements in descending order (versions can be
   // skipped as necessary).
-  const QuicVersionVector supported_versions_;
+  QuicVersionVector supported_versions_;
+
+  // FLAGS_quic_disable_pre_30
+  bool disable_quic_pre_30_;
+  // The list of versions that may be supported by this dispatcher.
+  // |supported_versions| is derived from this list and |disable_quic_pre_30_|.
+  const QuicVersionVector allowed_supported_versions_;
 
   // Information about the packet currently being handled.
   IPEndPoint current_client_address_;
   IPEndPoint current_server_address_;
   const QuicReceivedPacket* current_packet_;
   QuicConnectionId current_connection_id_;
 
   QuicFramer framer_;
 
   // The last error set by SetLastError(), which is called by
   // framer_visitor_->OnError().
   QuicErrorCode last_error_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicDispatcher);
 };
 
 }  // namespace net
 
 #endif  // NET_TOOLS_QUIC_QUIC_DISPATCHER_H_