Deprecate --quic_stateless_version_negotiation

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 119 matching lines @@
     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();
   if (header.version_flag) {
     QuicVersion packet_version = header.versions.front();
-    if (framer_.IsSupportedVersion(packet_version)) {
-      version = packet_version;
-    } else {
-      if (FLAGS_quic_stateless_version_negotiation) {
-        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_,
-            current_client_address_);
-        return false;
-      } else {
-        // Packets set to be processed but having an unsupported version will
-        // cause a connection to be created.  The connection will handle
-        // sending a version negotiation packet.
-        // TODO(ianswett): This will malfunction if the full header of the
-        // packet causes a parsing error when parsed using the server's
-        // preferred version.
+    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_,
+          current_client_address_);
+      return false;
     }
+    version = packet_version;
   }
   // Set the framer's version and continue processing.
   framer_.set_version(version);
   return true;
 }
 
 bool QuicDispatcher::OnUnauthenticatedHeader(const QuicPacketHeader& header) {
   QuicConnectionId connection_id = header.public_header.connection_id;
 
   if (time_wait_list_manager_->IsConnectionIdInTimeWait(
@@ skipping 174 matching lines @@
   SetLastError(error);
   DVLOG(1) << QuicUtils::ErrorToString(error);
 }
 
 bool QuicDispatcher::ShouldCreateSessionForUnknownVersion(QuicTag version_tag) {
   return false;
 }
 
 bool QuicDispatcher::OnProtocolVersionMismatch(
     QuicVersion /*received_version*/) {
-  if (FLAGS_quic_stateless_version_negotiation) {
-    QUIC_BUG_IF(
-        !time_wait_list_manager_->IsConnectionIdInTimeWait(
-            current_connection_id_) &&
-        !ShouldCreateSessionForUnknownVersion(framer_.last_version_tag()))
-        << "Unexpected version mismatch: "
-        << QuicUtils::TagToString(framer_.last_version_tag());
-  }
+  QUIC_BUG_IF(!time_wait_list_manager_->IsConnectionIdInTimeWait(
+                  current_connection_id_) &&
+              !ShouldCreateSessionForUnknownVersion(framer_.last_version_tag()))
+      << "Unexpected version mismatch: "
+      << QuicUtils::TagToString(framer_.last_version_tag());
 
   // Keep processing after protocol mismatch - this will be dealt with by the
   // time wait list or connection that we will create.
   return true;
 }
 
 void QuicDispatcher::OnPublicResetPacket(
     const QuicPublicResetPacket& /*packet*/) {
   DCHECK(false);
 }
@@ skipping 112 matching lines @@
 
 QuicPacketWriter* QuicDispatcher::CreatePerConnectionWriter() {
   return new QuicPerConnectionPacketWriter(writer_.get());
 }
 
 void QuicDispatcher::SetLastError(QuicErrorCode error) {
   last_error_ = error;
 }
 
 }  // namespace net