BASELINE: Update Chromium to 76.0.3809.94

Change-Id: I321c3f5f929c105aec0f98c5091ef6108822e647 Reviewed-by: Michael Brüning <michael.bruning@qt.io>
author: Allan Sandfeld Jensen <allan.jensen@qt.io> 2019-07-31 15:50:41 +0200
committer: Allan Sandfeld Jensen <allan.jensen@qt.io> 2019-08-30 12:35:23 +0000
commit: 7b2ffa587235a47d4094787d72f38102089f402a (patch)
tree: 30e82af9cbab08a7fa028bb18f4f2987a3f74dfa /chromium/net/quic
parent: d94af01c90575348c4e81a418257f254b6f8d225 (diff)
download: qtwebengine-chromium-7b2ffa587235a47d4094787d72f38102089f402a.tar.gz
58 files changed, 2838 insertions, 1502 deletions
diff --git a/chromium/net/quic/address_utils.h b/chromium/net/quic/address_utils.h
new file mode 100644
index 00000000000..f067db7f9b0
--- /dev/null
+++ b/chromium/net/quic/address_utils.h
@@ -0,0 +1,48 @@
+#ifndef NET_QUIC_ADDRESS_UTILS_H_
+#define NET_QUIC_ADDRESS_UTILS_H_
+
+#include "net/base/ip_address.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_ip_address.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_ip_address_family.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
+
+namespace net {
+
+inline IPEndPoint ToIPEndPoint(quic::QuicSocketAddress address) {
+  if (!address.IsInitialized()) {
+    return IPEndPoint();
+  }
+
+  IPEndPoint result;
+  sockaddr_storage storage = address.generic_address();
+  const bool success = result.FromSockAddr(
+      reinterpret_cast<const sockaddr*>(&storage), sizeof(storage));
+  DCHECK(success);
+  return result;
+}
+
+inline IPAddress ToIPAddress(quic::QuicIpAddress address) {
+  if (!address.IsInitialized()) {
+    return IPAddress();
+  }
+
+  switch (address.address_family()) {
+    case quic::IpAddressFamily::IP_V4: {
+      in_addr raw_address = address.GetIPv4();
+      return IPAddress(reinterpret_cast<const uint8_t*>(&raw_address),
+                       sizeof(raw_address));
+    }
+    case quic::IpAddressFamily::IP_V6: {
+      in6_addr raw_address = address.GetIPv6();
+      return IPAddress(reinterpret_cast<const uint8_t*>(&raw_address),
+                       sizeof(raw_address));
+    }
+    default:
+      DCHECK_EQ(address.address_family(), quic::IpAddressFamily::IP_UNSPEC);
+      return IPAddress();
+  }
+}
+
+}  // namespace net
+
+#endif  // NET_QUIC_ADDRESS_UTILS_H_
diff --git a/chromium/net/quic/bidirectional_stream_quic_impl_unittest.cc b/chromium/net/quic/bidirectional_stream_quic_impl_unittest.cc
index 0a7fab132bf..3256fa84450 100644
--- a/chromium/net/quic/bidirectional_stream_quic_impl_unittest.cc
+++ b/chromium/net/quic/bidirectional_stream_quic_impl_unittest.cc
@@ -6,7 +6,6 @@
 
 #include <utility>
 
-#include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ -139,7 +138,7 @@ class TestDelegateBase : public BidirectionalStreamImpl::Delegate {
     ++on_data_read_count_;
     CHECK_GE(bytes_read, OK);
     data_received_.append(read_buf_->data(), bytes_read);
-    base::ResetAndReturn(&callback_).Run(bytes_read);
+    std::move(callback_).Run(bytes_read);
   }
 
   void OnDataSent() override {
@@ -393,7 +392,7 @@ class DeleteStreamDelegate : public TestDelegateBase {
 
 class BidirectionalStreamQuicImplTest
     : public ::testing::TestWithParam<
-          std::tuple<quic::QuicTransportVersion, bool>>,
+          std::tuple<quic::ParsedQuicVersion, bool>>,
       public WithScopedTaskEnvironment {
  protected:
   static const bool kFin = true;
@@ -500,8 +499,7 @@ class BidirectionalStreamQuicImplTest
         helper_.get(), alarm_factory_.get(),
         new QuicChromiumPacketWriter(socket.get(), runner_.get()),
         true /* owns_writer */, quic::Perspective::IS_CLIENT,
-        quic::test::SupportedVersions(
-            quic::ParsedQuicVersion(quic::PROTOCOL_QUIC_CRYPTO, version_)));
+        quic::test::SupportedVersions(version_));
     if (connection_->version().KnowsWhichDecrypterToUse()) {
       connection_->InstallDecrypter(quic::ENCRYPTION_FORWARD_SECURE,
                                     quic::QuicMakeUnique<quic::NullDecrypter>(
@@ -822,11 +820,12 @@ class BidirectionalStreamQuicImplTest
   QuicChromiumClientSession* session() const { return session_.get(); }
 
   quic::QuicStreamId GetNthClientInitiatedBidirectionalStreamId(int n) {
-    return quic::test::GetNthClientInitiatedBidirectionalStreamId(version_, n);
+    return quic::test::GetNthClientInitiatedBidirectionalStreamId(
+        version_.transport_version, n);
   }
 
   std::string ConstructDataHeader(size_t body_len) {
-    if (version_ != quic::QUIC_VERSION_99) {
+    if (version_.transport_version != quic::QUIC_VERSION_99) {
       return "";
     }
     quic::HttpEncoder encoder;
@@ -836,7 +835,7 @@ class BidirectionalStreamQuicImplTest
   }
 
  protected:
-  const quic::QuicTransportVersion version_;
+  const quic::ParsedQuicVersion version_;
   const bool client_headers_include_h2_stream_dependency_;
   BoundTestNetLog net_log_;
   scoped_refptr<TestTaskRunner> runner_;
@@ -869,9 +868,8 @@ class BidirectionalStreamQuicImplTest
 INSTANTIATE_TEST_SUITE_P(
     Version,
     BidirectionalStreamQuicImplTest,
-    ::testing::Combine(
-        ::testing::ValuesIn(quic::AllSupportedTransportVersions()),
-        ::testing::Bool()));
+    ::testing::Combine(::testing::ValuesIn(quic::AllVersionsExcept99()),
+                       ::testing::Bool()));
 
 TEST_P(BidirectionalStreamQuicImplTest, GetRequest) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
@@ -1065,7 +1063,7 @@ TEST_P(BidirectionalStreamQuicImplTest, CoalesceDataBuffersNotHeadersFrame) {
   AddWrite(ConstructRequestHeadersPacketInner(
       2, GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     AddWrite(ConstructClientMultipleDataFramesPacket(3, kIncludeVersion, !kFin,
                                                      0, {kBody1, kBody2}));
   } else {
@@ -1083,7 +1081,7 @@ TEST_P(BidirectionalStreamQuicImplTest, CoalesceDataBuffersNotHeadersFrame) {
   std::string header5 = ConstructDataHeader(strlen(kBody5));
   quic::QuicStreamOffset data_offset =
       strlen(kBody1) + strlen(kBody2) + header.length() + header2.length();
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     AddWrite(ConstructClientMultipleDataFramesPacket(
         5, !kIncludeVersion, kFin, data_offset, {kBody3, kBody4, kBody5}));
   } else {
@@ -1200,7 +1198,7 @@ TEST_P(BidirectionalStreamQuicImplTest,
   AddWrite(ConstructInitialSettingsPacket(1, &header_stream_offset));
   const char kBody1[] = "here are some data";
   std::string header = ConstructDataHeader(strlen(kBody1));
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     AddWrite(ConstructRequestHeadersAndMultipleDataFramesPacket(
         2, !kFin, DEFAULT_PRIORITY, &header_stream_offset,
         &spdy_request_headers_frame_length, {header, kBody1}));
@@ -1215,7 +1213,7 @@ TEST_P(BidirectionalStreamQuicImplTest,
   const char kBody2[] = "really small";
   std::string header2 = ConstructDataHeader(strlen(kBody2));
   quic::QuicStreamOffset data_offset = strlen(kBody1) + header.length();
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     AddWrite(ConstructClientMultipleDataFramesPacket(
         4, !kIncludeVersion, kFin, data_offset, {header2, kBody2}));
   } else {
@@ -1319,7 +1317,7 @@ TEST_P(BidirectionalStreamQuicImplTest,
   std::string header = ConstructDataHeader(strlen(kBody1));
   std::string header2 = ConstructDataHeader(strlen(kBody2));
 
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     AddWrite(ConstructRequestHeadersAndMultipleDataFramesPacket(
         2, !kFin, DEFAULT_PRIORITY, &header_stream_offset,
         &spdy_request_headers_frame_length, {header, kBody1, header2, kBody2}));
@@ -1339,7 +1337,7 @@ TEST_P(BidirectionalStreamQuicImplTest,
   std::string header5 = ConstructDataHeader(strlen(kBody5));
   quic::QuicStreamOffset data_offset =
       strlen(kBody1) + strlen(kBody2) + header.length() + header2.length();
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     AddWrite(ConstructClientMultipleDataFramesPacket(
         4, !kIncludeVersion, kFin, data_offset,
         {header3, kBody3, header4, kBody4, header5, kBody5}));
@@ -1526,7 +1524,7 @@ TEST_P(BidirectionalStreamQuicImplTest, PostRequest) {
       2, GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
   std::string header = ConstructDataHeader(strlen(kUploadData));
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     AddWrite(ConstructClientMultipleDataFramesPacket(3, kIncludeVersion, kFin,
                                                      0, {header, kUploadData}));
   } else {
@@ -1619,7 +1617,7 @@ TEST_P(BidirectionalStreamQuicImplTest, EarlyDataOverrideRequest) {
       2, GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
   std::string header = ConstructDataHeader(strlen(kUploadData));
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     AddWrite(ConstructClientMultipleDataFramesPacket(3, kIncludeVersion, kFin,
                                                      0, {header, kUploadData}));
   } else {
@@ -1714,7 +1712,7 @@ TEST_P(BidirectionalStreamQuicImplTest, InterleaveReadDataAndSendData) {
       &spdy_request_headers_frame_length, &header_stream_offset));
 
   std::string header = ConstructDataHeader(strlen(kUploadData));
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     AddWrite(ConstructAckAndDataPacket(3, !kIncludeVersion, 2, 1, 2, !kFin, 0,
                                        kUploadData, &client_maker_));
     AddWrite(ConstructAckAndDataPacket(4, !kIncludeVersion, 3, 3, 3, kFin,
@@ -2263,7 +2261,7 @@ TEST_P(BidirectionalStreamQuicImplTest, AsyncFinRead) {
       2, GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
       &spdy_request_headers_frame_length, &header_stream_offset));
   std::string header = ConstructDataHeader(strlen(kBody));
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     AddWrite(ConstructClientMultipleDataFramesPacket(3, kIncludeVersion, kFin,
                                                      0, {header, kBody}));
   } else {
diff --git a/chromium/net/quic/crypto/proof_verifier_chromium.cc b/chromium/net/quic/crypto/proof_verifier_chromium.cc
index f9bbdd92500..e222a7e0ec5 100644
--- a/chromium/net/quic/crypto/proof_verifier_chromium.cc
+++ b/chromium/net/quic/crypto/proof_verifier_chromium.cc
@@ -80,6 +80,8 @@ class ProofVerifierChromium::Job {
   quic::QuicAsyncStatus VerifyCertChain(
       const std::string& hostname,
       const std::vector<std::string>& certs,
+      const std::string& ocsp_response,
+      const std::string& cert_sct,
       std::string* error_details,
       std::unique_ptr<quic::ProofVerifyDetails>* verify_details,
       std::unique_ptr<quic::ProofVerifierCallback> callback);
@@ -101,6 +103,8 @@ class ProofVerifierChromium::Job {
   quic::QuicAsyncStatus VerifyCert(
       const string& hostname,
       const uint16_t port,
+      const std::string& ocsp_response,
+      const std::string& cert_sct,
       std::string* error_details,
       std::unique_ptr<quic::ProofVerifyDetails>* verify_details,
       std::unique_ptr<quic::ProofVerifierCallback> callback);
@@ -133,6 +137,10 @@ class ProofVerifierChromium::Job {
   std::string hostname_;
   // |port| specifies the target port for the connection.
   uint16_t port_;
+  // Encoded stapled OCSP response for |certs|.
+  std::string ocsp_response_;
+  // Encoded SignedCertificateTimestampList for |certs|.
+  std::string cert_sct_;
 
   std::unique_ptr<quic::ProofVerifierCallback> callback_;
   std::unique_ptr<ProofVerifyDetailsChromium> verify_details_;
@@ -242,13 +250,15 @@ quic::QuicAsyncStatus ProofVerifierChromium::Job::VerifyProof(
   }
 
   DCHECK(enforce_policy_checking_);
-  return VerifyCert(hostname, port, error_details, verify_details,
-                    std::move(callback));
+  return VerifyCert(hostname, port, /*ocsp_response=*/std::string(), cert_sct,
+                    error_details, verify_details, std::move(callback));
 }
 
 quic::QuicAsyncStatus ProofVerifierChromium::Job::VerifyCertChain(
     const string& hostname,
     const std::vector<string>& certs,
+    const std::string& ocsp_response,
+    const std::string& cert_sct,
     std::string* error_details,
     std::unique_ptr<quic::ProofVerifyDetails>* verify_details,
     std::unique_ptr<quic::ProofVerifierCallback> callback) {
@@ -272,8 +282,8 @@ quic::QuicAsyncStatus ProofVerifierChromium::Job::VerifyCertChain(
 
   enforce_policy_checking_ = false;
   // |port| is not needed because |enforce_policy_checking_| is false.
-  return VerifyCert(hostname, /*port=*/0, error_details, verify_details,
-                    std::move(callback));
+  return VerifyCert(hostname, /*port=*/0, ocsp_response, cert_sct,
+                    error_details, verify_details, std::move(callback));
 }
 
 bool ProofVerifierChromium::Job::GetX509Certificate(
@@ -307,11 +317,15 @@ bool ProofVerifierChromium::Job::GetX509Certificate(
 quic::QuicAsyncStatus ProofVerifierChromium::Job::VerifyCert(
     const string& hostname,
     const uint16_t port,
+    const std::string& ocsp_response,
+    const std::string& cert_sct,
     std::string* error_details,
     std::unique_ptr<quic::ProofVerifyDetails>* verify_details,
     std::unique_ptr<quic::ProofVerifierCallback> callback) {
   hostname_ = hostname;
   port_ = port;
+  ocsp_response_ = ocsp_response;
+  cert_sct_ = cert_sct;
 
   next_state_ = STATE_VERIFY_CERT;
   switch (DoLoop(OK)) {
@@ -369,7 +383,7 @@ int ProofVerifierChromium::Job::DoVerifyCert(int result) {
 
   return verifier_->Verify(
       CertVerifier::RequestParams(cert_, hostname_, cert_verify_flags_,
-                                  std::string()),
+                                  ocsp_response_, cert_sct_),
       &verify_details_->cert_verify_result,
       base::Bind(&ProofVerifierChromium::Job::OnIOComplete,
                  base::Unretained(this)),
@@ -606,6 +620,8 @@ quic::QuicAsyncStatus ProofVerifierChromium::VerifyProof(
 quic::QuicAsyncStatus ProofVerifierChromium::VerifyCertChain(
     const std::string& hostname,
     const std::vector<std::string>& certs,
+    const std::string& ocsp_response,
+    const std::string& cert_sct,
     const quic::ProofVerifyContext* verify_context,
     std::string* error_details,
     std::unique_ptr<quic::ProofVerifyDetails>* verify_details,
@@ -620,8 +636,9 @@ quic::QuicAsyncStatus ProofVerifierChromium::VerifyCertChain(
       this, cert_verifier_, ct_policy_enforcer_, transport_security_state_,
       cert_transparency_verifier_, chromium_context->cert_verify_flags,
       chromium_context->net_log);
-  quic::QuicAsyncStatus status = job->VerifyCertChain(
-      hostname, certs, error_details, verify_details, std::move(callback));
+  quic::QuicAsyncStatus status =
+      job->VerifyCertChain(hostname, certs, ocsp_response, cert_sct,
+                           error_details, verify_details, std::move(callback));
   if (status == quic::QUIC_PENDING) {
     Job* job_ptr = job.get();
     active_jobs_[job_ptr] = std::move(job);
diff --git a/chromium/net/quic/crypto/proof_verifier_chromium.h b/chromium/net/quic/crypto/proof_verifier_chromium.h
index abadc174468..8581056b2ae 100644
--- a/chromium/net/quic/crypto/proof_verifier_chromium.h
+++ b/chromium/net/quic/crypto/proof_verifier_chromium.h
@@ -93,6 +93,8 @@ class NET_EXPORT_PRIVATE ProofVerifierChromium : public quic::ProofVerifier {
   quic::QuicAsyncStatus VerifyCertChain(
       const std::string& hostname,
       const std::vector<std::string>& certs,
+      const std::string& ocsp_response,
+      const std::string& cert_sct,
       const quic::ProofVerifyContext* verify_context,
       std::string* error_details,
       std::unique_ptr<quic::ProofVerifyDetails>* verify_details,
diff --git a/chromium/net/quic/crypto/proof_verifier_chromium_test.cc b/chromium/net/quic/crypto/proof_verifier_chromium_test.cc
index 7d60c11c957..591f37ebfb5 100644
--- a/chromium/net/quic/crypto/proof_verifier_chromium_test.cc
+++ b/chromium/net/quic/crypto/proof_verifier_chromium_test.cc
@@ -123,8 +123,8 @@ class ProofVerifierChromiumTest : public ::testing::Test {
         .WillRepeatedly(
             Return(ct::CTPolicyCompliance::CT_POLICY_NOT_ENOUGH_SCTS));
 
-    scoped_refptr<const CTLogVerifier> log(CTLogVerifier::Create(
-        ct::GetTestPublicKey(), kLogDescription, "dns.example.com"));
+    scoped_refptr<const CTLogVerifier> log(
+        CTLogVerifier::Create(ct::GetTestPublicKey(), kLogDescription));
     ASSERT_TRUE(log);
     log_verifiers_.push_back(log);
 
@@ -1004,8 +1004,9 @@ TEST_F(ProofVerifierChromiumTest, VerifyCertChain) {
   std::unique_ptr<DummyProofVerifierCallback> callback(
       new DummyProofVerifierCallback);
   quic::QuicAsyncStatus status = proof_verifier.VerifyCertChain(
-      kTestHostname, certs_, verify_context_.get(), &error_details_, &details_,
-      std::move(callback));
+      kTestHostname, certs_, /*ocsp_response=*/std::string(),
+      /*cert_sct=*/std::string(), verify_context_.get(), &error_details_,
+      &details_, std::move(callback));
   ASSERT_EQ(quic::QUIC_SUCCESS, status);
 
   ASSERT_TRUE(details_.get());
diff --git a/chromium/net/quic/mock_crypto_client_stream.cc b/chromium/net/quic/mock_crypto_client_stream.cc
index c1144481e9d..3406b2c2968 100644
--- a/chromium/net/quic/mock_crypto_client_stream.cc
+++ b/chromium/net/quic/mock_crypto_client_stream.cc
@@ -275,11 +275,14 @@ void MockCryptoClientStream::SetConfigNegotiated() {
       QuicTime::Delta::FromSeconds(2 * kMaximumIdleTimeoutSecs),
       QuicTime::Delta::FromSeconds(kMaximumIdleTimeoutSecs));
   config.SetBytesForConnectionIdToSend(PACKET_8BYTE_CONNECTION_ID);
-  config.SetMaxIncomingDynamicStreamsToSend(kDefaultMaxStreamsPerConnection /
-                                            2);
+  config.SetMaxIncomingBidirectionalStreamsToSend(
+      kDefaultMaxStreamsPerConnection / 2);
+  config.SetMaxIncomingUnidirectionalStreamsToSend(
+      kDefaultMaxStreamsPerConnection / 2);
 
   CryptoHandshakeMessage msg;
-  config.ToHandshakeMessage(&msg);
+  config.ToHandshakeMessage(
+      &msg, session()->connection()->version().transport_version);
   std::string error_details;
   const QuicErrorCode error =
       session()->config()->ProcessPeerHello(msg, CLIENT, &error_details);
diff --git a/chromium/net/quic/mock_decrypter.cc b/chromium/net/quic/mock_decrypter.cc
index 689c58d0558..9576ea7c31e 100644
--- a/chromium/net/quic/mock_decrypter.cc
+++ b/chromium/net/quic/mock_decrypter.cc
@@ -11,10 +11,15 @@ using quic::DiversificationNonce;
 using quic::Perspective;
 using quic::QuicPacketNumber;
 using quic::QuicStringPiece;
-using quic::QuicTransportVersion;
 
 namespace net {
 
+namespace {
+
+const size_t kPaddingSize = 12;
+
+}  // namespace
+
 MockDecrypter::MockDecrypter(Perspective perspective) {}
 
 bool MockDecrypter::SetKey(QuicStringPiece key) {
@@ -54,12 +59,16 @@ bool MockDecrypter::DecryptPacket(uint64_t /*packet_number*/,
                                   char* output,
                                   size_t* output_length,
                                   size_t max_output_length) {
-  if (ciphertext.length() > max_output_length) {
+  if (ciphertext.length() < kPaddingSize) {
+    return false;
+  }
+  size_t plaintext_size = ciphertext.length() - kPaddingSize;
+  if (plaintext_size > max_output_length) {
     return false;
   }
 
-  memcpy(output, ciphertext.data(), ciphertext.length());
-  *output_length = ciphertext.length();
+  memcpy(output, ciphertext.data(), plaintext_size);
+  *output_length = plaintext_size;
   return true;
 }
 
diff --git a/chromium/net/quic/mock_decrypter.h b/chromium/net/quic/mock_decrypter.h
index 7b9256f281e..5b7f0e22483 100644
--- a/chromium/net/quic/mock_decrypter.h
+++ b/chromium/net/quic/mock_decrypter.h
@@ -17,10 +17,10 @@
 
 namespace net {
 
-// A MockDecrypter is a QuicDecrypter that does no validation of
-// the given ciphertext and returns it untouched, ignoring the
-// associated data. This is used to allow fuzzing to mutate
-// plaintext packets.
+// A MockDecrypter is a QuicDecrypter that strips the last 12 bytes of
+// ciphertext (which should be zeroes, but are ignored), and returns the
+// remaining ciphertext untouched and ignores the associated data. This is used
+// to allow fuzzing to mutate plaintext packets.
 class MockDecrypter : public quic::QuicDecrypter {
  public:
   explicit MockDecrypter(quic::Perspective perspective);
diff --git a/chromium/net/quic/mock_encrypter.cc b/chromium/net/quic/mock_encrypter.cc
index 147cddaa81c..f1ed64da051 100644
--- a/chromium/net/quic/mock_encrypter.cc
+++ b/chromium/net/quic/mock_encrypter.cc
@@ -11,10 +11,15 @@ using quic::DiversificationNonce;
 using quic::Perspective;
 using quic::QuicPacketNumber;
 using quic::QuicStringPiece;
-using quic::QuicTransportVersion;
 
 namespace net {
 
+namespace {
+
+const size_t kPaddingSize = 12;
+
+}  // namespace
+
 MockEncrypter::MockEncrypter(Perspective perspective) {}
 
 bool MockEncrypter::SetKey(QuicStringPiece key) {
@@ -35,11 +40,12 @@ bool MockEncrypter::EncryptPacket(uint64_t /*packet_number*/,
                                   char* output,
                                   size_t* output_length,
                                   size_t max_output_length) {
-  if (max_output_length < plaintext.size()) {
+  size_t ciphertext_size = plaintext.size() + kPaddingSize;
+  if (max_output_length < ciphertext_size) {
     return false;
   }
-  memcpy(output, plaintext.data(), plaintext.length());
-  *output_length = plaintext.size();
+  memcpy(output, plaintext.data(), ciphertext_size);
+  *output_length = ciphertext_size;
   return true;
 }
 
@@ -65,11 +71,11 @@ size_t MockEncrypter::GetIVSize() const {
 }
 
 size_t MockEncrypter::GetMaxPlaintextSize(size_t ciphertext_size) const {
-  return ciphertext_size;
+  return ciphertext_size - kPaddingSize;
 }
 
 size_t MockEncrypter::GetCiphertextSize(size_t plaintext_size) const {
-  return plaintext_size;
+  return plaintext_size + kPaddingSize;
 }
 
 QuicStringPiece MockEncrypter::GetKey() const {
diff --git a/chromium/net/quic/mock_encrypter.h b/chromium/net/quic/mock_encrypter.h
index 9200cf1a4ae..3deda2d9a9e 100644
--- a/chromium/net/quic/mock_encrypter.h
+++ b/chromium/net/quic/mock_encrypter.h
@@ -16,9 +16,9 @@
 
 namespace net {
 
-// A MockEncrypter is a QuicEncrypter that returns a plaintext
-// unmodified. No encryption or MAC is applied. This is used
-// to allow fuzzing to mutate plaintext packets.
+// A MockEncrypter is a QuicEncrypter that returns this plaintext followed by 12
+// bytes of zeroes. No encryption or MAC is applied. This is used to allow
+// fuzzing to mutate plaintext packets.
 class MockEncrypter : public quic::QuicEncrypter {
  public:
   explicit MockEncrypter(quic::Perspective perspective);
diff --git a/chromium/net/quic/platform/impl/quic_containers_impl.h b/chromium/net/quic/platform/impl/quic_containers_impl.h
index c7d4de9c27c..1b619a7adf0 100644
--- a/chromium/net/quic/platform/impl/quic_containers_impl.h
+++ b/chromium/net/quic/platform/impl/quic_containers_impl.h
@@ -13,7 +13,7 @@
 #include "base/containers/queue.h"
 #include "base/containers/small_map.h"
 #include "net/base/interval_set.h"
-#include "net/base/linked_hash_map.h"
+#include "net/third_party/quiche/src/common/simple_linked_hash_map.h"
 
 namespace quic {
 
@@ -43,7 +43,7 @@ using QuicUnorderedSetImpl = std::unordered_set<Key, Hash, Eq, Alloc>;
 
 // A map which offers insertion-ordered iteration.
 template <typename Key, typename Value, typename Hash>
-using QuicLinkedHashMapImpl = net::linked_hash_map<Key, Value, Hash>;
+using QuicLinkedHashMapImpl = quiche::SimpleLinkedHashMap<Key, Value, Hash>;
 
 // A map which is faster than (for example) hash_map for a certain number of
 // unique key-value-pair elements, and upgrades itself to unordered_map when
diff --git a/chromium/net/quic/platform/impl/quic_default_proof_providers_impl.cc b/chromium/net/quic/platform/impl/quic_default_proof_providers_impl.cc
index 1a80e1be0c6..d40162d639d 100644
--- a/chromium/net/quic/platform/impl/quic_default_proof_providers_impl.cc
+++ b/chromium/net/quic/platform/impl/quic_default_proof_providers_impl.cc
@@ -7,6 +7,8 @@
 #include <utility>
 
 #include "base/files/file_path.h"
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert/ct_log_verifier.h"
 #include "net/cert/ct_policy_enforcer.h"
@@ -53,7 +55,7 @@ class ProofVerifierChromiumWithOwnership : public net::ProofVerifierChromium {
 
 std::unique_ptr<ProofVerifier> CreateDefaultProofVerifierImpl() {
   std::unique_ptr<net::CertVerifier> cert_verifier =
-      net::CertVerifier::CreateDefault();
+      net::CertVerifier::CreateDefault(/*cert_net_fetcher=*/nullptr);
   return QuicMakeUnique<ProofVerifierChromiumWithOwnership>(
       std::move(cert_verifier));
 }
@@ -61,8 +63,14 @@ std::unique_ptr<ProofVerifier> CreateDefaultProofVerifierImpl() {
 std::unique_ptr<ProofSource> CreateDefaultProofSourceImpl() {
   auto proof_source = std::make_unique<net::ProofSourceChromium>();
   CHECK(proof_source->Initialize(
+#if defined(OS_WIN)
+      base::FilePath(base::UTF8ToWide(GetQuicFlag(FLAGS_certificate_file))),
+      base::FilePath(base::UTF8ToWide(GetQuicFlag(FLAGS_key_file))),
+      base::FilePath()));
+#else
       base::FilePath(GetQuicFlag(FLAGS_certificate_file)),
       base::FilePath(GetQuicFlag(FLAGS_key_file)), base::FilePath()));
+#endif
   return std::move(proof_source);
 }
 
diff --git a/chromium/net/quic/platform/impl/quic_epoll_clock.cc b/chromium/net/quic/platform/impl/quic_epoll_clock.cc
index dfba1552335..7a84a684f34 100644
--- a/chromium/net/quic/platform/impl/quic_epoll_clock.cc
+++ b/chromium/net/quic/platform/impl/quic_epoll_clock.cc
@@ -4,13 +4,13 @@
 
 #include "net/quic/platform/impl/quic_epoll_clock.h"
 
+#include "net/third_party/quiche/src/epoll_server/simple_epoll_server.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
-#include "net/tools/epoll_server/epoll_server.h"
 
 namespace quic {
 
-QuicEpollClock::QuicEpollClock(net::EpollServer* epoll_server)
+QuicEpollClock::QuicEpollClock(epoll_server::SimpleEpollServer* epoll_server)
     : epoll_server_(epoll_server), largest_time_(QuicTime::Zero()) {}
 
 QuicEpollClock::~QuicEpollClock() {}
diff --git a/chromium/net/quic/platform/impl/quic_epoll_clock.h b/chromium/net/quic/platform/impl/quic_epoll_clock.h
index f20df24aa40..cece73fba46 100644
--- a/chromium/net/quic/platform/impl/quic_epoll_clock.h
+++ b/chromium/net/quic/platform/impl/quic_epoll_clock.h
@@ -10,17 +10,19 @@
 #include "net/third_party/quiche/src/quic/core/quic_time.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_clock.h"
 
-namespace quic {}  // namespace quic
-namespace net {
-class EpollServer;
-}  // namespace net
+namespace epoll_server {
+
+class SimpleEpollServer;
+
+}  // namespace epoll_server
+
 namespace quic {
 
 // Clock to efficiently retrieve an approximately accurate time from an
 // net::EpollServer.
 class QuicEpollClock : public QuicClock {
  public:
-  explicit QuicEpollClock(net::EpollServer* epoll_server);
+  explicit QuicEpollClock(epoll_server::SimpleEpollServer* epoll_server);
   ~QuicEpollClock() override;
 
   // Returns the approximate current time as a QuicTime object.
@@ -40,7 +42,7 @@ class QuicEpollClock : public QuicClock {
       const QuicWallTime& walltime) const override;
 
  protected:
-  net::EpollServer* epoll_server_;
+  epoll_server::SimpleEpollServer* epoll_server_;
   // Largest time returned from Now() so far.
   mutable QuicTime largest_time_;
 
diff --git a/chromium/net/quic/platform/impl/quic_epoll_clock_test.cc b/chromium/net/quic/platform/impl/quic_epoll_clock_test.cc
index 75caf111c99..d641f54a852 100644
--- a/chromium/net/quic/platform/impl/quic_epoll_clock_test.cc
+++ b/chromium/net/quic/platform/impl/quic_epoll_clock_test.cc
@@ -4,9 +4,9 @@
 
 #include "net/quic/platform/impl/quic_epoll_clock.h"
 
+#include "net/third_party/quiche/src/epoll_server/fake_simple_epoll_server.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/tools/epoll_server/fake_epoll_server.h"
 
 namespace quic {
 namespace test {
@@ -14,7 +14,7 @@ namespace test {
 class QuicEpollClockTest : public QuicTest {};
 
 TEST_F(QuicEpollClockTest, ApproximateNowInUsec) {
-  FakeEpollServer epoll_server;
+  epoll_server::test::FakeSimpleEpollServer epoll_server;
   QuicEpollClock clock(&epoll_server);
 
   epoll_server.set_now_in_usec(1000000);
@@ -35,7 +35,7 @@ TEST_F(QuicEpollClockTest, ApproximateNowInUsec) {
 }
 
 TEST_F(QuicEpollClockTest, NowInUsec) {
-  FakeEpollServer epoll_server;
+  epoll_server::test::FakeSimpleEpollServer epoll_server;
   QuicEpollClock clock(&epoll_server);
 
   epoll_server.set_now_in_usec(1000000);
@@ -47,7 +47,7 @@ TEST_F(QuicEpollClockTest, NowInUsec) {
 
 TEST_F(QuicEpollClockTest, MonotonicityWithRealEpollClock) {
   SetQuicReloadableFlag(quic_monotonic_epoll_clock, true);
-  net::EpollServer epoll_server;
+  epoll_server::SimpleEpollServer epoll_server;
   QuicEpollClock clock(&epoll_server);
 
   quic::QuicTime last_now = clock.Now();
@@ -61,7 +61,7 @@ TEST_F(QuicEpollClockTest, MonotonicityWithRealEpollClock) {
 }
 
 TEST_F(QuicEpollClockTest, MonotonicityWithFakeEpollClock) {
-  FakeEpollServer epoll_server;
+  epoll_server::test::FakeSimpleEpollServer epoll_server;
   QuicEpollClock clock(&epoll_server);
 
   epoll_server.set_now_in_usec(100);
diff --git a/chromium/net/quic/platform/impl/quic_epoll_impl.h b/chromium/net/quic/platform/impl/quic_epoll_impl.h
index 94a5b0b0218..f53ef8bce2b 100644
--- a/chromium/net/quic/platform/impl/quic_epoll_impl.h
+++ b/chromium/net/quic/platform/impl/quic_epoll_impl.h
@@ -10,14 +10,14 @@
 #ifndef NET_QUIC_PLATFORM_IMPL_QUIC_EPOLL_IMPL_H_
 #define NET_QUIC_PLATFORM_IMPL_QUIC_EPOLL_IMPL_H_
 
-#include "net/tools/epoll_server/epoll_server.h"
+#include "net/third_party/quiche/src/epoll_server/simple_epoll_server.h"
 
 namespace quic {
 
-using QuicEpollServerImpl = ::net::EpollServer;
-using QuicEpollEventImpl = ::net::EpollEvent;
-using QuicEpollAlarmBaseImpl = ::net::EpollAlarm;
-using QuicEpollCallbackInterfaceImpl = ::net::EpollCallbackInterface;
+using QuicEpollServerImpl = epoll_server::SimpleEpollServer;
+using QuicEpollEventImpl = epoll_server::EpollEvent;
+using QuicEpollAlarmBaseImpl = epoll_server::EpollAlarm;
+using QuicEpollCallbackInterfaceImpl = epoll_server::EpollCallbackInterface;
 
 }  // namespace quic
 
diff --git a/chromium/net/quic/platform/impl/quic_epoll_test_tools_impl.h b/chromium/net/quic/platform/impl/quic_epoll_test_tools_impl.h
index ed7443c0caa..1cde56a3a1a 100644
--- a/chromium/net/quic/platform/impl/quic_epoll_test_tools_impl.h
+++ b/chromium/net/quic/platform/impl/quic_epoll_test_tools_impl.h
@@ -5,8 +5,8 @@
 #ifndef NET_QUIC_PLATFORM_IMPL_QUIC_EPOLL_TEST_TOOLS_IMPL_H_
 #define NET_QUIC_PLATFORM_IMPL_QUIC_EPOLL_TEST_TOOLS_IMPL_H_
 
-#include "net/tools/epoll_server/fake_epoll_server.h"
+#include "net/third_party/quiche/src/epoll_server/fake_simple_epoll_server.h"
 
-using QuicFakeEpollServerImpl = quic::test::FakeEpollServer;
+using QuicFakeEpollServerImpl = epoll_server::test::FakeSimpleEpollServer;
 
 #endif  // NET_QUIC_PLATFORM_IMPL_QUIC_EPOLL_TEST_TOOLS_IMPL_H_
diff --git a/chromium/net/quic/platform/impl/quic_flag_utils_impl.h b/chromium/net/quic/platform/impl/quic_flag_utils_impl.h
index 846826c7970..b50e3e0a98f 100644
--- a/chromium/net/quic/platform/impl/quic_flag_utils_impl.h
+++ b/chromium/net/quic/platform/impl/quic_flag_utils_impl.h
@@ -8,12 +8,12 @@
 #include "base/logging.h"
 
 #define QUIC_RELOADABLE_FLAG_COUNT_IMPL(flag) \
-  DVLOG(2) << "FLAG_" #flag ": " << FLAGS_quic_reloadable_flag_##flag
+  DVLOG(3) << "FLAG_" #flag ": " << FLAGS_quic_reloadable_flag_##flag
 #define QUIC_RELOADABLE_FLAG_COUNT_N_IMPL(flag, instance, total) \
   QUIC_RELOADABLE_FLAG_COUNT_IMPL(flag)
 
 #define QUIC_RESTART_FLAG_COUNT_IMPL(flag) \
-  DVLOG(2) << "FLAG_" #flag ": " << FLAGS_quic_restart_flag_##flag
+  DVLOG(3) << "FLAG_" #flag ": " << FLAGS_quic_restart_flag_##flag
 #define QUIC_RESTART_FLAG_COUNT_N_IMPL(flag, instance, total) \
   QUIC_RESTART_FLAG_COUNT_IMPL(flag)
 
diff --git a/chromium/net/quic/platform/impl/quic_flags_impl.cc b/chromium/net/quic/platform/impl/quic_flags_impl.cc
index d3a9e8dc5cd..3cd9d447e09 100644
--- a/chromium/net/quic/platform/impl/quic_flags_impl.cc
+++ b/chromium/net/quic/platform/impl/quic_flags_impl.cc
@@ -201,6 +201,11 @@ std::vector<std::string> QuicParseCommandLineFlagsImpl(
   if (result.exit_status.has_value()) {
     exit(*result.exit_status);
   }
+
+  logging::LoggingSettings settings;
+  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
+  CHECK(logging::InitLogging(settings));
+
   return result.non_flag_args;
 }
 
diff --git a/chromium/net/quic/platform/impl/quic_flags_impl.h b/chromium/net/quic/platform/impl/quic_flags_impl.h
index 6ec16b7bdf4..fbc9a93a81c 100644
--- a/chromium/net/quic/platform/impl/quic_flags_impl.h
+++ b/chromium/net/quic/platform/impl/quic_flags_impl.h
@@ -46,27 +46,7 @@ inline std::string GetQuicFlagImpl(const std::string& flag) {
   return flag;
 }
 
-inline void SetQuicFlagImpl(bool* f, bool v) {
-  *f = v;
-}
-inline void SetQuicFlagImpl(int32_t* f, int32_t v) {
-  *f = v;
-}
-inline void SetQuicFlagImpl(uint32_t* f, uint32_t v) {
-  *f = v;
-}
-inline void SetQuicFlagImpl(int64_t* f, int64_t v) {
-  *f = v;
-}
-inline void SetQuicFlagImpl(uint64_t* f, uint64_t v) {
-  *f = v;
-}
-inline void SetQuicFlagImpl(double* f, double v) {
-  *f = v;
-}
-inline void SetQuicFlagImpl(std::string* f, const std::string& v) {
-  *f = v;
-}
+#define SetQuicFlagImpl(flag, value) ((flag) = (value))
 
 namespace quic {
 
@@ -207,10 +187,10 @@ QUIC_EXPORT_PRIVATE void QuicPrintCommandLineFlagHelpImpl(const char* usage);
 
 #define GetQuicReloadableFlagImpl(flag) GetQuicFlag(RELOADABLE_FLAG(flag))
 #define SetQuicReloadableFlagImpl(flag, value) \
-  SetQuicFlag(&RELOADABLE_FLAG(flag), value)
+  SetQuicFlag(RELOADABLE_FLAG(flag), value)
 #define GetQuicRestartFlagImpl(flag) GetQuicFlag(RESTART_FLAG(flag))
 #define SetQuicRestartFlagImpl(flag, value) \
-  SetQuicFlag(&RESTART_FLAG(flag), value)
+  SetQuicFlag(RESTART_FLAG(flag), value)
 
 }  // namespace quic
 #endif  // NET_QUIC_PLATFORM_IMPL_QUIC_FLAGS_IMPL_H_
diff --git a/chromium/net/quic/platform/impl/quic_flags_test.cc b/chromium/net/quic/platform/impl/quic_flags_test.cc
index aeb1599a99d..ce96ce91853 100644
--- a/chromium/net/quic/platform/impl/quic_flags_test.cc
+++ b/chromium/net/quic/platform/impl/quic_flags_test.cc
@@ -77,7 +77,7 @@ TEST_F(QuicCommandLineFlagTest, NotSpecified) {
 TEST_F(QuicCommandLineFlagTest, BoolFlag) {
   for (const char* s :
        {"--foo", "--foo=1", "--foo=t", "--foo=True", "--foo=Y", "--foo=yes"}) {
-    SetQuicFlag(&FLAGS_foo, false);
+    SetQuicFlag(FLAGS_foo, false);
     const char* argv[]{"argv0", s};
     auto parse_result = QuicParseCommandLineFlagsForTest(
         "usage message", base::size(argv), argv);
@@ -88,7 +88,7 @@ TEST_F(QuicCommandLineFlagTest, BoolFlag) {
 
   for (const char* s :
        {"--foo=0", "--foo=f", "--foo=False", "--foo=N", "--foo=no"}) {
-    SetQuicFlag(&FLAGS_foo, true);
+    SetQuicFlag(FLAGS_foo, true);
     const char* argv[]{"argv0", s};
     auto parse_result = QuicParseCommandLineFlagsForTest(
         "usage message", base::size(argv), argv);
@@ -98,7 +98,7 @@ TEST_F(QuicCommandLineFlagTest, BoolFlag) {
   }
 
   for (const char* s : {"--foo=7", "--foo=abc", "--foo=trueish"}) {
-    SetQuicFlag(&FLAGS_foo, false);
+    SetQuicFlag(FLAGS_foo, false);
     const char* argv[]{"argv0", s};
 
     testing::internal::CaptureStderr();
@@ -117,7 +117,7 @@ TEST_F(QuicCommandLineFlagTest, BoolFlag) {
 
 TEST_F(QuicCommandLineFlagTest, Int32Flag) {
   for (const int i : {-1, 0, 100, 38239832}) {
-    SetQuicFlag(&FLAGS_bar, 0);
+    SetQuicFlag(FLAGS_bar, 0);
     std::string flag_str = base::StringPrintf("--bar=%d", i);
     const char* argv[]{"argv0", flag_str.c_str()};
     auto parse_result = QuicParseCommandLineFlagsForTest(
@@ -128,7 +128,7 @@ TEST_F(QuicCommandLineFlagTest, Int32Flag) {
   }
 
   for (const char* s : {"--bar", "--bar=a", "--bar=9999999999999"}) {
-    SetQuicFlag(&FLAGS_bar, 0);
+    SetQuicFlag(FLAGS_bar, 0);
     const char* argv[]{"argv0", s};
 
     testing::internal::CaptureStderr();
@@ -147,7 +147,7 @@ TEST_F(QuicCommandLineFlagTest, Int32Flag) {
 
 TEST_F(QuicCommandLineFlagTest, StringFlag) {
   {
-    SetQuicFlag(&FLAGS_baz, "whee");
+    SetQuicFlag(FLAGS_baz, "whee");
     const char* argv[]{"argv0", "--baz"};
     auto parse_result = QuicParseCommandLineFlagsForTest(
         "usage message", base::size(argv), argv);
@@ -157,7 +157,7 @@ TEST_F(QuicCommandLineFlagTest, StringFlag) {
   }
 
   for (const char* s : {"", "12345", "abcdefg"}) {
-    SetQuicFlag(&FLAGS_baz, "qux");
+    SetQuicFlag(FLAGS_baz, "qux");
     std::string flag_str = base::StrCat({"--baz=", s});
     const char* argv[]{"argv0", flag_str.c_str()};
     auto parse_result = QuicParseCommandLineFlagsForTest(
diff --git a/chromium/net/quic/platform/impl/quic_ip_address_impl.cc b/chromium/net/quic/platform/impl/quic_ip_address_impl.cc
index 85af5747be0..37fa7427277 100644
--- a/chromium/net/quic/platform/impl/quic_ip_address_impl.cc
+++ b/chromium/net/quic/platform/impl/quic_ip_address_impl.cc
@@ -140,4 +140,14 @@ bool QuicIpAddressImpl::InSameSubnet(const QuicIpAddressImpl& other,
                                      subnet_length);
 }
 
+in_addr QuicIpAddressImpl::GetIPv4() const {
+  DCHECK_EQ(sizeof(in_addr), ip_address_.bytes().size());
+  return *(reinterpret_cast<const in_addr*>(ip_address_.bytes().data()));
+}
+
+in6_addr QuicIpAddressImpl::GetIPv6() const {
+  DCHECK_EQ(sizeof(in6_addr), ip_address_.bytes().size());
+  return *(reinterpret_cast<const in6_addr*>(ip_address_.bytes().data()));
+}
+
 }  // namespace quic
diff --git a/chromium/net/quic/platform/impl/quic_ip_address_impl.h b/chromium/net/quic/platform/impl/quic_ip_address_impl.h
index 6eefe666386..84579fe06b7 100644
--- a/chromium/net/quic/platform/impl/quic_ip_address_impl.h
+++ b/chromium/net/quic/platform/impl/quic_ip_address_impl.h
@@ -56,8 +56,10 @@ class QUIC_EXPORT_PRIVATE QuicIpAddressImpl {
   bool FromString(std::string str);
   bool IsIPv4() const;
   bool IsIPv6() const;
-
   bool InSameSubnet(const QuicIpAddressImpl& other, int subnet_length);
+
+  in_addr GetIPv4() const;
+  in6_addr GetIPv6() const;
   const net::IPAddress& ip_address() const { return ip_address_; }
 
  private:
diff --git a/chromium/net/quic/platform/impl/quic_mem_slice_impl.h b/chromium/net/quic/platform/impl/quic_mem_slice_impl.h
index 27ef7729c46..95cddf3aa4a 100644
--- a/chromium/net/quic/platform/impl/quic_mem_slice_impl.h
+++ b/chromium/net/quic/platform/impl/quic_mem_slice_impl.h
@@ -45,6 +45,10 @@ class QUIC_EXPORT_PRIVATE QuicMemSliceImpl {
 
   bool empty() const { return length_ == 0; }
 
+  scoped_refptr<net::IOBuffer>* impl() { return &io_buffer_; }
+
+  size_t* impl_length() { return &length_; }
+
  private:
   scoped_refptr<net::IOBuffer> io_buffer_;
   // Length of io_buffer_.
diff --git a/chromium/net/quic/platform/impl/quic_mem_slice_span_impl.cc b/chromium/net/quic/platform/impl/quic_mem_slice_span_impl.cc
index 606c0d7ed12..a7837f43313 100644
--- a/chromium/net/quic/platform/impl/quic_mem_slice_span_impl.cc
+++ b/chromium/net/quic/platform/impl/quic_mem_slice_span_impl.cc
@@ -8,10 +8,13 @@ namespace quic {
 
 QuicMemSliceSpanImpl::QuicMemSliceSpanImpl(
     const scoped_refptr<net::IOBuffer>* buffers,
-    const int* lengths,
+    const size_t* lengths,
     size_t num_buffers)
     : buffers_(buffers), lengths_(lengths), num_buffers_(num_buffers) {}
 
+QuicMemSliceSpanImpl::QuicMemSliceSpanImpl(QuicMemSliceImpl* slice)
+    : QuicMemSliceSpanImpl(slice->impl(), slice->impl_length(), 1) {}
+
 QuicMemSliceSpanImpl::QuicMemSliceSpanImpl(const QuicMemSliceSpanImpl& other) =
     default;
 QuicMemSliceSpanImpl& QuicMemSliceSpanImpl::operator=(
diff --git a/chromium/net/quic/platform/impl/quic_mem_slice_span_impl.h b/chromium/net/quic/platform/impl/quic_mem_slice_span_impl.h
index 90785fe499b..ba63a3e938d 100644
--- a/chromium/net/quic/platform/impl/quic_mem_slice_span_impl.h
+++ b/chromium/net/quic/platform/impl/quic_mem_slice_span_impl.h
@@ -17,8 +17,9 @@ namespace quic {
 class QUIC_EXPORT_PRIVATE QuicMemSliceSpanImpl {
  public:
   QuicMemSliceSpanImpl(const scoped_refptr<net::IOBuffer>* buffers,
-                       const int* lengths,
+                       const size_t* lengths,
                        size_t num_buffers);
+  explicit QuicMemSliceSpanImpl(QuicMemSliceImpl* slice);
 
   QuicMemSliceSpanImpl(const QuicMemSliceSpanImpl& other);
   QuicMemSliceSpanImpl& operator=(const QuicMemSliceSpanImpl& other);
@@ -54,7 +55,7 @@ class QUIC_EXPORT_PRIVATE QuicMemSliceSpanImpl {
 
  private:
   const scoped_refptr<net::IOBuffer>* buffers_;
-  const int* lengths_;
+  const size_t* lengths_;
   // Not const so that the move operator can work properly.
   size_t num_buffers_;
 };
diff --git a/chromium/net/quic/platform/impl/quic_mem_slice_storage_impl.h b/chromium/net/quic/platform/impl/quic_mem_slice_storage_impl.h
index 9987942367c..9e91fff9a37 100644
--- a/chromium/net/quic/platform/impl/quic_mem_slice_storage_impl.h
+++ b/chromium/net/quic/platform/impl/quic_mem_slice_storage_impl.h
@@ -35,7 +35,7 @@ class QUIC_EXPORT_PRIVATE QuicMemSliceStorageImpl {
 
  private:
   std::vector<scoped_refptr<net::IOBuffer>> buffers_;
-  std::vector<int> lengths_;
+  std::vector<size_t> lengths_;
 };
 
 }  // namespace quic
diff --git a/chromium/net/quic/platform/impl/quic_optional_impl.h b/chromium/net/quic/platform/impl/quic_optional_impl.h
new file mode 100644
index 00000000000..a21af4ea67f
--- /dev/null
+++ b/chromium/net/quic/platform/impl/quic_optional_impl.h
@@ -0,0 +1,17 @@
+// Copyright 2019 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.
+
+#ifndef NET_QUIC_PLATFORM_IMPL_QUIC_OPTIONAL_IMPL_H_
+#define NET_QUIC_PLATFORM_IMPL_QUIC_OPTIONAL_IMPL_H_
+
+#include "base/optional.h"
+
+namespace quic {
+
+template <typename T>
+using QuicOptionalImpl = base::Optional<T>;
+
+}  // namespace quic
+
+#endif  // NET_QUIC_PLATFORM_IMPL_QUIC_OPTIONAL_IMPL_H_
diff --git a/chromium/net/quic/platform/impl/quic_socket_address_impl.cc b/chromium/net/quic/platform/impl/quic_socket_address_impl.cc
index bc228d077c8..952a1823f1d 100644
--- a/chromium/net/quic/platform/impl/quic_socket_address_impl.cc
+++ b/chromium/net/quic/platform/impl/quic_socket_address_impl.cc
@@ -5,6 +5,7 @@
 #include "net/quic/platform/impl/quic_socket_address_impl.h"
 
 #include "net/base/sockaddr_storage.h"
+#include "net/quic/address_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
 
 using std::string;
@@ -14,9 +15,9 @@ namespace quic {
 QuicSocketAddressImpl::QuicSocketAddressImpl(const net::IPEndPoint& address)
     : socket_address_(address) {}
 
-QuicSocketAddressImpl::QuicSocketAddressImpl(QuicIpAddressImpl address,
+QuicSocketAddressImpl::QuicSocketAddressImpl(QuicIpAddress address,
                                              uint16_t port)
-    : socket_address_(address.ip_address(), port) {}
+    : socket_address_(net::ToIPAddress(address), port) {}
 
 QuicSocketAddressImpl::QuicSocketAddressImpl(
     const struct sockaddr_storage& saddr) {
diff --git a/chromium/net/quic/platform/impl/quic_socket_address_impl.h b/chromium/net/quic/platform/impl/quic_socket_address_impl.h
index e6d08d2a8c0..a6fa5439fe5 100644
--- a/chromium/net/quic/platform/impl/quic_socket_address_impl.h
+++ b/chromium/net/quic/platform/impl/quic_socket_address_impl.h
@@ -6,8 +6,8 @@
 #define NET_QUIC_PLATFORM_IMPL_QUIC_SOCKET_ADDRESS_IMPL_H_
 
 #include "net/base/ip_endpoint.h"
-#include "net/quic/platform/impl/quic_ip_address_impl.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_ip_address.h"
 
 namespace quic {
 
@@ -15,7 +15,7 @@ class QUIC_EXPORT_PRIVATE QuicSocketAddressImpl {
  public:
   QuicSocketAddressImpl() = default;
   explicit QuicSocketAddressImpl(const net::IPEndPoint& addr);
-  QuicSocketAddressImpl(QuicIpAddressImpl address, uint16_t port);
+  QuicSocketAddressImpl(QuicIpAddress address, uint16_t port);
   explicit QuicSocketAddressImpl(const struct sockaddr_storage& saddr);
   explicit QuicSocketAddressImpl(const struct sockaddr& saddr);
   QuicSocketAddressImpl(const QuicSocketAddressImpl& other) = default;
diff --git a/chromium/net/quic/platform/impl/quic_system_event_loop_impl.h b/chromium/net/quic/platform/impl/quic_system_event_loop_impl.h
index b3afccac3dc..e4654c59c36 100644
--- a/chromium/net/quic/platform/impl/quic_system_event_loop_impl.h
+++ b/chromium/net/quic/platform/impl/quic_system_event_loop_impl.h
@@ -16,7 +16,7 @@ inline void QuicRunSystemEventLoopIterationImpl() {
 class QuicSystemEventLoopImpl {
  public:
   QuicSystemEventLoopImpl(std::string context_name) {
-    base::ThreadPool::CreateAndStartWithDefaultParams(context_name);
+    base::ThreadPoolInstance::CreateAndStartWithDefaultParams(context_name);
   }
 
  private:
diff --git a/chromium/net/quic/platform/impl/quic_test_impl.cc b/chromium/net/quic/platform/impl/quic_test_impl.cc
index f1c3c06bdfe..a7e57370c45 100644
--- a/chromium/net/quic/platform/impl/quic_test_impl.cc
+++ b/chromium/net/quic/platform/impl/quic_test_impl.cc
@@ -27,3 +27,15 @@ std::string QuicGetTestMemoryCachePathImpl() {
   // The file path is known to be an ascii string.
   return path.MaybeAsASCII();
 }
+
+namespace quic {
+ParsedQuicVersionVector AllVersionsExcept99() {
+  ParsedQuicVersionVector result;
+  for (const ParsedQuicVersion& version : AllSupportedVersions()) {
+    if (version.transport_version != QUIC_VERSION_99) {
+      result.push_back(version);
+    }
+  }
+  return result;
+}
+}  // namespace quic
diff --git a/chromium/net/quic/platform/impl/quic_test_impl.h b/chromium/net/quic/platform/impl/quic_test_impl.h
index a95fe606ba7..72f248533bc 100644
--- a/chromium/net/quic/platform/impl/quic_test_impl.h
+++ b/chromium/net/quic/platform/impl/quic_test_impl.h
@@ -7,9 +7,11 @@
 
 #include "base/logging.h"
 #include "net/test/test_with_scoped_task_environment.h"
+#include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
-#include "testing/gmock/include/gmock/gmock.h"  // IWYU pragma: export
-#include "testing/gtest/include/gtest/gtest.h"  // IWYU pragma: export
+#include "testing/gmock/include/gmock/gmock.h"      // IWYU pragma: export
+#include "testing/gtest/include/gtest/gtest-spi.h"  // IWYU pragma: export
+#include "testing/gtest/include/gtest/gtest.h"      // IWYU pragma: export
 
 // When constructed, saves the current values of all QUIC flags. When
 // destructed, restores all QUIC flags to the saved values.
@@ -65,4 +67,14 @@ class ScopedEnvironmentForThreadsImpl {
 
 std::string QuicGetTestMemoryCachePathImpl();
 
+namespace quic {
+// A utility function that returns all versions except v99.  Intended to be a
+// drop-in replacement for quic::AllSupportedVersion() when disabling v99 in a
+// large test file is required.
+//
+// TODO(vasilvv): all of the tests should be fixed for v99, so that this
+// function can be removed.
+ParsedQuicVersionVector AllVersionsExcept99();
+}  // namespace quic
+
 #endif  // NET_QUIC_PLATFORM_IMPL_QUIC_TEST_IMPL_H_
diff --git a/chromium/net/quic/platform/impl/quic_test_mem_slice_vector_impl.cc b/chromium/net/quic/platform/impl/quic_test_mem_slice_vector_impl.cc
index ff0c376f4f6..b1c3198d973 100644
--- a/chromium/net/quic/platform/impl/quic_test_mem_slice_vector_impl.cc
+++ b/chromium/net/quic/platform/impl/quic_test_mem_slice_vector_impl.cc
@@ -21,6 +21,20 @@ QuicTestMemSliceVectorImpl::QuicTestMemSliceVectorImpl(
   }
 }
 
+QuicTestMemSliceVectorImpl::QuicTestMemSliceVectorImpl(
+    QuicTestMemSliceVectorImpl&& other) {
+  *this = std::move(other);
+}
+
+QuicTestMemSliceVectorImpl& QuicTestMemSliceVectorImpl::operator=(
+    QuicTestMemSliceVectorImpl&& other) {
+  if (this != &other) {
+    buffers_ = std::move(other.buffers_);
+    lengths_ = std::move(other.lengths_);
+  }
+  return *this;
+}
+
 QuicMemSliceSpanImpl QuicTestMemSliceVectorImpl::span() {
   return QuicMemSliceSpanImpl(buffers_.data(), lengths_.data(),
                               buffers_.size());
diff --git a/chromium/net/quic/platform/impl/quic_test_mem_slice_vector_impl.h b/chromium/net/quic/platform/impl/quic_test_mem_slice_vector_impl.h
index 26acc2f30c1..3b2ac14ee47 100644
--- a/chromium/net/quic/platform/impl/quic_test_mem_slice_vector_impl.h
+++ b/chromium/net/quic/platform/impl/quic_test_mem_slice_vector_impl.h
@@ -5,6 +5,8 @@
 #ifndef NET_QUIC_PLATFORM_IMPL_QUIC_TEST_MEM_SLICE_VECTOR_IMPL_H_
 #define NET_QUIC_PLATFORM_IMPL_QUIC_TEST_MEM_SLICE_VECTOR_IMPL_H_
 
+#include <memory>
+
 #include "net/quic/platform/impl/quic_mem_slice_span_impl.h"
 
 namespace quic {
@@ -25,11 +27,14 @@ class QuicTestMemSliceVectorImpl {
       std::vector<std::pair<char*, size_t>> buffers);
   ~QuicTestMemSliceVectorImpl();
 
+  QuicTestMemSliceVectorImpl(QuicTestMemSliceVectorImpl&& other);
+  QuicTestMemSliceVectorImpl& operator=(QuicTestMemSliceVectorImpl&& other);
+
   QuicMemSliceSpanImpl span();
 
  private:
   std::vector<scoped_refptr<net::IOBuffer>> buffers_;
-  std::vector<int> lengths_;
+  std::vector<size_t> lengths_;
 };
 
 }  // namespace test
diff --git a/chromium/net/quic/quic_chromium_client_session.cc b/chromium/net/quic/quic_chromium_client_session.cc
index b9744c8b598..dfd04101031 100644
--- a/chromium/net/quic/quic_chromium_client_session.cc
+++ b/chromium/net/quic/quic_chromium_client_session.cc
@@ -7,7 +7,6 @@
 #include <utility>
 
 #include "base/bind.h"
-#include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_functions.h"
@@ -28,6 +27,7 @@
 #include "net/http/transport_security_state.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_source_type.h"
+#include "net/quic/address_utils.h"
 #include "net/quic/crypto/proof_verifier_chromium.h"
 #include "net/quic/quic_chromium_connection_helper.h"
 #include "net/quic/quic_chromium_packet_writer.h"
@@ -39,7 +39,6 @@
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_log_util.h"
 #include "net/spdy/spdy_session.h"
-#include "net/ssl/channel_id_service.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/ssl/ssl_info.h"
 #include "net/third_party/quiche/src/quic/core/http/quic_client_promised_info.h"
@@ -103,38 +102,70 @@ void RecordUnexpectedNotGoingAway(Location location) {
                             NUM_LOCATIONS);
 }
 
+void RecordConnectionCloseErrorCode(quic::QuicErrorCode error,
+                                    quic::ConnectionCloseSource source,
+                                    const std::string& hostname,
+                                    bool handshake_confirmed) {
+  bool is_google_host = HasGoogleHost(GURL("https://" + hostname));
+  std::string histogram = "Net.QuicSession.ConnectionCloseErrorCode";
+
+  if (source == quic::ConnectionCloseSource::FROM_PEER) {
+    histogram += "Server";
+  } else {
+    histogram += "Client";
+  }
+  base::UmaHistogramSparse(histogram, error);
+
+  if (handshake_confirmed) {
+    base::UmaHistogramSparse(histogram + ".HandshakeConfirmed", error);
+  } else {
+    base::UmaHistogramSparse(histogram + ".HandshakeNotConfirmed", error);
+  }
+
+  if (is_google_host) {
+    histogram += "Google";
+    base::UmaHistogramSparse(histogram, error);
+
+    if (handshake_confirmed) {
+      base::UmaHistogramSparse(histogram + ".HandshakeConfirmed", error);
+    } else {
+      base::UmaHistogramSparse(histogram + ".HandshakeNotConfirmed", error);
+    }
+  }
+}
+
 NetLogParametersCallback NetLogQuicConnectionMigrationTriggerCallback(
     const char* trigger) {
   return NetLog::StringCallback("trigger", trigger);
 }
 
-std::unique_ptr<base::Value> NetLogQuicConnectionMigrationFailureCallback(
+base::Value NetLogQuicConnectionMigrationFailureCallback(
     quic::QuicConnectionId connection_id,
     std::string reason,
     NetLogCaptureMode capture_mode) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetString("connection_id", connection_id.ToString());
-  dict->SetString("reason", reason);
+  base::DictionaryValue dict;
+  dict.SetString("connection_id", connection_id.ToString());
+  dict.SetString("reason", reason);
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicConnectionMigrationSuccessCallback(
+base::Value NetLogQuicConnectionMigrationSuccessCallback(
     quic::QuicConnectionId connection_id,
     NetLogCaptureMode capture_mode) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetString("connection_id", connection_id.ToString());
+  base::DictionaryValue dict;
+  dict.SetString("connection_id", connection_id.ToString());
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogProbingResultCallback(
+base::Value NetLogProbingResultCallback(
     NetworkChangeNotifier::NetworkHandle network,
     const quic::QuicSocketAddress* peer_address,
     bool is_success,
     NetLogCaptureMode capture_mode) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetString("network", base::NumberToString(network));
-  dict->SetString("peer address", peer_address->ToString());
-  dict->SetBoolean("is_success", is_success);
+  base::DictionaryValue dict;
+  dict.SetString("network", base::NumberToString(network));
+  dict.SetString("peer address", peer_address->ToString());
+  dict.SetBoolean("is_success", is_success);
   return std::move(dict);
 }
 
@@ -191,29 +222,29 @@ std::string ConnectionMigrationCauseToString(ConnectionMigrationCause cause) {
   return "InvalidCause";
 }
 
-std::unique_ptr<base::Value> NetLogQuicClientSessionCallback(
+base::Value NetLogQuicClientSessionCallback(
     const quic::QuicServerId* server_id,
     int cert_verify_flags,
     bool require_confirmation,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetString("host", server_id->host());
-  dict->SetInteger("port", server_id->port());
-  dict->SetBoolean("privacy_mode", server_id->privacy_mode_enabled());
-  dict->SetBoolean("require_confirmation", require_confirmation);
-  dict->SetInteger("cert_verify_flags", cert_verify_flags);
+  base::DictionaryValue dict;
+  dict.SetString("host", server_id->host());
+  dict.SetInteger("port", server_id->port());
+  dict.SetBoolean("privacy_mode", server_id->privacy_mode_enabled());
+  dict.SetBoolean("require_confirmation", require_confirmation);
+  dict.SetInteger("cert_verify_flags", cert_verify_flags);
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicPushPromiseReceivedCallback(
+base::Value NetLogQuicPushPromiseReceivedCallback(
     const spdy::SpdyHeaderBlock* headers,
     spdy::SpdyStreamId stream_id,
     spdy::SpdyStreamId promised_stream_id,
     NetLogCaptureMode capture_mode) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->Set("headers", ElideSpdyHeaderBlockForNetLog(*headers, capture_mode));
-  dict->SetInteger("id", stream_id);
-  dict->SetInteger("promised_stream_id", promised_stream_id);
+  base::DictionaryValue dict;
+  dict.SetKey("headers", ElideSpdyHeaderBlockForNetLog(*headers, capture_mode));
+  dict.SetInteger("id", stream_id);
+  dict.SetInteger("promised_stream_id", promised_stream_id);
   return std::move(dict);
 }
 
@@ -461,7 +492,7 @@ int QuicChromiumClientSession::Handle::GetPeerAddress(
   if (!session_)
     return ERR_CONNECTION_CLOSED;
 
-  *address = session_->peer_address().impl().socket_address();
+  *address = ToIPEndPoint(session_->peer_address());
   return OK;
 }
 
@@ -470,7 +501,7 @@ int QuicChromiumClientSession::Handle::GetSelfAddress(
   if (!session_)
     return ERR_CONNECTION_CLOSED;
 
-  *address = session_->self_address().impl().socket_address();
+  *address = ToIPEndPoint(session_->self_address());
   return OK;
 }
 
@@ -522,7 +553,7 @@ void QuicChromiumClientSession::Handle::OnRendezvousResult(
   if (push_callback_) {
     DCHECK(push_handle_);
     push_handle_ = nullptr;
-    base::ResetAndReturn(&push_callback_).Run(rv);
+    std::move(push_callback_).Run(rv);
   }
 }
 
@@ -600,7 +631,7 @@ void QuicChromiumClientSession::StreamRequest::DoCallback(int rv) {
 
   // The client callback can do anything, including destroying this class,
   // so any pending callback must be issued after everything else is done.
-  base::ResetAndReturn(&callback_).Run(rv);
+  std::move(callback_).Run(rv);
 }
 
 int QuicChromiumClientSession::StreamRequest::DoLoop(int rv) {
@@ -788,7 +819,7 @@ QuicChromiumClientSession::QuicChromiumClientSession(
   }
   connect_timing_.dns_start = dns_resolution_start_time;
   connect_timing_.dns_end = dns_resolution_end_time;
-  if (migrate_session_early_v2_) {
+  if (!retransmittable_on_wire_timeout.IsZero()) {
     connection->set_retransmittable_on_wire_timeout(
         retransmittable_on_wire_timeout);
   }
@@ -799,17 +830,17 @@ QuicChromiumClientSession::~QuicChromiumClientSession() {
 
   net_log_.EndEvent(NetLogEventType::QUIC_SESSION);
   DCHECK(waiting_for_confirmation_callbacks_.empty());
-  if (!dynamic_streams().empty())
+  if (HasActiveRequestStreams())
     RecordUnexpectedOpenStreams(DESTRUCTOR);
   if (!handles_.empty())
     RecordUnexpectedObservers(DESTRUCTOR);
   if (!going_away_)
     RecordUnexpectedNotGoingAway(DESTRUCTOR);
 
-  while (!dynamic_streams().empty() || !handles_.empty() ||
+  while (HasActiveRequestStreams() || !handles_.empty() ||
          !stream_requests_.empty()) {
     // The session must be closed before it is destroyed.
-    DCHECK(dynamic_streams().empty());
+    DCHECK(!HasActiveRequestStreams());
     CloseAllStreams(ERR_UNEXPECTED);
     DCHECK(handles_.empty());
     CloseAllHandles(ERR_UNEXPECTED);
@@ -1143,7 +1174,7 @@ const quic::QuicCryptoClientStream* QuicChromiumClientSession::GetCryptoStream()
 }
 
 bool QuicChromiumClientSession::GetRemoteEndpoint(IPEndPoint* endpoint) {
-  *endpoint = peer_address().impl().socket_address();
+  *endpoint = ToIPEndPoint(peer_address());
   return true;
 }
 
@@ -1408,11 +1439,9 @@ void QuicChromiumClientSession::SendRstStream(
     quic::QuicStreamOffset bytes_written) {
   if (quic::QuicUtils::IsServerInitiatedStreamId(
           connection()->transport_version(), id)) {
-    StreamHandler handler = GetOrCreateStreamImpl(id, /*may_buffer=*/true);
-    if (handler.is_pending) {
-      bytes_pushed_count_ += handler.pending->stream_bytes_read();
-    } else if (handler.stream) {
-      bytes_pushed_count_ += handler.stream->stream_bytes_read();
+    quic::QuicStream* stream = GetOrCreateStream(id);
+    if (stream) {
+      bytes_pushed_count_ += stream->stream_bytes_read();
     }
   }
 
@@ -1442,7 +1471,7 @@ void QuicChromiumClientSession::OnConfigNegotiated() {
 
   // Server has sent an alternate address to connect to.
   IPEndPoint new_address =
-      config()->ReceivedAlternateServerAddress().impl().socket_address();
+      ToIPEndPoint(config()->ReceivedAlternateServerAddress());
   IPEndPoint old_address;
   GetDefaultSocket()->GetPeerAddress(&old_address);
 
@@ -1480,7 +1509,7 @@ void QuicChromiumClientSession::OnCryptoHandshakeEvent(
     // could be called because there are no error events in CryptoHandshakeEvent
     // enum. If error events are added to CryptoHandshakeEvent, then the
     // following code needs to changed.
-    base::ResetAndReturn(&callback_).Run(OK);
+    std::move(callback_).Run(OK);
   }
   if (event == HANDSHAKE_CONFIRMED) {
     if (stream_factory_)
@@ -1530,7 +1559,7 @@ void QuicChromiumClientSession::OnCryptoHandshakeMessageSent(
 void QuicChromiumClientSession::OnCryptoHandshakeMessageReceived(
     const quic::CryptoHandshakeMessage& message) {
   logger_->OnCryptoHandshakeMessageReceived(message);
-  if (message.tag() == quic::kREJ || message.tag() == quic::kSREJ) {
+  if (message.tag() == quic::kREJ) {
     UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.RejectLength",
                                 message.GetSerialized().length(), 1000, 10000,
                                 50);
@@ -1558,7 +1587,9 @@ void QuicChromiumClientSession::OnConnectionClosed(
     quic::ConnectionCloseSource source) {
   DCHECK(!connection()->connected());
   logger_->OnConnectionClosed(error, error_details, source);
-  bool is_google_host = HasGoogleHost(GURL("https://" + session_key_.host()));
+
+  RecordConnectionCloseErrorCode(error, source, session_key_.host(),
+                                 IsCryptoHandshakeConfirmed());
   if (source == quic::ConnectionCloseSource::FROM_PEER) {
     if (error == quic::QUIC_PUBLIC_RESET) {
       // is_from_google_server will be true if the received EPID is
@@ -1583,15 +1614,6 @@ void QuicChromiumClientSession::OnConnectionClosed(
       }
     }
     if (IsCryptoHandshakeConfirmed()) {
-      if (is_google_host) {
-        base::UmaHistogramSparse(
-            "Net.QuicSession.ConnectionCloseErrorCodeServerGoogle."
-            "HandshakeConfirmed",
-            error);
-      }
-      base::UmaHistogramSparse(
-          "Net.QuicSession.ConnectionCloseErrorCodeServer.HandshakeConfirmed",
-          error);
       base::HistogramBase* histogram = base::SparseHistogram::FactoryGet(
           "Net.QuicSession.StreamCloseErrorCodeServer.HandshakeConfirmed",
           base::HistogramBase::kUmaTargetedHistogramFlag);
@@ -1599,23 +1621,8 @@ void QuicChromiumClientSession::OnConnectionClosed(
       if (num_streams > 0)
         histogram->AddCount(error, num_streams);
     }
-    if (is_google_host) {
-      base::UmaHistogramSparse(
-          "Net.QuicSession.ConnectionCloseErrorCodeServerGoogle", error);
-    }
-    base::UmaHistogramSparse("Net.QuicSession.ConnectionCloseErrorCodeServer",
-                             error);
   } else {
     if (IsCryptoHandshakeConfirmed()) {
-      if (is_google_host) {
-        base::UmaHistogramSparse(
-            "Net.QuicSession.ConnectionCloseErrorCodeClientGoogle."
-            "HandshakeConfirmed",
-            error);
-      }
-      base::UmaHistogramSparse(
-          "Net.QuicSession.ConnectionCloseErrorCodeClient.HandshakeConfirmed",
-          error);
       base::HistogramBase* histogram = base::SparseHistogram::FactoryGet(
           "Net.QuicSession.StreamCloseErrorCodeClient.HandshakeConfirmed",
           base::HistogramBase::kUmaTargetedHistogramFlag);
@@ -1629,12 +1636,6 @@ void QuicChromiumClientSession::OnConnectionClosed(
             connection()->IsPathDegrading());
       }
     }
-    if (is_google_host) {
-      base::UmaHistogramSparse(
-          "Net.QuicSession.ConnectionCloseErrorCodeClientGoogle", error);
-    }
-    base::UmaHistogramSparse("Net.QuicSession.ConnectionCloseErrorCodeClient",
-                             error);
     if (error == quic::QUIC_TOO_MANY_RTOS) {
       UMA_HISTOGRAM_COUNTS_1000(
           "Net.QuicSession.ClosedByRtoAtClient.ReceivedPacketCount",
@@ -1707,13 +1708,13 @@ void QuicChromiumClientSession::OnConnectionClosed(
   quic::QuicSession::OnConnectionClosed(error, error_details, source);
 
   if (!callback_.is_null()) {
-    base::ResetAndReturn(&callback_).Run(ERR_QUIC_PROTOCOL_ERROR);
+    std::move(callback_).Run(ERR_QUIC_PROTOCOL_ERROR);
   }
 
   for (auto& socket : sockets_) {
     socket->Close();
   }
-  DCHECK(dynamic_streams().empty());
+  DCHECK(!HasActiveRequestStreams());
   CloseAllStreams(ERR_UNEXPECTED);
   CloseAllHandles(ERR_UNEXPECTED);
   CancelAllRequests(ERR_CONNECTION_CLOSED);
@@ -1862,7 +1863,7 @@ void QuicChromiumClientSession::MigrateSessionOnWriteError(
       NetLogEventType::QUIC_CONNECTION_MIGRATION_TRIGGERED,
       NetLogQuicConnectionMigrationTriggerCallback("WriteError"));
   MigrationResult result =
-      Migrate(new_network, connection()->peer_address().impl().socket_address(),
+      Migrate(new_network, ToIPEndPoint(connection()->peer_address()),
               /*close_session_on_error=*/false, migration_net_log);
   migration_net_log.EndEvent(
       NetLogEventType::QUIC_CONNECTION_MIGRATION_TRIGGERED);
@@ -2201,7 +2202,7 @@ void QuicChromiumClientSession::MigrateNetworkImmediately(
   probing_manager_.CancelProbing(network, peer_address());
 
   MigrationResult result =
-      Migrate(network, connection()->peer_address().impl().socket_address(),
+      Migrate(network, ToIPEndPoint(connection()->peer_address()),
               /*close_session_on_error=*/true, net_log_);
   if (result == MigrationResult::FAILURE)
     return;
@@ -2375,7 +2376,7 @@ void QuicChromiumClientSession::CloseSessionOnError(
   base::UmaHistogramSparse("Net.QuicSession.CloseSessionOnError", -net_error);
 
   if (!callback_.is_null()) {
-    base::ResetAndReturn(&callback_).Run(net_error);
+    std::move(callback_).Run(net_error);
   }
 
   CloseAllStreams(net_error);
@@ -2398,7 +2399,7 @@ void QuicChromiumClientSession::CloseSessionOnErrorLater(
   base::UmaHistogramSparse("Net.QuicSession.CloseSessionOnError", -net_error);
 
   if (!callback_.is_null()) {
-    base::ResetAndReturn(&callback_).Run(net_error);
+    std::move(callback_).Run(net_error);
   }
   CloseAllStreams(net_error);
   CloseAllHandles(net_error);
@@ -2413,11 +2414,26 @@ void QuicChromiumClientSession::CloseSessionOnErrorLater(
 }
 
 void QuicChromiumClientSession::CloseAllStreams(int net_error) {
-  while (!dynamic_streams().empty()) {
-    quic::QuicStream* stream = dynamic_streams().begin()->second.get();
-    quic::QuicStreamId id = stream->id();
-    static_cast<QuicChromiumClientStream*>(stream)->OnError(net_error);
-    CloseStream(id);
+  if (!eliminate_static_stream_map()) {
+    while (!dynamic_streams().empty()) {
+      quic::QuicStream* stream = dynamic_streams().begin()->second.get();
+      quic::QuicStreamId id = stream->id();
+      static_cast<QuicChromiumClientStream*>(stream)->OnError(net_error);
+      CloseStream(id);
+    }
+  } else {
+    quic::QuicSmallMap<quic::QuicStreamId, quic::QuicStream*, 10>
+        non_static_streams;
+    for (const auto& stream : dynamic_streams()) {
+      if (!stream.second->is_static()) {
+        non_static_streams[stream.first] = stream.second.get();
+      }
+    }
+    for (const auto& stream : non_static_streams) {
+      quic::QuicStreamId id = stream.first;
+      static_cast<QuicChromiumClientStream*>(stream.second)->OnError(net_error);
+      CloseStream(id);
+    }
   }
 }
 
@@ -2492,9 +2508,9 @@ ProbingResult QuicChromiumClientSession::StartProbeNetwork(
   // Create and configure socket on |network|.
   std::unique_ptr<DatagramClientSocket> probing_socket =
       stream_factory_->CreateSocket(net_log_.net_log(), net_log_.source());
-  if (stream_factory_->ConfigureSocket(
-          probing_socket.get(), peer_address.impl().socket_address(), network,
-          session_key_.socket_tag()) != OK) {
+  if (stream_factory_->ConfigureSocket(probing_socket.get(),
+                                       ToIPEndPoint(peer_address), network,
+                                       session_key_.socket_tag()) != OK) {
     HistogramAndLogMigrationFailure(
         migration_net_log, MIGRATION_STATUS_INTERNAL_ERROR, connection_id(),
         "Socket configuration failed");
@@ -2626,6 +2642,10 @@ void QuicChromiumClientSession::ResetNonMigratableStreams() {
   auto it = dynamic_streams().begin();
   // Stream may be deleted when iterating through the map.
   while (it != dynamic_streams().end()) {
+    if (eliminate_static_stream_map() && it->second->is_static()) {
+      it++;
+      continue;
+    }
     QuicChromiumClientStream* stream =
         static_cast<QuicChromiumClientStream*>(it->second.get());
     if (!stream->can_migrate_to_cellular_network()) {
@@ -2738,34 +2758,36 @@ void QuicChromiumClientSession::HistogramAndLogMigrationSuccess(
       base::Bind(&NetLogQuicConnectionMigrationSuccessCallback, connection_id));
 }
 
-std::unique_ptr<base::Value> QuicChromiumClientSession::GetInfoAsValue(
+base::Value QuicChromiumClientSession::GetInfoAsValue(
     const std::set<HostPortPair>& aliases) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetString("version",
-                  QuicVersionToString(connection()->transport_version()));
-  dict->SetInteger("open_streams", GetNumOpenOutgoingStreams());
+  base::DictionaryValue dict;
+  dict.SetString("version",
+                 QuicVersionToString(connection()->transport_version()));
+  dict.SetInteger("open_streams", GetNumOpenOutgoingStreams());
   std::unique_ptr<base::ListValue> stream_list(new base::ListValue());
   for (DynamicStreamMap::const_iterator it = dynamic_streams().begin();
        it != dynamic_streams().end(); ++it) {
+    if (eliminate_static_stream_map() && it->second->is_static())
+      continue;
     stream_list->AppendString(base::NumberToString(it->second->id()));
   }
-  dict->Set("active_streams", std::move(stream_list));
+  dict.Set("active_streams", std::move(stream_list));
 
-  dict->SetInteger("total_streams", num_total_streams_);
-  dict->SetString("peer_address", peer_address().ToString());
-  dict->SetString("connection_id", connection_id().ToString());
-  dict->SetBoolean("connected", connection()->connected());
+  dict.SetInteger("total_streams", num_total_streams_);
+  dict.SetString("peer_address", peer_address().ToString());
+  dict.SetString("connection_id", connection_id().ToString());
+  dict.SetBoolean("connected", connection()->connected());
   const quic::QuicConnectionStats& stats = connection()->GetStats();
-  dict->SetInteger("packets_sent", stats.packets_sent);
-  dict->SetInteger("packets_received", stats.packets_received);
-  dict->SetInteger("packets_lost", stats.packets_lost);
+  dict.SetInteger("packets_sent", stats.packets_sent);
+  dict.SetInteger("packets_received", stats.packets_received);
+  dict.SetInteger("packets_lost", stats.packets_lost);
   SSLInfo ssl_info;
 
   std::unique_ptr<base::ListValue> alias_list(new base::ListValue());
   for (const auto& alias : aliases) {
     alias_list->AppendString(alias.ToString());
   }
-  dict->Set("aliases", std::move(alias_list));
+  dict.Set("aliases", std::move(alias_list));
 
   return std::move(dict);
 }
@@ -2831,7 +2853,7 @@ void QuicChromiumClientSession::NotifyFactoryOfSessionGoingAway() {
 }
 
 void QuicChromiumClientSession::NotifyFactoryOfSessionClosedLater() {
-  if (!dynamic_streams().empty())
+  if (HasActiveRequestStreams())
     RecordUnexpectedOpenStreams(NOTIFY_FACTORY_OF_SESSION_CLOSED_LATER);
 
   if (!going_away_)
@@ -2847,7 +2869,7 @@ void QuicChromiumClientSession::NotifyFactoryOfSessionClosedLater() {
 }
 
 void QuicChromiumClientSession::NotifyFactoryOfSessionClosed() {
-  if (!dynamic_streams().empty())
+  if (HasActiveRequestStreams())
     RecordUnexpectedOpenStreams(NOTIFY_FACTORY_OF_SESSION_CLOSED);
 
   if (!going_away_)
diff --git a/chromium/net/quic/quic_chromium_client_session.h b/chromium/net/quic/quic_chromium_client_session.h
index 4f0faef437d..51111ee9542 100644
--- a/chromium/net/quic/quic_chromium_client_session.h
+++ b/chromium/net/quic/quic_chromium_client_session.h
@@ -537,8 +537,7 @@ class NET_EXPORT_PRIVATE QuicChromiumClientSession
                                 quic::QuicErrorCode quic_error,
                                 quic::ConnectionCloseBehavior behavior);
 
-  std::unique_ptr<base::Value> GetInfoAsValue(
-      const std::set<HostPortPair>& aliases);
+  base::Value GetInfoAsValue(const std::set<HostPortPair>& aliases);
 
   const NetLogWithSource& net_log() const { return net_log_; }
 
diff --git a/chromium/net/quic/quic_chromium_client_session_test.cc b/chromium/net/quic/quic_chromium_client_session_test.cc
index 6c0a8dbd488..830144abf82 100644
--- a/chromium/net/quic/quic_chromium_client_session_test.cc
+++ b/chromium/net/quic/quic_chromium_client_session_test.cc
@@ -83,7 +83,7 @@ class TestingQuicChromiumClientSession : public QuicChromiumClientSession {
 
 class QuicChromiumClientSessionTest
     : public ::testing::TestWithParam<
-          std::tuple<quic::QuicTransportVersion, bool>>,
+          std::tuple<quic::ParsedQuicVersion, bool>>,
       public WithScopedTaskEnvironment {
  public:
   QuicChromiumClientSessionTest()
@@ -140,8 +140,7 @@ class QuicChromiumClientSessionTest
         quic::QuicUtils::CreateRandomConnectionId(&random_),
         quic::QuicSocketAddress(quic::QuicSocketAddressImpl(kIpEndPoint)),
         &helper_, &alarm_factory_, writer, true, quic::Perspective::IS_CLIENT,
-        quic::test::SupportedVersions(
-            quic::ParsedQuicVersion(quic::PROTOCOL_QUIC_CRYPTO, version_)));
+        quic::test::SupportedVersions(version_));
     session_.reset(new TestingQuicChromiumClientSession(
         connection, std::move(socket),
         /*stream_factory=*/nullptr, &crypto_client_stream_factory_, &clock_,
@@ -199,25 +198,31 @@ class QuicChromiumClientSessionTest
   }
 
   quic::QuicStreamId GetNthClientInitiatedBidirectionalStreamId(int n) {
-    return quic::test::GetNthClientInitiatedBidirectionalStreamId(version_, n);
+    return quic::test::GetNthClientInitiatedBidirectionalStreamId(
+        version_.transport_version, n);
   }
 
   quic::QuicStreamId GetNthServerInitiatedUnidirectionalStreamId(int n) {
-    return quic::test::GetNthServerInitiatedUnidirectionalStreamId(version_, n);
+    return quic::test::GetNthServerInitiatedUnidirectionalStreamId(
+        version_.transport_version, n);
   }
 
   size_t GetMaxAllowedOutgoingBidirectionalStreams() {
     quic::QuicSession* quic_session =
         dynamic_cast<quic::QuicSession*>(&*session_);
-    if (version_ != quic::QUIC_VERSION_99) {
+    if (version_.transport_version != quic::QUIC_VERSION_99) {
       return quic::test::QuicSessionPeer::GetStreamIdManager(quic_session)
           ->max_open_outgoing_streams();
     }
+    // For version99, the count will include both static and dynamic streams.
+    // These tests are only concerned with dynamic streams (that is, the number
+    // of streams that they can create), so back out the static header stream.
     return quic::test::QuicSessionPeer::v99_streamid_manager(quic_session)
-        ->max_allowed_outgoing_bidirectional_streams();
+               ->max_allowed_outgoing_bidirectional_streams() -
+           1;
   }
 
-  const quic::QuicTransportVersion version_;
+  const quic::ParsedQuicVersion version_;
   const bool client_headers_include_h2_stream_dependency_;
   QuicFlagSaver flags_;  // Save/restore all QUIC flag values.
   quic::QuicCryptoClientConfig crypto_config_;
@@ -248,9 +253,8 @@ class QuicChromiumClientSessionTest
 INSTANTIATE_TEST_SUITE_P(
     VersionIncludeStreamDependencySequence,
     QuicChromiumClientSessionTest,
-    ::testing::Combine(
-        ::testing::ValuesIn(quic::AllSupportedTransportVersions()),
-        ::testing::Bool()));
+    ::testing::Combine(::testing::ValuesIn(quic::AllSupportedVersions()),
+                       ::testing::Bool()));
 
 TEST_P(QuicChromiumClientSessionTest, IsFatalErrorNotSetForNonFatalError) {
   MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
@@ -326,7 +330,7 @@ TEST_P(QuicChromiumClientSessionTest, Handle) {
       session_->CreateHandle(destination_);
   EXPECT_TRUE(handle->IsConnected());
   EXPECT_FALSE(handle->IsCryptoHandshakeConfirmed());
-  EXPECT_EQ(version_, handle->GetQuicVersion());
+  EXPECT_EQ(version_.transport_version, handle->GetQuicVersion());
   EXPECT_EQ(session_key_.server_id(), handle->server_id());
   EXPECT_EQ(session_net_log.source().type, handle->net_log().source().type);
   EXPECT_EQ(session_net_log.source().id, handle->net_log().source().id);
@@ -355,7 +359,7 @@ TEST_P(QuicChromiumClientSessionTest, Handle) {
   // Veirfy that the handle works correctly after the session is closed.
   EXPECT_FALSE(handle->IsConnected());
   EXPECT_TRUE(handle->IsCryptoHandshakeConfirmed());
-  EXPECT_EQ(version_, handle->GetQuicVersion());
+  EXPECT_EQ(version_.transport_version, handle->GetQuicVersion());
   EXPECT_EQ(session_key_.server_id(), handle->server_id());
   EXPECT_EQ(session_net_log.source().type, handle->net_log().source().type);
   EXPECT_EQ(session_net_log.source().id, handle->net_log().source().id);
@@ -380,7 +384,7 @@ TEST_P(QuicChromiumClientSessionTest, Handle) {
   // Veirfy that the handle works correctly after the session is deleted.
   EXPECT_FALSE(handle->IsConnected());
   EXPECT_TRUE(handle->IsCryptoHandshakeConfirmed());
-  EXPECT_EQ(version_, handle->GetQuicVersion());
+  EXPECT_EQ(version_.transport_version, handle->GetQuicVersion());
   EXPECT_EQ(session_key_.server_id(), handle->server_id());
   EXPECT_EQ(session_net_log.source().type, handle->net_log().source().type);
   EXPECT_EQ(session_net_log.source().id, handle->net_log().source().id);
@@ -507,24 +511,24 @@ TEST_P(QuicChromiumClientSessionTest, AsyncStreamRequest) {
   MockQuicData quic_data;
   quic_data.AddWrite(SYNCHRONOUS,
                      client_maker_.MakeInitialSettingsPacket(1, nullptr));
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     // The open stream limit is set to 50 by
     // MockCryptoClientStream::SetConfigNegotiated() so when the 51st stream is
-    // requested, a STREAM_ID_BLOCKED will be sent.
-    quic_data.AddWrite(
-        SYNCHRONOUS,
-        client_maker_.MakeStreamIdBlockedPacket(
-            2, true, GetNthClientInitiatedBidirectionalStreamId(49)));
+    // requested, a STREAMS_BLOCKED will be sent, indicating that it's blocked
+    // at the limit of 50. The +1 accounts for the header stream.
+    quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
+                                        2, true, 50 + 1,
+                                        /*unidirectional=*/false));
     quic_data.AddWrite(
         SYNCHRONOUS, client_maker_.MakeRstPacket(
                          3, true, GetNthClientInitiatedBidirectionalStreamId(0),
                          quic::QUIC_STREAM_CANCELLED, 0,
                          /*include_stop_sending_if_v99=*/false));
-    // After the STREAM_ID_BLOCKED is sent, receive a MAX_STREAM_ID to increase
-    // the limit.
+    // After the STREAMS_BLOCKED is sent, receive a MAX_STREAMS to increase
+    // the limit to 53.
     quic_data.AddRead(
-        ASYNC, server_maker_.MakeMaxStreamIdPacket(
-                   1, true, GetNthClientInitiatedBidirectionalStreamId(50)));
+        ASYNC, server_maker_.MakeMaxStreamsPacket(1, true, 53,
+                                                  /*unidirectional=*/false));
   } else {
     quic_data.AddWrite(
         SYNCHRONOUS, client_maker_.MakeRstPacket(
@@ -559,7 +563,7 @@ TEST_P(QuicChromiumClientSessionTest, AsyncStreamRequest) {
                                GetNthClientInitiatedBidirectionalStreamId(0),
                                quic::QUIC_STREAM_CANCELLED, 0);
   session_->OnRstStream(rst);
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     // For version99, to close the stream completely, we also must receive a
     // STOP_SENDING frame:
     quic::QuicStopSendingFrame stop_sending(
@@ -584,18 +588,17 @@ TEST_P(QuicChromiumClientSessionTest, ClosedWithAsyncStreamRequest) {
   MockQuicData quic_data;
   quic_data.AddWrite(SYNCHRONOUS,
                      client_maker_.MakeInitialSettingsPacket(1, nullptr));
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     // The open stream limit is set to 50 by
     // MockCryptoClientStream::SetConfigNegotiated() so when the 51st stream is
-    // requested, a STREAM_ID_BLOCKED will be sent.
-    quic_data.AddWrite(
-        SYNCHRONOUS,
-        client_maker_.MakeStreamIdBlockedPacket(
-            2, true, GetNthClientInitiatedBidirectionalStreamId(49)));
-    quic_data.AddWrite(
-        SYNCHRONOUS,
-        client_maker_.MakeStreamIdBlockedPacket(
-            3, true, GetNthClientInitiatedBidirectionalStreamId(49)));
+    // requested, a STREAMS_BLOCKED will be sent, indicating that it's blocked
+    // at the limit of 50. The +1 accounts for the header streams.
+    quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
+                                        2, true, 50 + 1,
+                                        /*unidirectional=*/false));
+    quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
+                                        3, true, 50 + 1,
+                                        /*unidirectional=*/false));
   }
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(ASYNC, OK);  // EOF
@@ -648,14 +651,13 @@ TEST_P(QuicChromiumClientSessionTest, CancelPendingStreamRequest) {
   MockQuicData quic_data;
   quic_data.AddWrite(SYNCHRONOUS,
                      client_maker_.MakeInitialSettingsPacket(1, nullptr));
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     // The open stream limit is set to 50 by
     // MockCryptoClientStream::SetConfigNegotiated() so when the 51st stream is
-    // requested, a STREAM_ID_BLOCKED will be sent.
-    quic_data.AddWrite(
-        SYNCHRONOUS,
-        client_maker_.MakeStreamIdBlockedPacket(
-            2, true, GetNthClientInitiatedBidirectionalStreamId(49)));
+    // requested, a STREAMS_BLOCKED will be sent.
+    quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
+                                        2, true, 51,
+                                        /*unidirectional=*/false));
     // This node receives the RST_STREAM+STOP_SENDING, it responds
     // with only a RST_STREAM.
     quic_data.AddWrite(
@@ -701,7 +703,7 @@ TEST_P(QuicChromiumClientSessionTest, CancelPendingStreamRequest) {
                                GetNthClientInitiatedBidirectionalStreamId(0),
                                quic::QUIC_STREAM_CANCELLED, 0);
   session_->OnRstStream(rst);
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     // For version99, we require a STOP_SENDING as well as a RESET_STREAM to
     // fully close the stream.
     quic::QuicStopSendingFrame stop_sending(
@@ -784,11 +786,10 @@ TEST_P(QuicChromiumClientSessionTest, ConnectionCloseWithPendingStreamRequest) {
   MockQuicData quic_data;
   quic_data.AddWrite(SYNCHRONOUS,
                      client_maker_.MakeInitialSettingsPacket(1, nullptr));
-  if (version_ == quic::QUIC_VERSION_99) {
-    quic_data.AddWrite(
-        SYNCHRONOUS,
-        client_maker_.MakeStreamIdBlockedPacket(
-            2, true, GetNthClientInitiatedBidirectionalStreamId(49)));
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
+    quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
+                                        2, true, 51,
+                                        /*unidirectional=*/false));
   }
   quic_data.AddRead(ASYNC, ERR_IO_PENDING);
   quic_data.AddRead(
@@ -832,24 +833,25 @@ TEST_P(QuicChromiumClientSessionTest, MaxNumStreams) {
   MockQuicData quic_data;
   quic_data.AddWrite(SYNCHRONOUS,
                      client_maker_.MakeInitialSettingsPacket(1, nullptr));
-  if (version_ == quic::QUIC_VERSION_99) {
-    // stream id blocked, stream id blocked on is #102, which is
-    // the 51st stream id...
-    quic_data.AddWrite(
-        SYNCHRONOUS,
-        client_maker_.MakeStreamIdBlockedPacket(
-            2, true, GetNthClientInitiatedBidirectionalStreamId(49)));
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
+    // Initial configuration is 50 dynamic streams. Taking into account
+    // the static stream (headers), expect to block on when hitting the limit
+    // of 51 streams
+    quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
+                                        2, true, 50 + 1,
+                                        /*unidirectional=*/false));
     quic_data.AddWrite(
         SYNCHRONOUS, client_maker_.MakeRstPacket(
                          3, true, GetNthClientInitiatedBidirectionalStreamId(0),
                          quic::QUIC_RST_ACKNOWLEDGEMENT));
-    quic_data.AddWrite(
-        SYNCHRONOUS,
-        client_maker_.MakeStreamIdBlockedPacket(
-            4, true, GetNthClientInitiatedBidirectionalStreamId(49)));
+    // For the second CreateOutgoingStream that fails because of hitting the
+    // stream count limit.
+    quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
+                                        4, true, 50 + 1,
+                                        /*unidirectional=*/false));
     quic_data.AddRead(
-        ASYNC, server_maker_.MakeMaxStreamIdPacket(
-                   1, true, GetNthClientInitiatedBidirectionalStreamId(50)));
+        ASYNC, server_maker_.MakeMaxStreamsPacket(1, true, 50 + 2,
+                                                  /*unidirectional=*/false));
   } else {
     quic_data.AddWrite(
         SYNCHRONOUS, client_maker_.MakeRstPacket(
@@ -871,6 +873,7 @@ TEST_P(QuicChromiumClientSessionTest, MaxNumStreams) {
     EXPECT_TRUE(stream);
     streams.push_back(stream);
   }
+  // This stream, the 51st dynamic stream, can not be opened.
   EXPECT_FALSE(
       QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get()));
 
@@ -1174,18 +1177,17 @@ TEST_P(QuicChromiumClientSessionTest, MaxNumStreamsViaRequest) {
   MockQuicData quic_data;
   quic_data.AddWrite(SYNCHRONOUS,
                      client_maker_.MakeInitialSettingsPacket(1, nullptr));
-  if (version_ == quic::QUIC_VERSION_99) {
-    quic_data.AddWrite(
-        SYNCHRONOUS,
-        client_maker_.MakeStreamIdBlockedPacket(
-            2, true, GetNthClientInitiatedBidirectionalStreamId(49)));
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
+    quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
+                                        2, true, 51,
+                                        /*unidirectional=*/false));
     quic_data.AddWrite(
         SYNCHRONOUS, client_maker_.MakeRstPacket(
                          3, true, GetNthClientInitiatedBidirectionalStreamId(0),
                          quic::QUIC_RST_ACKNOWLEDGEMENT));
     quic_data.AddRead(
-        ASYNC, server_maker_.MakeMaxStreamIdPacket(
-                   1, true, GetNthClientInitiatedBidirectionalStreamId(50)));
+        ASYNC, server_maker_.MakeMaxStreamsPacket(1, true, 53,
+                                                  /*unidirectional=*/false));
   } else {
     quic_data.AddWrite(
         SYNCHRONOUS, client_maker_.MakeRstPacket(
@@ -1199,7 +1201,6 @@ TEST_P(QuicChromiumClientSessionTest, MaxNumStreamsViaRequest) {
   Initialize();
   CompleteCryptoHandshake();
   const size_t kMaxOpenStreams = GetMaxAllowedOutgoingBidirectionalStreams();
-
   std::vector<QuicChromiumClientStream*> streams;
   for (size_t i = 0; i < kMaxOpenStreams; i++) {
     QuicChromiumClientStream* stream =
@@ -1550,10 +1551,6 @@ TEST_P(QuicChromiumClientSessionTest, MigrateToSocketReadError) {
 }
 
 TEST_P(QuicChromiumClientSessionTest, DetectPathDegradingDuringHandshake) {
-  if (version_ >= quic::QUIC_VERSION_47) {
-    // TODO(nharper): reenable once MakeDummyCHLOPacket() fixed
-    return;
-  }
   migrate_session_early_v2_ = true;
 
   MockQuicData quic_data;
diff --git a/chromium/net/quic/quic_chromium_client_stream.cc b/chromium/net/quic/quic_chromium_client_stream.cc
index 34c9b6a4a6b..45e4b802118 100644
--- a/chromium/net/quic/quic_chromium_client_stream.cc
+++ b/chromium/net/quic/quic_chromium_client_stream.cc
@@ -661,7 +661,8 @@ bool QuicChromiumClientStream::DeliverInitialHeaders(
   headers_delivered_ = true;
   net_log_.AddEvent(
       NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_READ_RESPONSE_HEADERS,
-      base::Bind(&SpdyHeaderBlockNetLogCallback, &initial_headers_));
+      base::BindRepeating(&QuicResponseNetLogCallback, id(), fin_received(),
+                          &initial_headers_));
 
   *headers = std::move(initial_headers_);
   *frame_len = initial_headers_frame_len_;
@@ -676,7 +677,8 @@ bool QuicChromiumClientStream::DeliverTrailingHeaders(
 
   net_log_.AddEvent(
       NetLogEventType::QUIC_CHROMIUM_CLIENT_STREAM_READ_RESPONSE_TRAILERS,
-      base::Bind(&SpdyHeaderBlockNetLogCallback, &received_trailers()));
+      base::BindRepeating(&QuicResponseNetLogCallback, id(), fin_received(),
+                          &received_trailers()));
 
   *headers = received_trailers().Clone();
   *frame_len = trailing_headers_frame_len_;
diff --git a/chromium/net/quic/quic_chromium_client_stream_test.cc b/chromium/net/quic/quic_chromium_client_stream_test.cc
index 90ee9828cae..7fc2ffe1507 100644
--- a/chromium/net/quic/quic_chromium_client_stream_test.cc
+++ b/chromium/net/quic/quic_chromium_client_stream_test.cc
@@ -544,6 +544,11 @@ TEST_P(QuicChromiumClientStreamTest, OnError) {
 }
 
 TEST_P(QuicChromiumClientStreamTest, OnTrailers) {
+  // TODO(vasilvv): reenable this for v99.
+  if (GetParam() == quic::QUIC_VERSION_99) {
+    return;
+  }
+
   InitializeHeaders();
   ProcessHeadersFull(headers_);
 
@@ -596,6 +601,11 @@ TEST_P(QuicChromiumClientStreamTest, OnTrailers) {
 // Tests that trailers are marked as consumed only before delegate is to be
 // immediately notified about trailers.
 TEST_P(QuicChromiumClientStreamTest, MarkTrailersConsumedWhenNotifyDelegate) {
+  // TODO(vasilvv): reenable this for v99.
+  if (GetParam() == quic::QUIC_VERSION_99) {
+    return;
+  }
+
   InitializeHeaders();
   ProcessHeadersFull(headers_);
 
@@ -655,6 +665,11 @@ TEST_P(QuicChromiumClientStreamTest, MarkTrailersConsumedWhenNotifyDelegate) {
 // are received but not yet delivered, Read() will return ERR_IO_PENDING instead
 // of 0 (EOF).
 TEST_P(QuicChromiumClientStreamTest, ReadAfterTrailersReceivedButNotDelivered) {
+  // TODO(vasilvv): reenable this for v99.
+  if (GetParam() == quic::QUIC_VERSION_99) {
+    return;
+  }
+
   InitializeHeaders();
   ProcessHeadersFull(headers_);
 
diff --git a/chromium/net/quic/quic_connection_logger.cc b/chromium/net/quic/quic_connection_logger.cc
index 36e41480ad6..0e6cf4223cb 100644
--- a/chromium/net/quic/quic_connection_logger.cc
+++ b/chromium/net/quic/quic_connection_logger.cc
@@ -22,6 +22,7 @@
 #include "net/log/net_log.h"
 #include "net/log/net_log_capture_mode.h"
 #include "net/log/net_log_event_type.h"
+#include "net/quic/address_utils.h"
 #include "net/quic/quic_address_mismatch.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake_message.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
@@ -38,97 +39,95 @@ namespace net {
 
 namespace {
 
-std::unique_ptr<base::Value> NetLogQuicPacketCallback(
-    const IPEndPoint* self_address,
-    const IPEndPoint* peer_address,
+base::Value NetLogQuicPacketCallback(
+    const quic::QuicSocketAddress* self_address,
+    const quic::QuicSocketAddress* peer_address,
     size_t packet_size,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetString("self_address", self_address->ToString());
-  dict->SetString("peer_address", peer_address->ToString());
-  dict->SetInteger("size", packet_size);
+  base::DictionaryValue dict;
+  dict.SetString("self_address", self_address->ToString());
+  dict.SetString("peer_address", peer_address->ToString());
+  dict.SetInteger("size", packet_size);
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicPacketSentCallback(
+base::Value NetLogQuicPacketSentCallback(
     const quic::SerializedPacket& serialized_packet,
     quic::TransmissionType transmission_type,
     quic::QuicTime sent_time,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetInteger("transmission_type", transmission_type);
-  dict->SetKey("packet_number",
-               NetLogNumberValue(serialized_packet.packet_number.ToUint64()));
-  dict->SetInteger("size", serialized_packet.encrypted_length);
-  dict->SetKey("sent_time_us", NetLogNumberValue(sent_time.ToDebuggingValue()));
+  base::DictionaryValue dict;
+  dict.SetInteger("transmission_type", transmission_type);
+  dict.SetKey("packet_number",
+              NetLogNumberValue(serialized_packet.packet_number.ToUint64()));
+  dict.SetInteger("size", serialized_packet.encrypted_length);
+  dict.SetKey("sent_time_us", NetLogNumberValue(sent_time.ToDebuggingValue()));
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicPacketRetransmittedCallback(
+base::Value NetLogQuicPacketRetransmittedCallback(
     quic::QuicPacketNumber old_packet_number,
     quic::QuicPacketNumber new_packet_number,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetKey("old_packet_number",
-               NetLogNumberValue(old_packet_number.ToUint64()));
-  dict->SetKey("new_packet_number",
-               NetLogNumberValue(new_packet_number.ToUint64()));
+  base::DictionaryValue dict;
+  dict.SetKey("old_packet_number",
+              NetLogNumberValue(old_packet_number.ToUint64()));
+  dict.SetKey("new_packet_number",
+              NetLogNumberValue(new_packet_number.ToUint64()));
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicPacketLostCallback(
+base::Value NetLogQuicPacketLostCallback(
     quic::QuicPacketNumber packet_number,
     quic::TransmissionType transmission_type,
     quic::QuicTime detection_time,
     NetLogCaptureMode /*capture_mode*/) {
-  auto dict = std::make_unique<base::DictionaryValue>();
-  dict->SetInteger("transmission_type", transmission_type);
-  dict->SetKey("packet_number", NetLogNumberValue(packet_number.ToUint64()));
-  dict->SetKey("detection_time_us",
-               NetLogNumberValue(detection_time.ToDebuggingValue()));
-  return dict;
+  base::DictionaryValue dict;
+  dict.SetInteger("transmission_type", transmission_type);
+  dict.SetKey("packet_number", NetLogNumberValue(packet_number.ToUint64()));
+  dict.SetKey("detection_time_us",
+              NetLogNumberValue(detection_time.ToDebuggingValue()));
+  return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicDuplicatePacketCallback(
+base::Value NetLogQuicDuplicatePacketCallback(
     quic::QuicPacketNumber packet_number,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetKey("packet_number", NetLogNumberValue(packet_number.ToUint64()));
+  base::DictionaryValue dict;
+  dict.SetKey("packet_number", NetLogNumberValue(packet_number.ToUint64()));
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicPacketHeaderCallback(
+base::Value NetLogQuicPacketHeaderCallback(
     const quic::QuicPacketHeader* header,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetString("connection_id",
-                  header->destination_connection_id.ToString());
-  dict->SetInteger("reset_flag", header->reset_flag);
-  dict->SetInteger("version_flag", header->version_flag);
-  dict->SetKey("packet_number",
-               NetLogNumberValue(header->packet_number.ToUint64()));
+  base::DictionaryValue dict;
+  dict.SetString("connection_id", header->destination_connection_id.ToString());
+  dict.SetInteger("reset_flag", header->reset_flag);
+  dict.SetInteger("version_flag", header->version_flag);
+  dict.SetKey("packet_number",
+              NetLogNumberValue(header->packet_number.ToUint64()));
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicStreamFrameCallback(
+base::Value NetLogQuicStreamFrameCallback(
     const quic::QuicStreamFrame& frame,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetInteger("stream_id", frame.stream_id);
-  dict->SetBoolean("fin", frame.fin);
-  dict->SetKey("offset", NetLogNumberValue(frame.offset));
-  dict->SetInteger("length", frame.data_length);
+  base::DictionaryValue dict;
+  dict.SetInteger("stream_id", frame.stream_id);
+  dict.SetBoolean("fin", frame.fin);
+  dict.SetKey("offset", NetLogNumberValue(frame.offset));
+  dict.SetInteger("length", frame.data_length);
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicAckFrameCallback(
-    const quic::QuicAckFrame* frame,
-    NetLogCaptureMode /* capture_mode */) {
-  auto dict = std::make_unique<base::DictionaryValue>();
-  dict->SetKey("largest_observed",
-               NetLogNumberValue(frame->largest_acked.ToUint64()));
-  dict->SetKey("delta_time_largest_observed_us",
-               NetLogNumberValue(frame->ack_delay_time.ToMicroseconds()));
+base::Value NetLogQuicAckFrameCallback(const quic::QuicAckFrame* frame,
+                                       NetLogCaptureMode /* capture_mode */) {
+  base::DictionaryValue dict;
+  dict.SetKey("largest_observed",
+              NetLogNumberValue(frame->largest_acked.ToUint64()));
+  dict.SetKey("delta_time_largest_observed_us",
+              NetLogNumberValue(frame->ack_delay_time.ToMicroseconds()));
 
   auto missing = std::make_unique<base::ListValue>();
   if (!frame->packets.Empty()) {
@@ -141,7 +140,7 @@ std::unique_ptr<base::Value> NetLogQuicAckFrameCallback(
       }
     }
   }
-  dict->Set("missing_packets", std::move(missing));
+  dict.Set("missing_packets", std::move(missing));
 
   auto received = std::make_unique<base::ListValue>();
   const quic::PacketTimeVector& received_times = frame->received_packet_times;
@@ -151,124 +150,124 @@ std::unique_ptr<base::Value> NetLogQuicAckFrameCallback(
     info->SetKey("received", NetLogNumberValue(it->second.ToDebuggingValue()));
     received->Append(std::move(info));
   }
-  dict->Set("received_packet_times", std::move(received));
+  dict.Set("received_packet_times", std::move(received));
 
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicRstStreamFrameCallback(
+base::Value NetLogQuicRstStreamFrameCallback(
     const quic::QuicRstStreamFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetInteger("stream_id", frame->stream_id);
-  dict->SetInteger("quic_rst_stream_error", frame->error_code);
+  base::DictionaryValue dict;
+  dict.SetInteger("stream_id", frame->stream_id);
+  dict.SetInteger("quic_rst_stream_error", frame->error_code);
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicConnectionCloseFrameCallback(
+base::Value NetLogQuicConnectionCloseFrameCallback(
     const quic::QuicConnectionCloseFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetInteger("quic_error", frame->quic_error_code);
-  dict->SetString("details", frame->error_details);
+  base::DictionaryValue dict;
+  dict.SetInteger("quic_error", frame->quic_error_code);
+  dict.SetString("details", frame->error_details);
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicWindowUpdateFrameCallback(
+base::Value NetLogQuicWindowUpdateFrameCallback(
     const quic::QuicWindowUpdateFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetInteger("stream_id", frame->stream_id);
-  dict->SetKey("byte_offset", NetLogNumberValue(frame->byte_offset));
+  base::DictionaryValue dict;
+  dict.SetInteger("stream_id", frame->stream_id);
+  dict.SetKey("byte_offset", NetLogNumberValue(frame->byte_offset));
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicBlockedFrameCallback(
+base::Value NetLogQuicBlockedFrameCallback(
     const quic::QuicBlockedFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetInteger("stream_id", frame->stream_id);
+  base::DictionaryValue dict;
+  dict.SetInteger("stream_id", frame->stream_id);
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicGoAwayFrameCallback(
+base::Value NetLogQuicGoAwayFrameCallback(
     const quic::QuicGoAwayFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetInteger("quic_error", frame->error_code);
-  dict->SetInteger("last_good_stream_id", frame->last_good_stream_id);
-  dict->SetString("reason_phrase", frame->reason_phrase);
+  base::DictionaryValue dict;
+  dict.SetInteger("quic_error", frame->error_code);
+  dict.SetInteger("last_good_stream_id", frame->last_good_stream_id);
+  dict.SetString("reason_phrase", frame->reason_phrase);
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicStopWaitingFrameCallback(
+base::Value NetLogQuicStopWaitingFrameCallback(
     const quic::QuicStopWaitingFrame* frame,
     NetLogCaptureMode /* capture_mode */) {
-  auto dict = std::make_unique<base::DictionaryValue>();
+  base::DictionaryValue dict;
   auto sent_info = std::make_unique<base::DictionaryValue>();
   sent_info->SetKey("least_unacked",
                     NetLogNumberValue(frame->least_unacked.ToUint64()));
-  dict->Set("sent_info", std::move(sent_info));
+  dict.Set("sent_info", std::move(sent_info));
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicVersionNegotiationPacketCallback(
+base::Value NetLogQuicVersionNegotiationPacketCallback(
     const quic::QuicVersionNegotiationPacket* packet,
     NetLogCaptureMode /* capture_mode */) {
-  auto dict = std::make_unique<base::DictionaryValue>();
+  base::DictionaryValue dict;
   auto versions = std::make_unique<base::ListValue>();
   for (auto it = packet->versions.begin(); it != packet->versions.end(); ++it) {
     versions->AppendString(ParsedQuicVersionToString(*it));
   }
-  dict->Set("versions", std::move(versions));
+  dict.Set("versions", std::move(versions));
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicPublicResetPacketCallback(
+base::Value NetLogQuicPublicResetPacketCallback(
     const IPEndPoint* server_hello_address,
-    const IPEndPoint* public_reset_address,
+    const quic::QuicSocketAddress* public_reset_address,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetString("server_hello_address", server_hello_address->ToString());
-  dict->SetString("public_reset_address", public_reset_address->ToString());
+  base::DictionaryValue dict;
+  dict.SetString("server_hello_address", server_hello_address->ToString());
+  dict.SetString("public_reset_address", public_reset_address->ToString());
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicCryptoHandshakeMessageCallback(
+base::Value NetLogQuicCryptoHandshakeMessageCallback(
     const quic::CryptoHandshakeMessage* message,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetString("quic_crypto_handshake_message", message->DebugString());
+  base::DictionaryValue dict;
+  dict.SetString("quic_crypto_handshake_message", message->DebugString());
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicOnConnectionClosedCallback(
+base::Value NetLogQuicOnConnectionClosedCallback(
     quic::QuicErrorCode error,
     string error_details,
     quic::ConnectionCloseSource source,
     NetLogCaptureMode /* capture_mode */) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetInteger("quic_error", error);
-  dict->SetString("details", error_details);
-  dict->SetBoolean("from_peer", source == quic::ConnectionCloseSource::FROM_PEER
-                                    ? true
-                                    : false);
+  base::DictionaryValue dict;
+  dict.SetInteger("quic_error", error);
+  dict.SetString("details", error_details);
+  dict.SetBoolean("from_peer", source == quic::ConnectionCloseSource::FROM_PEER
+                                   ? true
+                                   : false);
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogQuicCertificateVerifiedCallback(
+base::Value NetLogQuicCertificateVerifiedCallback(
     scoped_refptr<X509Certificate> cert,
     NetLogCaptureMode /* capture_mode */) {
   // Only the subjects are logged so that we can investigate connection pooling.
   // More fields could be logged in the future.
   std::vector<std::string> dns_names;
   cert->GetSubjectAltName(&dns_names, nullptr);
-  auto dict = std::make_unique<base::DictionaryValue>();
+  base::DictionaryValue dict;
   auto subjects = std::make_unique<base::ListValue>();
   for (auto& dns_name : dns_names) {
     subjects->GetList().emplace_back(std::move(dns_name));
   }
-  dict->Set("subjects", std::move(subjects));
+  dict.Set("subjects", std::move(subjects));
   return std::move(dict);
 }
 
@@ -395,9 +394,9 @@ void QuicConnectionLogger::OnFrameAddedToPacket(const quic::QuicFrame& frame) {
       break;
     case quic::NEW_CONNECTION_ID_FRAME:
       break;
-    case quic::MAX_STREAM_ID_FRAME:
+    case quic::MAX_STREAMS_FRAME:
       break;
-    case quic::STREAM_ID_BLOCKED_FRAME:
+    case quic::STREAMS_BLOCKED_FRAME:
       break;
     case quic::PATH_RESPONSE_FRAME:
       break;
@@ -479,9 +478,9 @@ void QuicConnectionLogger::OnFrameAddedToPacket(const quic::QuicFrame& frame) {
       break;
     case quic::NEW_CONNECTION_ID_FRAME:
       break;
-    case quic::MAX_STREAM_ID_FRAME:
+    case quic::MAX_STREAMS_FRAME:
       break;
-    case quic::STREAM_ID_BLOCKED_FRAME:
+    case quic::STREAMS_BLOCKED_FRAME:
       break;
     case quic::PATH_RESPONSE_FRAME:
       break;
@@ -543,10 +542,10 @@ void QuicConnectionLogger::OnPacketReceived(
     const quic::QuicSocketAddress& peer_address,
     const quic::QuicEncryptedPacket& packet) {
   if (local_address_from_self_.GetFamily() == ADDRESS_FAMILY_UNSPECIFIED) {
-    local_address_from_self_ = self_address.impl().socket_address();
+    local_address_from_self_ = ToIPEndPoint(self_address);
     UMA_HISTOGRAM_ENUMERATION(
         "Net.QuicSession.ConnectionTypeFromSelf",
-        GetRealAddressFamily(self_address.impl().socket_address().address()),
+        GetRealAddressFamily(ToIPEndPoint(self_address).address()),
         ADDRESS_FAMILY_LAST);
   }
 
@@ -554,11 +553,9 @@ void QuicConnectionLogger::OnPacketReceived(
   last_received_packet_size_ = packet.length();
   if (!net_log_is_capturing_)
     return;
-  net_log_.AddEvent(
-      NetLogEventType::QUIC_SESSION_PACKET_RECEIVED,
-      base::Bind(&NetLogQuicPacketCallback,
-                 &self_address.impl().socket_address(),
-                 &peer_address.impl().socket_address(), packet.length()));
+  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_PACKET_RECEIVED,
+                    base::Bind(&NetLogQuicPacketCallback, &self_address,
+                               &peer_address, packet.length()));
 }
 
 void QuicConnectionLogger::OnUnauthenticatedHeader(
@@ -740,13 +737,13 @@ void QuicConnectionLogger::OnPingFrame(const quic::QuicPingFrame& frame) {
 void QuicConnectionLogger::OnPublicResetPacket(
     const quic::QuicPublicResetPacket& packet) {
   UpdatePublicResetAddressMismatchHistogram(
-      local_address_from_shlo_, packet.client_address.impl().socket_address());
+      local_address_from_shlo_, ToIPEndPoint(packet.client_address));
   if (!net_log_is_capturing_)
     return;
-  net_log_.AddEvent(NetLogEventType::QUIC_SESSION_PUBLIC_RESET_PACKET_RECEIVED,
-                    base::Bind(&NetLogQuicPublicResetPacketCallback,
-                               &local_address_from_shlo_,
-                               &packet.client_address.impl().socket_address()));
+  net_log_.AddEvent(
+      NetLogEventType::QUIC_SESSION_PUBLIC_RESET_PACKET_RECEIVED,
+      base::Bind(&NetLogQuicPublicResetPacketCallback,
+                 &local_address_from_shlo_, &packet.client_address));
 }
 
 void QuicConnectionLogger::OnVersionNegotiationPacket(
@@ -766,7 +763,7 @@ void QuicConnectionLogger::OnCryptoHandshakeMessageReceived(
     if (message.GetStringPiece(quic::kCADR, &address) &&
         decoder.Decode(address.data(), address.size())) {
       local_address_from_shlo_ =
-          IPEndPoint(decoder.ip().impl().ip_address(), decoder.port());
+          IPEndPoint(ToIPAddress(decoder.ip()), decoder.port());
       UMA_HISTOGRAM_ENUMERATION(
           "Net.QuicSession.ConnectionTypeFromPeer",
           GetRealAddressFamily(local_address_from_shlo_.address()),
@@ -813,8 +810,8 @@ void QuicConnectionLogger::UpdateReceivedFrameCounts(
     quic::QuicStreamId stream_id,
     int num_frames_received,
     int num_duplicate_frames_received) {
-  if (stream_id != quic::QuicUtils::GetCryptoStreamId(
-                       session_->connection()->transport_version())) {
+  if (!quic::QuicUtils::IsCryptoStreamId(session_->transport_version(),
+                                         stream_id)) {
     num_frames_received_ += num_frames_received;
     num_duplicate_frames_received_ += num_duplicate_frames_received;
   }
diff --git a/chromium/net/quic/quic_connectivity_probing_manager.cc b/chromium/net/quic/quic_connectivity_probing_manager.cc
index 78e8461cbb3..7f335131789 100644
--- a/chromium/net/quic/quic_connectivity_probing_manager.cc
+++ b/chromium/net/quic/quic_connectivity_probing_manager.cc
@@ -9,6 +9,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "net/log/net_log.h"
+#include "net/quic/address_utils.h"
 
 namespace net {
 
@@ -17,38 +18,38 @@ namespace {
 // Default to 2 seconds timeout as the maximum timeout.
 const int64_t kMaxProbingTimeoutMs = 2000;
 
-std::unique_ptr<base::Value> NetLogStartProbingCallback(
+base::Value NetLogStartProbingCallback(
     NetworkChangeNotifier::NetworkHandle network,
     const quic::QuicSocketAddress* peer_address,
     base::TimeDelta initial_timeout,
     NetLogCaptureMode capture_mode) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetKey("network", NetLogNumberValue(network));
-  dict->SetString("peer address", peer_address->ToString());
-  dict->SetKey("initial_timeout_ms",
-               NetLogNumberValue(initial_timeout.InMilliseconds()));
+  base::DictionaryValue dict;
+  dict.SetKey("network", NetLogNumberValue(network));
+  dict.SetString("peer address", peer_address->ToString());
+  dict.SetKey("initial_timeout_ms",
+              NetLogNumberValue(initial_timeout.InMilliseconds()));
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogProbeReceivedCallback(
+base::Value NetLogProbeReceivedCallback(
     NetworkChangeNotifier::NetworkHandle network,
     const IPEndPoint* self_address,
     const quic::QuicSocketAddress* peer_address,
     NetLogCaptureMode capture_mode) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetKey("network", NetLogNumberValue(network));
-  dict->SetString("self address", self_address->ToString());
-  dict->SetString("peer address", peer_address->ToString());
+  base::DictionaryValue dict;
+  dict.SetKey("network", NetLogNumberValue(network));
+  dict.SetString("self address", self_address->ToString());
+  dict.SetString("peer address", peer_address->ToString());
   return std::move(dict);
 }
 
-std::unique_ptr<base::Value> NetLogProbingDestinationCallback(
+base::Value NetLogProbingDestinationCallback(
     NetworkChangeNotifier::NetworkHandle network,
     const quic::QuicSocketAddress* peer_address,
     NetLogCaptureMode capture_mode) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetString("network", base::NumberToString(network));
-  dict->SetString("peer address", peer_address->ToString());
+  base::DictionaryValue dict;
+  dict.SetString("network", base::NumberToString(network));
+  dict.SetString("peer address", peer_address->ToString());
   return std::move(dict);
 }
 
@@ -173,7 +174,7 @@ void QuicConnectivityProbingManager::OnConnectivityProbingReceived(
            << local_address.ToString() << ", to peer ip:port "
            << peer_address_.ToString();
 
-  if (quic::QuicSocketAddressImpl(local_address) != self_address.impl() ||
+  if (local_address != ToIPEndPoint(self_address) ||
       peer_address_ != peer_address) {
     DVLOG(1) << "Received probing response from peer ip:port "
              << peer_address.ToString() << ", to self ip:port "
diff --git a/chromium/net/quic/quic_end_to_end_unittest.cc b/chromium/net/quic/quic_end_to_end_unittest.cc
index d9b9de532a6..85dabee8522 100644
--- a/chromium/net/quic/quic_end_to_end_unittest.cc
+++ b/chromium/net/quic/quic_end_to_end_unittest.cc
@@ -80,24 +80,9 @@ class TestTransactionFactory : public HttpTransactionFactory {
   std::unique_ptr<HttpNetworkSession> session_;
 };
 
-struct TestParams {
-  explicit TestParams(bool use_stateless_rejects)
-      : use_stateless_rejects(use_stateless_rejects) {}
-
-  friend std::ostream& operator<<(std::ostream& os, const TestParams& p) {
-    os << "{ use_stateless_rejects: " << p.use_stateless_rejects << " }";
-    return os;
-  }
-  bool use_stateless_rejects;
-};
-
-std::vector<TestParams> GetTestParams() {
-  return std::vector<TestParams>{TestParams(true), TestParams(false)};
-}
-
 }  // namespace
 
-class QuicEndToEndTest : public ::testing::TestWithParam<TestParams>,
+class QuicEndToEndTest : public ::testing::Test,
                          public WithScopedTaskEnvironment {
  protected:
   QuicEndToEndTest()
@@ -115,9 +100,6 @@ class QuicEndToEndTest : public ::testing::TestWithParam<TestParams>,
         net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
 
     session_params_.enable_quic = true;
-    if (GetParam().use_stateless_rejects) {
-      session_params_.quic_connection_options.push_back(quic::kSREJ);
-    }
 
     session_context_.quic_random = nullptr;
     session_context_.host_resolver = &host_resolver_;
@@ -256,11 +238,7 @@ class QuicEndToEndTest : public ::testing::TestWithParam<TestParams>,
   bool strike_register_no_startup_period_;
 };
 
-INSTANTIATE_TEST_SUITE_P(Tests,
-                         QuicEndToEndTest,
-                         ::testing::ValuesIn(GetTestParams()));
-
-TEST_P(QuicEndToEndTest, LargeGetWithNoPacketLoss) {
+TEST_F(QuicEndToEndTest, LargeGetWithNoPacketLoss) {
   std::string response(10 * 1024, 'x');
 
   AddToCache(request_.url.PathForRequest(), 200, "OK", response);
@@ -277,9 +255,9 @@ TEST_P(QuicEndToEndTest, LargeGetWithNoPacketLoss) {
 
 // crbug.com/559173
 #if defined(THREAD_SANITIZER)
-TEST_P(QuicEndToEndTest, DISABLED_LargePostWithNoPacketLoss) {
+TEST_F(QuicEndToEndTest, DISABLED_LargePostWithNoPacketLoss) {
 #else
-TEST_P(QuicEndToEndTest, LargePostWithNoPacketLoss) {
+TEST_F(QuicEndToEndTest, LargePostWithNoPacketLoss) {
 #endif
   InitializePostRequest(1024 * 1024);
 
@@ -297,9 +275,9 @@ TEST_P(QuicEndToEndTest, LargePostWithNoPacketLoss) {
 
 // crbug.com/559173
 #if defined(THREAD_SANITIZER)
-TEST_P(QuicEndToEndTest, DISABLED_LargePostWithPacketLoss) {
+TEST_F(QuicEndToEndTest, DISABLED_LargePostWithPacketLoss) {
 #else
-TEST_P(QuicEndToEndTest, LargePostWithPacketLoss) {
+TEST_F(QuicEndToEndTest, LargePostWithPacketLoss) {
 #endif
   // FLAGS_fake_packet_loss_percentage = 30;
   InitializePostRequest(1024 * 1024);
@@ -319,9 +297,9 @@ TEST_P(QuicEndToEndTest, LargePostWithPacketLoss) {
 
 // crbug.com/536845
 #if defined(THREAD_SANITIZER)
-TEST_P(QuicEndToEndTest, DISABLED_UberTest) {
+TEST_F(QuicEndToEndTest, DISABLED_UberTest) {
 #else
-TEST_P(QuicEndToEndTest, UberTest) {
+TEST_F(QuicEndToEndTest, UberTest) {
 #endif
   // FLAGS_fake_packet_loss_percentage = 30;
 
diff --git a/chromium/net/quic/quic_flags_list.h b/chromium/net/quic/quic_flags_list.h
index f739eb56aca..9f68e2cf365 100644
--- a/chromium/net/quic/quic_flags_list.h
+++ b/chromium/net/quic/quic_flags_list.h
@@ -28,7 +28,7 @@ QUIC_FLAG(int64_t, FLAGS_quic_time_wait_list_max_connections, 600000)
 // Enables server-side support for QUIC stateless rejects.
 QUIC_FLAG(bool,
           FLAGS_quic_reloadable_flag_enable_quic_stateless_reject_support,
-          true)
+          false)
 
 // If true, require handshake confirmation for QUIC connections, functionally
 // disabling 0-rtt handshakes.
@@ -47,7 +47,7 @@ QUIC_FLAG(bool, FLAGS_quic_enforce_single_packet_chlo, true)
 // connection.
 QUIC_FLAG(bool,
           FLAGS_quic_reloadable_flag_quic_use_cheap_stateless_rejects,
-          true)
+          false)
 
 // If true, allows packets to be buffered in anticipation of a future CHLO, and
 // allow CHLO packets to be buffered until next iteration of the event loop.
@@ -64,6 +64,11 @@ QUIC_FLAG(double, FLAGS_quic_bbr_cwnd_gain, 2.0f)
 // reordering window for every spurious retransmit.
 QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_fix_adaptive_time_loss, false)
 
+// If true, adjust congestion window when doing bandwidth resumption in BBR.
+QUIC_FLAG(bool,
+          FLAGS_quic_reloadable_flag_quic_fix_bbr_cwnd_in_bandwidth_resumption,
+          true)
+
 // When true, defaults to BBR congestion control instead of Cubic.
 QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_default_to_bbr, false)
 
@@ -79,10 +84,7 @@ QUIC_FLAG(uint32_t, FLAGS_quic_send_buffer_max_data_slice_size, 4096u)
 QUIC_FLAG(bool, FLAGS_quic_supports_tls_handshake, false)
 
 // Allow QUIC to accept initial packet numbers that are random, not 1.
-QUIC_FLAG(bool, FLAGS_quic_restart_flag_quic_enable_accept_random_ipn, false)
-
-// If true, enable QUIC v43.
-QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_enable_version_43, true)
+QUIC_FLAG(bool, FLAGS_quic_restart_flag_quic_enable_accept_random_ipn, true)
 
 // Enables 3 new connection options to make PROBE_RTT more aggressive
 QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_bbr_less_probe_rtt, false)
@@ -101,6 +103,12 @@ QUIC_FLAG(int32_t, FLAGS_quic_lumpy_pacing_size, 1)
 // pacing.
 QUIC_FLAG(double, FLAGS_quic_lumpy_pacing_cwnd_fraction, 0.25f)
 
+// If true, static streams in a QuicSession will be stored inside dynamic
+// stream map. static_stream_map will no longer be used.
+QUIC_FLAG(bool,
+          FLAGS_quic_reloadable_flag_quic_eliminate_static_stream_map_3,
+          false)
+
 // Default enables QUIC ack decimation and adds a connection option to disable
 // it.
 QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_enable_ack_decimation, false)
@@ -115,9 +123,7 @@ QUIC_FLAG(int32_t, FLAGS_quic_max_pace_time_into_future_ms, 10)
 QUIC_FLAG(double, FLAGS_quic_pace_time_into_future_srtt_fraction, 0.125f)
 
 // Mechanism to override version label and ALPN for IETF interop.
-QUIC_FLAG(int32_t,  // allow-non-std-int
-          FLAGS_quic_ietf_draft_version,
-          0)
+QUIC_FLAG(int32_t, FLAGS_quic_ietf_draft_version, 0)
 
 // If true, enable QUIC v44.
 QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_enable_version_44, true)
@@ -145,7 +151,7 @@ QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_bbr_one_mss_conservation, false)
 
 // Add 3 connection options to decrease the pacing and CWND gain in QUIC BBR
 // STARTUP.
-QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_bbr_slower_startup3, false)
+QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_bbr_slower_startup3, true)
 
 // When true, the LOSS connection option allows for 1/8 RTT of reording instead
 // of the current 1/8th threshold which has been found to be too large for fast
@@ -190,7 +196,7 @@ QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_send_timestamps, false)
 // connection, such that version negotiation is not supported in connection.
 QUIC_FLAG(bool,
           FLAGS_quic_restart_flag_quic_no_server_conn_ver_negotiation2,
-          false)
+          true)
 
 // If true, enable QUIC version 46.
 QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_enable_version_46, true)
@@ -206,6 +212,13 @@ QUIC_FLAG(
 // allocated.
 QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_use_common_stream_check, false)
 
+// When true, remove packets from inflight where they're declared lost,
+// rather than in MarkForRetransmission.  Also no longer marks handshake
+// packets as no longer inflight when they're retransmitted.
+QUIC_FLAG(bool,
+          FLAGS_quic_reloadable_flag_quic_loss_removes_from_inflight,
+          false)
+
 // If true, QuicEpollClock::Now() will monotonically increase.
 QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_monotonic_epoll_clock, false)
 
@@ -225,12 +238,6 @@ QUIC_FLAG(bool,
           FLAGS_quic_reloadable_flag_quic_bbr_startup_rate_reduction,
           false)
 
-// If true, QuicPacketCreator::SetTransmissionType will set the transmission
-// type of the next successfully added frame.
-QUIC_FLAG(bool,
-          FLAGS_quic_reloadable_flag_quic_set_transmission_type_for_next_frame,
-          true)
-
 // If true, log leaf cert subject name into warning log.
 QUIC_FLAG(bool,
           FLAGS_quic_reloadable_flag_quic_log_cert_name_for_empty_sct,
@@ -243,20 +250,14 @@ QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_enable_version_47, false)
 QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_disable_version_39, false)
 
 // If true, use one loss algorithm per encryption level.
-QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_use_uber_loss_algorithm, false)
-
-// When true, QuicFramer will use AppendIetfConnectionIdsNew instead of
-// AppendIetfConnectionId.
-QUIC_FLAG(bool,
-          FLAGS_quic_reloadable_flag_quic_use_new_append_connection_id,
-          false)
+QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_use_uber_loss_algorithm, true)
 
 // If true, QuicStreamSequencerBuffer will switch to a new
 // QuicIntervalSet::AddOptimizedForAppend method in OnStreamData().
 QUIC_FLAG(
     bool,
     FLAGS_quic_reloadable_flag_quic_faster_interval_add_in_sequence_buffer,
-    false)
+    true)
 
 // If true, GFE time wait list will send termination packets based on current
 // packet's encryption level.
@@ -266,34 +267,28 @@ QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_fix_termination_packets, true)
 // from QuicConnection.
 QUIC_FLAG(bool,
           FLAGS_quic_reloadable_flag_quic_deprecate_ack_bundling_mode,
-          false)
+          true)
 
 // If both this flag and gfe2_reloadable_flag_quic_deprecate_ack_bundling_mode
 // are true, QuicReceivedPacketManager decides when to send ACKs.
 QUIC_FLAG(bool,
           FLAGS_quic_reloadable_flag_quic_rpm_decides_when_to_send_acks,
-          false)
-
-// If true, instead of send encryption none termination packets, send stateless
-// reset in reponse to short headers.
-QUIC_FLAG(bool,
-          FLAGS_quic_reloadable_flag_quic_always_reset_short_header_packets,
           true)
 
 // In QUIC, do not close connection if received an in-order ACK with decreased
 // largest_acked.
-QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_tolerate_reneging, false)
+QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_tolerate_reneging, true)
 
 QUIC_FLAG(
     bool,
     FLAGS_quic_reloadable_flag_quic_validate_packet_number_post_decryption,
-    false)
+    true)
 
 // If this flag and quic_rpm_decides_when_to_send_acks is true, use uber
 // received packet manager instead of the single received packet manager.
 QUIC_FLAG(bool,
           FLAGS_quic_reloadable_flag_quic_use_uber_received_packet_manager,
-          false)
+          true)
 
 // If true and using Leto for QUIC shared-key calculations, GFE will react to a
 // failure to contact Leto by sending a REJ containing a fallback ServerConfig,
@@ -328,3 +323,63 @@ QUIC_FLAG(bool,
 
 // If true, non-ASCII QUIC tags are printed as hex instead of integers."
 QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_print_tag_hex, false)
+
+// If true, terminate Google QUIC connections similary as IETF QUIC.
+QUIC_FLAG(bool,
+          FLAGS_quic_reloadable_flag_quic_terminate_gquic_connection_as_ietf,
+          true)
+
+// If true, disable QUIC trial decryption in V44 and above.
+QUIC_FLAG(bool,
+          FLAGS_quic_reloadable_flag_quic_v44_disable_trial_decryption,
+          false)
+
+// In v44 and above, where STOP_WAITING is never sent, close the connection if
+// it's received.
+QUIC_FLAG(bool,
+          FLAGS_quic_reloadable_flag_quic_do_not_accept_stop_waiting,
+          false)
+
+// If true, deprecate queued_control_frames_ from QuicPacketGenerator.
+QUIC_FLAG(bool,
+          FLAGS_quic_reloadable_flag_quic_deprecate_queued_control_frames,
+          false)
+
+// When true, QUIC server will drop IETF QUIC Version Negotiation packets.
+QUIC_FLAG(bool,
+          FLAGS_quic_restart_flag_quic_server_drop_version_negotiation,
+          false)
+
+// When true, version negotiation packets sent by the server will set the fixed
+// bit.
+QUIC_FLAG(bool,
+          FLAGS_quic_reloadable_flag_quic_send_version_negotiation_fixed_bit,
+          false)
+
+// When true, allow variable length QUIC connection IDs for unsupported
+// versions. This allows performing version negotiation when the client-chosen
+// server connection ID length is not 8.
+QUIC_FLAG(
+    bool,
+    FLAGS_quic_restart_flag_quic_allow_variable_length_connection_id_for_negotiation,
+    false)
+
+// If true, set burst token to 2 in cwnd bootstrapping experiment.
+QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_conservative_bursts, false)
+
+// If true, make QuicDispatcher no longer have an instance of QuicFramer.
+QUIC_FLAG(bool,
+          FLAGS_quic_restart_flag_quic_no_framer_object_in_dispatcher,
+          false)
+
+// When true, QuicFramer will not override connection IDs in headers and will
+// instead respect the source/destination direction as expected by IETF QUIC.
+QUIC_FLAG(bool,
+          FLAGS_quic_restart_flag_quic_do_not_override_connection_id,
+          false)
+
+// Do not send STOP_WAITING if no_stop_waiting_frame_ is true.
+QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_simplify_stop_waiting, false)
+
+// If true, export number of packets written per write operation histogram.")
+QUIC_FLAG(bool, FLAGS_quic_export_server_num_packets_per_write_histogram, false)
diff --git a/chromium/net/quic/quic_http_stream.cc b/chromium/net/quic/quic_http_stream.cc
index 265847a6e31..740f2298f8e 100644
--- a/chromium/net/quic/quic_http_stream.cc
+++ b/chromium/net/quic/quic_http_stream.cc
@@ -8,7 +8,6 @@
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
-#include "base/callback_helpers.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_split.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ -35,13 +34,12 @@ namespace net {
 
 namespace {
 
-std::unique_ptr<base::Value> NetLogQuicPushStreamCallback(
-    quic::QuicStreamId stream_id,
-    const GURL* url,
-    NetLogCaptureMode capture_mode) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetInteger("stream_id", stream_id);
-  dict->SetString("url", url->spec());
+base::Value NetLogQuicPushStreamCallback(quic::QuicStreamId stream_id,
+                                         const GURL* url,
+                                         NetLogCaptureMode capture_mode) {
+  base::DictionaryValue dict;
+  dict.SetInteger("stream_id", stream_id);
+  dict.SetString("url", url->spec());
   return std::move(dict);
 }
 
@@ -94,6 +92,8 @@ HttpResponseInfo::ConnectionInfo QuicHttpStream::ConnectionInfoFromQuicVersion(
       return HttpResponseInfo::CONNECTION_INFO_QUIC_47;
     case quic::QUIC_VERSION_99:
       return HttpResponseInfo::CONNECTION_INFO_QUIC_99;
+    case quic::QUIC_VERSION_RESERVED_FOR_NEGOTIATION:
+      return HttpResponseInfo::CONNECTION_INFO_QUIC_999;
   }
   NOTREACHED();
   return HttpResponseInfo::CONNECTION_INFO_QUIC_UNKNOWN_VERSION;
@@ -456,7 +456,7 @@ void QuicHttpStream::DoCallback(int rv) {
 
   // The client callback can do anything, including destroying this class,
   // so any pending callback must be issued after everything else is done.
-  base::ResetAndReturn(&callback_).Run(MapStreamError(rv));
+  std::move(callback_).Run(MapStreamError(rv));
 }
 
 int QuicHttpStream::DoLoop(int rv) {
diff --git a/chromium/net/quic/quic_http_stream_test.cc b/chromium/net/quic/quic_http_stream_test.cc
index b2e826e51ac..51384856d78 100644
--- a/chromium/net/quic/quic_http_stream_test.cc
+++ b/chromium/net/quic/quic_http_stream_test.cc
@@ -171,7 +171,7 @@ class QuicHttpStreamPeer {
 };
 
 class QuicHttpStreamTest : public ::testing::TestWithParam<
-                               std::tuple<quic::QuicTransportVersion, bool>>,
+                               std::tuple<quic::ParsedQuicVersion, bool>>,
                            public WithScopedTaskEnvironment {
  public:
   void CloseStream(QuicHttpStream* stream, int /*rv*/) { stream->Close(false); }
@@ -296,9 +296,8 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<
     alarm_factory_.reset(new QuicChromiumAlarmFactory(runner_.get(), &clock_));
 
     connection_ = new TestQuicConnection(
-        quic::test::SupportedVersions(
-            quic::ParsedQuicVersion(quic::PROTOCOL_QUIC_CRYPTO, version_)),
-        connection_id_, peer_addr_, helper_.get(), alarm_factory_.get(),
+        quic::test::SupportedVersions(version_), connection_id_, peer_addr_,
+        helper_.get(), alarm_factory_.get(),
         new QuicChromiumPacketWriter(
             socket.get(), base::ThreadTaskRunnerHandle::Get().get()));
     connection_->set_visitor(&visitor_);
@@ -639,7 +638,7 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<
   }
 
   std::string ConstructDataHeader(size_t body_len) {
-    if (version_ != quic::QUIC_VERSION_99) {
+    if (version_.transport_version != quic::QUIC_VERSION_99) {
       return "";
     }
     quic::HttpEncoder encoder;
@@ -670,14 +669,16 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<
   }
 
   quic::QuicStreamId GetNthClientInitiatedBidirectionalStreamId(int n) {
-    return quic::test::GetNthClientInitiatedBidirectionalStreamId(version_, n);
+    return quic::test::GetNthClientInitiatedBidirectionalStreamId(
+        version_.transport_version, n);
   }
 
   quic::QuicStreamId GetNthServerInitiatedUnidirectionalStreamId(int n) {
-    return quic::test::GetNthServerInitiatedUnidirectionalStreamId(version_, n);
+    return quic::test::GetNthServerInitiatedUnidirectionalStreamId(
+        version_.transport_version, n);
   }
 
-  const quic::QuicTransportVersion version_;
+  const quic::ParsedQuicVersion version_;
   const bool client_headers_include_h2_stream_dependency_;
 
   BoundTestNetLog net_log_;
@@ -729,9 +730,8 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<
 INSTANTIATE_TEST_SUITE_P(
     VersionIncludeStreamDependencySequence,
     QuicHttpStreamTest,
-    ::testing::Combine(
-        ::testing::ValuesIn(quic::AllSupportedTransportVersions()),
-        ::testing::Bool()));
+    ::testing::Combine(::testing::ValuesIn(quic::AllVersionsExcept99()),
+                       ::testing::Bool()));
 
 TEST_P(QuicHttpStreamTest, RenewStreamForAuth) {
   Initialize();
@@ -1245,7 +1245,7 @@ TEST_P(QuicHttpStreamTest, SendPostRequest) {
   AddWrite(ConstructInitialSettingsPacket(&header_stream_offset));
 
   std::string header = ConstructDataHeader(strlen(kUploadData));
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     AddWrite(ConstructRequestHeadersAndDataFramesPacket(
         2, GetNthClientInitiatedBidirectionalStreamId(0), kIncludeVersion, kFin,
         DEFAULT_PRIORITY, 0, &header_stream_offset,
@@ -1326,7 +1326,7 @@ TEST_P(QuicHttpStreamTest, SendPostRequestAndReceiveSoloFin) {
   quic::QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructInitialSettingsPacket(&header_stream_offset));
   std::string header = ConstructDataHeader(strlen(kUploadData));
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     AddWrite(ConstructRequestHeadersAndDataFramesPacket(
         2, GetNthClientInitiatedBidirectionalStreamId(0), kIncludeVersion, kFin,
         DEFAULT_PRIORITY, 0, &header_stream_offset,
@@ -1410,7 +1410,7 @@ TEST_P(QuicHttpStreamTest, SendChunkedPostRequest) {
   quic::QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructInitialSettingsPacket(&header_stream_offset));
   std::string header = ConstructDataHeader(chunk_size);
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     AddWrite(ConstructRequestHeadersAndDataFramesPacket(
         2, GetNthClientInitiatedBidirectionalStreamId(0), kIncludeVersion,
         !kFin, DEFAULT_PRIORITY, 0, &header_stream_offset,
@@ -1497,7 +1497,7 @@ TEST_P(QuicHttpStreamTest, SendChunkedPostRequestWithFinalEmptyDataPacket) {
   AddWrite(ConstructInitialSettingsPacket(&header_stream_offset));
   std::string header = ConstructDataHeader(chunk_size);
 
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     AddWrite(ConstructRequestHeadersAndDataFramesPacket(
         2, GetNthClientInitiatedBidirectionalStreamId(0), kIncludeVersion,
         !kFin, DEFAULT_PRIORITY, 0, &header_stream_offset,
@@ -1734,7 +1734,7 @@ TEST_P(QuicHttpStreamTest, SessionClosedDuringDoLoop) {
   quic::QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructInitialSettingsPacket(&header_stream_offset));
   std::string header = ConstructDataHeader(strlen(kUploadData));
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     AddWrite(ConstructRequestHeadersAndDataFramesPacket(
         2, GetNthClientInitiatedBidirectionalStreamId(0), kIncludeVersion,
         !kFin, DEFAULT_PRIORITY, 0, &header_stream_offset,
@@ -1895,7 +1895,7 @@ TEST_P(QuicHttpStreamTest, SessionClosedBeforeSendBundledBodyComplete) {
   quic::QuicStreamOffset header_stream_offset = 0;
   AddWrite(ConstructInitialSettingsPacket(&header_stream_offset));
   std::string header = ConstructDataHeader(strlen(kUploadData));
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     AddWrite(ConstructRequestHeadersAndDataFramesPacket(
         2, GetNthClientInitiatedBidirectionalStreamId(0), kIncludeVersion,
         !kFin, DEFAULT_PRIORITY, 0, &header_stream_offset,
@@ -2312,16 +2312,16 @@ TEST_P(QuicHttpStreamTest, ServerPushVaryCheckFail) {
 
   uint64_t client_packet_number = 2;
   if (client_headers_include_h2_stream_dependency_ &&
-      version_ >= quic::QUIC_VERSION_43) {
+      version_.transport_version >= quic::QUIC_VERSION_43) {
     AddWrite(ConstructClientPriorityPacket(
         client_packet_number++, kIncludeVersion, promise_id_, 0,
         DEFAULT_PRIORITY, &header_stream_offset));
   }
   AddWrite(ConstructClientRstStreamVaryMismatchAndRequestHeadersPacket(
       client_packet_number++,
-      stream_id_ + quic::QuicUtils::StreamIdDelta(version_), !kIncludeVersion,
-      kFin, DEFAULT_PRIORITY, promise_id_, &spdy_request_header_frame_length,
-      &header_stream_offset));
+      stream_id_ + quic::QuicUtils::StreamIdDelta(version_.transport_version),
+      !kIncludeVersion, kFin, DEFAULT_PRIORITY, promise_id_,
+      &spdy_request_header_frame_length, &header_stream_offset));
   AddWrite(ConstructClientAckPacket(client_packet_number++, 3, 1, 2));
   AddWrite(ConstructClientRstStreamCancelledPacket(client_packet_number++));
 
@@ -2381,7 +2381,7 @@ TEST_P(QuicHttpStreamTest, ServerPushVaryCheckFail) {
   EXPECT_EQ(
       QuicHttpStreamPeer::GetQuicChromiumClientStream(promised_stream_.get())
           ->id(),
-      stream_id_ + quic::QuicUtils::StreamIdDelta(version_));
+      stream_id_ + quic::QuicUtils::StreamIdDelta(version_.transport_version));
 
   // After rendezvous failure, the push stream has been cancelled.
   EXPECT_EQ(session_->GetPromisedByUrl(promise_url_), nullptr);
@@ -2395,8 +2395,9 @@ TEST_P(QuicHttpStreamTest, ServerPushVaryCheckFail) {
   SetResponse("404 Not Found", string());
   size_t spdy_response_header_frame_length;
   ProcessPacket(InnerConstructResponseHeadersPacket(
-      3, stream_id_ + quic::QuicUtils::StreamIdDelta(version_), kFin,
-      &spdy_response_header_frame_length));
+      3,
+      stream_id_ + quic::QuicUtils::StreamIdDelta(version_.transport_version),
+      kFin, &spdy_response_header_frame_length));
 
   base::RunLoop().RunUntilIdle();
 
diff --git a/chromium/net/quic/quic_http_utils.cc b/chromium/net/quic/quic_http_utils.cc
index 4245e685c44..1f1f2762c80 100644
--- a/chromium/net/quic/quic_http_utils.cc
+++ b/chromium/net/quic/quic_http_utils.cc
@@ -36,31 +36,39 @@ RequestPriority ConvertQuicPriorityToRequestPriority(
                          : static_cast<RequestPriority>(HIGHEST - priority);
 }
 
-std::unique_ptr<base::Value> QuicRequestNetLogCallback(
-    quic::QuicStreamId stream_id,
-    const spdy::SpdyHeaderBlock* headers,
-    spdy::SpdyPriority priority,
-    NetLogCaptureMode capture_mode) {
-  std::unique_ptr<base::DictionaryValue> dict(
-      static_cast<base::DictionaryValue*>(
-          SpdyHeaderBlockNetLogCallback(headers, capture_mode).release()));
-  dict->SetInteger("quic_priority", static_cast<int>(priority));
-  dict->SetInteger("quic_stream_id", static_cast<int>(stream_id));
-  return std::move(dict);
+base::Value QuicRequestNetLogCallback(quic::QuicStreamId stream_id,
+                                      const spdy::SpdyHeaderBlock* headers,
+                                      spdy::SpdyPriority priority,
+                                      NetLogCaptureMode capture_mode) {
+  base::Value dict = SpdyHeaderBlockNetLogCallback(headers, capture_mode);
+  DCHECK(dict.is_dict());
+  dict.SetIntKey("quic_priority", static_cast<int>(priority));
+  dict.SetIntKey("quic_stream_id", static_cast<int>(stream_id));
+  return dict;
 }
 
-quic::QuicTransportVersionVector FilterSupportedAltSvcVersions(
+base::Value QuicResponseNetLogCallback(quic::QuicStreamId stream_id,
+                                       bool fin_received,
+                                       const spdy::SpdyHeaderBlock* headers,
+                                       NetLogCaptureMode capture_mode) {
+  base::Value dict = SpdyHeaderBlockNetLogCallback(headers, capture_mode);
+  dict.SetIntKey("quic_stream_id", static_cast<int>(stream_id));
+  dict.SetBoolKey("fin", fin_received);
+  return dict;
+}
+
+quic::ParsedQuicVersionVector FilterSupportedAltSvcVersions(
     const spdy::SpdyAltSvcWireFormat::AlternativeService& quic_alt_svc,
-    const quic::QuicTransportVersionVector& supported_versions,
+    const quic::ParsedQuicVersionVector& supported_versions,
     bool support_ietf_format_quic_altsvc) {
-  quic::QuicTransportVersionVector supported_alt_svc_versions;
+  quic::ParsedQuicVersionVector supported_alt_svc_versions;
   if (support_ietf_format_quic_altsvc && quic_alt_svc.protocol_id == "hq") {
     // Using IETF format for advertising QUIC. In this case,
     // |alternative_service_entry.version| will store QUIC version labels.
     for (uint32_t quic_version_label : quic_alt_svc.version) {
-      for (quic::QuicTransportVersion supported : supported_versions) {
+      for (quic::ParsedQuicVersion supported : supported_versions) {
         quic::QuicVersionLabel supported_version_label_network_order =
-            QuicVersionToQuicVersionLabel(supported);
+            CreateQuicVersionLabel(supported);
         if (supported_version_label_network_order == quic_version_label) {
           supported_alt_svc_versions.push_back(supported);
           RecordAltSvcFormat(IETF_FORMAT);
@@ -69,8 +77,9 @@ quic::QuicTransportVersionVector FilterSupportedAltSvcVersions(
     }
   } else if (quic_alt_svc.protocol_id == "quic") {
     for (uint32_t quic_version : quic_alt_svc.version) {
-      for (quic::QuicTransportVersion supported : supported_versions) {
-        if (static_cast<uint32_t>(supported) == quic_version) {
+      for (quic::ParsedQuicVersion supported : supported_versions) {
+        if (static_cast<uint32_t>(supported.transport_version) ==
+            quic_version) {
           supported_alt_svc_versions.push_back(supported);
           RecordAltSvcFormat(GOOGLE_FORMAT);
         }
diff --git a/chromium/net/quic/quic_http_utils.h b/chromium/net/quic/quic_http_utils.h
index 31a99de1dca..3fe19fcce64 100644
--- a/chromium/net/quic/quic_http_utils.h
+++ b/chromium/net/quic/quic_http_utils.h
@@ -21,18 +21,26 @@ NET_EXPORT_PRIVATE spdy::SpdyPriority ConvertRequestPriorityToQuicPriority(
 NET_EXPORT_PRIVATE RequestPriority
 ConvertQuicPriorityToRequestPriority(spdy::SpdyPriority priority);
 
-// Converts a spdy::SpdyHeaderBlock and priority into NetLog event parameters.
-NET_EXPORT std::unique_ptr<base::Value> QuicRequestNetLogCallback(
+// Converts a spdy::SpdyHeaderBlock, stream_id and priority into NetLog event
+// parameters.
+NET_EXPORT base::Value QuicRequestNetLogCallback(
     quic::QuicStreamId stream_id,
     const spdy::SpdyHeaderBlock* headers,
     spdy::SpdyPriority priority,
     NetLogCaptureMode capture_mode);
 
-// Parses |alt_svc_versions| into a quic::QuicTransportVersionVector and removes
+// Converts a spdy::SpdyHeaderBlock and stream into NetLog event parameters.
+NET_EXPORT base::Value QuicResponseNetLogCallback(
+    quic::QuicStreamId stream_id,
+    bool fin_received,
+    const spdy::SpdyHeaderBlock* headers,
+    NetLogCaptureMode capture_mode);
+
+// Parses |alt_svc_versions| into a quic::ParsedQuicVersionVector and removes
 // all entries that aren't found in |supported_versions|.
-NET_EXPORT quic::QuicTransportVersionVector FilterSupportedAltSvcVersions(
+NET_EXPORT quic::ParsedQuicVersionVector FilterSupportedAltSvcVersions(
     const spdy::SpdyAltSvcWireFormat::AlternativeService& quic_alt_svc,
-    const quic::QuicTransportVersionVector& supported_versions,
+    const quic::ParsedQuicVersionVector& supported_versions,
     bool support_ietf_format_quic_altsvc);
 
 }  // namespace net
diff --git a/chromium/net/quic/quic_http_utils_test.cc b/chromium/net/quic/quic_http_utils_test.cc
index 2d070e2ad5c..8a92955fa74 100644
--- a/chromium/net/quic/quic_http_utils_test.cc
+++ b/chromium/net/quic/quic_http_utils_test.cc
@@ -12,6 +12,9 @@
 #include "net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using quic::ParsedQuicVersion;
+using quic::PROTOCOL_QUIC_CRYPTO;
+
 namespace net {
 namespace test {
 
@@ -38,8 +41,10 @@ TEST(QuicHttpUtilsTest, ConvertQuicPriorityToRequestPriority) {
 }
 
 TEST(QuicHttpUtilsTest, FilterSupportedAltSvcVersions) {
-  quic::QuicTransportVersionVector supported_versions = {
-      quic::QUIC_VERSION_46, quic::QUIC_VERSION_39, quic::QUIC_VERSION_44};
+  quic::ParsedQuicVersionVector supported_versions = {
+      ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, quic::QUIC_VERSION_46),
+      ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, quic::QUIC_VERSION_39),
+      ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, quic::QUIC_VERSION_44)};
 
   std::vector<uint32_t> alt_svc_versions_google = {quic::QUIC_VERSION_44,
                                                    quic::QUIC_VERSION_43};
@@ -47,8 +52,8 @@ TEST(QuicHttpUtilsTest, FilterSupportedAltSvcVersions) {
       QuicVersionToQuicVersionLabel(quic::QUIC_VERSION_44),
       QuicVersionToQuicVersionLabel(quic::QUIC_VERSION_43)};
 
-  quic::QuicTransportVersionVector supported_alt_svc_versions = {
-      quic::QUIC_VERSION_44};
+  quic::ParsedQuicVersionVector supported_alt_svc_versions = {
+      ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, quic::QUIC_VERSION_44)};
   spdy::SpdyAltSvcWireFormat::AlternativeService altsvc;
 
   altsvc.protocol_id = "quic";
@@ -62,14 +67,14 @@ TEST(QuicHttpUtilsTest, FilterSupportedAltSvcVersions) {
   altsvc.version = alt_svc_versions_ietf;
   EXPECT_EQ(supported_alt_svc_versions,
             FilterSupportedAltSvcVersions(altsvc, supported_versions, true));
-  EXPECT_EQ(quic::QuicTransportVersionVector(),
+  EXPECT_EQ(quic::ParsedQuicVersionVector(),
             FilterSupportedAltSvcVersions(altsvc, supported_versions, false));
 
   altsvc.protocol_id = "invalid_protocol";
   altsvc.version = alt_svc_versions_ietf;
-  EXPECT_EQ(quic::QuicTransportVersionVector(),
+  EXPECT_EQ(quic::ParsedQuicVersionVector(),
             FilterSupportedAltSvcVersions(altsvc, supported_versions, true));
-  EXPECT_EQ(quic::QuicTransportVersionVector(),
+  EXPECT_EQ(quic::ParsedQuicVersionVector(),
             FilterSupportedAltSvcVersions(altsvc, supported_versions, false));
 }
 
diff --git a/chromium/net/quic/quic_network_transaction_unittest.cc b/chromium/net/quic/quic_network_transaction_unittest.cc
index 17f9ac870e2..ca519c5d65c 100644
--- a/chromium/net/quic/quic_network_transaction_unittest.cc
+++ b/chromium/net/quic/quic_network_transaction_unittest.cc
@@ -119,7 +119,7 @@ const char kDifferentHostname[] = "different.example.com";
 struct PoolingTestParams {
   friend std::ostream& operator<<(std::ostream& os,
                                   const PoolingTestParams& p) {
-    os << "{ version: " << QuicVersionToString(p.version)
+    os << "{ version: " << ParsedQuicVersionToString(p.version)
        << ", destination_type: ";
     switch (p.destination_type) {
       case SAME_AS_FIRST:
@@ -138,27 +138,27 @@ struct PoolingTestParams {
     return os;
   }
 
-  quic::QuicTransportVersion version;
+  quic::ParsedQuicVersion version;
   DestinationType destination_type;
   bool client_headers_include_h2_stream_dependency;
 };
 
 std::string GenerateQuicVersionsListForAltSvcHeader(
-    const quic::QuicTransportVersionVector& versions) {
+    const quic::ParsedQuicVersionVector& versions) {
   std::string result = "";
-  for (const quic::QuicTransportVersion& version : versions) {
+  for (const quic::ParsedQuicVersion& version : versions) {
     if (!result.empty())
       result.append(",");
-    result.append(base::NumberToString(version));
+    result.append(base::NumberToString(version.transport_version));
   }
   return result;
 }
 
 std::vector<PoolingTestParams> GetPoolingTestParams() {
   std::vector<PoolingTestParams> params;
-  quic::QuicTransportVersionVector all_supported_versions =
-      quic::AllSupportedTransportVersions();
-  for (const quic::QuicTransportVersion version : all_supported_versions) {
+  quic::ParsedQuicVersionVector all_supported_versions =
+      quic::AllVersionsExcept99();
+  for (const quic::ParsedQuicVersion version : all_supported_versions) {
     params.push_back(PoolingTestParams{version, SAME_AS_FIRST, false});
     params.push_back(PoolingTestParams{version, SAME_AS_FIRST, true});
     params.push_back(PoolingTestParams{version, SAME_AS_SECOND, false});
@@ -256,13 +256,13 @@ class TestSocketPerformanceWatcherFactory
 class QuicNetworkTransactionTest
     : public PlatformTest,
       public ::testing::WithParamInterface<
-          std::tuple<quic::QuicTransportVersion, bool>>,
+          std::tuple<quic::ParsedQuicVersion, bool>>,
       public WithScopedTaskEnvironment {
  protected:
   QuicNetworkTransactionTest()
       : version_(std::get<0>(GetParam())),
         client_headers_include_h2_stream_dependency_(std::get<1>(GetParam())),
-        supported_versions_(quic::test::SupportedTransportVersions(version_)),
+        supported_versions_(quic::test::SupportedVersions(version_)),
         random_generator_(0),
         client_maker_(
             version_,
@@ -278,6 +278,7 @@ class QuicNetworkTransactionTest
             kDefaultServerHostName,
             quic::Perspective::IS_SERVER,
             false),
+        quic_task_runner_(new TestTaskRunner(&clock_)),
         cert_transparency_verifier_(new MultiLogCTVerifier()),
         ssl_config_service_(new SSLConfigServiceDefaults),
         proxy_resolution_service_(ProxyResolutionService::CreateDirect()),
@@ -675,7 +676,7 @@ class QuicNetworkTransactionTest
   }
 
   std::string ConstructDataHeader(size_t body_len) {
-    if (version_ != quic::QUIC_VERSION_99) {
+    if (version_.transport_version != quic::QUIC_VERSION_99) {
       return "";
     }
     quic::HttpEncoder encoder;
@@ -684,8 +685,7 @@ class QuicNetworkTransactionTest
     return std::string(buffer.get(), header_length);
   }
 
-  void CreateSession(
-      const quic::QuicTransportVersionVector& supported_versions) {
+  void CreateSession(const quic::ParsedQuicVersionVector& supported_versions) {
     session_params_.enable_quic = true;
     session_params_.quic_supported_versions = supported_versions;
     session_params_.quic_headers_include_h2_stream_dependency =
@@ -725,7 +725,8 @@ class QuicNetworkTransactionTest
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
     EXPECT_TRUE(response->was_fetched_via_spdy);
     EXPECT_TRUE(response->was_alpn_negotiated);
-    EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion(version_),
+    EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion(
+                  version_.transport_version),
               response->connection_info);
   }
 
@@ -935,11 +936,13 @@ class QuicNetworkTransactionTest
   }
 
   quic::QuicStreamId GetNthClientInitiatedBidirectionalStreamId(int n) {
-    return quic::test::GetNthClientInitiatedBidirectionalStreamId(version_, n);
+    return quic::test::GetNthClientInitiatedBidirectionalStreamId(
+        version_.transport_version, n);
   }
 
   quic::QuicStreamId GetNthServerInitiatedUnidirectionalStreamId(int n) {
-    return quic::test::GetNthServerInitiatedUnidirectionalStreamId(version_, n);
+    return quic::test::GetNthServerInitiatedUnidirectionalStreamId(
+        version_.transport_version, n);
   }
 
   static void AddCertificate(SSLSocketDataProvider* ssl_data) {
@@ -948,14 +951,15 @@ class QuicNetworkTransactionTest
     ASSERT_TRUE(ssl_data->ssl_info.cert);
   }
 
-  const quic::QuicTransportVersion version_;
+  const quic::ParsedQuicVersion version_;
   const bool client_headers_include_h2_stream_dependency_;
-  quic::QuicTransportVersionVector supported_versions_;
+  quic::ParsedQuicVersionVector supported_versions_;
   QuicFlagSaver flags_;  // Save/restore all QUIC flag values.
   quic::MockClock clock_;
   quic::test::MockRandom random_generator_;
   QuicTestPacketMaker client_maker_;
   QuicTestPacketMaker server_maker_;
+  scoped_refptr<TestTaskRunner> quic_task_runner_;
   std::unique_ptr<HttpNetworkSession> session_;
   MockClientSocketFactory socket_factory_;
   ProofVerifyDetailsChromium verify_details_;
@@ -1004,9 +1008,8 @@ class QuicNetworkTransactionTest
 INSTANTIATE_TEST_SUITE_P(
     VersionIncludeStreamDependencySequence,
     QuicNetworkTransactionTest,
-    ::testing::Combine(
-        ::testing::ValuesIn(quic::AllSupportedTransportVersions()),
-        ::testing::Bool()));
+    ::testing::Combine(::testing::ValuesIn(quic::AllVersionsExcept99()),
+                       ::testing::Bool()));
 
 TEST_P(QuicNetworkTransactionTest, WriteErrorHandshakeConfirmed) {
   session_params_.retry_without_alt_svc_on_quic_errors = false;
@@ -1213,7 +1216,7 @@ TEST_P(QuicNetworkTransactionTest, ForceQuic) {
 
   int log_stream_id;
   ASSERT_TRUE(entries[pos].GetIntegerValue("stream_id", &log_stream_id));
-  EXPECT_EQ(quic::QuicUtils::GetHeadersStreamId(version_),
+  EXPECT_EQ(quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
             static_cast<quic::QuicStreamId>(log_stream_id));
 }
 
@@ -1251,10 +1254,12 @@ TEST_P(QuicNetworkTransactionTest, LargeResponseHeaders) {
   for (size_t offset = 0; offset < spdy_frame.size(); offset += chunk_size) {
     size_t len = std::min(chunk_size, spdy_frame.size() - offset);
     mock_quic_data.AddRead(
-        ASYNC, ConstructServerDataPacket(
-                   packet_number++,
-                   quic::QuicUtils::GetHeadersStreamId(version_), false, false,
-                   offset, base::StringPiece(spdy_frame.data() + offset, len)));
+        ASYNC,
+        ConstructServerDataPacket(
+            packet_number++,
+            quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+            false, false, offset,
+            base::StringPiece(spdy_frame.data() + offset, len)));
   }
 
   std::string header = ConstructDataHeader(6);
@@ -1272,6 +1277,8 @@ TEST_P(QuicNetworkTransactionTest, LargeResponseHeaders) {
   CreateSession();
 
   SendRequestAndExpectQuicResponse("hello!");
+  EXPECT_TRUE(mock_quic_data.AllReadDataConsumed());
+  EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicNetworkTransactionTest, TooLargeResponseHeaders) {
@@ -1310,10 +1317,12 @@ TEST_P(QuicNetworkTransactionTest, TooLargeResponseHeaders) {
   for (size_t offset = 0; offset < spdy_frame.size(); offset += chunk_size) {
     size_t len = std::min(chunk_size, spdy_frame.size() - offset);
     mock_quic_data.AddRead(
-        ASYNC, ConstructServerDataPacket(
-                   packet_number++,
-                   quic::QuicUtils::GetHeadersStreamId(version_), false, false,
-                   offset, base::StringPiece(spdy_frame.data() + offset, len)));
+        ASYNC,
+        ConstructServerDataPacket(
+            packet_number++,
+            quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+            false, false, offset,
+            base::StringPiece(spdy_frame.data() + offset, len)));
   }
 
   std::string header = ConstructDataHeader(6);
@@ -1523,12 +1532,10 @@ TEST_P(QuicNetworkTransactionTest, AlternativeServicesDifferentHost) {
 }
 
 TEST_P(QuicNetworkTransactionTest, DoNotUseQuicForUnsupportedVersion) {
-  quic::QuicTransportVersion unsupported_version =
-      quic::QUIC_VERSION_UNSUPPORTED;
+  quic::ParsedQuicVersion unsupported_version = quic::UnsupportedQuicVersion();
   // Add support for another QUIC version besides |version_|. Also find a
   // unsupported version.
-  for (const quic::QuicTransportVersion& version :
-       quic::AllSupportedTransportVersions()) {
+  for (const quic::ParsedQuicVersion& version : quic::AllSupportedVersions()) {
     if (version == version_)
       continue;
     if (supported_versions_.size() != 2) {
@@ -1538,7 +1545,7 @@ TEST_P(QuicNetworkTransactionTest, DoNotUseQuicForUnsupportedVersion) {
     unsupported_version = version;
     break;
   }
-  DCHECK_NE(unsupported_version, quic::QUIC_VERSION_UNSUPPORTED);
+  DCHECK_NE(unsupported_version, quic::UnsupportedQuicVersion());
 
   // Set up alternative service to use QUIC with a version that is not
   // supported.
@@ -1562,8 +1569,7 @@ TEST_P(QuicNetworkTransactionTest, DoNotUseQuicForUnsupportedVersion) {
   // the response from the server will advertise new Alt-Svc with supported
   // versions.
   std::string advertised_versions_list_str =
-      GenerateQuicVersionsListForAltSvcHeader(
-          quic::AllSupportedTransportVersions());
+      GenerateQuicVersionsListForAltSvcHeader(quic::AllSupportedVersions());
   std::string altsvc_header =
       base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%s\"\r\n\r\n",
                          advertised_versions_list_str.c_str());
@@ -1618,7 +1624,11 @@ TEST_P(QuicNetworkTransactionTest, DoNotUseQuicForUnsupportedVersion) {
   EXPECT_EQ(kProtoQUIC, alt_svc_info_vector[0].alternative_service().protocol);
   EXPECT_EQ(2u, alt_svc_info_vector[0].advertised_versions().size());
   // Advertised versions will be lised in a sorted order.
-  std::sort(supported_versions_.begin(), supported_versions_.end());
+  std::sort(
+      supported_versions_.begin(), supported_versions_.end(),
+      [](const quic::ParsedQuicVersion& a, const quic::ParsedQuicVersion& b) {
+        return a.transport_version < b.transport_version;
+      });
   EXPECT_EQ(supported_versions_[0],
             alt_svc_info_vector[0].advertised_versions()[0]);
   EXPECT_EQ(supported_versions_[1],
@@ -1813,10 +1823,8 @@ TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceWithVersionForQuic1) {
 
   // Add support for another QUIC version besides |version_| on the client side.
   // Also find a different version advertised by the server.
-  quic::QuicTransportVersion advertised_version_2 =
-      quic::QUIC_VERSION_UNSUPPORTED;
-  for (const quic::QuicTransportVersion& version :
-       quic::AllSupportedTransportVersions()) {
+  quic::ParsedQuicVersion advertised_version_2 = quic::UnsupportedQuicVersion();
+  for (const quic::ParsedQuicVersion& version : quic::AllSupportedVersions()) {
     if (version == version_)
       continue;
     if (supported_versions_.size() != 2) {
@@ -1826,11 +1834,11 @@ TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceWithVersionForQuic1) {
     advertised_version_2 = version;
     break;
   }
-  DCHECK_NE(advertised_version_2, quic::QUIC_VERSION_UNSUPPORTED);
+  DCHECK_NE(advertised_version_2, quic::UnsupportedQuicVersion());
 
-  std::string QuicAltSvcWithVersionHeader =
-      base::StringPrintf("Alt-Svc: quic=\":443\";v=\"%d,%d\"\r\n\r\n",
-                         advertised_version_2, version_);
+  std::string QuicAltSvcWithVersionHeader = base::StringPrintf(
+      "Alt-Svc: quic=\":443\";v=\"%d,%d\"\r\n\r\n",
+      advertised_version_2.transport_version, version_.transport_version);
 
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
@@ -1879,21 +1887,21 @@ TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceWithVersionForQuic2) {
   // The QuicStreamFactoy will pick the preferred QUIC_VERSION: |version_|,
   // which is verified as the PacketMakers are using |version_|.
 
-  quic::QuicTransportVersion common_version_2 = quic::QUIC_VERSION_UNSUPPORTED;
-  for (const quic::QuicTransportVersion& version :
-       quic::AllSupportedTransportVersions()) {
+  quic::ParsedQuicVersion common_version_2 = quic::UnsupportedQuicVersion();
+  for (const quic::ParsedQuicVersion& version : quic::AllSupportedVersions()) {
     if (version == version_)
       continue;
     common_version_2 = version;
     break;
   }
-  DCHECK_NE(common_version_2, quic::QUIC_VERSION_UNSUPPORTED);
+  DCHECK_NE(common_version_2, quic::UnsupportedQuicVersion());
 
   supported_versions_.push_back(
       common_version_2);  // Supported but unpreferred.
 
   std::string QuicAltSvcWithVersionHeader = base::StringPrintf(
-      "Alt-Svc: quic=\":443\";v=\"%d,%d\"\r\n\r\n", common_version_2, version_);
+      "Alt-Svc: quic=\":443\";v=\"%d,%d\"\r\n\r\n",
+      common_version_2.transport_version, version_.transport_version);
 
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
@@ -2051,8 +2059,7 @@ TEST_P(QuicNetworkTransactionTest, DoNotGetAltSvcForDifferentOrigin) {
 TEST_P(QuicNetworkTransactionTest,
        StoreMutuallySupportedVersionsWhenProcessAltSvc) {
   // Add support for another QUIC version besides |version_|.
-  for (const quic::QuicTransportVersion& version :
-       quic::AllSupportedTransportVersions()) {
+  for (const quic::ParsedQuicVersion& version : quic::AllSupportedVersions()) {
     if (version == version_)
       continue;
     supported_versions_.push_back(version);
@@ -2060,8 +2067,7 @@ TEST_P(QuicNetworkTransactionTest,
   }
 
   std::string advertised_versions_list_str =
-      GenerateQuicVersionsListForAltSvcHeader(
-          quic::AllSupportedTransportVersions());
+      GenerateQuicVersionsListForAltSvcHeader(quic::AllSupportedVersions());
   std::string altsvc_header =
       base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%s\"\r\n\r\n",
                          advertised_versions_list_str.c_str());
@@ -2116,7 +2122,11 @@ TEST_P(QuicNetworkTransactionTest,
   EXPECT_EQ(kProtoQUIC, alt_svc_info_vector[0].alternative_service().protocol);
   EXPECT_EQ(2u, alt_svc_info_vector[0].advertised_versions().size());
   // Advertised versions will be lised in a sorted order.
-  std::sort(supported_versions_.begin(), supported_versions_.end());
+  std::sort(
+      supported_versions_.begin(), supported_versions_.end(),
+      [](const quic::ParsedQuicVersion& a, const quic::ParsedQuicVersion& b) {
+        return a.transport_version < b.transport_version;
+      });
   EXPECT_EQ(supported_versions_[0],
             alt_svc_info_vector[0].advertised_versions()[0]);
   EXPECT_EQ(supported_versions_[1],
@@ -2124,8 +2134,8 @@ TEST_P(QuicNetworkTransactionTest,
 }
 
 TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceAllSupportedVersion) {
-  std::string altsvc_header =
-      base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%u\"\r\n\r\n", version_);
+  std::string altsvc_header = base::StringPrintf(
+      "Alt-Svc: quic=\":443\"; v=\"%u\"\r\n\r\n", version_.transport_version);
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()),
       MockRead("hello world"),
@@ -2169,7 +2179,7 @@ TEST_P(QuicNetworkTransactionTest, UseAlternativeServiceAllSupportedVersion) {
 }
 
 TEST_P(QuicNetworkTransactionTest, GoAwayWithConnectionMigrationOnPortsOnly) {
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     // Not available under version 99
     return;
   }
@@ -2247,10 +2257,6 @@ TEST_P(QuicNetworkTransactionTest, GoAwayWithConnectionMigrationOnPortsOnly) {
 // alternate network as well, QUIC is marked as broken and the brokenness will
 // not expire when default network changes.
 TEST_P(QuicNetworkTransactionTest, QuicFailsOnBothNetworksWhileTCPSucceeds) {
-  if (version_ >= quic::QUIC_VERSION_47) {
-    // TODO(nharper): reenable once MakeDummyCHLOPacket() fixed
-    return;
-  }
   SetUpTestForRetryConnectionOnAlternateNetwork();
 
   std::string request_data;
@@ -2272,7 +2278,7 @@ TEST_P(QuicNetworkTransactionTest, QuicFailsOnBothNetworksWhileTCPSucceeds) {
   quic_data.AddWrite(SYNCHRONOUS,
                      client_maker_.MakeDummyCHLOPacket(packet_num++));
   // TODO(zhongyi): remove condition check once b/115926584 is fixed.
-  if (version_ <= quic::QUIC_VERSION_39) {
+  if (version_.transport_version <= quic::QUIC_VERSION_39) {
     quic_data.AddWrite(SYNCHRONOUS,
                        client_maker_.MakeDummyCHLOPacket(packet_num++));
   }
@@ -2311,7 +2317,6 @@ TEST_P(QuicNetworkTransactionTest, QuicFailsOnBothNetworksWhileTCPSucceeds) {
   CreateSession();
   session_->quic_stream_factory()->set_require_confirmation(true);
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -2367,10 +2372,6 @@ TEST_P(QuicNetworkTransactionTest, QuicFailsOnBothNetworksWhileTCPSucceeds) {
 // alternate network, QUIC is marked as broken. The brokenness will expire when
 // the default network changes.
 TEST_P(QuicNetworkTransactionTest, RetryOnAlternateNetworkWhileTCPSucceeds) {
-  if (version_ >= quic::QUIC_VERSION_47) {
-    // TODO(nharper): reenable once MakeDummyCHLOPacket() fixed
-    return;
-  }
   SetUpTestForRetryConnectionOnAlternateNetwork();
 
   std::string request_data;
@@ -2392,7 +2393,7 @@ TEST_P(QuicNetworkTransactionTest, RetryOnAlternateNetworkWhileTCPSucceeds) {
   quic_data.AddWrite(SYNCHRONOUS,
                      client_maker_.MakeDummyCHLOPacket(packet_num++));
   // TODO(zhongyi): remove condition check once b/115926584 is fixed.
-  if (version_ <= quic::QUIC_VERSION_39) {
+  if (version_.transport_version <= quic::QUIC_VERSION_39) {
     quic_data.AddWrite(SYNCHRONOUS,
                        client_maker_.MakeDummyCHLOPacket(packet_num++));
   }
@@ -2438,7 +2439,6 @@ TEST_P(QuicNetworkTransactionTest, RetryOnAlternateNetworkWhileTCPSucceeds) {
   CreateSession();
   session_->quic_stream_factory()->set_require_confirmation(true);
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -2501,10 +2501,6 @@ TEST_P(QuicNetworkTransactionTest, RetryOnAlternateNetworkWhileTCPSucceeds) {
 // before handshake is confirmed. If TCP doesn't succeed but QUIC on the
 // alternative network succeeds, QUIC is not marked as broken.
 TEST_P(QuicNetworkTransactionTest, RetryOnAlternateNetworkWhileTCPHanging) {
-  if (version_ >= quic::QUIC_VERSION_47) {
-    // TODO(nharper): reenable once MakeDummyCHLOPacket() fixed
-    return;
-  }
   SetUpTestForRetryConnectionOnAlternateNetwork();
 
   std::string request_data;
@@ -2527,7 +2523,7 @@ TEST_P(QuicNetworkTransactionTest, RetryOnAlternateNetworkWhileTCPHanging) {
                      client_maker_.MakeDummyCHLOPacket(packet_num++));
   // TODO(zhongyi): remove condition check once b/115926584 is fixed, i.e.,
   // quic_fix_has_pending_crypto_data is introduced and enabled.
-  if (version_ <= quic::QUIC_VERSION_39) {
+  if (version_.transport_version <= quic::QUIC_VERSION_39) {
     quic_data.AddWrite(SYNCHRONOUS,
                        client_maker_.MakeDummyCHLOPacket(packet_num++));
   }
@@ -2578,7 +2574,6 @@ TEST_P(QuicNetworkTransactionTest, RetryOnAlternateNetworkWhileTCPHanging) {
   CreateSession();
   session_->quic_stream_factory()->set_require_confirmation(true);
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -2654,42 +2649,50 @@ TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmed) {
                      client_maker_.MakeInitialSettingsPacketAndSaveData(
                          2, &header_stream_offset, &settings_data));
   // TLP 1
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         3, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          3, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
   // TLP 2
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         4, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          4, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 1
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         5, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         6, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          5, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          6, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 2
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         7, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         8, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          7, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          8, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 3
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         9, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       10, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                       false, settings_offset, settings_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          9, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          10, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
 
   quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket(
                                       11, true, quic::QUIC_NETWORK_IDLE_TIMEOUT,
@@ -2710,7 +2713,6 @@ TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmed) {
 
   CreateSession();
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -2764,51 +2766,61 @@ TEST_P(QuicNetworkTransactionTest, TooManyRtosAfterHandshakeConfirmed) {
                      client_maker_.MakeInitialSettingsPacketAndSaveData(
                          2, &header_stream_offset, &settings_data));
   // TLP 1
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         3, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          3, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
   // TLP 2
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         4, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          4, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 1
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         5, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         6, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          5, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          6, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 2
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         7, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         8, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          7, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          8, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 3
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         9, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       10, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                       false, settings_offset, settings_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          9, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          10, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 4
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       11, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                       false, 0, request_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          11, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       12, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                       false, settings_offset, settings_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          12, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 5
   quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket(
                                       13, true, quic::QUIC_TOO_MANY_RTOS,
@@ -2828,7 +2840,6 @@ TEST_P(QuicNetworkTransactionTest, TooManyRtosAfterHandshakeConfirmed) {
 
   CreateSession();
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -2887,51 +2898,58 @@ TEST_P(QuicNetworkTransactionTest,
                          3, true, GetNthClientInitiatedBidirectionalStreamId(0),
                          quic::QUIC_STREAM_CANCELLED));
   // TLP 1
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         4, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          4, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
   // TLP 2
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         5, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          5, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 1
   quic_data.AddWrite(SYNCHRONOUS,
                      client_maker_.MakeRstPacket(
                          6, true, GetNthClientInitiatedBidirectionalStreamId(0),
                          quic::QUIC_STREAM_CANCELLED));
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         7, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          7, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
   // RTO 2
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         8, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          8, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   quic_data.AddWrite(SYNCHRONOUS,
                      client_maker_.MakeRstPacket(
                          9, true, GetNthClientInitiatedBidirectionalStreamId(0),
                          quic::QUIC_STREAM_CANCELLED));
   // RTO 3
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       10, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                       false, 0, request_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          10, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       11, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                       false, settings_offset, settings_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          11, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 4
   quic_data.AddWrite(
       SYNCHRONOUS, client_maker_.MakeRstPacket(
                        12, true, GetNthClientInitiatedBidirectionalStreamId(0),
                        quic::QUIC_STREAM_CANCELLED));
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       13, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                       false, 0, request_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          13, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
   // RTO 5
   quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket(
                                       14, true, quic::QUIC_TOO_MANY_RTOS,
@@ -2951,7 +2969,6 @@ TEST_P(QuicNetworkTransactionTest,
 
   CreateSession();
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -3075,42 +3092,50 @@ TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmedThenBroken) {
                      client_maker_.MakeInitialSettingsPacketAndSaveData(
                          2, &header_stream_offset, &settings_data));
   // TLP 1
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         3, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          3, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
   // TLP 2
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         4, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          4, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 1
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         5, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         6, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          5, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          6, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 2
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         7, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         8, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          7, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          8, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 3
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         9, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       10, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                       false, settings_offset, settings_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          9, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          10, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
 
   quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket(
                                       11, true, quic::QUIC_NETWORK_IDLE_TIMEOUT,
@@ -3145,7 +3170,6 @@ TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmedThenBroken) {
 
   CreateSession();
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -3209,42 +3233,50 @@ TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmedThenBroken2) {
                      client_maker_.MakeInitialSettingsPacketAndSaveData(
                          2, &header_stream_offset, &settings_data));
   // TLP 1
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         3, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          3, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
   // TLP 2
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         4, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          4, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 1
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         5, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         6, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          5, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          6, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 2
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         7, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         8, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          7, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          8, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 3
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         9, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       10, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                       false, settings_offset, settings_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          9, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          10, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
 
   quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket(
                                       11, true, quic::QUIC_NETWORK_IDLE_TIMEOUT,
@@ -3279,7 +3311,6 @@ TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmedThenBroken2) {
 
   CreateSession();
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -3358,41 +3389,49 @@ TEST_P(QuicNetworkTransactionTest,
 
   // TLP 1
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       4, quic::QuicUtils::GetHeadersStreamId(version_), false,
-                       false, 0, request_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          4, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          false, false, 0, request_data));
   // TLP 2
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       5, quic::QuicUtils::GetHeadersStreamId(version_), false,
-                       false, settings_offset, settings_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          5, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          false, false, settings_offset, settings_data));
   // RTO 1
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       6, quic::QuicUtils::GetHeadersStreamId(version_), false,
-                       false, 0, request_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          6, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          false, false, 0, request_data));
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       7, quic::QuicUtils::GetHeadersStreamId(version_), false,
-                       false, settings_offset, settings_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          7, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          false, false, settings_offset, settings_data));
   // RTO 2
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       8, quic::QuicUtils::GetHeadersStreamId(version_), false,
-                       false, 0, request_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          8, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          false, false, 0, request_data));
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       9, quic::QuicUtils::GetHeadersStreamId(version_), false,
-                       false, settings_offset, settings_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          9, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          false, false, settings_offset, settings_data));
   // RTO 3
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       10, quic::QuicUtils::GetHeadersStreamId(version_), false,
-                       false, 0, request_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          10, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          false, false, 0, request_data));
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       11, quic::QuicUtils::GetHeadersStreamId(version_), false,
-                       false, settings_offset, settings_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          11, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          false, false, settings_offset, settings_data));
 
   if (GetQuicReloadableFlag(
           quic_fix_time_of_first_packet_sent_after_receiving)) {
@@ -3425,7 +3464,6 @@ TEST_P(QuicNetworkTransactionTest,
 
   CreateSession();
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -3492,51 +3530,61 @@ TEST_P(QuicNetworkTransactionTest,
                      client_maker_.MakeInitialSettingsPacketAndSaveData(
                          2, &header_stream_offset, &settings_data));
   // TLP 1
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         3, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          3, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
   // TLP 2
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         4, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          4, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 1
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         5, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         6, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          5, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          6, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 2
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         7, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         8, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          7, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          8, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 3
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         9, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       10, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                       false, settings_offset, settings_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          9, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          10, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 4
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       11, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                       false, 0, request_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          11, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       12, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                       false, settings_offset, settings_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          12, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
 
   quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket(
                                       13, true, quic::QUIC_TOO_MANY_RTOS,
@@ -3570,7 +3618,6 @@ TEST_P(QuicNetworkTransactionTest,
 
   CreateSession();
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -3640,51 +3687,58 @@ TEST_P(QuicNetworkTransactionTest,
                          3, true, GetNthClientInitiatedBidirectionalStreamId(0),
                          quic::QUIC_STREAM_CANCELLED));
   // TLP 1
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         4, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          4, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
   // TLP 2
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         5, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          5, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 1
   quic_data.AddWrite(SYNCHRONOUS,
                      client_maker_.MakeRstPacket(
                          6, true, GetNthClientInitiatedBidirectionalStreamId(0),
                          quic::QUIC_STREAM_CANCELLED));
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         7, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, 0, request_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          7, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
   // RTO 2
-  quic_data.AddWrite(SYNCHRONOUS,
-                     client_maker_.MakeDataPacket(
-                         8, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                         false, settings_offset, settings_data));
+  quic_data.AddWrite(
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          8, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   quic_data.AddWrite(SYNCHRONOUS,
                      client_maker_.MakeRstPacket(
                          9, true, GetNthClientInitiatedBidirectionalStreamId(0),
                          quic::QUIC_STREAM_CANCELLED));
   // RTO 3
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       10, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                       false, 0, request_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          10, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       11, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                       false, settings_offset, settings_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          11, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, settings_offset, settings_data));
   // RTO 4
   quic_data.AddWrite(
       SYNCHRONOUS, client_maker_.MakeRstPacket(
                        12, true, GetNthClientInitiatedBidirectionalStreamId(0),
                        quic::QUIC_STREAM_CANCELLED));
   quic_data.AddWrite(
-      SYNCHRONOUS, client_maker_.MakeDataPacket(
-                       13, quic::QuicUtils::GetHeadersStreamId(version_), true,
-                       false, 0, request_data));
+      SYNCHRONOUS,
+      client_maker_.MakeDataPacket(
+          13, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          true, false, 0, request_data));
   // RTO 5
   quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket(
                                       14, true, quic::QUIC_TOO_MANY_RTOS,
@@ -3704,7 +3758,6 @@ TEST_P(QuicNetworkTransactionTest,
 
   CreateSession();
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -4077,7 +4130,6 @@ TEST_P(QuicNetworkTransactionTest,
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
   CreateSession();
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -4117,8 +4169,9 @@ TEST_P(QuicNetworkTransactionTest,
 
 TEST_P(QuicNetworkTransactionTest,
        DoNotUseAlternativeServiceQuicUnsupportedVersion) {
-  std::string altsvc_header = base::StringPrintf(
-      "Alt-Svc: quic=\":443\"; v=\"%u\"\r\n\r\n", version_ - 1);
+  std::string altsvc_header =
+      base::StringPrintf("Alt-Svc: quic=\":443\"; v=\"%u\"\r\n\r\n",
+                         version_.transport_version - 1);
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"), MockRead(altsvc_header.c_str()),
       MockRead("hello world"),
@@ -4210,7 +4263,6 @@ TEST_P(QuicNetworkTransactionTest, UseExistingAlternativeServiceForQuic) {
 
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -4292,7 +4344,6 @@ TEST_P(QuicNetworkTransactionTest, UseExistingQUICAlternativeProxy) {
   request_.url = GURL("http://mail.example.org/");
 
   CreateSession();
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -4363,7 +4414,6 @@ TEST_P(QuicNetworkTransactionTest, PoolByOrigin) {
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -4457,7 +4507,6 @@ TEST_P(QuicNetworkTransactionTest, PoolByDestination) {
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -4588,7 +4637,6 @@ TEST_P(QuicNetworkTransactionTest,
 
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -5032,8 +5080,8 @@ TEST_P(QuicNetworkTransactionTest, ZeroRTTWithTooEarlyResponse) {
   mock_quic_data.AddWrite(
       SYNCHRONOUS,
       client_maker_.MakeDataPacket(
-          3, quic::QuicUtils::GetHeadersStreamId(version_), false, false,
-          client_header_stream_offset,
+          3, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          false, false, client_header_stream_offset,
           quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size())));
   client_header_stream_offset += spdy_frame.size();
 
@@ -5069,7 +5117,6 @@ TEST_P(QuicNetworkTransactionTest, ZeroRTTWithTooEarlyResponse) {
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -5125,8 +5172,8 @@ TEST_P(QuicNetworkTransactionTest, ZeroRTTWithMultipleTooEarlyResponse) {
   mock_quic_data.AddWrite(
       SYNCHRONOUS,
       client_maker_.MakeDataPacket(
-          3, quic::QuicUtils::GetHeadersStreamId(version_), false, false,
-          client_header_stream_offset,
+          3, quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+          false, false, client_header_stream_offset,
           quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size())));
   client_header_stream_offset += spdy_frame.size();
 
@@ -5160,7 +5207,6 @@ TEST_P(QuicNetworkTransactionTest, ZeroRTTWithMultipleTooEarlyResponse) {
   AddHangingNonAlternateProtocolSocketData();
   CreateSession();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
       std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
@@ -5188,8 +5234,9 @@ TEST_P(QuicNetworkTransactionTest, ZeroRTTWithMultipleTooEarlyResponse) {
   EXPECT_EQ("HTTP/1.1 425 TOO_EARLY", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_alpn_negotiated);
-  EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion(version_),
-            response->connection_info);
+  EXPECT_EQ(
+      QuicHttpStream::ConnectionInfoFromQuicVersion(version_.transport_version),
+      response->connection_info);
 }
 
 TEST_P(QuicNetworkTransactionTest,
@@ -5357,8 +5404,9 @@ TEST_P(QuicNetworkTransactionTest, RstSteamErrorHandling) {
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_alpn_negotiated);
-  EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion(version_),
-            response->connection_info);
+  EXPECT_EQ(
+      QuicHttpStream::ConnectionInfoFromQuicVersion(version_.transport_version),
+      response->connection_info);
 
   std::string response_data;
   ASSERT_EQ(ERR_QUIC_PROTOCOL_ERROR, ReadTransaction(&trans, &response_data));
@@ -5739,10 +5787,6 @@ TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolOnConnectFailure) {
 }
 
 TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnect) {
-  if (version_ >= quic::QUIC_VERSION_47) {
-    // TODO(nharper): reenable once MakeDummyCHLOPacket() fixed
-    return;
-  }
   MockQuicData mock_quic_data;
   mock_quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeDummyCHLOPacket(1));
   mock_quic_data.AddRead(ASYNC, ConstructServerConnectionClosePacket(1));
@@ -6101,7 +6145,6 @@ TEST_P(QuicNetworkTransactionTest, MaxRetriesAfterAsyncNoBufferSpace) {
 
   CreateSession();
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetTaskRunner(session_->quic_stream_factory(),
                                        quic_task_runner_.get());
 
@@ -6139,7 +6182,6 @@ TEST_P(QuicNetworkTransactionTest, MaxRetriesAfterSynchronousNoBufferSpace) {
 
   CreateSession();
   // Use a TestTaskRunner to avoid waiting in real time for timeouts.
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetTaskRunner(session_->quic_stream_factory(),
                                        quic_task_runner_.get());
 
@@ -6218,7 +6260,7 @@ TEST_P(QuicNetworkTransactionTest, QuicServerPush) {
                  GetRequestHeaders("GET", "https", "/pushed.jpg"),
                  &server_header_offset, &server_maker_));
   if (client_headers_include_h2_stream_dependency_ &&
-      version_ >= quic::QUIC_VERSION_43) {
+      version_.transport_version >= quic::QUIC_VERSION_43) {
     mock_quic_data.AddWrite(SYNCHRONOUS,
                             ConstructClientPriorityPacket(
                                 client_packet_number++, false,
@@ -6312,7 +6354,7 @@ TEST_P(QuicNetworkTransactionTest, CancelServerPushAfterConnectionClose) {
                  GetRequestHeaders("GET", "https", "/pushed.jpg"),
                  &server_header_offset, &server_maker_));
   if (client_headers_include_h2_stream_dependency_ &&
-      version_ >= quic::QUIC_VERSION_43) {
+      version_.transport_version >= quic::QUIC_VERSION_43) {
     mock_quic_data.AddWrite(SYNCHRONOUS,
                             ConstructClientPriorityPacket(
                                 client_packet_number++, false,
@@ -6388,7 +6430,7 @@ TEST_P(QuicNetworkTransactionTest, QuicForceHolBlocking) {
                                            write_packet_index++, &offset));
 
   std::string header = ConstructDataHeader(1);
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     mock_quic_data.AddWrite(
         SYNCHRONOUS,
         ConstructClientRequestHeadersAndDataFramesPacket(
@@ -6570,7 +6612,7 @@ TEST_P(QuicNetworkTransactionTest, RawHeaderSizeSuccessfullPushHeadersFirst) {
                  &server_header_offset, &server_maker_));
 
   if (client_headers_include_h2_stream_dependency_ &&
-      version_ >= quic::QUIC_VERSION_43) {
+      version_.transport_version >= quic::QUIC_VERSION_43) {
     mock_quic_data.AddWrite(SYNCHRONOUS,
                             ConstructClientPriorityPacket(
                                 client_packet_number++, false,
@@ -6724,7 +6766,7 @@ class QuicNetworkTransactionWithDestinationTest
       : version_(GetParam().version),
         client_headers_include_h2_stream_dependency_(
             GetParam().client_headers_include_h2_stream_dependency),
-        supported_versions_(quic::test::SupportedTransportVersions(version_)),
+        supported_versions_(quic::test::SupportedVersions(version_)),
         destination_type_(GetParam().destination_type),
         cert_transparency_verifier_(new MultiLogCTVerifier()),
         ssl_config_service_(new SSLConfigServiceDefaults),
@@ -6860,7 +6902,7 @@ class QuicNetworkTransactionWithDestinationTest
       quic::QuicStreamId stream_id,
       QuicTestPacketMaker* maker) {
     std::string header = "";
-    if (version_ == quic::QUIC_VERSION_99) {
+    if (version_.transport_version == quic::QUIC_VERSION_99) {
       quic::HttpEncoder encoder;
       std::unique_ptr<char[]> buffer;
       auto header_length = encoder.SerializeDataFrameHeader(5, &buffer);
@@ -6940,19 +6982,21 @@ class QuicNetworkTransactionWithDestinationTest
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
     EXPECT_TRUE(response->was_fetched_via_spdy);
     EXPECT_TRUE(response->was_alpn_negotiated);
-    EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion(version_),
+    EXPECT_EQ(QuicHttpStream::ConnectionInfoFromQuicVersion(
+                  version_.transport_version),
               response->connection_info);
     EXPECT_EQ(443, response->remote_endpoint.port());
   }
 
   quic::QuicStreamId GetNthClientInitiatedBidirectionalStreamId(int n) {
-    return quic::test::GetNthClientInitiatedBidirectionalStreamId(version_, n);
+    return quic::test::GetNthClientInitiatedBidirectionalStreamId(
+        version_.transport_version, n);
   }
 
   quic::MockClock clock_;
-  const quic::QuicTransportVersion version_;
+  const quic::ParsedQuicVersion version_;
   const bool client_headers_include_h2_stream_dependency_;
-  quic::QuicTransportVersionVector supported_versions_;
+  quic::ParsedQuicVersionVector supported_versions_;
   DestinationType destination_type_;
   std::string origin1_;
   std::string origin2_;
@@ -7103,10 +7147,10 @@ TEST_P(QuicNetworkTransactionWithDestinationTest, PoolIfCertificateValid) {
   AddHangingSocketData();
   AddHangingSocketData();
 
-  scoped_refptr<TestTaskRunner> quic_task_runner_(new TestTaskRunner(&clock_));
+  scoped_refptr<TestTaskRunner> quic_task_runner(new TestTaskRunner(&clock_));
   QuicStreamFactoryPeer::SetAlarmFactory(
       session_->quic_stream_factory(),
-      std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner_.get(),
+      std::make_unique<QuicChromiumAlarmFactory>(quic_task_runner.get(),
                                                  &clock_));
 
   SendRequestAndExpectQuicResponse(origin1_);
@@ -7244,7 +7288,7 @@ TEST_P(QuicNetworkTransactionTest, QuicServerPushMatchesRequestWithBody) {
                  GetRequestHeaders("GET", "https", "/pushed.jpg"),
                  &server_header_offset, &server_maker_));
   if (client_headers_include_h2_stream_dependency_ &&
-      version_ >= quic::QUIC_VERSION_43) {
+      version_.transport_version >= quic::QUIC_VERSION_43) {
     mock_quic_data.AddWrite(SYNCHRONOUS,
                             ConstructClientPriorityPacket(
                                 client_packet_number++, false,
@@ -7286,7 +7330,7 @@ TEST_P(QuicNetworkTransactionTest, QuicServerPushMatchesRequestWithBody) {
                               quic::QUIC_STREAM_CANCELLED, 5, 5, 1));
   const char kBody[] = "1";
   std::string header3 = ConstructDataHeader(1);
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     mock_quic_data.AddWrite(
         SYNCHRONOUS,
         ConstructClientRequestHeadersAndDataFramesPacket(
@@ -7435,7 +7479,7 @@ TEST_P(QuicNetworkTransactionTest, QuicProxyConnectHttpsServer) {
       "Host: mail.example.org\r\n"
       "Connection: keep-alive\r\n\r\n";
   std::string header = ConstructDataHeader(strlen(get_request));
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     mock_quic_data.AddWrite(
         SYNCHRONOUS,
         ConstructClientAckAndDataPacket(
@@ -7528,7 +7572,7 @@ TEST_P(QuicNetworkTransactionTest, QuicProxyConnectSpdyServer) {
   spdy::SpdySerializedFrame get_frame =
       spdy_util.ConstructSpdyGet("https://mail.example.org/", 1, LOWEST);
   std::string header = ConstructDataHeader(get_frame.size());
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     mock_quic_data.AddWrite(
         SYNCHRONOUS,
         ConstructClientAckAndDataPacket(
@@ -7633,7 +7677,7 @@ TEST_P(QuicNetworkTransactionTest, QuicProxyConnectReuseTransportSocket) {
       "Host: mail.example.org\r\n"
       "Connection: keep-alive\r\n\r\n";
   std::string header = ConstructDataHeader(strlen(get_request_1));
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     mock_quic_data.AddWrite(
         SYNCHRONOUS,
         ConstructClientAckAndDataPacket(
@@ -7677,7 +7721,7 @@ TEST_P(QuicNetworkTransactionTest, QuicProxyConnectReuseTransportSocket) {
       "Host: mail.example.org\r\n"
       "Connection: keep-alive\r\n\r\n";
   std::string header4 = ConstructDataHeader(strlen(get_request_2));
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     mock_quic_data.AddWrite(
         SYNCHRONOUS,
         ConstructClientMultipleDataFramesPacket(
@@ -7797,7 +7841,7 @@ TEST_P(QuicNetworkTransactionTest, QuicProxyConnectReuseQuicSession) {
       "Host: mail.example.org\r\n"
       "Connection: keep-alive\r\n\r\n";
   std::string header = ConstructDataHeader(strlen(get_request));
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     mock_quic_data.AddWrite(
         SYNCHRONOUS,
         ConstructClientAckAndDataPacket(
@@ -7845,7 +7889,7 @@ TEST_P(QuicNetworkTransactionTest, QuicProxyConnectReuseQuicSession) {
   spdy::SpdySerializedFrame get_frame =
       spdy_util.ConstructSpdyGet("https://different.example.org/", 1, LOWEST);
   std::string header4 = ConstructDataHeader(get_frame.size());
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     mock_quic_data.AddWrite(
         SYNCHRONOUS,
         ConstructClientAckAndDataPacket(
@@ -8070,7 +8114,7 @@ TEST_P(QuicNetworkTransactionTest, QuicProxyConnectBadCertificate) {
       "Host: mail.example.org\r\n"
       "Connection: keep-alive\r\n\r\n";
   std::string header = ConstructDataHeader(strlen(get_request));
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     mock_quic_data.AddWrite(
         SYNCHRONOUS,
         ConstructClientAckAndDataPacket(
@@ -8478,7 +8522,7 @@ TEST_P(QuicNetworkTransactionTest, QuicProxyAuth) {
 TEST_P(QuicNetworkTransactionTest, QuicServerPushUpdatesPriority) {
   // Only run this test if HTTP/2 stream dependency info is sent by client (sent
   // in HEADERS frames for requests and PRIORITY frames).
-  if (version_ < quic::QUIC_VERSION_43 ||
+  if (version_.transport_version < quic::QUIC_VERSION_43 ||
       !client_headers_include_h2_stream_dependency_) {
     return;
   }
diff --git a/chromium/net/quic/quic_proxy_client_socket.cc b/chromium/net/quic/quic_proxy_client_socket.cc
index e6f2b811d18..3e925c90bee 100644
--- a/chromium/net/quic/quic_proxy_client_socket.cc
+++ b/chromium/net/quic/quic_proxy_client_socket.cc
@@ -409,14 +409,6 @@ int QuicProxyClientSocket::DoReadReplyComplete(int result) {
       next_state_ = STATE_CONNECT_COMPLETE;
       return OK;
 
-    case 302:  // Found / Moved Temporarily
-      // Try to return a sanitized response so we can follow auth redirects.
-      // If we can't, fail the tunnel connection.
-      if (!SanitizeProxyRedirect(&response_))
-        return ERR_TUNNEL_CONNECTION_FAILED;
-      next_state_ = STATE_DISCONNECTED;
-      return ERR_HTTPS_PROXY_TUNNEL_RESPONSE_REDIRECT;
-
     case 407:  // Proxy Authentication Required
       next_state_ = STATE_CONNECT_COMPLETE;
       if (!SanitizeProxyAuth(&response_))
diff --git a/chromium/net/quic/quic_proxy_client_socket_unittest.cc b/chromium/net/quic/quic_proxy_client_socket_unittest.cc
index 60e259eb66c..9f3b4384dff 100644
--- a/chromium/net/quic/quic_proxy_client_socket_unittest.cc
+++ b/chromium/net/quic/quic_proxy_client_socket_unittest.cc
@@ -83,7 +83,7 @@ namespace test {
 
 class QuicProxyClientSocketTest
     : public ::testing::TestWithParam<
-          std::tuple<quic::QuicTransportVersion, bool>>,
+          std::tuple<quic::ParsedQuicVersion, bool>>,
       public WithScopedTaskEnvironment {
  protected:
   static const bool kFin = true;
@@ -94,7 +94,7 @@ class QuicProxyClientSocketTest
 
   static size_t GetStreamFrameDataLengthFromPacketLength(
       quic::QuicByteCount packet_length,
-      quic::QuicTransportVersion version,
+      quic::ParsedQuicVersion version,
       bool include_version,
       bool include_diversification_nonce,
       quic::QuicConnectionIdLength connection_id_length,
@@ -103,7 +103,8 @@ class QuicProxyClientSocketTest
     quic::QuicVariableLengthIntegerLength retry_token_length_length =
         quic::VARIABLE_LENGTH_INTEGER_LENGTH_0;
     quic::QuicVariableLengthIntegerLength length_length =
-        quic::QuicVersionHasLongHeaderLengths(version) && include_version
+        quic::QuicVersionHasLongHeaderLengths(version.transport_version) &&
+                include_version
             ? quic::VARIABLE_LENGTH_INTEGER_LENGTH_2
             : quic::VARIABLE_LENGTH_INTEGER_LENGTH_0;
     size_t min_data_length = 1;
@@ -111,7 +112,7 @@ class QuicProxyClientSocketTest
         quic::NullEncrypter(quic::Perspective::IS_CLIENT)
             .GetCiphertextSize(min_data_length) +
         quic::QuicPacketCreator::StreamFramePacketOverhead(
-            version, quic::PACKET_8BYTE_CONNECTION_ID,
+            version.transport_version, quic::PACKET_8BYTE_CONNECTION_ID,
             quic::PACKET_0BYTE_CONNECTION_ID, include_version,
             include_diversification_nonce, packet_number_length,
             retry_token_length_length, length_length, offset);
@@ -122,8 +123,9 @@ class QuicProxyClientSocketTest
 
   QuicProxyClientSocketTest()
       : version_(std::get<0>(GetParam())),
-        client_data_stream_id1_(quic::QuicUtils::GetHeadersStreamId(version_) +
-                                quic::QuicUtils::StreamIdDelta(version_)),
+        client_data_stream_id1_(
+            quic::QuicUtils::GetHeadersStreamId(version_.transport_version) +
+            quic::QuicUtils::StreamIdDelta(version_.transport_version)),
         client_headers_include_h2_stream_dependency_(std::get<1>(GetParam())),
         crypto_config_(quic::test::crypto_test_utils::ProofVerifierForTesting(),
                        quic::TlsClientHandshaker::CreateSslCtx()),
@@ -193,9 +195,7 @@ class QuicProxyClientSocketTest
         connection_id_,
         quic::QuicSocketAddress(quic::QuicSocketAddressImpl(peer_addr_)),
         helper_.get(), alarm_factory_.get(), writer, true /* owns_writer */,
-        quic::Perspective::IS_CLIENT,
-        quic::test::SupportedVersions(
-            quic::ParsedQuicVersion(quic::PROTOCOL_QUIC_CRYPTO, version_)));
+        quic::Perspective::IS_CLIENT, quic::test::SupportedVersions(version_));
     connection->set_visitor(&visitor_);
     quic::test::QuicConnectionPeer::SetSendAlgorithm(connection,
                                                      send_algorithm_);
@@ -553,7 +553,7 @@ class QuicProxyClientSocketTest
   }
 
   std::string ConstructDataHeader(size_t body_len) {
-    if (version_ != quic::QUIC_VERSION_99) {
+    if (version_.transport_version != quic::QUIC_VERSION_99) {
       return "";
     }
     quic::HttpEncoder encoder;
@@ -562,7 +562,7 @@ class QuicProxyClientSocketTest
     return std::string(buffer.get(), header_length);
   }
 
-  const quic::QuicTransportVersion version_;
+  const quic::ParsedQuicVersion version_;
   const quic::QuicStreamId client_data_stream_id1_;
   const bool client_headers_include_h2_stream_dependency_;
 
@@ -674,6 +674,7 @@ TEST_P(QuicProxyClientSocketTest, ConnectWithAuthCredentials) {
   ASSERT_EQ(200, response->headers->response_code());
 }
 
+// Tests that a redirect response from a CONNECT fails.
 TEST_P(QuicProxyClientSocketTest, ConnectRedirects) {
   mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructSettingsPacket(1));
   mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructConnectRequestPacket(2));
@@ -686,15 +687,14 @@ TEST_P(QuicProxyClientSocketTest, ConnectRedirects) {
 
   Initialize();
 
-  AssertConnectFails(ERR_HTTPS_PROXY_TUNNEL_RESPONSE_REDIRECT);
+  AssertConnectFails(ERR_TUNNEL_CONNECTION_FAILED);
 
   const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
   ASSERT_TRUE(response != nullptr);
 
   const HttpResponseHeaders* headers = response->headers.get();
   ASSERT_EQ(302, headers->response_code());
-  ASSERT_FALSE(headers->HasHeader("set-cookie"));
-  ASSERT_TRUE(headers->HasHeaderValue("content-length", "0"));
+  ASSERT_TRUE(headers->HasHeader("set-cookie"));
 
   std::string location;
   ASSERT_TRUE(headers->IsRedirect(&location));
@@ -855,7 +855,7 @@ TEST_P(QuicProxyClientSocketTest, WriteSendsDataInDataFrame) {
   mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructConnectRequestPacket(2));
   mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
   mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     std::string header = ConstructDataHeader(kLen1);
     mock_quic_data_.AddWrite(
         SYNCHRONOUS, ConstructAckAndMultipleDataFramesPacket(
@@ -897,7 +897,7 @@ TEST_P(QuicProxyClientSocketTest, WriteSplitsLargeDataIntoMultiplePackets) {
   mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
   mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
   std::string header = ConstructDataHeader(kLen1);
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     mock_quic_data_.AddWrite(
         SYNCHRONOUS, ConstructAckAndDataPacket(write_packet_index++, 1, 1, 1, 0,
                                                std::string(kMsg1, kLen1)));
@@ -914,7 +914,7 @@ TEST_P(QuicProxyClientSocketTest, WriteSplitsLargeDataIntoMultiplePackets) {
   std::string data(numDataPackets * quic::kDefaultMaxPacketSize, 'x');
   quic::QuicStreamOffset offset = kLen1 + header.length();
 
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     numDataPackets++;
   }
   size_t total_data_length = 0;
@@ -923,7 +923,7 @@ TEST_P(QuicProxyClientSocketTest, WriteSplitsLargeDataIntoMultiplePackets) {
         quic::kDefaultMaxPacketSize, version_, !kIncludeVersion,
         !kIncludeDiversificationNonce, quic::PACKET_8BYTE_CONNECTION_ID,
         quic::PACKET_1BYTE_PACKET_NUMBER, offset);
-    if (version_ == quic::QUIC_VERSION_99 && i == 0) {
+    if (version_.transport_version == quic::QUIC_VERSION_99 && i == 0) {
       // 3973 is the data frame length from packet length.
       std::string header2 = ConstructDataHeader(3973);
       mock_quic_data_.AddWrite(
@@ -932,7 +932,8 @@ TEST_P(QuicProxyClientSocketTest, WriteSplitsLargeDataIntoMultiplePackets) {
                            {header2, std::string(data.c_str(),
                                                  max_packet_data_length - 7)}));
       offset += max_packet_data_length - header2.length() - 1;
-    } else if (version_ == quic::QUIC_VERSION_99 && i == numDataPackets - 1) {
+    } else if (version_.transport_version == quic::QUIC_VERSION_99 &&
+               i == numDataPackets - 1) {
       mock_quic_data_.AddWrite(
           SYNCHRONOUS, ConstructDataPacket(write_packet_index++, offset,
                                            std::string(data.c_str(), 7)));
@@ -1281,7 +1282,7 @@ TEST_P(QuicProxyClientSocketTest, AsyncReadAroundWrite) {
                            ConstructAckPacket(write_packet_index++, 2, 1, 1));
 
   std::string header2 = ConstructDataHeader(kLen2);
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     mock_quic_data_.AddWrite(
         SYNCHRONOUS,
         ConstructMultipleDataFramesPacket(
@@ -1346,7 +1347,7 @@ TEST_P(QuicProxyClientSocketTest, AsyncWriteAroundReads) {
   mock_quic_data_.AddWrite(ASYNC, ERR_IO_PENDING);  // Pause
 
   std::string header3 = ConstructDataHeader(kLen2);
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     mock_quic_data_.AddWrite(
         ASYNC, ConstructDataPacket(4, 0, std::string(kMsg2, kLen2)));
     mock_quic_data_.AddWrite(
@@ -1627,7 +1628,7 @@ TEST_P(QuicProxyClientSocketTest, RstWithReadAndWritePending) {
       ASYNC, ConstructServerRstPacket(2, quic::QUIC_STREAM_CANCELLED, 0));
   mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
   std::string header = ConstructDataHeader(kLen2);
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     mock_quic_data_.AddWrite(
         ASYNC,
         ConstructAckAndDataPacket(3, 1, 1, 1, 0, std::string(kMsg2, kLen2)));
@@ -1759,7 +1760,7 @@ TEST_P(QuicProxyClientSocketTest, RstWithReadAndWritePendingDelete) {
   mock_quic_data_.AddRead(
       ASYNC, ConstructServerRstPacket(2, quic::QUIC_STREAM_CANCELLED, 0));
   mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     mock_quic_data_.AddWrite(
         ASYNC,
         ConstructAckAndDataPacket(3, 1, 1, 1, 0, std::string(kMsg1, kLen1)));
@@ -1806,9 +1807,8 @@ TEST_P(QuicProxyClientSocketTest, RstWithReadAndWritePendingDelete) {
 INSTANTIATE_TEST_SUITE_P(
     VersionIncludeStreamDependencySequence,
     QuicProxyClientSocketTest,
-    ::testing::Combine(
-        ::testing::ValuesIn(quic::AllSupportedTransportVersions()),
-        ::testing::Bool()));
+    ::testing::Combine(::testing::ValuesIn(quic::AllVersionsExcept99()),
+                       ::testing::Bool()));
 
 }  // namespace test
 }  // namespace net
diff --git a/chromium/net/quic/quic_stream_factory.cc b/chromium/net/quic/quic_stream_factory.cc
index 31037583f34..7a73796abd8 100644
--- a/chromium/net/quic/quic_stream_factory.cc
+++ b/chromium/net/quic/quic_stream_factory.cc
@@ -10,7 +10,6 @@
 #include <utility>
 
 #include "base/bind.h"
-#include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_functions.h"
@@ -37,6 +36,7 @@
 #include "net/log/net_log_capture_mode.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_source_type.h"
+#include "net/quic/address_utils.h"
 #include "net/quic/crypto/proof_verifier_chromium.h"
 #include "net/quic/properties_based_quic_server_info.h"
 #include "net/quic/quic_chromium_alarm_factory.h"
@@ -105,11 +105,11 @@ const int32_t kQuicSocketReceiveBufferSize = 1024 * 1024;  // 1MB
 // Set the maximum number of undecryptable packets the connection will store.
 const int32_t kMaxUndecryptablePackets = 100;
 
-std::unique_ptr<base::Value> NetLogQuicStreamFactoryJobCallback(
+base::Value NetLogQuicStreamFactoryJobCallback(
     const quic::QuicServerId* server_id,
     NetLogCaptureMode capture_mode) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  dict->SetString(
+  base::DictionaryValue dict;
+  dict.SetString(
       "server_id",
       "https://" +
           HostPortPair(server_id->host(), server_id->port()).ToString() +
@@ -274,8 +274,9 @@ class QuicStreamFactory::CertVerifierJob {
     auto* verify_callback_ptr = verify_callback.get();
     quic::QuicAsyncStatus status =
         crypto_config->proof_verifier()->VerifyCertChain(
-            server_id_.host(), cached->certs(), verify_context_.get(),
-            &verify_error_details_, &verify_details_,
+            server_id_.host(), cached->certs(),
+            /*ocsp_response=*/std::string(), cached->cert_sct(),
+            verify_context_.get(), &verify_error_details_, &verify_details_,
             std::move(verify_callback));
     if (status == quic::QUIC_PENDING) {
       verify_callback_ = verify_callback_ptr;
@@ -288,7 +289,7 @@ class QuicStreamFactory::CertVerifierJob {
     UMA_HISTOGRAM_TIMES("Net.QuicSession.CertVerifierJob.CompleteTime",
                         base::TimeTicks::Now() - start_time_);
     if (!callback_.is_null())
-      base::ResetAndReturn(&callback_).Run(OK);
+      std::move(callback_).Run(OK);
   }
 
   const quic::QuicServerId& server_id() const { return server_id_; }
@@ -412,7 +413,7 @@ class QuicStreamFactory::Job {
   bool DoesPeerAddressMatchWithFreshAddressList() {
     std::vector<net::IPEndPoint> endpoints =
         fresh_resolve_host_request_->GetAddressResults().value().endpoints();
-    IPEndPoint stale_address = session_->peer_address().impl().socket_address();
+    IPEndPoint stale_address = ToIPEndPoint(session_->peer_address());
 
     if (std::find(endpoints.begin(), endpoints.end(), stale_address) !=
         endpoints.end()) {
@@ -589,7 +590,7 @@ void QuicStreamFactory::Job::OnResolveHostComplete(int rv) {
       LogConnectionIpPooling(true);
       CloseStaleHostConnection();
       if (!callback_.is_null())
-        base::ResetAndReturn(&callback_).Run(OK);
+        std::move(callback_).Run(OK);
       return;
     } else if (io_state_ != STATE_HOST_VALIDATION) {
       // Case where host resolution returns successfully, but stale connection
@@ -623,7 +624,7 @@ void QuicStreamFactory::Job::OnResolveHostComplete(int rv) {
   }
 
   if (rv != ERR_IO_PENDING && !callback_.is_null())
-    base::ResetAndReturn(&callback_).Run(rv);
+    std::move(callback_).Run(rv);
 }
 
 void QuicStreamFactory::Job::OnConnectComplete(int rv) {
@@ -634,7 +635,7 @@ void QuicStreamFactory::Job::OnConnectComplete(int rv) {
 
   rv = DoLoop(rv);
   if (rv != ERR_IO_PENDING && !callback_.is_null())
-    base::ResetAndReturn(&callback_).Run(rv);
+    std::move(callback_).Run(rv);
 }
 
 void QuicStreamFactory::Job::PopulateNetErrorDetails(
@@ -658,6 +659,7 @@ int QuicStreamFactory::Job::DoResolveHost() {
   HostResolver::ResolveHostParameters parameters;
   parameters.initial_priority = priority_;
   if (race_stale_dns_on_connection_) {
+    // Allow host resolver to return stale result immediately.
     parameters.cache_usage =
         HostResolver::ResolveHostParameters::CacheUsage::STALE_ALLOWED;
   }
@@ -665,6 +667,8 @@ int QuicStreamFactory::Job::DoResolveHost() {
       host_resolver_->CreateRequest(key_.destination(), net_log_, parameters);
   // Unretained is safe because |this| owns the request, ensuring cancellation
   // on destruction.
+  // When race_stale_dns_on_connection_ is on, this request will query for stale
+  // cache if no fresh host result is available.
   int rv = resolve_host_request_->Start(base::BindOnce(
       &QuicStreamFactory::Job::OnResolveHostComplete, base::Unretained(this)));
 
@@ -685,6 +689,7 @@ int QuicStreamFactory::Job::DoResolveHost() {
       host_resolver_->CreateRequest(key_.destination(), net_log_, parameters);
   // Unretained is safe because |this| owns the request, ensuring cancellation
   // on destruction.
+  // This request will only query fresh host resolution.
   int fresh_rv = fresh_resolve_host_request_->Start(base::BindOnce(
       &QuicStreamFactory::Job::OnResolveHostComplete, base::Unretained(this)));
   if (fresh_rv != ERR_IO_PENDING) {
@@ -694,6 +699,10 @@ int QuicStreamFactory::Job::DoResolveHost() {
     return rv;
   }
 
+  // No fresh host resolution is available at this time, but there is available
+  // stale result. End time for stale host resolution is recorded and connection
+  // from stale host will be tried.
+  dns_resolution_end_time_ = base::TimeTicks().Now();
   io_state_ = STATE_CONNECT;
   LogStaleHostRacing(true);
   return OK;
@@ -721,6 +730,7 @@ int QuicStreamFactory::Job::DoResolveHostComplete(int rv) {
 }
 
 int QuicStreamFactory::Job::DoConnect() {
+  DCHECK(dns_resolution_end_time_ != base::TimeTicks());
   io_state_ = STATE_CONNECT_COMPLETE;
   bool require_confirmation = was_alternative_service_recently_broken_;
   net_log_.BeginEvent(
@@ -880,8 +890,7 @@ int QuicStreamFactory::Job::DoConfirmConnection(int rv) {
   DCHECK(!factory_->HasActiveSession(key_.session_key()));
   // There may well now be an active session for this IP.  If so, use the
   // existing session instead.
-  AddressList address(
-      session_->connection()->peer_address().impl().socket_address());
+  AddressList address(ToIPEndPoint(session_->connection()->peer_address()));
   if (factory_->HasMatchingIpSession(key_, address)) {
     LogConnectionIpPooling(true);
     session_->connection()->CloseConnection(
@@ -960,12 +969,12 @@ void QuicStreamRequest::SetSession(
 
 void QuicStreamRequest::OnConnectionFailedOnDefaultNetwork() {
   if (!failed_on_default_network_callback_.is_null())
-    base::ResetAndReturn(&failed_on_default_network_callback_).Run(OK);
+    std::move(failed_on_default_network_callback_).Run(OK);
 }
 
 void QuicStreamRequest::OnRequestComplete(int rv) {
   factory_ = nullptr;
-  base::ResetAndReturn(&callback_).Run(rv);
+  std::move(callback_).Run(rv);
 }
 
 void QuicStreamRequest::ExpectOnHostResolution() {
@@ -976,7 +985,7 @@ void QuicStreamRequest::OnHostResolutionComplete(int rv) {
   DCHECK(expect_on_host_resolution_);
   expect_on_host_resolution_ = false;
   if (!host_resolution_callback_.is_null()) {
-    base::ResetAndReturn(&host_resolution_callback_).Run(rv);
+    std::move(host_resolution_callback_).Run(rv);
   }
 }
 
@@ -1040,7 +1049,8 @@ QuicStreamFactory::QuicStreamFactory(
     bool headers_include_h2_stream_dependency,
     const quic::QuicTagVector& connection_options,
     const quic::QuicTagVector& client_connection_options,
-    bool enable_socket_recv_optimization)
+    bool enable_socket_recv_optimization,
+    int initial_rtt_for_handshake_milliseconds)
     : require_confirmation_(true),
       net_log_(net_log),
       host_resolver_(host_resolver),
@@ -1110,6 +1120,8 @@ QuicStreamFactory::QuicStreamFactory(
       task_runner_(nullptr),
       ssl_config_service_(ssl_config_service),
       enable_socket_recv_optimization_(enable_socket_recv_optimization),
+      initial_rtt_for_handshake_milliseconds_(
+          initial_rtt_for_handshake_milliseconds),
       weak_factory_(this) {
   DCHECK(transport_security_state_);
   DCHECK(http_server_properties_);
@@ -1125,6 +1137,12 @@ QuicStreamFactory::QuicStreamFactory(
   if (migrate_sessions_early_v2 || retry_on_alternate_network_before_handshake)
     DCHECK(migrate_sessions_on_network_change_v2);
 
+  if (retransmittable_on_wire_timeout_milliseconds == 0 &&
+      migrate_sessions_early_v2) {
+    retransmittable_on_wire_timeout_ = quic::QuicTime::Delta::FromMilliseconds(
+        kDefaultRetransmittableOnWireTimeoutMillisecs);
+  }
+
   // goaway_sessions_on_ip_change and close_sessions_on_ip_change should never
   // be simultaneously set to true.
   DCHECK(!(close_sessions_on_ip_change_ && goaway_sessions_on_ip_change_));
@@ -1536,7 +1554,7 @@ std::unique_ptr<base::Value> QuicStreamFactory::QuicStreamFactoryInfoToValue()
         hosts.insert(HostPortPair(alias_it->server_id().host(),
                                   alias_it->server_id().port()));
       }
-      list->Append(session->GetInfoAsValue(hosts));
+      list->GetList().push_back(session->GetInfoAsValue(hosts));
     }
   }
   return std::move(list);
@@ -1886,7 +1904,7 @@ void QuicStreamFactory::ActivateSession(const QuicSessionAliasKey& key,
   active_sessions_[key.session_key()] = session;
   session_aliases_[session].insert(key);
   const IPEndPoint peer_address =
-      session->connection()->peer_address().impl().socket_address();
+      ToIPEndPoint(session->connection()->peer_address());
   DCHECK(!base::ContainsKey(ip_aliases_[peer_address], session));
   ip_aliases_[peer_address].insert(session);
   DCHECK(!base::ContainsKey(session_peer_ip_, session));
@@ -1916,6 +1934,13 @@ void QuicStreamFactory::ConfigureInitialRttEstimate(
     return;
   }
 
+  if (initial_rtt_for_handshake_milliseconds_ > 0) {
+    SetInitialRttEstimate(base::TimeDelta::FromMilliseconds(
+                              initial_rtt_for_handshake_milliseconds_),
+                          INITIAL_RTT_DEFAULT, config);
+    return;
+  }
+
   SetInitialRttEstimate(base::TimeDelta(), INITIAL_RTT_DEFAULT, config);
 }
 
diff --git a/chromium/net/quic/quic_stream_factory.h b/chromium/net/quic/quic_stream_factory.h
index aa5973891bc..bae47ec979e 100644
--- a/chromium/net/quic/quic_stream_factory.h
+++ b/chromium/net/quic/quic_stream_factory.h
@@ -83,8 +83,8 @@ const int kIdleConnectionTimeoutSeconds = 30;
 // Sessions can migrate if they have been idle for less than this period.
 const int kDefaultIdleSessionMigrationPeriodSeconds = 30;
 
-// The maximum time allowed to have no retransmittable packets on the wire
-// (after sending the first retransmittable packet) if
+// The default maximum time allowed to have no retransmittable packets on the
+// wire (after sending the first retransmittable packet) if
 // |migrate_session_early_v2_| is true. PING frames will be sent as needed to
 // enforce this.
 const int64_t kDefaultRetransmittableOnWireTimeoutMillisecs = 100;
@@ -275,7 +275,8 @@ class NET_EXPORT_PRIVATE QuicStreamFactory
       bool headers_include_h2_stream_dependency,
       const quic::QuicTagVector& connection_options,
       const quic::QuicTagVector& client_connection_options,
-      bool enable_socket_recv_optimization);
+      bool enable_socket_recv_optimization,
+      int initial_rtt_for_handshake_milliseconds);
   ~QuicStreamFactory() override;
 
   // Returns true if there is an existing session for |session_key| or if the
@@ -628,6 +629,9 @@ class NET_EXPORT_PRIVATE QuicStreamFactory
   // experimental optimization enabled for receiving data.
   bool enable_socket_recv_optimization_;
 
+  // The initial rtt for handshake.
+  const int initial_rtt_for_handshake_milliseconds_;
+
   base::WeakPtrFactory<QuicStreamFactory> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicStreamFactory);
diff --git a/chromium/net/quic/quic_stream_factory_fuzzer.cc b/chromium/net/quic/quic_stream_factory_fuzzer.cc
index ad443436ec0..60d828be793 100644
--- a/chromium/net/quic/quic_stream_factory_fuzzer.cc
+++ b/chromium/net/quic/quic_stream_factory_fuzzer.cc
@@ -12,7 +12,8 @@
 #include "net/cert/do_nothing_ct_verifier.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/cert/x509_certificate.h"
-#include "net/dns/fuzzed_context_host_resolver.h"
+#include "net/dns/context_host_resolver.h"
+#include "net/dns/fuzzed_host_resolver_util.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/transport_security_state.h"
 #include "net/quic/mock_crypto_client_stream_factory.h"
@@ -83,9 +84,10 @@ static struct Env* env = new Env();
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   base::FuzzedDataProvider data_provider(data, size);
 
-  FuzzedContextHostResolver host_resolver(HostResolver::Options(), nullptr,
-                                          &data_provider,
-                                          true /* enable_caching */);
+  std::unique_ptr<ContextHostResolver> host_resolver =
+      CreateFuzzedContextHostResolver(HostResolver::ManagerOptions(), nullptr,
+                                      &data_provider,
+                                      true /* enable_caching */);
   FuzzedSocketFactory socket_factory(&data_provider);
 
   // Initialize this on each loop since some options mutate this.
@@ -128,8 +130,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
 
   std::unique_ptr<QuicStreamFactory> factory =
       std::make_unique<QuicStreamFactory>(
-          env->net_log.net_log(), &host_resolver, env->ssl_config_service.get(),
-          &socket_factory, &http_server_properties, env->cert_verifier.get(),
+          env->net_log.net_log(), host_resolver.get(),
+          env->ssl_config_service.get(), &socket_factory,
+          &http_server_properties, env->cert_verifier.get(),
           &env->ct_policy_enforcer, &env->transport_security_state,
           env->cert_transparency_verifier.get(), nullptr,
           &env->crypto_client_stream_factory, &env->random_generator,
@@ -151,7 +154,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
           go_away_on_path_degrading, race_cert_verification,
           estimate_initial_rtt, headers_include_h2_stream_dependency,
           env->connection_options, env->client_connection_options,
-          enable_socket_recv_optimization);
+          enable_socket_recv_optimization, 0);
 
   QuicStreamRequest request(factory.get());
   TestCompletionCallback callback;
diff --git a/chromium/net/quic/quic_stream_factory_test.cc b/chromium/net/quic/quic_stream_factory_test.cc
index 4fa477949a2..4c909798498 100644
--- a/chromium/net/quic/quic_stream_factory_test.cc
+++ b/chromium/net/quic/quic_stream_factory_test.cc
@@ -27,10 +27,12 @@
 #include "net/http/http_util.h"
 #include "net/http/transport_security_state.h"
 #include "net/http/transport_security_state_test_util.h"
+#include "net/quic/address_utils.h"
 #include "net/quic/crypto/proof_verifier_chromium.h"
 #include "net/quic/mock_crypto_client_stream_factory.h"
 #include "net/quic/mock_quic_data.h"
 #include "net/quic/properties_based_quic_server_info.h"
+#include "net/quic/quic_chromium_alarm_factory.h"
 #include "net/quic/quic_http_stream.h"
 #include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_server_info.h"
@@ -117,20 +119,20 @@ const char kNonCachedIPAddress[] = "192.168.0.1";
 // and enable_connection_racting.
 struct TestParams {
   friend std::ostream& operator<<(std::ostream& os, const TestParams& p) {
-    os << "{ version: " << QuicVersionToString(p.version)
+    os << "{ version: " << ParsedQuicVersionToString(p.version)
        << ", client_headers_include_h2_stream_dependency: "
        << p.client_headers_include_h2_stream_dependency << " }";
     return os;
   }
 
-  quic::QuicTransportVersion version;
+  quic::ParsedQuicVersion version;
   bool client_headers_include_h2_stream_dependency;
 };
 
 std::vector<TestParams> GetTestParams() {
   std::vector<TestParams> params;
-  quic::QuicTransportVersionVector all_supported_versions =
-      quic::AllSupportedTransportVersions();
+  quic::ParsedQuicVersionVector all_supported_versions =
+      quic::AllVersionsExcept99();
   for (const auto& version : all_supported_versions) {
     params.push_back(TestParams{version, false});
     params.push_back(TestParams{version, true});
@@ -143,7 +145,7 @@ std::vector<TestParams> GetTestParams() {
 struct PoolingTestParams {
   friend std::ostream& operator<<(std::ostream& os,
                                   const PoolingTestParams& p) {
-    os << "{ version: " << QuicVersionToString(p.version)
+    os << "{ version: " << ParsedQuicVersionToString(p.version)
        << ", destination_type: ";
     switch (p.destination_type) {
       case SAME_AS_FIRST:
@@ -162,16 +164,16 @@ struct PoolingTestParams {
     return os;
   }
 
-  quic::QuicTransportVersion version;
+  quic::ParsedQuicVersion version;
   DestinationType destination_type;
   bool client_headers_include_h2_stream_dependency;
 };
 
 std::vector<PoolingTestParams> GetPoolingTestParams() {
   std::vector<PoolingTestParams> params;
-  quic::QuicTransportVersionVector all_supported_versions =
-      quic::AllSupportedTransportVersions();
-  for (const quic::QuicTransportVersion version : all_supported_versions) {
+  quic::ParsedQuicVersionVector all_supported_versions =
+      quic::AllVersionsExcept99();
+  for (const quic::ParsedQuicVersion version : all_supported_versions) {
     params.push_back(PoolingTestParams{version, SAME_AS_FIRST, false});
     params.push_back(PoolingTestParams{version, SAME_AS_FIRST, true});
     params.push_back(PoolingTestParams{version, SAME_AS_SECOND, false});
@@ -218,7 +220,7 @@ class TestConnectionMigrationSocketFactory : public MockClientSocketFactory {
 
 class QuicStreamFactoryTestBase : public WithScopedTaskEnvironment {
  protected:
-  QuicStreamFactoryTestBase(quic::QuicTransportVersion version,
+  QuicStreamFactoryTestBase(quic::ParsedQuicVersion version,
                             bool client_headers_include_h2_stream_dependency)
       : host_resolver_(new MockHostResolver),
         ssl_config_service_(new MockSSLConfigService),
@@ -296,7 +298,8 @@ class QuicStreamFactoryTestBase : public WithScopedTaskEnvironment {
         test_params_.quic_headers_include_h2_stream_dependency,
         test_params_.quic_connection_options,
         test_params_.quic_client_connection_options,
-        test_params_.quic_enable_socket_recv_optimization));
+        test_params_.quic_enable_socket_recv_optimization,
+        test_params_.quic_initial_rtt_for_handshake_milliseconds));
   }
 
   void InitializeConnectionMigrationV2Test(
@@ -384,12 +387,12 @@ class QuicStreamFactoryTestBase : public WithScopedTaskEnvironment {
 
     QuicStreamRequest request(factory_.get());
     GURL url("https://" + destination.host() + "/");
-    EXPECT_EQ(
-        ERR_IO_PENDING,
-        request.Request(
-            destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-            /*cert_verify_flags=*/0, url, net_log_, &net_error_details_,
-            failed_on_default_network_callback_, callback_.callback()));
+    EXPECT_EQ(ERR_IO_PENDING,
+              request.Request(
+                  destination, version_.transport_version, privacy_mode_,
+                  DEFAULT_PRIORITY, SocketTag(),
+                  /*cert_verify_flags=*/0, url, net_log_, &net_error_details_,
+                  failed_on_default_network_callback_, callback_.callback()));
 
     EXPECT_THAT(callback_.WaitForResult(), IsOk());
     std::unique_ptr<HttpStream> stream = CreateStream(&request);
@@ -545,8 +548,8 @@ class QuicStreamFactoryTestBase : public WithScopedTaskEnvironment {
     QuicStreamRequest request(factory_.get());
     EXPECT_EQ(ERR_IO_PENDING,
               request.Request(
-                  host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                  SocketTag(),
+                  host_port_pair_, version_.transport_version, privacy_mode_,
+                  DEFAULT_PRIORITY, SocketTag(),
                   /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                   failed_on_default_network_callback_, callback_.callback()));
     EXPECT_EQ(OK, callback_.WaitForResult());
@@ -733,7 +736,8 @@ class QuicStreamFactoryTestBase : public WithScopedTaskEnvironment {
     EXPECT_EQ(ERR_IO_PENDING,
               request.Request(
                   HostPortPair(quic_server_id.host(), quic_server_id.port()),
-                  version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+                  version_.transport_version, privacy_mode_, DEFAULT_PRIORITY,
+                  SocketTag(),
                   /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                   failed_on_default_network_callback_, callback_.callback()));
     EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -768,7 +772,8 @@ class QuicStreamFactoryTestBase : public WithScopedTaskEnvironment {
     EXPECT_EQ(ERR_IO_PENDING,
               request2.Request(
                   HostPortPair(quic_server_id2.host(), quic_server_id2.port()),
-                  version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+                  version_.transport_version, privacy_mode_, DEFAULT_PRIORITY,
+                  SocketTag(),
                   /*cert_verify_flags=*/0, GURL("https://mail.example.org/"),
                   net_log_, &net_error_details_,
                   failed_on_default_network_callback_, callback_.callback()));
@@ -795,11 +800,34 @@ class QuicStreamFactoryTestBase : public WithScopedTaskEnvironment {
   }
 
   quic::QuicStreamId GetNthClientInitiatedBidirectionalStreamId(int n) {
-    return quic::test::GetNthClientInitiatedBidirectionalStreamId(version_, n);
+    return quic::test::GetNthClientInitiatedBidirectionalStreamId(
+        version_.transport_version, n);
+  }
+
+  std::string ConstructDataHeader(size_t body_len) {
+    if (version_.transport_version != quic::QUIC_VERSION_99) {
+      return "";
+    }
+    quic::HttpEncoder encoder;
+    std::unique_ptr<char[]> buffer;
+    auto header_length = encoder.SerializeDataFrameHeader(body_len, &buffer);
+    return std::string(buffer.get(), header_length);
+  }
+
+  std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerDataPacket(
+      uint64_t packet_number,
+      quic::QuicStreamId stream_id,
+      bool should_include_version,
+      bool fin,
+      quic::QuicStreamOffset offset,
+      quic::QuicStringPiece data) {
+    return server_maker_.MakeDataPacket(
+        packet_number, stream_id, should_include_version, fin, offset, data);
   }
 
   quic::QuicStreamId GetNthServerInitiatedUnidirectionalStreamId(int n) {
-    return quic::test::GetNthServerInitiatedUnidirectionalStreamId(version_, n);
+    return quic::test::GetNthServerInitiatedUnidirectionalStreamId(
+        version_.transport_version, n);
   }
 
   void OnFailedOnDefaultNetwork(int rv) { failed_on_default_network_ = true; }
@@ -847,7 +875,7 @@ class QuicStreamFactoryTestBase : public WithScopedTaskEnvironment {
   quic::test::MockRandom random_generator_;
   quic::MockClock clock_;
   scoped_refptr<TestTaskRunner> runner_;
-  const quic::QuicTransportVersion version_;
+  const quic::ParsedQuicVersion version_;
   QuicTestPacketMaker client_maker_;
   QuicTestPacketMaker server_maker_;
   HttpServerPropertiesImpl http_server_properties_;
@@ -902,8 +930,8 @@ TEST_P(QuicStreamFactoryTest, Create) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -914,8 +942,8 @@ TEST_P(QuicStreamFactoryTest, Create) {
   EXPECT_EQ(DEFAULT_PRIORITY, host_resolver_->last_request_priority());
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
-                                 DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                  /*cert_verify_flags=*/0, url_, net_log_,
                                  &net_error_details_,
                                  failed_on_default_network_callback_,
@@ -928,8 +956,8 @@ TEST_P(QuicStreamFactoryTest, Create) {
   // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result
   // in streams on different sessions.
   QuicStreamRequest request3(factory_.get());
-  EXPECT_EQ(OK, request3.Request(host_port_pair_, version_, privacy_mode_,
-                                 DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request3.Request(host_port_pair_, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                  /*cert_verify_flags=*/0, url_, net_log_,
                                  &net_error_details_,
                                  failed_on_default_network_callback_,
@@ -958,8 +986,8 @@ TEST_P(QuicStreamFactoryTest, CreateZeroRtt) {
                                             "192.168.0.1", "");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
-                                DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request.Request(host_port_pair_, version_.transport_version,
+                                privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                 /*cert_verify_flags=*/0, url_, net_log_,
                                 &net_error_details_,
                                 failed_on_default_network_callback_,
@@ -984,8 +1012,8 @@ TEST_P(QuicStreamFactoryTest, DefaultInitialRtt) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -1012,8 +1040,8 @@ TEST_P(QuicStreamFactoryTest, FactoryDestroyedWhenJobPending) {
   auto request = std::make_unique<QuicStreamRequest>(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request->Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   request.reset();
@@ -1042,8 +1070,8 @@ TEST_P(QuicStreamFactoryTest, RequireConfirmation) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -1083,8 +1111,8 @@ TEST_P(QuicStreamFactoryTest, DontRequireConfirmationFromSameIP) {
 
   QuicStreamRequest request(factory_.get());
   EXPECT_THAT(request.Request(
-                  host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                  SocketTag(),
+                  host_port_pair_, version_.transport_version, privacy_mode_,
+                  DEFAULT_PRIORITY, SocketTag(),
                   /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                   failed_on_default_network_callback_, callback_.callback()),
               IsOk());
@@ -1123,8 +1151,8 @@ TEST_P(QuicStreamFactoryTest, CachedInitialRtt) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -1156,8 +1184,8 @@ TEST_P(QuicStreamFactoryTest, 2gInitialRtt) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -1189,8 +1217,8 @@ TEST_P(QuicStreamFactoryTest, 3gInitialRtt) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -1217,8 +1245,8 @@ TEST_P(QuicStreamFactoryTest, GoAway) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -1249,8 +1277,8 @@ TEST_P(QuicStreamFactoryTest, GoAwayForConnectionMigrationWithPortOnly) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -1294,8 +1322,8 @@ TEST_P(QuicStreamFactoryTest, Pooling) {
   host_resolver_->rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
-                                DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request.Request(host_port_pair_, version_.transport_version,
+                                privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                 /*cert_verify_flags=*/0, url_, net_log_,
                                 &net_error_details_,
                                 failed_on_default_network_callback_,
@@ -1305,11 +1333,12 @@ TEST_P(QuicStreamFactoryTest, Pooling) {
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK,
-            request2.Request(
-                server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-                /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
-                failed_on_default_network_callback_, callback.callback()));
+  EXPECT_EQ(OK, request2.Request(server2, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+                                 /*cert_verify_flags=*/0, url2_, net_log_,
+                                 &net_error_details_,
+                                 failed_on_default_network_callback_,
+                                 callback.callback()));
   std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
   EXPECT_TRUE(stream2.get());
 
@@ -1358,7 +1387,8 @@ TEST_P(QuicStreamFactoryTest, PoolingWithServerMigration) {
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(
-                server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+                server2, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback.callback()));
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -1392,8 +1422,8 @@ TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
   host_resolver_->rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
-                                DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request.Request(host_port_pair_, version_.transport_version,
+                                privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                 /*cert_verify_flags=*/0, url_, net_log_,
                                 &net_error_details_,
                                 failed_on_default_network_callback_,
@@ -1403,11 +1433,12 @@ TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK,
-            request2.Request(
-                server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-                /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
-                failed_on_default_network_callback_, callback.callback()));
+  EXPECT_EQ(OK, request2.Request(server2, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+                                 /*cert_verify_flags=*/0, url2_, net_log_,
+                                 &net_error_details_,
+                                 failed_on_default_network_callback_,
+                                 callback.callback()));
   std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
   EXPECT_TRUE(stream2.get());
 
@@ -1417,11 +1448,12 @@ TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
 
   TestCompletionCallback callback3;
   QuicStreamRequest request3(factory_.get());
-  EXPECT_EQ(OK,
-            request3.Request(
-                server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-                /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
-                failed_on_default_network_callback_, callback3.callback()));
+  EXPECT_EQ(OK, request3.Request(server2, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+                                 /*cert_verify_flags=*/0, url2_, net_log_,
+                                 &net_error_details_,
+                                 failed_on_default_network_callback_,
+                                 callback3.callback()));
   std::unique_ptr<HttpStream> stream3 = CreateStream(&request3);
   EXPECT_TRUE(stream3.get());
 
@@ -1452,21 +1484,23 @@ TEST_P(QuicStreamFactoryTest, HttpsPooling) {
   host_resolver_->rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK,
-            request.Request(
-                server1, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-                /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
-                failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(OK, request.Request(server1, version_.transport_version,
+                                privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+                                /*cert_verify_flags=*/0, url_, net_log_,
+                                &net_error_details_,
+                                failed_on_default_network_callback_,
+                                callback_.callback()));
   std::unique_ptr<HttpStream> stream = CreateStream(&request);
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK,
-            request2.Request(
-                server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-                /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
-                failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(OK, request2.Request(server2, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+                                 /*cert_verify_flags=*/0, url2_, net_log_,
+                                 &net_error_details_,
+                                 failed_on_default_network_callback_,
+                                 callback_.callback()));
   std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
   EXPECT_TRUE(stream2.get());
 
@@ -1500,21 +1534,23 @@ TEST_P(QuicStreamFactoryTest, HttpsPoolingWithMatchingPins) {
   host_resolver_->rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK,
-            request.Request(
-                server1, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-                /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
-                failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(OK, request.Request(server1, version_.transport_version,
+                                privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+                                /*cert_verify_flags=*/0, url_, net_log_,
+                                &net_error_details_,
+                                failed_on_default_network_callback_,
+                                callback_.callback()));
   std::unique_ptr<HttpStream> stream = CreateStream(&request);
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK,
-            request2.Request(
-                server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-                /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
-                failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(OK, request2.Request(server2, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+                                 /*cert_verify_flags=*/0, url2_, net_log_,
+                                 &net_error_details_,
+                                 failed_on_default_network_callback_,
+                                 callback_.callback()));
   std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
   EXPECT_TRUE(stream2.get());
 
@@ -1559,21 +1595,23 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithDifferentPins) {
   host_resolver_->rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK,
-            request.Request(
-                server1, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-                /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
-                failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(OK, request.Request(server1, version_.transport_version,
+                                privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+                                /*cert_verify_flags=*/0, url_, net_log_,
+                                &net_error_details_,
+                                failed_on_default_network_callback_,
+                                callback_.callback()));
   std::unique_ptr<HttpStream> stream = CreateStream(&request);
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK,
-            request2.Request(
-                server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-                /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
-                failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(OK, request2.Request(server2, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+                                 /*cert_verify_flags=*/0, url2_, net_log_,
+                                 &net_error_details_,
+                                 failed_on_default_network_callback_,
+                                 callback_.callback()));
   std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
   EXPECT_TRUE(stream2.get());
 
@@ -1603,8 +1641,8 @@ TEST_P(QuicStreamFactoryTest, Goaway) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -1625,8 +1663,8 @@ TEST_P(QuicStreamFactoryTest, Goaway) {
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -1655,11 +1693,10 @@ TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
   quic::QuicStreamId stream_id = GetNthClientInitiatedBidirectionalStreamId(0);
   MockQuicData socket_data;
   socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket());
-  if (version_ == quic::QUIC_VERSION_99) {
-    socket_data.AddWrite(
-        SYNCHRONOUS,
-        client_maker_.MakeStreamIdBlockedPacket(
-            2, true, GetNthClientInitiatedBidirectionalStreamId(49)));
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
+    socket_data.AddWrite(SYNCHRONOUS, client_maker_.MakeStreamsBlockedPacket(
+                                          2, true, 51,
+                                          /*unidirectional=*/false));
     socket_data.AddWrite(
         SYNCHRONOUS, client_maker_.MakeRstPacket(3, true, stream_id,
                                                  quic::QUIC_STREAM_CANCELLED));
@@ -1667,8 +1704,8 @@ TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
         ASYNC, server_maker_.MakeRstPacket(1, false, stream_id,
                                            quic::QUIC_STREAM_CANCELLED));
     socket_data.AddRead(
-        ASYNC, server_maker_.MakeMaxStreamIdPacket(
-                   4, true, GetNthClientInitiatedBidirectionalStreamId(50)));
+        ASYNC, server_maker_.MakeMaxStreamsPacket(4, true, 52,
+                                                  /*unidirectional=*/false));
   } else {
     socket_data.AddWrite(
         SYNCHRONOUS, client_maker_.MakeRstPacket(2, true, stream_id,
@@ -1690,7 +1727,8 @@ TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
   for (size_t i = 0; i < quic::kDefaultMaxStreamsPerConnection / 2; i++) {
     QuicStreamRequest request(factory_.get());
     int rv = request.Request(
-        host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+        host_port_pair_, version_.transport_version, privacy_mode_,
+        DEFAULT_PRIORITY, SocketTag(),
         /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
         failed_on_default_network_callback_, callback_.callback());
     if (i == 0) {
@@ -1708,8 +1746,8 @@ TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
   }
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
-                                DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request.Request(host_port_pair_, version_.transport_version,
+                                privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                 /*cert_verify_flags=*/0, url_, net_log_,
                                 &net_error_details_,
                                 failed_on_default_network_callback_,
@@ -1749,8 +1787,8 @@ TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -1770,8 +1808,8 @@ TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -1791,8 +1829,8 @@ TEST_P(QuicStreamFactoryTest, CancelCreate) {
     QuicStreamRequest request(factory_.get());
     EXPECT_EQ(ERR_IO_PENDING,
               request.Request(
-                  host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                  SocketTag(),
+                  host_port_pair_, version_.transport_version, privacy_mode_,
+                  DEFAULT_PRIORITY, SocketTag(),
                   /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                   failed_on_default_network_callback_, callback_.callback()));
   }
@@ -1800,8 +1838,8 @@ TEST_P(QuicStreamFactoryTest, CancelCreate) {
   base::RunLoop().RunUntilIdle();
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
-                                 DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                  /*cert_verify_flags=*/0, url_, net_log_,
                                  &net_error_details_,
                                  failed_on_default_network_callback_,
@@ -1839,8 +1877,8 @@ TEST_P(QuicStreamFactoryTest, CloseAllSessions) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -1864,8 +1902,8 @@ TEST_P(QuicStreamFactoryTest, CloseAllSessions) {
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -1900,8 +1938,8 @@ TEST_P(QuicStreamFactoryTest,
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED, callback_.WaitForResult());
@@ -1921,8 +1959,8 @@ TEST_P(QuicStreamFactoryTest,
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_FALSE(HasActiveSession(host_port_pair_));
@@ -1966,8 +2004,8 @@ TEST_P(QuicStreamFactoryTest, WriteErrorInCryptoConnectWithSyncHostResolution) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   // Check no active session, or active jobs left for this server.
@@ -1987,8 +2025,8 @@ TEST_P(QuicStreamFactoryTest, WriteErrorInCryptoConnectWithSyncHostResolution) {
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_FALSE(HasActiveSession(host_port_pair_));
@@ -2036,8 +2074,8 @@ TEST_P(QuicStreamFactoryTest, CloseSessionsOnIPAddressChanged) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -2071,8 +2109,8 @@ TEST_P(QuicStreamFactoryTest, CloseSessionsOnIPAddressChanged) {
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -2129,8 +2167,8 @@ TEST_P(QuicStreamFactoryTest, GoAwaySessionsOnIPAddressChanged) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -2175,8 +2213,8 @@ TEST_P(QuicStreamFactoryTest, GoAwaySessionsOnIPAddressChanged) {
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -2214,8 +2252,8 @@ TEST_P(QuicStreamFactoryTest, OnIPAddressChangedWithConnectionMigration) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -2237,8 +2275,8 @@ TEST_P(QuicStreamFactoryTest, OnIPAddressChangedWithConnectionMigration) {
 
   // Attempting a new request to the same origin uses the same connection.
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
-                                 DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                  /*cert_verify_flags=*/0, url_, net_log_,
                                  &net_error_details_,
                                  failed_on_default_network_callback_,
@@ -2315,8 +2353,8 @@ void QuicStreamFactoryTestBase::TestMigrationOnNetworkMadeDefault(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -2494,8 +2532,8 @@ TEST_P(QuicStreamFactoryTest, MigratedToBlockedSocketAfterProbing) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -2638,8 +2676,8 @@ TEST_P(QuicStreamFactoryTest, MigrationTimeoutWithNoNewNetwork) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -2755,8 +2793,8 @@ void QuicStreamFactoryTestBase::TestOnNetworkMadeDefaultNonMigratableStream(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -2820,8 +2858,8 @@ TEST_P(QuicStreamFactoryTest, OnNetworkMadeDefaultConnectionMigrationDisabled) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -2912,8 +2950,8 @@ void QuicStreamFactoryTestBase::TestOnNetworkDisconnectedNonMigratableStream(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -2976,8 +3014,8 @@ TEST_P(QuicStreamFactoryTest,
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -3065,8 +3103,8 @@ void QuicStreamFactoryTestBase::TestOnNetworkMadeDefaultNoOpenStreams(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -3133,8 +3171,8 @@ void QuicStreamFactoryTestBase::TestOnNetworkDisconnectedNoOpenStreams(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -3206,8 +3244,8 @@ void QuicStreamFactoryTestBase::TestMigrationOnNetworkDisconnected(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -3325,8 +3363,8 @@ TEST_P(QuicStreamFactoryTest, NewNetworkConnectedAfterNoNetwork) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -3488,8 +3526,8 @@ TEST_P(QuicStreamFactoryTest, MigrateToProbingSocket) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -3662,8 +3700,8 @@ void QuicStreamFactoryTestBase::TestMigrationOnPathDegrading(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -3800,8 +3838,8 @@ TEST_P(QuicStreamFactoryTest, GoawayOnPathDegrading) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cerf_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -3841,8 +3879,8 @@ TEST_P(QuicStreamFactoryTest, GoawayOnPathDegrading) {
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -3917,8 +3955,8 @@ TEST_P(QuicStreamFactoryTest, DoNotMigrateToBadSocketOnPathDegrading) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -4020,8 +4058,12 @@ void QuicStreamFactoryTestBase::TestMigrateSessionWithDrainingStream(
       ASYNC, ConstructOkResponsePacket(
                  2, GetNthClientInitiatedBidirectionalStreamId(0), false,
                  true));  // keep sending version.
-  quic_data1.AddWrite(SYNCHRONOUS, client_maker_.MakeAckPacket(
-                                       packet_number++, 2, 2, 2, 1, true));
+  if (!GetQuicRestartFlag(quic_enable_accept_random_ipn)) {
+    // Packet 2 is considered as out of order packet and an ACK will be sent
+    // immediately.
+    quic_data1.AddWrite(SYNCHRONOUS, client_maker_.MakeAckPacket(
+                                         packet_number++, 2, 2, 2, 1, true));
+  }
   quic_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
   quic_data1.AddSocketDataToFactory(socket_factory_.get());
 
@@ -4055,8 +4097,8 @@ void QuicStreamFactoryTestBase::TestMigrateSessionWithDrainingStream(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -4212,8 +4254,8 @@ TEST_P(QuicStreamFactoryTest, MigrateOnNewNetworkConnectAfterPathDegrading) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -4351,21 +4393,23 @@ TEST_P(QuicStreamFactoryTest,
 
   // Create request and QuicHttpStream to create session1.
   QuicStreamRequest request1(factory_.get());
-  EXPECT_EQ(OK,
-            request1.Request(
-                server1, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-                /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
-                failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(OK, request1.Request(server1, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+                                 /*cert_verify_flags=*/0, url_, net_log_,
+                                 &net_error_details_,
+                                 failed_on_default_network_callback_,
+                                 callback_.callback()));
   std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
   EXPECT_TRUE(stream1.get());
 
   // Create request and QuicHttpStream to create session2.
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK,
-            request2.Request(
-                server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-                /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
-                failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(OK, request2.Request(server2, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+                                 /*cert_verify_flags=*/0, url2_, net_log_,
+                                 &net_error_details_,
+                                 failed_on_default_network_callback_,
+                                 callback_.callback()));
   std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
   EXPECT_TRUE(stream2.get());
 
@@ -4476,8 +4520,8 @@ TEST_P(QuicStreamFactoryTest, MigrateOnPathDegradingWithNoNewNetwork) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -4590,8 +4634,8 @@ void QuicStreamFactoryTestBase::TestMigrateSessionEarlyNonMigratableStream(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -4656,8 +4700,8 @@ TEST_P(QuicStreamFactoryTest, MigrateSessionEarlyConnectionMigrationDisabled) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -4758,8 +4802,8 @@ TEST_P(QuicStreamFactoryTest, MigrateSessionOnAysncWriteError) {
   QuicStreamRequest request1(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request1.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -4778,8 +4822,8 @@ TEST_P(QuicStreamFactoryTest, MigrateSessionOnAysncWriteError) {
   // Request #2 returns synchronously because it pools to existing session.
   TestCompletionCallback callback2;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
-                                 DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                  /*cert_verify_flags=*/0, url_, net_log_,
                                  &net_error_details_,
                                  failed_on_default_network_callback_,
@@ -4895,8 +4939,8 @@ TEST_P(QuicStreamFactoryTest, MigrateBackToDefaultPostMigrationOnWriteError) {
   QuicStreamRequest request1(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request1.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -5017,8 +5061,8 @@ TEST_P(QuicStreamFactoryTest,
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -5078,8 +5122,8 @@ void QuicStreamFactoryTestBase::TestNoAlternateNetworkBeforeHandshake(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -5200,8 +5244,8 @@ void QuicStreamFactoryTestBase::
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -5317,8 +5361,8 @@ TEST_P(QuicStreamFactoryTest, MigrationOnWriteErrorBeforeHandshakeConfirmed) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(ERR_QUIC_HANDSHAKE_FAILED, callback_.WaitForResult());
@@ -5338,8 +5382,8 @@ TEST_P(QuicStreamFactoryTest, MigrationOnWriteErrorBeforeHandshakeConfirmed) {
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_FALSE(HasActiveSession(host_port_pair_));
@@ -5412,8 +5456,8 @@ TEST_P(QuicStreamFactoryTest,
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   // Ensure that the session is alive but not active.
@@ -5482,8 +5526,8 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteError(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
@@ -5579,8 +5623,8 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorNoNewNetwork(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
@@ -5716,8 +5760,8 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorWithMultipleRequests(
   QuicStreamRequest request1(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request1.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -5736,8 +5780,8 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorWithMultipleRequests(
   // Second request returns synchronously because it pools to existing session.
   TestCompletionCallback callback2;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
-                                 DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                  /*cert_verify_flags=*/0, url_, net_log_,
                                  &net_error_details_,
                                  failed_on_default_network_callback_,
@@ -5852,8 +5896,8 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorMixedStreams(
   QuicStreamRequest request1(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request1.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -5872,8 +5916,8 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorMixedStreams(
   // Second request returns synchronously because it pools to existing session.
   TestCompletionCallback callback2;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
-                                 DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                  /*cert_verify_flags=*/0, url_, net_log_,
                                  &net_error_details_,
                                  failed_on_default_network_callback_,
@@ -5999,8 +6043,8 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorMixedStreams2(
   QuicStreamRequest request1(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request1.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -6019,8 +6063,8 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorMixedStreams2(
   // Second request returns synchronously because it pools to existing session.
   TestCompletionCallback callback2;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
-                                 DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                  /*cert_verify_flags=*/0, url_, net_log_,
                                  &net_error_details_,
                                  failed_on_default_network_callback_,
@@ -6132,8 +6176,8 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorNonMigratableStream(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
@@ -6219,8 +6263,8 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorMigrationDisabled(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
@@ -6345,8 +6389,8 @@ void QuicStreamFactoryTestBase::TestMigrationOnMultipleWriteErrors(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
@@ -6440,8 +6484,8 @@ TEST_P(QuicStreamFactoryTest, NoMigrationBeforeHandshakeOnNetworkDisconnected) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   // Deliver the network notification, which should cause the connection to be
@@ -6479,8 +6523,8 @@ void QuicStreamFactoryTestBase::
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
@@ -6613,8 +6657,8 @@ void QuicStreamFactoryTestBase::
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
@@ -6753,8 +6797,8 @@ void QuicStreamFactoryTestBase::TestMigrationOnWriteErrorPauseBeforeConnected(
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -6884,8 +6928,8 @@ TEST_P(QuicStreamFactoryTest, IgnoreWriteErrorFromOldWriterAfterMigration) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
@@ -6988,8 +7032,8 @@ TEST_P(QuicStreamFactoryTest, IgnoreReadErrorFromOldReaderAfterMigration) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
@@ -7102,8 +7146,8 @@ TEST_P(QuicStreamFactoryTest, IgnoreReadErrorOnOldReaderDuringMigration) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
@@ -7184,12 +7228,880 @@ TEST_P(QuicStreamFactoryTest, IgnoreReadErrorOnOldReaderDuringMigration) {
   EXPECT_EQ(200, response.headers->response_code());
 
   stream.reset();
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data1.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
+}
+
+// This test verifies that when connection migration on path degrading is
+// enabled, and no custom retransmittable on wire timeout is specified, the
+// default value is used.
+TEST_P(QuicStreamFactoryTest, DefaultRetransmittableOnWireTimeoutForMigration) {
+  InitializeConnectionMigrationV2Test(
+      {kDefaultNetworkForTests, kNewNetworkForTests});
+  ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+
+  // Using a testing task runner.
+  auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
+  QuicStreamFactoryPeer::SetAlarmFactory(
+      factory_.get(),
+      std::make_unique<QuicChromiumAlarmFactory>(task_runner.get(), &clock_));
+
+  MockQuicData socket_data;
+  quic::QuicStreamOffset header_stream_offset = 0;
+  socket_data.AddWrite(
+      SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset));
+  socket_data.AddRead(ASYNC, ERR_IO_PENDING);  // Pause
+  socket_data.AddRead(ASYNC, ERR_ADDRESS_UNREACHABLE);
+  socket_data.AddSocketDataToFactory(socket_factory_.get());
+
+  // Set up second socket data provider that is used after
+  // migration. The request is written to this new socket, and the
+  // response to the request is read on this new socket.
+  MockQuicData socket_data1;
+  // The PING packet sent post migration.
+  socket_data1.AddWrite(SYNCHRONOUS, client_maker_.MakePingPacket(2, true));
+  socket_data1.AddWrite(
+      SYNCHRONOUS, ConstructGetRequestPacket(
+                       3, GetNthClientInitiatedBidirectionalStreamId(0), true,
+                       true, &header_stream_offset));
+  socket_data1.AddRead(ASYNC, ERR_IO_PENDING);  // Pause.
+  // Read two packets so that client will send ACK immedaitely.
+  spdy::SpdyHeaderBlock response_headers =
+      server_maker_.GetResponseHeaders("200 OK");
+  response_headers["key1"] = std::string(2000, 'A');
+  spdy::SpdyHeadersIR headers_frame(
+      GetNthClientInitiatedBidirectionalStreamId(0),
+      std::move(response_headers));
+  spdy::SpdyFramer response_framer(spdy::SpdyFramer::ENABLE_COMPRESSION);
+  spdy::SpdySerializedFrame spdy_frame =
+      response_framer.SerializeFrame(headers_frame);
+  size_t chunk_size = 1200;
+  unsigned int packet_number = 1;
+  for (size_t offset = 0; offset < spdy_frame.size(); offset += chunk_size) {
+    size_t len = std::min(chunk_size, spdy_frame.size() - offset);
+    socket_data1.AddRead(
+        ASYNC,
+        server_maker_.MakeDataPacket(
+            packet_number++,
+            quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+            false, false, offset,
+            base::StringPiece(spdy_frame.data() + offset, len)));
+  }
+  // Read an ACK from server which acks all client data.
+  socket_data1.AddRead(SYNCHRONOUS,
+                       server_maker_.MakeAckPacket(3, 3, 1, 1, false));
+  socket_data1.AddWrite(ASYNC, client_maker_.MakeAckPacket(4, 2, 1, 1, false));
+  // The PING packet sent for retransmittable on wire.
+  socket_data1.AddWrite(SYNCHRONOUS, client_maker_.MakePingPacket(5, false));
+  socket_data1.AddRead(ASYNC, ERR_IO_PENDING);  // Pause.
+  std::string header = ConstructDataHeader(6);
+  socket_data1.AddRead(
+      ASYNC, ConstructServerDataPacket(
+                 3, GetNthClientInitiatedBidirectionalStreamId(0), false, true,
+                 0, header + "hello!"));
+  socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more data to read.
+  socket_data1.AddWrite(
+      SYNCHRONOUS, client_maker_.MakeRstPacket(
+                       6, false, GetNthClientInitiatedBidirectionalStreamId(0),
+                       quic::QUIC_STREAM_CANCELLED));
+  socket_data1.AddSocketDataToFactory(socket_factory_.get());
+
+  // Create request and QuicHttpStream.
+  QuicStreamRequest request(factory_.get());
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
+                /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+                failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(OK, callback_.WaitForResult());
+  std::unique_ptr<HttpStream> stream = CreateStream(&request);
+  EXPECT_TRUE(stream.get());
+
+  // Cause QUIC stream to be created.
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("https://www.example.org/");
+  request_info.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
+  EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
+                                         net_log_, CompletionOnceCallback()));
+
+  // Ensure that session is alive and active.
+  QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+
+  // Now notify network is disconnected, cause the migration to complete
+  // immediately.
+  scoped_mock_network_change_notifier_->mock_network_change_notifier()
+      ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
+
+  // Complete migration.
+  task_runner->RunUntilIdle();
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+  EXPECT_EQ(1u, session->GetNumActiveStreams());
+
+  // Send GET request on stream.
+  HttpResponseInfo response;
+  HttpRequestHeaders request_headers;
+  EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
+                                    callback_.callback()));
+  socket_data1.Resume();
+  // Spin up the message loop to read incoming data from server till the ACK.
+  base::RunLoop().RunUntilIdle();
+
+  // Ack delay time.
+  int delay = task_runner->NextPendingTaskDelay().InMilliseconds();
+  EXPECT_GT(kDefaultRetransmittableOnWireTimeoutMillisecs, delay);
+  // Fire the ack alarm, since ack has been sent, no ack will be sent.
+  clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+  task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
+
+  // Fire the ping alarm with retransmittable-on-wire timeout, send PING.
+  delay = kDefaultRetransmittableOnWireTimeoutMillisecs - delay;
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(delay),
+            task_runner->NextPendingTaskDelay());
+  clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+  task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
+
+  socket_data1.Resume();
+
+  // Verify that response headers on the migrated socket were delivered to the
+  // stream.
+  EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
+  EXPECT_EQ(200, response.headers->response_code());
+
+  // Resume the old socket data, a read error will be delivered to the old
+  // packet reader. Verify that the session is not affected.
+  socket_data.Resume();
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+  EXPECT_EQ(1u, session->GetNumActiveStreams());
+
+  stream.reset();
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
+  EXPECT_TRUE(socket_data1.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
+}
+
+// This test verifies that when connection migration on path degrading is
+// enabled, and a custom retransmittable on wire timeout is specified, the
+// custom value is used.
+TEST_P(QuicStreamFactoryTest, CustomRetransmittableOnWireTimeoutForMigration) {
+  int custom_timeout_value = 200;
+  test_params_.quic_retransmittable_on_wire_timeout_milliseconds =
+      custom_timeout_value;
+  InitializeConnectionMigrationV2Test(
+      {kDefaultNetworkForTests, kNewNetworkForTests});
+  ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+
+  // Using a testing task runner.
+  auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
+  QuicStreamFactoryPeer::SetAlarmFactory(
+      factory_.get(),
+      std::make_unique<QuicChromiumAlarmFactory>(task_runner.get(), &clock_));
+
+  MockQuicData socket_data;
+  quic::QuicStreamOffset header_stream_offset = 0;
+  socket_data.AddWrite(
+      SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset));
+  socket_data.AddRead(ASYNC, ERR_IO_PENDING);  // Pause
+  socket_data.AddRead(ASYNC, ERR_ADDRESS_UNREACHABLE);
+  socket_data.AddSocketDataToFactory(socket_factory_.get());
+
+  // Set up second socket data provider that is used after
+  // migration. The request is written to this new socket, and the
+  // response to the request is read on this new socket.
+  MockQuicData socket_data1;
+  // The PING packet sent post migration.
+  socket_data1.AddWrite(SYNCHRONOUS, client_maker_.MakePingPacket(2, true));
+  socket_data1.AddWrite(
+      SYNCHRONOUS, ConstructGetRequestPacket(
+                       3, GetNthClientInitiatedBidirectionalStreamId(0), true,
+                       true, &header_stream_offset));
+  socket_data1.AddRead(ASYNC, ERR_IO_PENDING);  // Pause.
+  // Read two packets so that client will send ACK immedaitely.
+  spdy::SpdyHeaderBlock response_headers =
+      server_maker_.GetResponseHeaders("200 OK");
+  response_headers["key1"] = std::string(2000, 'A');
+  spdy::SpdyHeadersIR headers_frame(
+      GetNthClientInitiatedBidirectionalStreamId(0),
+      std::move(response_headers));
+  spdy::SpdyFramer response_framer(spdy::SpdyFramer::ENABLE_COMPRESSION);
+  spdy::SpdySerializedFrame spdy_frame =
+      response_framer.SerializeFrame(headers_frame);
+  size_t chunk_size = 1200;
+  unsigned int packet_number = 1;
+  for (size_t offset = 0; offset < spdy_frame.size(); offset += chunk_size) {
+    size_t len = std::min(chunk_size, spdy_frame.size() - offset);
+    socket_data1.AddRead(
+        ASYNC,
+        server_maker_.MakeDataPacket(
+            packet_number++,
+            quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+            false, false, offset,
+            base::StringPiece(spdy_frame.data() + offset, len)));
+  }
+  // Read an ACK from server which acks all client data.
+  socket_data1.AddRead(SYNCHRONOUS,
+                       server_maker_.MakeAckPacket(3, 3, 1, 1, false));
+  socket_data1.AddWrite(ASYNC, client_maker_.MakeAckPacket(4, 2, 1, 1, false));
+  // The PING packet sent for retransmittable on wire.
+  socket_data1.AddWrite(SYNCHRONOUS, client_maker_.MakePingPacket(5, false));
+  socket_data1.AddRead(ASYNC, ERR_IO_PENDING);  // Pause.
+  std::string header = ConstructDataHeader(6);
+  socket_data1.AddRead(
+      ASYNC, ConstructServerDataPacket(
+                 3, GetNthClientInitiatedBidirectionalStreamId(0), false, true,
+                 0, header + "hello!"));
+  socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more data to read.
+  socket_data1.AddWrite(
+      SYNCHRONOUS, client_maker_.MakeRstPacket(
+                       6, false, GetNthClientInitiatedBidirectionalStreamId(0),
+                       quic::QUIC_STREAM_CANCELLED));
+  socket_data1.AddSocketDataToFactory(socket_factory_.get());
+
+  // Create request and QuicHttpStream.
+  QuicStreamRequest request(factory_.get());
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
+                /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+                failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(OK, callback_.WaitForResult());
+  std::unique_ptr<HttpStream> stream = CreateStream(&request);
+  EXPECT_TRUE(stream.get());
+
+  // Cause QUIC stream to be created.
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("https://www.example.org/");
+  request_info.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
+  EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
+                                         net_log_, CompletionOnceCallback()));
+
+  // Ensure that session is alive and active.
+  QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+
+  // Now notify network is disconnected, cause the migration to complete
+  // immediately.
+  scoped_mock_network_change_notifier_->mock_network_change_notifier()
+      ->NotifyNetworkDisconnected(kDefaultNetworkForTests);
+
+  // Complete migration.
+  task_runner->RunUntilIdle();
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+  EXPECT_EQ(1u, session->GetNumActiveStreams());
+
+  // Send GET request on stream.
+  HttpResponseInfo response;
+  HttpRequestHeaders request_headers;
+  EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
+                                    callback_.callback()));
+  socket_data1.Resume();
+  // Spin up the message loop to read incoming data from server till the ACK.
+  base::RunLoop().RunUntilIdle();
+
+  // Ack delay time.
+  int delay = task_runner->NextPendingTaskDelay().InMilliseconds();
+  EXPECT_GT(custom_timeout_value, delay);
+  // Fire the ack alarm, since ack has been sent, no ack will be sent.
+  clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+  task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
+
+  // Fire the ping alarm with retransmittable-on-wire timeout, send PING.
+  delay = custom_timeout_value - delay;
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(delay),
+            task_runner->NextPendingTaskDelay());
+  clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+  task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
+
+  socket_data1.Resume();
+
+  // Verify that response headers on the migrated socket were delivered to the
+  // stream.
+  EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
+  EXPECT_EQ(200, response.headers->response_code());
+
+  // Resume the old socket data, a read error will be delivered to the old
+  // packet reader. Verify that the session is not affected.
+  socket_data.Resume();
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+  EXPECT_EQ(1u, session->GetNumActiveStreams());
+
+  stream.reset();
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
 }
 
+// This test verifies that when no migration is enabled, but a custom value for
+// retransmittable-on-wire timeout is specified, the ping alarm is set up to
+// send retransmittable pings with the custom value.
+TEST_P(QuicStreamFactoryTest, CustomRetransmittableOnWireTimeout) {
+  int custom_timeout_value = 200;
+  test_params_.quic_retransmittable_on_wire_timeout_milliseconds =
+      custom_timeout_value;
+  Initialize();
+  ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+
+  // Using a testing task runner.
+  auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
+  QuicStreamFactoryPeer::SetAlarmFactory(
+      factory_.get(),
+      std::make_unique<QuicChromiumAlarmFactory>(task_runner.get(), &clock_));
+
+  MockQuicData socket_data1;
+  quic::QuicStreamOffset header_stream_offset = 0;
+  socket_data1.AddWrite(
+      SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset));
+  socket_data1.AddWrite(
+      SYNCHRONOUS, ConstructGetRequestPacket(
+                       2, GetNthClientInitiatedBidirectionalStreamId(0), true,
+                       true, &header_stream_offset));
+  socket_data1.AddRead(ASYNC, ERR_IO_PENDING);  // Pause.
+  // Read two packets so that client will send ACK immedaitely.
+  spdy::SpdyHeaderBlock response_headers =
+      server_maker_.GetResponseHeaders("200 OK");
+  response_headers["key1"] = std::string(2000, 'A');
+  spdy::SpdyHeadersIR headers_frame(
+      GetNthClientInitiatedBidirectionalStreamId(0),
+      std::move(response_headers));
+  spdy::SpdyFramer response_framer(spdy::SpdyFramer::ENABLE_COMPRESSION);
+  spdy::SpdySerializedFrame spdy_frame =
+      response_framer.SerializeFrame(headers_frame);
+  size_t chunk_size = 1200;
+  unsigned int packet_number = 1;
+  for (size_t offset = 0; offset < spdy_frame.size(); offset += chunk_size) {
+    size_t len = std::min(chunk_size, spdy_frame.size() - offset);
+    socket_data1.AddRead(
+        ASYNC,
+        server_maker_.MakeDataPacket(
+            packet_number++,
+            quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+            false, false, offset,
+            base::StringPiece(spdy_frame.data() + offset, len)));
+  }
+  // Read an ACK from server which acks all client data.
+  socket_data1.AddRead(SYNCHRONOUS,
+                       server_maker_.MakeAckPacket(3, 2, 1, 1, false));
+  socket_data1.AddWrite(ASYNC, client_maker_.MakeAckPacket(3, 2, 1, 1, false));
+  // The PING packet sent for retransmittable on wire.
+  socket_data1.AddWrite(SYNCHRONOUS, client_maker_.MakePingPacket(4, false));
+  socket_data1.AddRead(ASYNC, ERR_IO_PENDING);  // Pause.
+  std::string header = ConstructDataHeader(6);
+  socket_data1.AddRead(
+      ASYNC, ConstructServerDataPacket(
+                 3, GetNthClientInitiatedBidirectionalStreamId(0), false, true,
+                 0, header + "hello!"));
+  socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more data to read.
+  socket_data1.AddWrite(
+      SYNCHRONOUS, client_maker_.MakeRstPacket(
+                       5, false, GetNthClientInitiatedBidirectionalStreamId(0),
+                       quic::QUIC_STREAM_CANCELLED));
+  socket_data1.AddSocketDataToFactory(socket_factory_.get());
+
+  // Create request and QuicHttpStream.
+  QuicStreamRequest request(factory_.get());
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
+                /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+                failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(OK, callback_.WaitForResult());
+  std::unique_ptr<HttpStream> stream = CreateStream(&request);
+  EXPECT_TRUE(stream.get());
+
+  // Cause QUIC stream to be created.
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("https://www.example.org/");
+  request_info.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
+  EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
+                                         net_log_, CompletionOnceCallback()));
+
+  // Ensure that session is alive and active.
+  QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+
+  // Complete migration.
+  task_runner->RunUntilIdle();
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+  EXPECT_EQ(1u, session->GetNumActiveStreams());
+
+  // Send GET request on stream.
+  HttpResponseInfo response;
+  HttpRequestHeaders request_headers;
+  EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
+                                    callback_.callback()));
+  socket_data1.Resume();
+  // Spin up the message loop to read incoming data from server till the ACK.
+  base::RunLoop().RunUntilIdle();
+
+  // Ack delay time.
+  int delay = task_runner->NextPendingTaskDelay().InMilliseconds();
+  EXPECT_GT(custom_timeout_value, delay);
+  // Fire the ack alarm, since ack has been sent, no ack will be sent.
+  clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+  task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
+
+  // Fire the ping alarm with retransmittable-on-wire timeout, send PING.
+  delay = custom_timeout_value - delay;
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(delay),
+            task_runner->NextPendingTaskDelay());
+  clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+  task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
+
+  socket_data1.Resume();
+
+  // Verify that response headers on the migrated socket were delivered to the
+  // stream.
+  EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
+  EXPECT_EQ(200, response.headers->response_code());
+
+  // Resume the old socket data, a read error will be delivered to the old
+  // packet reader. Verify that the session is not affected.
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+  EXPECT_EQ(1u, session->GetNumActiveStreams());
+
+  stream.reset();
+  EXPECT_TRUE(socket_data1.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
+}
+
+// This test verifies that when no migration is enabled, and no custom value
+// for retransmittable-on-wire timeout is specified, the ping alarm will not
+// send any retransmittable pings.
+TEST_P(QuicStreamFactoryTest, NoRetransmittableOnWireTimeout) {
+  Initialize();
+  ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+
+  // Using a testing task runner.
+  auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
+  QuicStreamFactoryPeer::SetAlarmFactory(
+      factory_.get(),
+      std::make_unique<QuicChromiumAlarmFactory>(task_runner.get(), &clock_));
+
+  MockQuicData socket_data1;
+  quic::QuicStreamOffset header_stream_offset = 0;
+  socket_data1.AddWrite(
+      SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset));
+  socket_data1.AddWrite(
+      SYNCHRONOUS, ConstructGetRequestPacket(
+                       2, GetNthClientInitiatedBidirectionalStreamId(0), true,
+                       true, &header_stream_offset));
+  socket_data1.AddRead(ASYNC, ERR_IO_PENDING);  // Pause.
+  // Read two packets so that client will send ACK immedaitely.
+  spdy::SpdyHeaderBlock response_headers =
+      server_maker_.GetResponseHeaders("200 OK");
+  response_headers["key1"] = std::string(2000, 'A');
+  spdy::SpdyHeadersIR headers_frame(
+      GetNthClientInitiatedBidirectionalStreamId(0),
+      std::move(response_headers));
+  spdy::SpdyFramer response_framer(spdy::SpdyFramer::ENABLE_COMPRESSION);
+  spdy::SpdySerializedFrame spdy_frame =
+      response_framer.SerializeFrame(headers_frame);
+  size_t chunk_size = 1200;
+  unsigned int packet_number = 1;
+  for (size_t offset = 0; offset < spdy_frame.size(); offset += chunk_size) {
+    size_t len = std::min(chunk_size, spdy_frame.size() - offset);
+    socket_data1.AddRead(
+        ASYNC,
+        server_maker_.MakeDataPacket(
+            packet_number++,
+            quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+            false, false, offset,
+            base::StringPiece(spdy_frame.data() + offset, len)));
+  }
+  // Read an ACK from server which acks all client data.
+  socket_data1.AddRead(SYNCHRONOUS,
+                       server_maker_.MakeAckPacket(3, 2, 1, 1, false));
+  socket_data1.AddWrite(ASYNC, client_maker_.MakeAckPacket(3, 2, 1, 1, false));
+  std::string header = ConstructDataHeader(6);
+  socket_data1.AddRead(
+      ASYNC, ConstructServerDataPacket(
+                 3, GetNthClientInitiatedBidirectionalStreamId(0), false, true,
+                 0, header + "hello!"));
+  socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more data to read.
+  socket_data1.AddWrite(
+      SYNCHRONOUS, client_maker_.MakeRstPacket(
+                       4, false, GetNthClientInitiatedBidirectionalStreamId(0),
+                       quic::QUIC_STREAM_CANCELLED));
+  socket_data1.AddSocketDataToFactory(socket_factory_.get());
+
+  // Create request and QuicHttpStream.
+  QuicStreamRequest request(factory_.get());
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
+                /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+                failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(OK, callback_.WaitForResult());
+  std::unique_ptr<HttpStream> stream = CreateStream(&request);
+  EXPECT_TRUE(stream.get());
+
+  // Cause QUIC stream to be created.
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("https://www.example.org/");
+  request_info.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
+  EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
+                                         net_log_, CompletionOnceCallback()));
+
+  // Ensure that session is alive and active.
+  QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+
+  // Complete migration.
+  task_runner->RunUntilIdle();
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+  EXPECT_EQ(1u, session->GetNumActiveStreams());
+
+  // Send GET request on stream.
+  HttpResponseInfo response;
+  HttpRequestHeaders request_headers;
+  EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
+                                    callback_.callback()));
+  socket_data1.Resume();
+  // Spin up the message loop to read incoming data from server till the ACK.
+  base::RunLoop().RunUntilIdle();
+
+  // Ack delay time.
+  int delay = task_runner->NextPendingTaskDelay().InMilliseconds();
+  EXPECT_GT(kDefaultRetransmittableOnWireTimeoutMillisecs, delay);
+  // Fire the ack alarm, since ack has been sent, no ack will be sent.
+  clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+  task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
+
+  // Verify that the ping alarm is not set with any default value.
+  int wrong_delay = kDefaultRetransmittableOnWireTimeoutMillisecs - delay;
+  delay = task_runner->NextPendingTaskDelay().InMilliseconds();
+  EXPECT_NE(wrong_delay, delay);
+  clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+  task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
+
+  // Verify that response headers on the migrated socket were delivered to the
+  // stream.
+  EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
+  EXPECT_EQ(200, response.headers->response_code());
+
+  // Resume the old socket data, a read error will be delivered to the old
+  // packet reader. Verify that the session is not affected.
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+  EXPECT_EQ(1u, session->GetNumActiveStreams());
+
+  stream.reset();
+  EXPECT_TRUE(socket_data1.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
+}
+
+// This test verifies that when only migration on network change is enabled, and
+// a custom value for retransmittable-on-wire is specified, the ping alarm will
+// send retransmittable pings to the peer with custom value.
+TEST_P(QuicStreamFactoryTest,
+       CustomeRetransmittableOnWireTimeoutWithMigrationOnNetworkChangeOnly) {
+  int custom_timeout_value = 200;
+  test_params_.quic_retransmittable_on_wire_timeout_milliseconds =
+      custom_timeout_value;
+  test_params_.quic_migrate_sessions_on_network_change_v2 = true;
+  Initialize();
+  ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+
+  // Using a testing task runner.
+  auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
+  QuicStreamFactoryPeer::SetAlarmFactory(
+      factory_.get(),
+      std::make_unique<QuicChromiumAlarmFactory>(task_runner.get(), &clock_));
+
+  MockQuicData socket_data1;
+  quic::QuicStreamOffset header_stream_offset = 0;
+  socket_data1.AddWrite(
+      SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset));
+  socket_data1.AddWrite(
+      SYNCHRONOUS, ConstructGetRequestPacket(
+                       2, GetNthClientInitiatedBidirectionalStreamId(0), true,
+                       true, &header_stream_offset));
+  socket_data1.AddRead(ASYNC, ERR_IO_PENDING);  // Pause.
+  // Read two packets so that client will send ACK immedaitely.
+  spdy::SpdyHeaderBlock response_headers =
+      server_maker_.GetResponseHeaders("200 OK");
+  response_headers["key1"] = std::string(2000, 'A');
+  spdy::SpdyHeadersIR headers_frame(
+      GetNthClientInitiatedBidirectionalStreamId(0),
+      std::move(response_headers));
+  spdy::SpdyFramer response_framer(spdy::SpdyFramer::ENABLE_COMPRESSION);
+  spdy::SpdySerializedFrame spdy_frame =
+      response_framer.SerializeFrame(headers_frame);
+  size_t chunk_size = 1200;
+  unsigned int packet_number = 1;
+  for (size_t offset = 0; offset < spdy_frame.size(); offset += chunk_size) {
+    size_t len = std::min(chunk_size, spdy_frame.size() - offset);
+    socket_data1.AddRead(
+        ASYNC,
+        server_maker_.MakeDataPacket(
+            packet_number++,
+            quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+            false, false, offset,
+            base::StringPiece(spdy_frame.data() + offset, len)));
+  }
+  // Read an ACK from server which acks all client data.
+  socket_data1.AddRead(SYNCHRONOUS,
+                       server_maker_.MakeAckPacket(3, 2, 1, 1, false));
+  socket_data1.AddWrite(ASYNC, client_maker_.MakeAckPacket(3, 2, 1, 1, false));
+  // The PING packet sent for retransmittable on wire.
+  socket_data1.AddWrite(SYNCHRONOUS, client_maker_.MakePingPacket(4, false));
+  socket_data1.AddRead(ASYNC, ERR_IO_PENDING);  // Pause.
+  std::string header = ConstructDataHeader(6);
+  socket_data1.AddRead(
+      ASYNC, ConstructServerDataPacket(
+                 3, GetNthClientInitiatedBidirectionalStreamId(0), false, true,
+                 0, header + "hello!"));
+  socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more data to read.
+  socket_data1.AddWrite(
+      SYNCHRONOUS, client_maker_.MakeRstPacket(
+                       5, false, GetNthClientInitiatedBidirectionalStreamId(0),
+                       quic::QUIC_STREAM_CANCELLED));
+  socket_data1.AddSocketDataToFactory(socket_factory_.get());
+
+  // Create request and QuicHttpStream.
+  QuicStreamRequest request(factory_.get());
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
+                /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+                failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(OK, callback_.WaitForResult());
+  std::unique_ptr<HttpStream> stream = CreateStream(&request);
+  EXPECT_TRUE(stream.get());
+
+  // Cause QUIC stream to be created.
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("https://www.example.org/");
+  request_info.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
+  EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
+                                         net_log_, CompletionOnceCallback()));
+
+  // Ensure that session is alive and active.
+  QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+
+  // Complete migration.
+  task_runner->RunUntilIdle();
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+  EXPECT_EQ(1u, session->GetNumActiveStreams());
+
+  // Send GET request on stream.
+  HttpResponseInfo response;
+  HttpRequestHeaders request_headers;
+  EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
+                                    callback_.callback()));
+  socket_data1.Resume();
+  // Spin up the message loop to read incoming data from server till the ACK.
+  base::RunLoop().RunUntilIdle();
+
+  // Ack delay time.
+  int delay = task_runner->NextPendingTaskDelay().InMilliseconds();
+  EXPECT_GT(custom_timeout_value, delay);
+  // Fire the ack alarm, since ack has been sent, no ack will be sent.
+  clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+  task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
+
+  // Fire the ping alarm with retransmittable-on-wire timeout, send PING.
+  delay = custom_timeout_value - delay;
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(delay),
+            task_runner->NextPendingTaskDelay());
+  clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+  task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
+
+  socket_data1.Resume();
+
+  // Verify that response headers on the migrated socket were delivered to the
+  // stream.
+  EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
+  EXPECT_EQ(200, response.headers->response_code());
+
+  // Resume the old socket data, a read error will be delivered to the old
+  // packet reader. Verify that the session is not affected.
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+  EXPECT_EQ(1u, session->GetNumActiveStreams());
+
+  stream.reset();
+  EXPECT_TRUE(socket_data1.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
+}
+
+// This test verifies that when only migration on network change is enabled, and
+// no custom value for retransmittable-on-wire is specified, the ping alarm will
+// NOT send retransmittable pings to the peer with custom value.
+TEST_P(QuicStreamFactoryTest,
+       NoRetransmittableOnWireTimeoutWithMigrationOnNetworkChangeOnly) {
+  test_params_.quic_migrate_sessions_on_network_change_v2 = true;
+  Initialize();
+  ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+
+  // Using a testing task runner.
+  auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
+  QuicStreamFactoryPeer::SetAlarmFactory(
+      factory_.get(),
+      std::make_unique<QuicChromiumAlarmFactory>(task_runner.get(), &clock_));
+
+  MockQuicData socket_data1;
+  quic::QuicStreamOffset header_stream_offset = 0;
+  socket_data1.AddWrite(
+      SYNCHRONOUS, ConstructInitialSettingsPacket(1, &header_stream_offset));
+  socket_data1.AddWrite(
+      SYNCHRONOUS, ConstructGetRequestPacket(
+                       2, GetNthClientInitiatedBidirectionalStreamId(0), true,
+                       true, &header_stream_offset));
+  socket_data1.AddRead(ASYNC, ERR_IO_PENDING);  // Pause.
+  // Read two packets so that client will send ACK immedaitely.
+  spdy::SpdyHeaderBlock response_headers =
+      server_maker_.GetResponseHeaders("200 OK");
+  response_headers["key1"] = std::string(2000, 'A');
+  spdy::SpdyHeadersIR headers_frame(
+      GetNthClientInitiatedBidirectionalStreamId(0),
+      std::move(response_headers));
+  spdy::SpdyFramer response_framer(spdy::SpdyFramer::ENABLE_COMPRESSION);
+  spdy::SpdySerializedFrame spdy_frame =
+      response_framer.SerializeFrame(headers_frame);
+  size_t chunk_size = 1200;
+  unsigned int packet_number = 1;
+  for (size_t offset = 0; offset < spdy_frame.size(); offset += chunk_size) {
+    size_t len = std::min(chunk_size, spdy_frame.size() - offset);
+    socket_data1.AddRead(
+        ASYNC,
+        server_maker_.MakeDataPacket(
+            packet_number++,
+            quic::QuicUtils::GetHeadersStreamId(version_.transport_version),
+            false, false, offset,
+            base::StringPiece(spdy_frame.data() + offset, len)));
+  }
+  // Read an ACK from server which acks all client data.
+  socket_data1.AddRead(SYNCHRONOUS,
+                       server_maker_.MakeAckPacket(3, 2, 1, 1, false));
+  socket_data1.AddWrite(ASYNC, client_maker_.MakeAckPacket(3, 2, 1, 1, false));
+  std::string header = ConstructDataHeader(6);
+  socket_data1.AddRead(
+      ASYNC, ConstructServerDataPacket(
+                 3, GetNthClientInitiatedBidirectionalStreamId(0), false, true,
+                 0, header + "hello!"));
+  socket_data1.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more data to read.
+  socket_data1.AddWrite(
+      SYNCHRONOUS, client_maker_.MakeRstPacket(
+                       4, false, GetNthClientInitiatedBidirectionalStreamId(0),
+                       quic::QUIC_STREAM_CANCELLED));
+  socket_data1.AddSocketDataToFactory(socket_factory_.get());
+
+  // Create request and QuicHttpStream.
+  QuicStreamRequest request(factory_.get());
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
+                /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+                failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(OK, callback_.WaitForResult());
+  std::unique_ptr<HttpStream> stream = CreateStream(&request);
+  EXPECT_TRUE(stream.get());
+
+  // Cause QUIC stream to be created.
+  HttpRequestInfo request_info;
+  request_info.method = "GET";
+  request_info.url = GURL("https://www.example.org/");
+  request_info.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
+  EXPECT_EQ(OK, stream->InitializeStream(&request_info, true, DEFAULT_PRIORITY,
+                                         net_log_, CompletionOnceCallback()));
+
+  // Ensure that session is alive and active.
+  QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+
+  // Complete migration.
+  task_runner->RunUntilIdle();
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+  EXPECT_EQ(1u, session->GetNumActiveStreams());
+
+  // Send GET request on stream.
+  HttpResponseInfo response;
+  HttpRequestHeaders request_headers;
+  EXPECT_EQ(OK, stream->SendRequest(request_headers, &response,
+                                    callback_.callback()));
+  socket_data1.Resume();
+  // Spin up the message loop to read incoming data from server till the ACK.
+  base::RunLoop().RunUntilIdle();
+
+  // Ack delay time.
+  int delay = task_runner->NextPendingTaskDelay().InMilliseconds();
+  EXPECT_GT(kDefaultRetransmittableOnWireTimeoutMillisecs, delay);
+  // Fire the ack alarm, since ack has been sent, no ack will be sent.
+  clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+  task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
+
+  // Verify ping alarm is not set with default value.
+  int wrong_delay = kDefaultRetransmittableOnWireTimeoutMillisecs - delay;
+  delay = task_runner->NextPendingTaskDelay().InMilliseconds();
+  EXPECT_NE(wrong_delay, delay);
+  clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(delay));
+  task_runner->FastForwardBy(task_runner->NextPendingTaskDelay());
+
+  // Verify that response headers on the migrated socket were delivered to the
+  // stream.
+  EXPECT_EQ(OK, stream->ReadResponseHeaders(callback_.callback()));
+  EXPECT_EQ(200, response.headers->response_code());
+
+  // Resume the old socket data, a read error will be delivered to the old
+  // packet reader. Verify that the session is not affected.
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
+  EXPECT_TRUE(HasActiveSession(host_port_pair_));
+  EXPECT_EQ(1u, session->GetNumActiveStreams());
+
+  stream.reset();
+  EXPECT_TRUE(socket_data1.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
+}
+
 // This test verifies that after migration on write error is posted, packet
 // read error on the old reader will be ignored and will not close the
 // connection.
@@ -7217,8 +8129,8 @@ TEST_P(QuicStreamFactoryTest,
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
@@ -7362,8 +8274,8 @@ void QuicStreamFactoryTestBase::
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
@@ -7455,8 +8367,8 @@ void QuicStreamFactoryTestBase::
       ->NotifyNetworkMadeDefault(kNewNetworkForTests);
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
-                                 DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                  /*cert_verify_flags=*/0, url_, net_log_,
                                  &net_error_details_,
                                  failed_on_default_network_callback_,
@@ -7541,8 +8453,8 @@ TEST_P(QuicStreamFactoryTest, DefaultIdleMigrationPeriod) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -7655,8 +8567,8 @@ TEST_P(QuicStreamFactoryTest, CustomIdleMigrationPeriod) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
@@ -7733,8 +8645,8 @@ TEST_P(QuicStreamFactoryTest, ServerMigration) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
@@ -7885,8 +8797,8 @@ TEST_P(QuicStreamFactoryTest, ServerMigrationIPv4ToIPv6Fails) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
@@ -7943,8 +8855,8 @@ TEST_P(QuicStreamFactoryTest, OnCertDBChanged) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -7966,8 +8878,8 @@ TEST_P(QuicStreamFactoryTest, OnCertDBChanged) {
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -8084,8 +8996,8 @@ TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) {
                                             "192.168.0.1", "");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
-                                DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request.Request(host_port_pair_, version_.transport_version,
+                                privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                 /*cert_verify_flags=*/0, url_, net_log_,
                                 &net_error_details_,
                                 failed_on_default_network_callback_,
@@ -8135,8 +9047,8 @@ TEST_P(QuicStreamFactoryTest, ReducePingTimeoutOnConnectionTimeOutOpenStreams) {
   EXPECT_EQ(quic::QuicTime::Delta::FromSeconds(quic::kPingTimeoutSecs),
             QuicStreamFactoryPeer::GetPingTimeout(factory_.get()));
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
-                                DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request.Request(host_port_pair_, version_.transport_version,
+                                privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                 /*cert_verify_flags=*/0, url_, net_log_,
                                 &net_error_details_,
                                 failed_on_default_network_callback_,
@@ -8173,11 +9085,12 @@ TEST_P(QuicStreamFactoryTest, ReducePingTimeoutOnConnectionTimeOutOpenStreams) {
   DVLOG(1) << "Create 2nd session and timeout with open stream";
   TestCompletionCallback callback2;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK,
-            request2.Request(
-                server2, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-                /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
-                failed_on_default_network_callback_, callback2.callback()));
+  EXPECT_EQ(OK, request2.Request(server2, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
+                                 /*cert_verify_flags=*/0, url2_, net_log_,
+                                 &net_error_details_,
+                                 failed_on_default_network_callback_,
+                                 callback2.callback()));
   QuicChromiumClientSession* session2 = GetActiveSession(server2);
   EXPECT_EQ(quic::QuicTime::Delta::FromSeconds(10),
             session2->connection()->ping_timeout());
@@ -8246,8 +9159,8 @@ TEST_P(QuicStreamFactoryTest, StartCertVerifyJob) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -8293,8 +9206,8 @@ TEST_P(QuicStreamFactoryTest, YieldAfterPackets) {
                                        "StartReading");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
-                                DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request.Request(host_port_pair_, version_.transport_version,
+                                privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                 /*cert_verify_flags=*/0, url_, net_log_,
                                 &net_error_details_,
                                 failed_on_default_network_callback_,
@@ -8342,8 +9255,8 @@ TEST_P(QuicStreamFactoryTest, YieldAfterDuration) {
                                        "StartReading");
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(OK, request.Request(host_port_pair_, version_, privacy_mode_,
-                                DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request.Request(host_port_pair_, version_.transport_version,
+                                privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                 /*cert_verify_flags=*/0, url_, net_log_,
                                 &net_error_details_,
                                 failed_on_default_network_callback_,
@@ -8378,8 +9291,8 @@ TEST_P(QuicStreamFactoryTest, ServerPushSessionAffinity) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -8399,8 +9312,8 @@ TEST_P(QuicStreamFactoryTest, ServerPushSessionAffinity) {
         ->promised_by_url())[kDefaultUrl] = &promised;
 
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_, privacy_mode_,
-                                 DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request2.Request(host_port_pair_, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                  /*cert_verify_flags=*/0, url_, net_log_,
                                  &net_error_details_,
                                  failed_on_default_network_callback_,
@@ -8432,8 +9345,8 @@ TEST_P(QuicStreamFactoryTest, ServerPushPrivacyModeMismatch) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -8460,8 +9373,8 @@ TEST_P(QuicStreamFactoryTest, ServerPushPrivacyModeMismatch) {
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(
-                host_port_pair_, version_, PRIVACY_MODE_ENABLED,
-                DEFAULT_PRIORITY, SocketTag(),
+                host_port_pair_, version_.transport_version,
+                PRIVACY_MODE_ENABLED, DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -8495,12 +9408,12 @@ TEST_P(QuicStreamFactoryTest, PoolByOrigin) {
   socket_data.AddSocketDataToFactory(socket_factory_.get());
 
   QuicStreamRequest request1(factory_.get());
-  EXPECT_EQ(
-      ERR_IO_PENDING,
-      request1.Request(
-          destination1, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-          /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
-          failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request1.Request(
+                destination1, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
+                /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+                failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
   EXPECT_TRUE(stream1.get());
@@ -8509,8 +9422,8 @@ TEST_P(QuicStreamFactoryTest, PoolByOrigin) {
   // Second request returns synchronously because it pools to existing session.
   TestCompletionCallback callback2;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(destination2, version_, privacy_mode_,
-                                 DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request2.Request(destination2, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                  /*cert_verify_flags=*/0, url_, net_log_,
                                  &net_error_details_,
                                  failed_on_default_network_callback_,
@@ -8616,12 +9529,12 @@ TEST_P(QuicStreamFactoryWithDestinationTest, InvalidCertificate) {
   AddHangingSocketData();
 
   QuicStreamRequest request(factory_.get());
-  EXPECT_EQ(
-      ERR_IO_PENDING,
-      request.Request(
-          destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-          /*cert_verify_flags=*/0, url, net_log_, &net_error_details_,
-          failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(
+                destination, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
+                /*cert_verify_flags=*/0, url, net_log_, &net_error_details_,
+                failed_on_default_network_callback_, callback_.callback()));
 
   EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_QUIC_HANDSHAKE_FAILED));
 
@@ -8661,12 +9574,12 @@ TEST_P(QuicStreamFactoryWithDestinationTest, SharedCertificate) {
   sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data));
 
   QuicStreamRequest request1(factory_.get());
-  EXPECT_EQ(
-      ERR_IO_PENDING,
-      request1.Request(
-          destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-          /*cert_verify_flags=*/0, url1, net_log_, &net_error_details_,
-          failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request1.Request(
+                destination, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
+                /*cert_verify_flags=*/0, url1, net_log_, &net_error_details_,
+                failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
 
   std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
@@ -8676,8 +9589,8 @@ TEST_P(QuicStreamFactoryWithDestinationTest, SharedCertificate) {
   // Second request returns synchronously because it pools to existing session.
   TestCompletionCallback callback2;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(OK, request2.Request(destination, version_, privacy_mode_,
-                                 DEFAULT_PRIORITY, SocketTag(),
+  EXPECT_EQ(OK, request2.Request(destination, version_.transport_version,
+                                 privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
                                  /*cert_verify_flags=*/0, url2, net_log_,
                                  &net_error_details_,
                                  failed_on_default_network_callback_,
@@ -8742,8 +9655,8 @@ TEST_P(QuicStreamFactoryWithDestinationTest, DifferentPrivacyMode) {
   QuicStreamRequest request1(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request1.Request(
-                destination, version_, PRIVACY_MODE_DISABLED, DEFAULT_PRIORITY,
-                SocketTag(),
+                destination, version_.transport_version, PRIVACY_MODE_DISABLED,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url1, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
@@ -8755,8 +9668,8 @@ TEST_P(QuicStreamFactoryWithDestinationTest, DifferentPrivacyMode) {
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(
-                destination, version_, PRIVACY_MODE_ENABLED, DEFAULT_PRIORITY,
-                SocketTag(),
+                destination, version_.transport_version, PRIVACY_MODE_ENABLED,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url2, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback2.callback()));
   EXPECT_EQ(OK, callback2.WaitForResult());
@@ -8827,12 +9740,12 @@ TEST_P(QuicStreamFactoryWithDestinationTest, DisjointCertificate) {
   sequenced_socket_data_vector_.push_back(std::move(sequenced_socket_data1));
 
   QuicStreamRequest request1(factory_.get());
-  EXPECT_EQ(
-      ERR_IO_PENDING,
-      request1.Request(
-          destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-          /*cert_verify_flags=*/0, url1, net_log_, &net_error_details_,
-          failed_on_default_network_callback_, callback_.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request1.Request(
+                destination, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
+                /*cert_verify_flags=*/0, url1, net_log_, &net_error_details_,
+                failed_on_default_network_callback_, callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream1 = CreateStream(&request1);
   EXPECT_TRUE(stream1.get());
@@ -8840,12 +9753,12 @@ TEST_P(QuicStreamFactoryWithDestinationTest, DisjointCertificate) {
 
   TestCompletionCallback callback2;
   QuicStreamRequest request2(factory_.get());
-  EXPECT_EQ(
-      ERR_IO_PENDING,
-      request2.Request(
-          destination, version_, privacy_mode_, DEFAULT_PRIORITY, SocketTag(),
-          /*cert_verify_flags=*/0, url2, net_log_, &net_error_details_,
-          failed_on_default_network_callback_, callback2.callback()));
+  EXPECT_EQ(ERR_IO_PENDING,
+            request2.Request(
+                destination, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
+                /*cert_verify_flags=*/0, url2, net_log_, &net_error_details_,
+                failed_on_default_network_callback_, callback2.callback()));
   EXPECT_THAT(callback2.WaitForResult(), IsOk());
   std::unique_ptr<HttpStream> stream2 = CreateStream(&request2);
   EXPECT_TRUE(stream2.get());
@@ -8953,8 +9866,8 @@ TEST_P(QuicStreamFactoryTest, HostResolverUsesRequestPriority) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, MAXIMUM_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                MAXIMUM_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -8981,8 +9894,8 @@ TEST_P(QuicStreamFactoryTest, HostResolverRequestReprioritizedOnSetPriority) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, MAXIMUM_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                MAXIMUM_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -8992,8 +9905,8 @@ TEST_P(QuicStreamFactoryTest, HostResolverRequestReprioritizedOnSetPriority) {
   QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url2_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_EQ(DEFAULT_PRIORITY, host_resolver_->last_request_priority());
@@ -9037,8 +9950,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterHostResolutionCallbackAsyncSync) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -9091,8 +10004,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterHostResolutionCallbackAsyncAsync) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -9142,8 +10055,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterHostResolutionCallbackSyncSync) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_QUIC_PROTOCOL_ERROR,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -9180,8 +10093,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterHostResolutionCallbackSyncAsync) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -9214,8 +10127,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterHostResolutionCallbackFailSync) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -9240,8 +10153,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterHostResolutionCallbackFailAsync) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -9284,7 +10197,7 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceAndHostResolutionSync) {
   HostCache* cache = host_resolver_->GetHostCache();
   cache->Set(key, entry, base::TimeTicks::Now(), zero);
   // Expire the cache
-  cache->OnNetworkChange();
+  cache->Invalidate();
 
   MockQuicData quic_data;
   quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@@ -9293,17 +10206,15 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceAndHostResolutionSync) {
 
   QuicStreamRequest request(factory_.get());
   EXPECT_THAT(request.Request(
-                  host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                  SocketTag(),
+                  host_port_pair_, version_.transport_version, privacy_mode_,
+                  DEFAULT_PRIORITY, SocketTag(),
                   /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                   failed_on_default_network_callback_, callback_.callback()),
               IsOk());
   std::unique_ptr<HttpStream> stream = CreateStream(&request);
   EXPECT_TRUE(stream.get());
   QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
-  EXPECT_EQ(
-      session->peer_address().impl().socket_address().ToStringWithoutPort(),
-      kNonCachedIPAddress);
+  EXPECT_EQ(session->peer_address().host().ToString(), kNonCachedIPAddress);
 
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
@@ -9331,8 +10242,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceAndHostResolutionAsync) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   TestCompletionCallback host_resolution_callback;
@@ -9350,9 +10261,7 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceAndHostResolutionAsync) {
   EXPECT_TRUE(stream.get());
   QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
 
-  EXPECT_EQ(
-      session->peer_address().impl().socket_address().ToStringWithoutPort(),
-      kNonCachedIPAddress);
+  EXPECT_EQ(session->peer_address().host().ToString(), kNonCachedIPAddress);
 
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
@@ -9381,7 +10290,7 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceHostResolveAsyncStaleMatch) {
   HostCache* cache = host_resolver_->GetHostCache();
   cache->Set(key, entry, base::TimeTicks::Now(), zero);
   // Expire the cache
-  cache->OnNetworkChange();
+  cache->Invalidate();
 
   MockQuicData quic_data;
   quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@@ -9391,8 +10300,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceHostResolveAsyncStaleMatch) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -9408,9 +10317,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceHostResolveAsyncStaleMatch) {
 
   QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
 
-  EXPECT_EQ(
-      session->peer_address().impl().socket_address().ToStringWithoutPort(),
-      kCachedIPAddress.ToString());
+  EXPECT_EQ(session->peer_address().host().ToString(),
+            kCachedIPAddress.ToString());
 
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
@@ -9443,7 +10351,7 @@ TEST_P(QuicStreamFactoryTest,
   HostCache* cache = host_resolver_->GetHostCache();
   cache->Set(key, entry, base::TimeTicks::Now(), zero);
   // Expire the cache
-  cache->OnNetworkChange();
+  cache->Invalidate();
 
   MockQuicData quic_data;
   quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@@ -9453,8 +10361,8 @@ TEST_P(QuicStreamFactoryTest,
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -9476,9 +10384,8 @@ TEST_P(QuicStreamFactoryTest,
 
   QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
 
-  EXPECT_EQ(
-      session->peer_address().impl().socket_address().ToStringWithoutPort(),
-      kCachedIPAddress.ToString());
+  EXPECT_EQ(session->peer_address().host().ToString(),
+            kCachedIPAddress.ToString());
 
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
@@ -9511,7 +10418,7 @@ TEST_P(QuicStreamFactoryTest,
   HostCache* cache = host_resolver_->GetHostCache();
   cache->Set(key, entry, base::TimeTicks::Now(), zero);
   // Expire the cache
-  cache->OnNetworkChange();
+  cache->Invalidate();
 
   MockQuicData quic_data;
   quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@@ -9521,8 +10428,8 @@ TEST_P(QuicStreamFactoryTest,
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -9540,9 +10447,8 @@ TEST_P(QuicStreamFactoryTest,
   EXPECT_TRUE(stream.get());
 
   QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
-  EXPECT_EQ(
-      session->peer_address().impl().socket_address().ToStringWithoutPort(),
-      kCachedIPAddress.ToString());
+  EXPECT_EQ(session->peer_address().host().ToString(),
+            kCachedIPAddress.ToString());
 
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
@@ -9572,7 +10478,7 @@ TEST_P(QuicStreamFactoryTest,
   HostCache* cache = host_resolver_->GetHostCache();
   cache->Set(key, entry, base::TimeTicks::Now(), zero);
   // Expire the cache
-  cache->OnNetworkChange();
+  cache->Invalidate();
 
   // Socket for the stale connection which will invoke connection closure.
   MockQuicData quic_data;
@@ -9593,8 +10499,8 @@ TEST_P(QuicStreamFactoryTest,
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -9611,9 +10517,7 @@ TEST_P(QuicStreamFactoryTest,
 
   QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
 
-  EXPECT_EQ(
-      session->peer_address().impl().socket_address().ToStringWithoutPort(),
-      kNonCachedIPAddress);
+  EXPECT_EQ(session->peer_address().host().ToString(), kNonCachedIPAddress);
 
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
@@ -9647,7 +10551,7 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleAsyncResolveAsyncNoMatch) {
   HostCache* cache = host_resolver_->GetHostCache();
   cache->Set(key, entry, base::TimeTicks::Now(), zero);
   // Expire the cache
-  cache->OnNetworkChange();
+  cache->Invalidate();
 
   MockQuicData quic_data;
   quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@@ -9665,8 +10569,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleAsyncResolveAsyncNoMatch) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -9685,9 +10589,7 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleAsyncResolveAsyncNoMatch) {
   EXPECT_TRUE(stream.get());
 
   QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
-  EXPECT_EQ(
-      session->peer_address().impl().socket_address().ToStringWithoutPort(),
-      kNonCachedIPAddress);
+  EXPECT_EQ(session->peer_address().host().ToString(), kNonCachedIPAddress);
 
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
@@ -9721,7 +10623,7 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceResolveAsyncStaleAsyncNoMatch) {
   HostCache* cache = host_resolver_->GetHostCache();
   cache->Set(key, entry, base::TimeTicks::Now(), zero);
   // Expire the cache
-  cache->OnNetworkChange();
+  cache->Invalidate();
 
   MockQuicData quic_data;
   quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@@ -9741,8 +10643,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceResolveAsyncStaleAsyncNoMatch) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   // Finish dns resolution, but need to wait for stale connection.
@@ -9756,9 +10658,7 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceResolveAsyncStaleAsyncNoMatch) {
   EXPECT_TRUE(stream.get());
 
   QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
-  EXPECT_EQ(
-      session->peer_address().impl().socket_address().ToStringWithoutPort(),
-      kNonCachedIPAddress);
+  EXPECT_EQ(session->peer_address().host().ToString(), kNonCachedIPAddress);
 
   EXPECT_TRUE(quic_data.AllReadDataConsumed());
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
@@ -9785,8 +10685,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceHostResolveError) {
 
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 }
@@ -9810,8 +10710,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceHostResolveAsyncError) {
 
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -9842,7 +10742,7 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleSyncHostResolveError) {
   HostCache* cache = host_resolver_->GetHostCache();
   cache->Set(key, entry, base::TimeTicks::Now(), zero);
   // Expire the cache
-  cache->OnNetworkChange();
+  cache->Invalidate();
 
   // Socket for the stale connection which is supposed to disconnect.
   MockQuicData quic_data;
@@ -9857,8 +10757,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleSyncHostResolveError) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -9875,7 +10775,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleSyncHostResolveError) {
 }
 
 // With dns race experiment on, dns resolve async, stale used and connection
-// return error, then dns matches
+// return error, then dns matches.
+// This serves as a regression test for crbug.com/956374.
 TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleErrorDNSMatches) {
   test_params_.quic_race_stale_dns_on_connection = true;
   host_resolver_ = std::make_unique<MockCachingHostResolver>();
@@ -9897,7 +10798,7 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleErrorDNSMatches) {
   HostCache* cache = host_resolver_->GetHostCache();
   cache->Set(key, entry, base::TimeTicks::Now(), zero);
   // Expire the cache
-  cache->OnNetworkChange();
+  cache->Invalidate();
 
   // Simulate synchronous connect failure.
   MockQuicData quic_data;
@@ -9911,8 +10812,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleErrorDNSMatches) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
   EXPECT_FALSE(HasLiveSession(host_port_pair_));
@@ -9945,7 +10846,7 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleErrorDNSNoMatch) {
   HostCache* cache = host_resolver_->GetHostCache();
   cache->Set(key, entry, base::TimeTicks::Now(), zero);
   // Expire the cache
-  cache->OnNetworkChange();
+  cache->Invalidate();
 
   // Add failure for the stale connection.
   MockQuicData quic_data;
@@ -9960,8 +10861,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleErrorDNSNoMatch) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -9978,9 +10879,7 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleErrorDNSNoMatch) {
 
   QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
 
-  EXPECT_EQ(
-      session->peer_address().impl().socket_address().ToStringWithoutPort(),
-      kNonCachedIPAddress);
+  EXPECT_EQ(session->peer_address().host().ToString(), kNonCachedIPAddress);
 
   EXPECT_TRUE(quic_data2.AllReadDataConsumed());
   EXPECT_TRUE(quic_data2.AllWriteDataConsumed());
@@ -10009,7 +10908,7 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleErrorDNSNoMatchError) {
   HostCache* cache = host_resolver_->GetHostCache();
   cache->Set(key, entry, base::TimeTicks::Now(), zero);
   // Expire the cache
-  cache->OnNetworkChange();
+  cache->Invalidate();
 
   // Add failure for stale connection.
   MockQuicData quic_data;
@@ -10024,8 +10923,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceStaleErrorDNSNoMatchError) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -10063,7 +10962,7 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceResolveAsyncErrorStaleAsync) {
   HostCache* cache = host_resolver_->GetHostCache();
   cache->Set(key, entry, base::TimeTicks::Now(), zero);
   // Expire the cache
-  cache->OnNetworkChange();
+  cache->Invalidate();
 
   // Socket data for stale connection which is supposed to disconnect.
   MockQuicData quic_data;
@@ -10078,8 +10977,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceResolveAsyncErrorStaleAsync) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -10117,7 +11016,7 @@ TEST_P(QuicStreamFactoryTest,
   HostCache* cache = host_resolver_->GetHostCache();
   cache->Set(key, entry, base::TimeTicks::Now(), zero);
   // Expire the cache
-  cache->OnNetworkChange();
+  cache->Invalidate();
 
   MockQuicData quic_data;
   quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@@ -10131,8 +11030,8 @@ TEST_P(QuicStreamFactoryTest,
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -10166,8 +11065,8 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceHostResolveAsync) {
   QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(
-                host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY,
-                SocketTag(),
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
                 /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
                 failed_on_default_network_callback_, callback_.callback()));
 
@@ -10189,6 +11088,70 @@ TEST_P(QuicStreamFactoryTest, ResultAfterDNSRaceHostResolveAsync) {
   EXPECT_TRUE(quic_data.AllWriteDataConsumed());
 }
 
+TEST_P(QuicStreamFactoryTest, ConfigInitialRttForHandshake) {
+  int kInitialRtt = 400;
+  test_params_.quic_initial_rtt_for_handshake_milliseconds = kInitialRtt;
+  crypto_client_stream_factory_.set_handshake_mode(
+      MockCryptoClientStream::COLD_START_WITH_CHLO_SENT);
+  Initialize();
+  factory_->set_require_confirmation(true);
+  ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
+  crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
+
+  // Using a testing task runner so that we can control time.
+  auto task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
+
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), task_runner.get());
+  QuicStreamFactoryPeer::SetAlarmFactory(
+      factory_.get(),
+      std::make_unique<QuicChromiumAlarmFactory>(task_runner.get(), &clock_));
+
+  MockQuicData socket_data;
+  socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
+  socket_data.AddWrite(ASYNC, client_maker_.MakeDummyCHLOPacket(1));
+  socket_data.AddWrite(ASYNC, client_maker_.MakeDummyCHLOPacket(2));
+  client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
+  socket_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(3, 0));
+  socket_data.AddSocketDataToFactory(socket_factory_.get());
+
+  QuicStreamRequest request(factory_.get());
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(
+                host_port_pair_, version_.transport_version, privacy_mode_,
+                DEFAULT_PRIORITY, SocketTag(),
+                /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
+                failed_on_default_network_callback_, callback_.callback()));
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_FALSE(HasActiveSession(host_port_pair_));
+  EXPECT_TRUE(HasActiveJob(host_port_pair_, privacy_mode_));
+
+  // The pending task is scheduled for handshake timeout retransmission,
+  // which is 2 * 400ms for v99 and 1.5 * 400ms for others.
+  int handshake_timeout = version_.transport_version == quic::QUIC_VERSION_99
+                              ? 2 * kInitialRtt
+                              : 1.5 * kInitialRtt;
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(handshake_timeout),
+            task_runner->NextPendingTaskDelay());
+
+  // The alarm factory dependes on |clock_|, so clock is advanced to trigger
+  // retransmission alarm.
+  clock_.AdvanceTime(
+      quic::QuicTime::Delta::FromMilliseconds(handshake_timeout));
+  task_runner->FastForwardBy(
+      base::TimeDelta::FromMilliseconds(handshake_timeout));
+
+  crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
+      quic::QuicSession::HANDSHAKE_CONFIRMED);
+
+  EXPECT_THAT(callback_.WaitForResult(), IsOk());
+
+  QuicChromiumClientSession* session = GetActiveSession(host_port_pair_);
+  EXPECT_EQ(400000u, session->config()->GetInitialRoundTripTimeUsToSend());
+  EXPECT_TRUE(socket_data.AllReadDataConsumed());
+  EXPECT_TRUE(socket_data.AllWriteDataConsumed());
+}
+
 // Test that QuicStreamRequests with similar and different tags results in
 // reused and unique QUIC streams using appropriately tagged sockets.
 TEST_P(QuicStreamFactoryTest, Tag) {
@@ -10220,7 +11183,8 @@ TEST_P(QuicStreamFactoryTest, Tag) {
   // Request a stream with |tag1|.
   QuicStreamRequest request1(factory_.get());
   int rv = request1.Request(
-      host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY, tag1,
+      host_port_pair_, version_.transport_version, privacy_mode_,
+      DEFAULT_PRIORITY, tag1,
       /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
       failed_on_default_network_callback_, callback_.callback());
   EXPECT_THAT(callback_.GetResult(rv), IsOk());
@@ -10235,7 +11199,8 @@ TEST_P(QuicStreamFactoryTest, Tag) {
   // Request a stream with |tag1| and verify underlying session is reused.
   QuicStreamRequest request2(factory_.get());
   rv = request2.Request(
-      host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY, tag1,
+      host_port_pair_, version_.transport_version, privacy_mode_,
+      DEFAULT_PRIORITY, tag1,
       /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
       failed_on_default_network_callback_, callback_.callback());
   EXPECT_THAT(callback_.GetResult(rv), IsOk());
@@ -10248,7 +11213,8 @@ TEST_P(QuicStreamFactoryTest, Tag) {
   // Request a stream with |tag2| and verify a new session is created.
   QuicStreamRequest request3(factory_.get());
   rv = request3.Request(
-      host_port_pair_, version_, privacy_mode_, DEFAULT_PRIORITY, tag2,
+      host_port_pair_, version_.transport_version, privacy_mode_,
+      DEFAULT_PRIORITY, tag2,
       /*cert_verify_flags=*/0, url_, net_log_, &net_error_details_,
       failed_on_default_network_callback_, callback_.callback());
   EXPECT_THAT(callback_.GetResult(rv), IsOk());
diff --git a/chromium/net/quic/quic_test_packet_maker.cc b/chromium/net/quic/quic_test_packet_maker.cc
index 4fae4ca4ae6..26dae2b6526 100644
--- a/chromium/net/quic/quic_test_packet_maker.cc
+++ b/chromium/net/quic/quic_test_packet_maker.cc
@@ -28,7 +28,7 @@ quic::QuicAckFrame MakeAckFrame(uint64_t largest_observed) {
 }  // namespace
 
 QuicTestPacketMaker::QuicTestPacketMaker(
-    quic::QuicTransportVersion version,
+    quic::ParsedQuicVersion version,
     quic::QuicConnectionId connection_id,
     quic::MockClock* clock,
     const std::string& host,
@@ -45,7 +45,7 @@ QuicTestPacketMaker::QuicTestPacketMaker(
       long_header_type_(quic::INVALID_PACKET_TYPE),
       client_headers_include_h2_stream_dependency_(
           client_headers_include_h2_stream_dependency &&
-          version >= quic::QUIC_VERSION_43) {
+          version.transport_version >= quic::QUIC_VERSION_43) {
   DCHECK(!(perspective_ == quic::Perspective::IS_SERVER &&
            client_headers_include_h2_stream_dependency_));
 }
@@ -70,22 +70,22 @@ QuicTestPacketMaker::MakeConnectivityProbingPacket(uint64_t num,
   header.packet_number_length = GetPacketNumberLength();
   header.packet_number = quic::QuicPacketNumber(num);
 
-  if (quic::QuicVersionHasLongHeaderLengths(version_) && header.version_flag) {
+  if (quic::QuicVersionHasLongHeaderLengths(version_.transport_version) &&
+      header.version_flag) {
     if (long_header_type_ == quic::INITIAL) {
       header.retry_token_length_length = quic::VARIABLE_LENGTH_INTEGER_LENGTH_1;
     }
     header.length_length = quic::VARIABLE_LENGTH_INTEGER_LENGTH_2;
   }
 
-  quic::QuicFramer framer(quic::test::SupportedVersions(quic::ParsedQuicVersion(
-                              quic::PROTOCOL_QUIC_CRYPTO, version_)),
+  quic::QuicFramer framer(quic::test::SupportedVersions(version_),
                           clock_->Now(), perspective_,
                           quic::kQuicDefaultConnectionIdLength);
   size_t max_plaintext_size =
       framer.GetMaxPlaintextSize(quic::kDefaultMaxPacketSize);
   char buffer[quic::kDefaultMaxPacketSize];
   size_t length;
-  if (version_ != quic::QUIC_VERSION_99) {
+  if (version_.transport_version != quic::QUIC_VERSION_99) {
     length = framer.BuildConnectivityProbingPacket(
         header, buffer, max_plaintext_size, encryption_level_);
   } else if (perspective_ == quic::Perspective::IS_CLIENT) {
@@ -125,7 +125,8 @@ std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakePingPacket(
   header.packet_number_length = GetPacketNumberLength();
   header.packet_number = quic::QuicPacketNumber(num);
 
-  if (quic::QuicVersionHasLongHeaderLengths(version_) && header.version_flag) {
+  if (quic::QuicVersionHasLongHeaderLengths(version_.transport_version) &&
+      header.version_flag) {
     if (long_header_type_ == quic::INITIAL) {
       header.retry_token_length_length = quic::VARIABLE_LENGTH_INTEGER_LENGTH_1;
     }
@@ -149,10 +150,10 @@ QuicTestPacketMaker::MakeDummyCHLOPacket(uint64_t packet_num) {
   quic::QuicCryptoFrame crypto_frame;
   quic::test::SimpleDataProducer producer;
   quic::QuicStreamFrameDataProducer* producer_p = nullptr;
-  if (!QuicVersionUsesCryptoFrames(version_)) {
-    quic::QuicStreamFrame frame(quic::QuicUtils::GetCryptoStreamId(version_),
-                                /*fin=*/false, /*offset=*/0,
-                                data.AsStringPiece());
+  if (!QuicVersionUsesCryptoFrames(version_.transport_version)) {
+    quic::QuicStreamFrame frame(
+        quic::QuicUtils::GetCryptoStreamId(version_.transport_version),
+        /*fin=*/false, /*offset=*/0, data.AsStringPiece());
     frames.push_back(quic::QuicFrame(frame));
   } else {
     crypto_frame =
@@ -188,7 +189,8 @@ QuicTestPacketMaker::MakeAckAndPingPacket(uint64_t num,
   header.packet_number_length = GetPacketNumberLength();
   header.packet_number = quic::QuicPacketNumber(num);
 
-  if (quic::QuicVersionHasLongHeaderLengths(version_) && header.version_flag) {
+  if (quic::QuicVersionHasLongHeaderLengths(version_.transport_version) &&
+      header.version_flag) {
     if (long_header_type_ == quic::INITIAL) {
       header.retry_token_length_length = quic::VARIABLE_LENGTH_INTEGER_LENGTH_1;
     }
@@ -242,7 +244,8 @@ std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakeRstPacket(
   header.packet_number_length = GetPacketNumberLength();
   header.packet_number = quic::QuicPacketNumber(num);
 
-  if (quic::QuicVersionHasLongHeaderLengths(version_) && header.version_flag) {
+  if (quic::QuicVersionHasLongHeaderLengths(version_.transport_version) &&
+      header.version_flag) {
     if (long_header_type_ == quic::INITIAL) {
       header.retry_token_length_length = quic::VARIABLE_LENGTH_INTEGER_LENGTH_1;
     }
@@ -258,7 +261,8 @@ std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakeRstPacket(
   // The STOP_SENDING frame must be outside of the if (version==99) so that it
   // stays in scope until the packet is built.
   quic::QuicStopSendingFrame stop(1, stream_id, error_code);
-  if (include_stop_sending_if_v99 && version_ == quic::QUIC_VERSION_99) {
+  if (include_stop_sending_if_v99 &&
+      version_.transport_version == quic::QUIC_VERSION_99) {
     frames.push_back(quic::QuicFrame(&stop));
     DVLOG(1) << "Adding frame: " << frames.back();
   }
@@ -266,9 +270,11 @@ std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakeRstPacket(
 }
 
 std::unique_ptr<quic::QuicReceivedPacket>
-QuicTestPacketMaker::MakeStreamIdBlockedPacket(uint64_t num,
-                                               bool include_version,
-                                               quic::QuicStreamId stream_id) {
+QuicTestPacketMaker::MakeStreamsBlockedPacket(
+    uint64_t num,
+    bool include_version,
+    quic::QuicStreamCount stream_count,
+    bool unidirectional) {
   quic::QuicPacketHeader header;
   header.destination_connection_id = connection_id_;
   header.destination_connection_id_included = HasDestinationConnectionId();
@@ -280,22 +286,24 @@ QuicTestPacketMaker::MakeStreamIdBlockedPacket(uint64_t num,
   header.packet_number_length = GetPacketNumberLength();
   header.packet_number = quic::QuicPacketNumber(num);
 
-  if (quic::QuicVersionHasLongHeaderLengths(version_) && header.version_flag) {
+  if (quic::QuicVersionHasLongHeaderLengths(version_.transport_version) &&
+      header.version_flag) {
     if (long_header_type_ == quic::INITIAL) {
       header.retry_token_length_length = quic::VARIABLE_LENGTH_INTEGER_LENGTH_1;
     }
     header.length_length = quic::VARIABLE_LENGTH_INTEGER_LENGTH_2;
   }
 
-  quic::QuicStreamIdBlockedFrame frame(1, stream_id);
+  quic::QuicStreamsBlockedFrame frame(1, stream_count, unidirectional);
   DVLOG(1) << "Adding frame: " << quic::QuicFrame(frame);
   return MakePacket(header, quic::QuicFrame(frame));
 }
 
 std::unique_ptr<quic::QuicReceivedPacket>
-QuicTestPacketMaker::MakeMaxStreamIdPacket(uint64_t num,
-                                           bool include_version,
-                                           quic::QuicStreamId stream_id) {
+QuicTestPacketMaker::MakeMaxStreamsPacket(uint64_t num,
+                                          bool include_version,
+                                          quic::QuicStreamCount stream_count,
+                                          bool unidirectional) {
   quic::QuicPacketHeader header;
   header.destination_connection_id = connection_id_;
   header.destination_connection_id_included = HasDestinationConnectionId();
@@ -307,14 +315,15 @@ QuicTestPacketMaker::MakeMaxStreamIdPacket(uint64_t num,
   header.packet_number_length = GetPacketNumberLength();
   header.packet_number = quic::QuicPacketNumber(num);
 
-  if (quic::QuicVersionHasLongHeaderLengths(version_) && header.version_flag) {
+  if (quic::QuicVersionHasLongHeaderLengths(version_.transport_version) &&
+      header.version_flag) {
     if (long_header_type_ == quic::INITIAL) {
       header.retry_token_length_length = quic::VARIABLE_LENGTH_INTEGER_LENGTH_1;
     }
     header.length_length = quic::VARIABLE_LENGTH_INTEGER_LENGTH_2;
   }
 
-  quic::QuicMaxStreamIdFrame frame(1, stream_id);
+  quic::QuicMaxStreamsFrame frame(1, stream_count, unidirectional);
   DVLOG(1) << "Adding frame: " << quic::QuicFrame(frame);
   return MakePacket(header, quic::QuicFrame(frame));
 }
@@ -345,7 +354,8 @@ QuicTestPacketMaker::MakeRstAndRequestHeadersPacket(
     *offset += spdy_frame.size();
   }
   quic::QuicStreamFrame headers_frame(
-      quic::QuicUtils::GetHeadersStreamId(version_), false, header_offset,
+      quic::QuicUtils::GetHeadersStreamId(version_.transport_version), false,
+      header_offset,
       quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
 
   quic::QuicFrames frames;
@@ -355,7 +365,7 @@ QuicTestPacketMaker::MakeRstAndRequestHeadersPacket(
   // The STOP_SENDING frame must be outside of the if (version==99) so that it
   // stays in scope until the packet is built.
   quic::QuicStopSendingFrame stop(1, rst_stream_id, rst_error_code);
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     frames.push_back(quic::QuicFrame(&stop));
     DVLOG(1) << "Adding frame: " << frames.back();
   }
@@ -405,7 +415,8 @@ QuicTestPacketMaker::MakeAckAndRstPacket(
   header.packet_number_length = GetPacketNumberLength();
   header.packet_number = quic::QuicPacketNumber(num);
 
-  if (quic::QuicVersionHasLongHeaderLengths(version_) && header.version_flag) {
+  if (quic::QuicVersionHasLongHeaderLengths(version_.transport_version) &&
+      header.version_flag) {
     if (long_header_type_ == quic::INITIAL) {
       header.retry_token_length_length = quic::VARIABLE_LENGTH_INTEGER_LENGTH_1;
     }
@@ -433,7 +444,8 @@ QuicTestPacketMaker::MakeAckAndRstPacket(
   // The STOP_SENDING frame must be outside of the if (version==99) so that it
   // stays in scope until the packet is built.
   quic::QuicStopSendingFrame stop(1, stream_id, error_code);
-  if (version_ == quic::QUIC_VERSION_99 && include_stop_sending_if_v99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99 &&
+      include_stop_sending_if_v99) {
     frames.push_back(quic::QuicFrame(&stop));
     DVLOG(1) << "Adding frame: " << frames.back();
   }
@@ -464,7 +476,8 @@ QuicTestPacketMaker::MakeRstAckAndConnectionClosePacket(
   header.packet_number_length = GetPacketNumberLength();
   header.packet_number = quic::QuicPacketNumber(num);
 
-  if (quic::QuicVersionHasLongHeaderLengths(version_) && header.version_flag) {
+  if (quic::QuicVersionHasLongHeaderLengths(version_.transport_version) &&
+      header.version_flag) {
     if (long_header_type_ == quic::INITIAL) {
       header.retry_token_length_length = quic::VARIABLE_LENGTH_INTEGER_LENGTH_1;
     }
@@ -480,7 +493,7 @@ QuicTestPacketMaker::MakeRstAckAndConnectionClosePacket(
   // stays in scope until the packet is built.
   quic::QuicStopSendingFrame stop(
       1, stream_id, static_cast<quic::QuicApplicationErrorCode>(error_code));
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     frames.push_back(quic::QuicFrame(&stop));
     DVLOG(1) << "Adding frame: " << frames.back();
   }
@@ -501,7 +514,7 @@ QuicTestPacketMaker::MakeRstAckAndConnectionClosePacket(
   quic::QuicConnectionCloseFrame close;
   close.quic_error_code = quic_error;
   close.error_details = quic_error_details;
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     close.close_type = quic::IETF_QUIC_TRANSPORT_CONNECTION_CLOSE;
   }
 
@@ -532,7 +545,8 @@ QuicTestPacketMaker::MakeAckAndConnectionClosePacket(
   header.packet_number_length = GetPacketNumberLength();
   header.packet_number = quic::QuicPacketNumber(num);
 
-  if (quic::QuicVersionHasLongHeaderLengths(version_) && header.version_flag) {
+  if (quic::QuicVersionHasLongHeaderLengths(version_.transport_version) &&
+      header.version_flag) {
     if (long_header_type_ == quic::INITIAL) {
       header.retry_token_length_length = quic::VARIABLE_LENGTH_INTEGER_LENGTH_1;
     }
@@ -556,7 +570,7 @@ QuicTestPacketMaker::MakeAckAndConnectionClosePacket(
   quic::QuicConnectionCloseFrame close;
   close.quic_error_code = quic_error;
   close.error_details = quic_error_details;
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     close.close_type = quic::IETF_QUIC_TRANSPORT_CONNECTION_CLOSE;
   }
 
@@ -583,7 +597,8 @@ QuicTestPacketMaker::MakeConnectionClosePacket(
   header.packet_number_length = GetPacketNumberLength();
   header.packet_number = quic::QuicPacketNumber(num);
 
-  if (quic::QuicVersionHasLongHeaderLengths(version_) && header.version_flag) {
+  if (quic::QuicVersionHasLongHeaderLengths(version_.transport_version) &&
+      header.version_flag) {
     if (long_header_type_ == quic::INITIAL) {
       header.retry_token_length_length = quic::VARIABLE_LENGTH_INTEGER_LENGTH_1;
     }
@@ -593,7 +608,7 @@ QuicTestPacketMaker::MakeConnectionClosePacket(
   quic::QuicConnectionCloseFrame close;
   close.quic_error_code = quic_error;
   close.error_details = quic_error_details;
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     close.close_type = quic::IETF_QUIC_TRANSPORT_CONNECTION_CLOSE;
   }
 
@@ -615,7 +630,8 @@ std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakeGoAwayPacket(
   header.packet_number_length = GetPacketNumberLength();
   header.packet_number = quic::QuicPacketNumber(num);
 
-  if (quic::QuicVersionHasLongHeaderLengths(version_) && header.version_flag) {
+  if (quic::QuicVersionHasLongHeaderLengths(version_.transport_version) &&
+      header.version_flag) {
     if (long_header_type_ == quic::INITIAL) {
       header.retry_token_length_length = quic::VARIABLE_LENGTH_INTEGER_LENGTH_1;
     }
@@ -682,7 +698,8 @@ std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakeAckPacket(
   header.packet_number_length = GetPacketNumberLength();
   header.packet_number = quic::QuicPacketNumber(packet_number);
 
-  if (quic::QuicVersionHasLongHeaderLengths(version_) && header.version_flag) {
+  if (quic::QuicVersionHasLongHeaderLengths(version_.transport_version) &&
+      header.version_flag) {
     if (long_header_type_ == quic::INITIAL) {
       header.retry_token_length_length = quic::VARIABLE_LENGTH_INTEGER_LENGTH_1;
     }
@@ -700,8 +717,7 @@ std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakeAckPacket(
     ack.packets.AddRange(quic::QuicPacketNumber(first_received),
                          quic::QuicPacketNumber(largest_received + 1));
   }
-  quic::QuicFramer framer(quic::test::SupportedVersions(quic::ParsedQuicVersion(
-                              quic::PROTOCOL_QUIC_CRYPTO, version_)),
+  quic::QuicFramer framer(quic::test::SupportedVersions(version_),
                           clock_->Now(), perspective_,
                           quic::kQuicDefaultConnectionIdLength);
   quic::QuicFrames frames;
@@ -709,6 +725,17 @@ std::unique_ptr<quic::QuicReceivedPacket> QuicTestPacketMaker::MakeAckPacket(
   frames.push_back(ack_frame);
   DVLOG(1) << "Adding frame: " << frames.back();
 
+  size_t max_plaintext_size =
+      framer.GetMaxPlaintextSize(quic::kDefaultMaxPacketSize);
+  size_t ack_frame_length = framer.GetSerializedFrameLength(
+      ack_frame, max_plaintext_size, /*first_frame*/ true, /*last_frame*/ false,
+      header.packet_number_length);
+  const size_t min_plaintext_size = 7;
+  if (version_.HasHeaderProtection() && ack_frame_length < min_plaintext_size) {
+    size_t padding_length = min_plaintext_size - ack_frame_length;
+    frames.push_back(quic::QuicFrame(quic::QuicPaddingFrame(padding_length)));
+  }
+
   std::unique_ptr<quic::QuicPacket> packet(
       quic::test::BuildUnsizedDataPacket(&framer, header, frames));
   char buffer[quic::kMaxOutgoingPacketSize];
@@ -851,7 +878,8 @@ QuicTestPacketMaker::MakeRequestHeadersAndMultipleDataFramesPacket(
   quic::QuicStreamOffset header_offset =
       header_stream_offset == nullptr ? 0 : *header_stream_offset;
   quic::QuicStreamFrame frame(
-      quic::QuicUtils::GetHeadersStreamId(version_), false, header_offset,
+      quic::QuicUtils::GetHeadersStreamId(version_.transport_version), false,
+      header_offset,
       quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
   frames.push_back(quic::QuicFrame(frame));
   DVLOG(1) << "Adding frame: " << frames.back();
@@ -931,14 +959,14 @@ QuicTestPacketMaker::MakeRequestHeadersPacketAndSaveData(
 
   if (offset != nullptr) {
     quic::QuicStreamFrame frame(
-        quic::QuicUtils::GetHeadersStreamId(version_), false, *offset,
-        quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
+        quic::QuicUtils::GetHeadersStreamId(version_.transport_version), false,
+        *offset, quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
     *offset += spdy_frame.size();
     return MakePacket(header_, quic::QuicFrame(frame));
   } else {
     quic::QuicStreamFrame frame(
-        quic::QuicUtils::GetHeadersStreamId(version_), false, 0,
-        quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
+        quic::QuicUtils::GetHeadersStreamId(version_.transport_version), false,
+        0, quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
 
     return MakePacket(header_, quic::QuicFrame(frame));
   }
@@ -968,7 +996,8 @@ QuicTestPacketMaker::MakeRequestHeadersAndRstPacket(
     *header_stream_offset += spdy_frame.size();
   }
   quic::QuicStreamFrame headers_frame(
-      quic::QuicUtils::GetHeadersStreamId(version_), false, header_offset,
+      quic::QuicUtils::GetHeadersStreamId(version_.transport_version), false,
+      header_offset,
       quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
 
   quic::QuicRstStreamFrame rst_frame(1, stream_id, error_code, bytes_written);
@@ -982,7 +1011,7 @@ QuicTestPacketMaker::MakeRequestHeadersAndRstPacket(
   // The STOP_SENDING frame must be outside of the if (version==99) so that it
   // stays in scope until the packet is built.
   quic::QuicStopSendingFrame stop(1, stream_id, error_code);
-  if (version_ == quic::QUIC_VERSION_99) {
+  if (version_.transport_version == quic::QUIC_VERSION_99) {
     frames.push_back(quic::QuicFrame(&stop));
     DVLOG(1) << "Adding frame: " << frames.back();
   }
@@ -1053,14 +1082,14 @@ QuicTestPacketMaker::MakePushPromisePacket(
   }
   if (offset != nullptr) {
     quic::QuicStreamFrame frame(
-        quic::QuicUtils::GetHeadersStreamId(version_), false, *offset,
-        quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
+        quic::QuicUtils::GetHeadersStreamId(version_.transport_version), false,
+        *offset, quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
     *offset += spdy_frame.size();
     return MakePacket(header_, quic::QuicFrame(frame));
   } else {
     quic::QuicStreamFrame frame(
-        quic::QuicUtils::GetHeadersStreamId(version_), false, 0,
-        quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
+        quic::QuicUtils::GetHeadersStreamId(version_.transport_version), false,
+        0, quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
     return MakePacket(header_, quic::QuicFrame(frame));
   }
 }
@@ -1078,8 +1107,8 @@ QuicTestPacketMaker::MakeForceHolDataPacket(uint64_t packet_number,
       spdy_request_framer_.SerializeFrame(spdy_data));
   InitializeHeader(packet_number, should_include_version);
   quic::QuicStreamFrame quic_frame(
-      quic::QuicUtils::GetHeadersStreamId(version_), false, *offset,
-      quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
+      quic::QuicUtils::GetHeadersStreamId(version_.transport_version), false,
+      *offset, quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
   *offset += spdy_frame.size();
   return MakePacket(header_, quic::QuicFrame(quic_frame));
 }
@@ -1106,14 +1135,14 @@ QuicTestPacketMaker::MakeResponseHeadersPacket(
   }
   if (offset != nullptr) {
     quic::QuicStreamFrame frame(
-        quic::QuicUtils::GetHeadersStreamId(version_), false, *offset,
-        quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
+        quic::QuicUtils::GetHeadersStreamId(version_.transport_version), false,
+        *offset, quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
     *offset += spdy_frame.size();
     return MakePacket(header_, quic::QuicFrame(frame));
   } else {
     quic::QuicStreamFrame frame(
-        quic::QuicUtils::GetHeadersStreamId(version_), false, 0,
-        quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
+        quic::QuicUtils::GetHeadersStreamId(version_.transport_version), false,
+        0, quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
     return MakePacket(header_, quic::QuicFrame(frame));
   }
 }
@@ -1197,17 +1226,38 @@ QuicTestPacketMaker::MakeMultipleFramesPacket(
     const quic::QuicPacketHeader& header,
     const quic::QuicFrames& frames,
     quic::QuicStreamFrameDataProducer* data_producer) {
-  quic::QuicFramer framer(quic::test::SupportedVersions(quic::ParsedQuicVersion(
-                              quic::PROTOCOL_QUIC_CRYPTO, version_)),
+  quic::QuicFramer framer(quic::test::SupportedVersions(version_),
                           clock_->Now(), perspective_,
                           quic::kQuicDefaultConnectionIdLength);
   if (data_producer != nullptr) {
     framer.set_data_producer(data_producer);
   }
+  quic::QuicFrames frames_copy = frames;
   size_t max_plaintext_size =
       framer.GetMaxPlaintextSize(quic::kDefaultMaxPacketSize);
+  if (version_.HasHeaderProtection()) {
+    size_t packet_size =
+        quic::GetPacketHeaderSize(version_.transport_version, header);
+    size_t frames_size = 0;
+    for (size_t i = 0; i < frames.size(); ++i) {
+      bool first_frame = i == 0;
+      bool last_frame = i == frames.size() - 1;
+      const size_t frame_size = framer.GetSerializedFrameLength(
+          frames[i], max_plaintext_size - packet_size, first_frame, last_frame,
+          header.packet_number_length);
+      packet_size += frame_size;
+      frames_size += frame_size;
+    }
+    // This should be done by calling QuicPacketCreator::MinPlaintextPacketSize.
+    const size_t min_plaintext_size = 7;
+    if (frames_size < min_plaintext_size) {
+      size_t padding_length = min_plaintext_size - frames_size;
+      frames_copy.push_back(
+          quic::QuicFrame(quic::QuicPaddingFrame(padding_length)));
+    }
+  }
   std::unique_ptr<quic::QuicPacket> packet(quic::test::BuildUnsizedDataPacket(
-      &framer, header, frames, max_plaintext_size));
+      &framer, header, frames_copy, max_plaintext_size));
   char buffer[quic::kMaxOutgoingPacketSize];
   size_t encrypted_size =
       framer.EncryptPayload(quic::ENCRYPTION_INITIAL, header.packet_number,
@@ -1229,7 +1279,7 @@ void QuicTestPacketMaker::InitializeHeader(uint64_t packet_number,
   header_.long_packet_type = long_header_type_;
   header_.packet_number_length = GetPacketNumberLength();
   header_.packet_number = quic::QuicPacketNumber(packet_number);
-  if (quic::QuicVersionHasLongHeaderLengths(version_) &&
+  if (quic::QuicVersionHasLongHeaderLengths(version_.transport_version) &&
       should_include_version) {
     if (long_header_type_ == quic::INITIAL) {
       header_.retry_token_length_length =
@@ -1261,13 +1311,13 @@ QuicTestPacketMaker::MakeInitialSettingsPacketAndSaveData(
   *stream_data = std::string(spdy_frame.data(), spdy_frame.size());
   if (offset != nullptr) {
     quic::QuicStreamFrame quic_frame(
-        quic::QuicUtils::GetHeadersStreamId(version_), false, *offset,
-        quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
+        quic::QuicUtils::GetHeadersStreamId(version_.transport_version), false,
+        *offset, quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
     *offset += spdy_frame.size();
     return MakePacket(header_, quic::QuicFrame(quic_frame));
   }
   quic::QuicStreamFrame quic_frame(
-      quic::QuicUtils::GetHeadersStreamId(version_), false, 0,
+      quic::QuicUtils::GetHeadersStreamId(version_.transport_version), false, 0,
       quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
   return MakePacket(header_, quic::QuicFrame(quic_frame));
 }
@@ -1294,7 +1344,8 @@ QuicTestPacketMaker::MakePriorityPacket(uint64_t packet_number,
     *offset += spdy_frame.size();
   }
   quic::QuicStreamFrame quic_frame(
-      quic::QuicUtils::GetHeadersStreamId(version_), false, header_offset,
+      quic::QuicUtils::GetHeadersStreamId(version_.transport_version), false,
+      header_offset,
       quic::QuicStringPiece(spdy_frame.data(), spdy_frame.size()));
   DVLOG(1) << "Adding frame: " << quic::QuicFrame(quic_frame);
   InitializeHeader(packet_number, should_include_version);
@@ -1341,8 +1392,8 @@ QuicTestPacketMaker::MakeAckAndMultiplePriorityFramesPacket(
 
     spdy::SpdySerializedFrame* spdy_frame = spdy_frames.back().get();
     quic::QuicStreamFrame stream_frame(
-        quic::QuicUtils::GetHeadersStreamId(version_), false, *offset,
-        quic::QuicStringPiece(spdy_frame->data(), spdy_frame->size()));
+        quic::QuicUtils::GetHeadersStreamId(version_.transport_version), false,
+        *offset, quic::QuicStringPiece(spdy_frame->data(), spdy_frame->size()));
     *offset += spdy_frame->size();
 
     frames.push_back(quic::QuicFrame(stream_frame));
@@ -1372,7 +1423,7 @@ void QuicTestPacketMaker::SetEncryptionLevel(quic::EncryptionLevel level) {
 }
 
 bool QuicTestPacketMaker::ShouldIncludeVersion(bool include_version) const {
-  if (version_ > quic::QUIC_VERSION_43) {
+  if (version_.transport_version > quic::QUIC_VERSION_43) {
     return encryption_level_ < quic::ENCRYPTION_FORWARD_SECURE;
   }
   return include_version;
@@ -1380,9 +1431,9 @@ bool QuicTestPacketMaker::ShouldIncludeVersion(bool include_version) const {
 
 quic::QuicPacketNumberLength QuicTestPacketMaker::GetPacketNumberLength()
     const {
-  if (version_ > quic::QUIC_VERSION_43 &&
+  if (version_.transport_version > quic::QUIC_VERSION_43 &&
       encryption_level_ < quic::ENCRYPTION_FORWARD_SECURE &&
-      version_ != quic::QUIC_VERSION_99) {
+      version_.transport_version != quic::QUIC_VERSION_99) {
     return quic::PACKET_4BYTE_PACKET_NUMBER;
   }
   return quic::PACKET_1BYTE_PACKET_NUMBER;
@@ -1391,7 +1442,7 @@ quic::QuicPacketNumberLength QuicTestPacketMaker::GetPacketNumberLength()
 quic::QuicConnectionIdIncluded QuicTestPacketMaker::HasDestinationConnectionId()
     const {
   if (perspective_ == quic::Perspective::IS_SERVER &&
-      version_ > quic::QUIC_VERSION_43) {
+      version_.transport_version > quic::QUIC_VERSION_43) {
     return quic::CONNECTION_ID_ABSENT;
   }
   return quic::CONNECTION_ID_PRESENT;
@@ -1400,7 +1451,7 @@ quic::QuicConnectionIdIncluded QuicTestPacketMaker::HasDestinationConnectionId()
 quic::QuicConnectionIdIncluded QuicTestPacketMaker::HasSourceConnectionId()
     const {
   if (perspective_ == quic::Perspective::IS_SERVER &&
-      version_ > quic::QUIC_VERSION_43 &&
+      version_.transport_version > quic::QUIC_VERSION_43 &&
       encryption_level_ < quic::ENCRYPTION_FORWARD_SECURE) {
     return quic::CONNECTION_ID_PRESENT;
   }
diff --git a/chromium/net/quic/quic_test_packet_maker.h b/chromium/net/quic/quic_test_packet_maker.h
index 216b8b56027..9569b53a1db 100644
--- a/chromium/net/quic/quic_test_packet_maker.h
+++ b/chromium/net/quic/quic_test_packet_maker.h
@@ -40,7 +40,7 @@ class QuicTestPacketMaker {
   // stream id set to the |parent_stream_id| param of MakeRequestHeaders...().
   // Otherwise, headers are constructed with the exclusive flag set to false and
   // the parent stream ID set to 0 (ignoring the |parent_stream_id| param).
-  QuicTestPacketMaker(quic::QuicTransportVersion version,
+  QuicTestPacketMaker(quic::ParsedQuicVersion version,
                       quic::QuicConnectionId connection_id,
                       quic::MockClock* clock,
                       const std::string& host,
@@ -64,15 +64,17 @@ class QuicTestPacketMaker {
       uint64_t smallest_received,
       uint64_t least_unacked);
 
-  std::unique_ptr<quic::QuicReceivedPacket> MakeStreamIdBlockedPacket(
+  std::unique_ptr<quic::QuicReceivedPacket> MakeStreamsBlockedPacket(
       uint64_t num,
       bool include_version,
-      quic::QuicStreamId stream_id);
+      quic::QuicStreamCount stream_count,
+      bool unidirectional);
 
-  std::unique_ptr<quic::QuicReceivedPacket> MakeMaxStreamIdPacket(
+  std::unique_ptr<quic::QuicReceivedPacket> MakeMaxStreamsPacket(
       uint64_t num,
       bool include_version,
-      quic::QuicStreamId stream_id);
+      quic::QuicStreamCount stream_count,
+      bool unidirectional);
 
   std::unique_ptr<quic::QuicReceivedPacket> MakeRstPacket(
       uint64_t num,
@@ -408,7 +410,7 @@ class QuicTestPacketMaker {
   quic::QuicConnectionIdIncluded HasDestinationConnectionId() const;
   quic::QuicConnectionIdIncluded HasSourceConnectionId() const;
 
-  quic::QuicTransportVersion version_;
+  quic::ParsedQuicVersion version_;
   quic::QuicConnectionId connection_id_;
   quic::MockClock* clock_;  // Owned by QuicStreamFactory.
   std::string host_;
author	Allan Sandfeld Jensen <allan.jensen@qt.io>	2019-07-31 15:50:41 +0200
committer	Allan Sandfeld Jensen <allan.jensen@qt.io>	2019-08-30 12:35:23 +0000
commit	7b2ffa587235a47d4094787d72f38102089f402a (patch)
tree	30e82af9cbab08a7fa028bb18f4f2987a3f74dfa /chromium/net/quic
parent	d94af01c90575348c4e81a418257f254b6f8d225 (diff)
download	qtwebengine-chromium-7b2ffa587235a47d4094787d72f38102089f402a.tar.gz