Disable QUIC v29 and earlier. Protected by FLAGS_quic_disable_pre_30.

net/tools/quic/quic_dispatcher.cc

 // 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.
 
 #include "net/tools/quic/quic_dispatcher.h"
 
 #include <utility>
 
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
@@ skipping 183 matching lines @@
     : config_(config),
       crypto_config_(crypto_config),
       compressed_certs_cache_(
           QuicCompressedCertsCache::kQuicCompressedCertsCacheSize),
       helper_(std::move(helper)),
       session_helper_(std::move(session_helper)),
       alarm_factory_(std::move(alarm_factory)),
       delete_sessions_alarm_(
           alarm_factory_->CreateAlarm(new DeleteSessionsAlarm(this))),
       supported_versions_(supported_versions),
+      disable_quic_pre_30_(FLAGS_quic_disable_pre_30),
+      allowed_supported_versions_(supported_versions),
       current_packet_(nullptr),
       framer_(supported_versions,
               /*unused*/ QuicTime::Zero(),
               Perspective::IS_SERVER),
       last_error_(QUIC_NO_ERROR) {
   framer_.set_visitor(this);
 }
 
 QuicDispatcher::~QuicDispatcher() {
   STLDeleteValues(&session_map_);
@@ skipping 62 matching lines @@
   if (time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id)) {
     // Set the framer's version based on the recorded version for this
     // connection and continue processing for non-public-reset packets.
     return HandlePacketForTimeWait(header);
   }
 
   // The packet has an unknown connection ID.
 
   // Unless the packet provides a version, assume that we can continue
   // processing using our preferred version.
-  QuicVersion version = supported_versions_.front();
+  QuicVersion version = GetSupportedVersions().front();
   if (header.version_flag) {
     QuicVersion packet_version = header.versions.front();
     if (!framer_.IsSupportedVersion(packet_version)) {
       if (ShouldCreateSessionForUnknownVersion(framer_.last_version_tag())) {
         return true;
       }
       // Since the version is not supported, send a version negotiation
       // packet and stop processing the current packet.
       time_wait_list_manager()->SendVersionNegotiationPacket(
-          connection_id, supported_versions_, current_server_address_,
+          connection_id, GetSupportedVersions(), current_server_address_,
           current_client_address_);
       return false;
     }
     version = packet_version;
   }
   // Set the framer's version and continue processing.
   framer_.set_version(version);
   return true;
 }
 
@@ skipping 285 matching lines @@
   DCHECK(false);
 }
 
 QuicServerSessionBase* QuicDispatcher::CreateQuicSession(
     QuicConnectionId connection_id,
     const IPEndPoint& client_address) {
   // The QuicServerSessionBase takes ownership of |connection| below.
   QuicConnection* connection = new QuicConnection(
       connection_id, client_address, helper_.get(), alarm_factory_.get(),
       CreatePerConnectionWriter(),
-      /* owns_writer= */ true, Perspective::IS_SERVER, supported_versions_);
+      /* owns_writer= */ true, Perspective::IS_SERVER, GetSupportedVersions());
 
   QuicServerSessionBase* session = new QuicSimpleServerSession(
       config_, connection, this, session_helper_.get(), crypto_config_,
       &compressed_certs_cache_);
   session->Initialize();
   return session;
 }
 
 void QuicDispatcher::OnConnectionRejectedStatelessly() {}
 
@@ skipping 100 matching lines @@
           rejector.reply().GetSerialized().AsStringPiece());
       OnConnectionRejectedStatelessly();
       return kFateTimeWait;
     }
   }
 
   QUIC_BUG << "Rejector has unknown invalid state.";
   return kFateDrop;
 }
 
+const QuicVersionVector& QuicDispatcher::GetSupportedVersions() {
+  // Filter (or un-filter) the list of supported versions based on the flag.
+  if (disable_quic_pre_30_ != FLAGS_quic_disable_pre_30) {
+    DCHECK_EQ(supported_versions_.capacity(),
+              allowed_supported_versions_.capacity());
+    disable_quic_pre_30_ = FLAGS_quic_disable_pre_30;
+    supported_versions_ = FilterSupportedVersions(allowed_supported_versions_);
+  }
+  return supported_versions_;
+}
+
 }  // namespace net