Removing QUIC's VERSION_6, now that QUIC no longer needs to support the

net/quic/quic_protocol.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/quic/quic_protocol.h"
 
 #include "base/stl_util.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
@@ skipping 105 matching lines @@
 
 uint32 MakeQuicTag(char a, char b, char c, char d) {
   return static_cast<uint32>(a) |
          static_cast<uint32>(b) << 8 |
          static_cast<uint32>(c) << 16 |
          static_cast<uint32>(d) << 24;
 }
 
 QuicVersion QuicVersionMax() { return kSupportedQuicVersions[0]; }
 
+QuicVersion QuicVersionMin() {
+  return kSupportedQuicVersions[arraysize(kSupportedQuicVersions) - 1];
+}
+
 QuicTag QuicVersionToQuicTag(const QuicVersion version) {
   switch (version) {
-    case QUIC_VERSION_6:
-      return MakeQuicTag('Q', '0', '0', '6');
     case QUIC_VERSION_7:
       return MakeQuicTag('Q', '0', '0', '7');
     case QUIC_VERSION_8:
       return MakeQuicTag('Q', '0', '0', '8');
     default:
       // This shold be an ERROR because we should never attempt to convert an
       // invalid QuicVersion to be written to the wire.
       LOG(ERROR) << "Unsupported QuicVersion: " << version;
       return 0;
   }
 }
 
 QuicVersion QuicTagToQuicVersion(const QuicTag version_tag) {
-  const QuicTag quic_tag_v6 = MakeQuicTag('Q', '0', '0', '6');
   const QuicTag quic_tag_v7 = MakeQuicTag('Q', '0', '0', '7');
   const QuicTag quic_tag_v8 = MakeQuicTag('Q', '0', '0', '8');
 
-  if (version_tag == quic_tag_v6) {
-    return QUIC_VERSION_6;
-  } else if (version_tag == quic_tag_v7) {
+  if (version_tag == quic_tag_v7) {
     return QUIC_VERSION_7;
   } else if (version_tag == quic_tag_v8) {
     return QUIC_VERSION_8;
   } else {
     // Reading from the client so this should not be considered an ERROR.
     DLOG(INFO) << "Unsupported QuicTag version: "
                << QuicUtils::TagToString(version_tag);
     return QUIC_VERSION_UNSUPPORTED;
   }
 }
 
 #define RETURN_STRING_LITERAL(x) \
 case x: \
 return #x
 
 string QuicVersionToString(const QuicVersion version) {
   switch (version) {
-    RETURN_STRING_LITERAL(QUIC_VERSION_6);
     RETURN_STRING_LITERAL(QUIC_VERSION_7);
     RETURN_STRING_LITERAL(QUIC_VERSION_8);
     default:
       return "QUIC_VERSION_UNSUPPORTED";
   }
 }
 
 string QuicVersionArrayToString(const QuicVersion versions[],
                                 int num_versions) {
   string result = "";
@@ skipping 244 matching lines @@
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicConsumedData& s) {
   os << "bytes_consumed: " << s.bytes_consumed
      << " fin_consumed: " << s.fin_consumed;
   return os;
 }
 
 }  // namespace net