Update from https://crrev.com/311076

net/quic/quic_protocol_test.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 "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ skipping 50 matching lines @@
 
   // TODO(rtenneti): Enable checking of Log(ERROR) messages.
 #if 0
   // Any logs would indicate an unsupported version which we don't expect.
   ScopedMockLog log(kDoNotCaptureLogsYet);
   EXPECT_CALL(log, Log(_, _, _)).Times(0);
   log.StartCapturingLogs();
 #endif
 
   // Explicitly test a specific version.
-  EXPECT_EQ(MakeQuicTag('Q', '0', '1', '9'),
-            QuicVersionToQuicTag(QUIC_VERSION_19));
+  EXPECT_EQ(MakeQuicTag('Q', '0', '2', '3'),
+            QuicVersionToQuicTag(QUIC_VERSION_23));
 
   // Loop over all supported versions and make sure that we never hit the
   // default case (i.e. all supported versions should be successfully converted
   // to valid QuicTags).
   for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
     QuicVersion version = kSupportedQuicVersions[i];
     EXPECT_LT(0u, QuicVersionToQuicTag(version));
   }
 }
 
@@ skipping 17 matching lines @@
 
   // TODO(rtenneti): Enable checking of Log(ERROR) messages.
 #if 0
   // Any logs would indicate an unsupported version which we don't expect.
   ScopedMockLog log(kDoNotCaptureLogsYet);
   EXPECT_CALL(log, Log(_, _, _)).Times(0);
   log.StartCapturingLogs();
 #endif
 
   // Explicitly test specific versions.
-  EXPECT_EQ(QUIC_VERSION_19,
-            QuicTagToQuicVersion(MakeQuicTag('Q', '0', '1', '9')));
+  EXPECT_EQ(QUIC_VERSION_23,
+            QuicTagToQuicVersion(MakeQuicTag('Q', '0', '2', '3')));
 
   for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
     QuicVersion version = kSupportedQuicVersions[i];
 
     // Get the tag from the version (we can loop over QuicVersions easily).
     QuicTag tag = QuicVersionToQuicTag(version);
     EXPECT_LT(0u, tag);
 
     // Now try converting back.
     QuicVersion tag_to_quic_version = QuicTagToQuicVersion(tag);
@@ skipping 10 matching lines @@
   EXPECT_CALL(log, Log(INFO, _, "Unsupported QuicTag version: FAKE")).Times(1);
 #endif
   log.StartCapturingLogs();
 #endif
 
   EXPECT_EQ(QUIC_VERSION_UNSUPPORTED,
             QuicTagToQuicVersion(MakeQuicTag('F', 'A', 'K', 'E')));
 }
 
 TEST(QuicProtocolTest, QuicVersionToString) {
-  EXPECT_EQ("QUIC_VERSION_19", QuicVersionToString(QUIC_VERSION_19));
+  EXPECT_EQ("QUIC_VERSION_23", QuicVersionToString(QUIC_VERSION_23));
   EXPECT_EQ("QUIC_VERSION_UNSUPPORTED",
             QuicVersionToString(QUIC_VERSION_UNSUPPORTED));
 
-  QuicVersion single_version[] = {QUIC_VERSION_19};
+  QuicVersion single_version[] = {QUIC_VERSION_23};
   QuicVersionVector versions_vector;
   for (size_t i = 0; i < arraysize(single_version); ++i) {
     versions_vector.push_back(single_version[i]);
   }
-  EXPECT_EQ("QUIC_VERSION_19", QuicVersionVectorToString(versions_vector));
+  EXPECT_EQ("QUIC_VERSION_23", QuicVersionVectorToString(versions_vector));
 
-  QuicVersion multiple_versions[] = {QUIC_VERSION_UNSUPPORTED, QUIC_VERSION_19};
+  QuicVersion multiple_versions[] = {QUIC_VERSION_UNSUPPORTED, QUIC_VERSION_23};
   versions_vector.clear();
   for (size_t i = 0; i < arraysize(multiple_versions); ++i) {
     versions_vector.push_back(multiple_versions[i]);
   }
-  EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_19",
+  EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_23",
             QuicVersionVectorToString(versions_vector));
 
   // Make sure that all supported versions are present in QuicVersionToString.
   for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
     QuicVersion version = kSupportedQuicVersions[i];
     EXPECT_NE("QUIC_VERSION_UNSUPPORTED", QuicVersionToString(version));
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net