BASELINE: Update Chromium to 79.0.3945.139

Change-Id: I336b7182fab9bca80b709682489c07db112eaca5
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

24 files changed, 395 insertions, 168 deletions

diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_backend_response.h b/chromium/net/third_party/quiche/src/quic/tools/quic_backend_response.h
index b5789151b2f..f0b7b893889 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_backend_response.h
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_backend_response.h
@@ -42,6 +42,8 @@ class QuicBackendResponse {
     STOP_SENDING,          // Acts like INCOMPLETE_RESPONSE in that the entire
                            // response is not sent. After sending what is sent,
                            // the server will send a STOP_SENDING.
+    GENERATE_BYTES         // Sends a response with a length equal to the number
+                           // of bytes in the URL path.
   };
   QuicBackendResponse();
 
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_client.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_client.cc
index 123cf1ee30f..cccb7ba3e6f 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_client.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_client.cc
@@ -12,6 +12,8 @@
 #include <sys/socket.h>
 #include <sys/types.h>
 
+#include <utility>
+
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
 #include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection.h"
@@ -109,7 +111,7 @@ QuicClient::~QuicClient() = default;
 std::unique_ptr<QuicSession> QuicClient::CreateQuicClientSession(
     const ParsedQuicVersionVector& supported_versions,
     QuicConnection* connection) {
-  return QuicMakeUnique<QuicSimpleClientSession>(
+  return std::make_unique<QuicSimpleClientSession>(
       *config(), supported_versions, connection, server_id(), crypto_config(),
       push_promise_index(), drop_response_body());
 }
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_client_epoll_network_helper.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_client_epoll_network_helper.cc
index d16a128d903..2f6d47d93c6 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_client_epoll_network_helper.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_client_epoll_network_helper.cc
@@ -21,7 +21,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_server_id.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_system_event_loop.h"
 #include "net/quic/platform/impl/quic_socket_utils.h"
 
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_client_interop_test_bin.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_client_interop_test_bin.cc
index 39f8ff9abe7..278a22e29ba 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_client_interop_test_bin.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_client_interop_test_bin.cc
@@ -5,12 +5,17 @@
 #include <iostream>
 #include <memory>
 #include <string>
+#include <utility>
 
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_epoll.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_system_event_loop.h"
+#include "net/quic/platform/impl/quic_epoll_clock.h"
+#include "net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h"
 #include "net/third_party/quiche/src/quic/tools/fake_proof_verifier.h"
 #include "net/third_party/quiche/src/quic/tools/quic_client.h"
+#include "net/third_party/quiche/src/quic/tools/quic_url.h"
 
 DEFINE_QUIC_COMMAND_LINE_FLAG(std::string,
                               host,
@@ -22,6 +27,7 @@ DEFINE_QUIC_COMMAND_LINE_FLAG(int32_t, port, 0, "The port to connect to.");
 namespace quic {
 
 enum class Feature {
+  // First row of features ("table stakes")
   // A version negotiation response is elicited and acted on.
   kVersionNegotiation,
   // The handshake completes successfully.
@@ -30,9 +36,16 @@ enum class Feature {
   kStreamData,
   // The connection close procedcure completes with a zero error code.
   kConnectionClose,
+  // A RETRY packet was successfully processed.
+  kRetry,
+
+  // Second row of features (anything else protocol-related)
+  // We switched to a different port and the server migrated to it.
+  kRebinding,
+
+  // Third row of features (H3 tests)
   // An H3 transaction succeeded.
   kHttp3,
-  // TODO(nharper): Add Retry to list of tested features.
 };
 
 char MatrixLetter(Feature f) {
@@ -47,17 +60,23 @@ char MatrixLetter(Feature f) {
       return 'C';
     case Feature::kHttp3:
       return '3';
+    case Feature::kRetry:
+      return 'S';
+    case Feature::kRebinding:
+      return 'B';
   }
 }
 
 std::set<Feature> AttemptRequest(QuicSocketAddress addr,
                                  std::string authority,
                                  QuicServerId server_id,
-                                 ParsedQuicVersionVector versions) {
+                                 ParsedQuicVersionVector versions,
+                                 bool attempt_rebind) {
   std::set<Feature> features;
-  auto proof_verifier = QuicMakeUnique<FakeProofVerifier>();
+  auto proof_verifier = std::make_unique<FakeProofVerifier>();
   QuicEpollServer epoll_server;
-  auto client = QuicMakeUnique<QuicClient>(
+  QuicEpollClock epoll_clock(&epoll_server);
+  auto client = std::make_unique<QuicClient>(
       addr, server_id, versions, &epoll_server, std::move(proof_verifier));
   if (!client->Initialize()) {
     return features;
@@ -88,9 +107,30 @@ std::set<Feature> AttemptRequest(QuicSocketAddress addr,
   client->set_store_response(true);
   client->SendRequest(header_block, "", /*fin=*/true);
 
-  // TODO(nharper): After some period of time, time out and don't report
-  // success.
+  const QuicTime request_start_time = epoll_clock.Now();
+  static const auto request_timeout = QuicTime::Delta::FromSeconds(20);
   while (client->WaitForEvents()) {
+    if (epoll_clock.Now() - request_start_time >= request_timeout) {
+      QUIC_LOG(ERROR) << "Timed out waiting for HTTP response";
+      return features;
+    }
+  }
+
+  QuicConnection* connection = client->session()->connection();
+  if (connection != nullptr) {
+    QuicConnectionStats client_stats = connection->GetStats();
+    if (client_stats.retry_packet_processed) {
+      features.insert(Feature::kRetry);
+    }
+    QuicSentPacketManager* sent_packet_manager =
+        test::QuicConnectionPeer::GetSentPacketManager(connection);
+    const bool received_forward_secure_ack =
+        sent_packet_manager != nullptr &&
+        sent_packet_manager->GetLargestAckedPacket(ENCRYPTION_FORWARD_SECURE)
+            .IsInitialized();
+    if (client_stats.stream_bytes_received > 0 && received_forward_secure_ack) {
+      features.insert(Feature::kStreamData);
+    }
   }
 
   if (!client->connected()) {
@@ -99,14 +139,50 @@ std::set<Feature> AttemptRequest(QuicSocketAddress addr,
 
   if (client->latest_response_code() != -1) {
     features.insert(Feature::kHttp3);
+
+    if (attempt_rebind) {
+      // Now make a second request after switching to a different client port.
+      if (client->ChangeEphemeralPort()) {
+        client->SendRequest(header_block, "", /*fin=*/true);
+
+        const QuicTime second_request_start_time = epoll_clock.Now();
+        while (client->WaitForEvents()) {
+          if (epoll_clock.Now() - second_request_start_time >=
+              request_timeout) {
+            // Rebinding does not work, retry without attempting it.
+            return AttemptRequest(addr, authority, server_id, versions,
+                                  /*attempt_rebind=*/false);
+          }
+        }
+        features.insert(Feature::kRebinding);
+      } else {
+        QUIC_LOG(ERROR) << "Failed to change ephemeral port";
+      }
+    }
+  }
+
+  if (connection != nullptr && connection->connected()) {
+    test::QuicConnectionPeer::SendConnectionClosePacket(
+        connection, QUIC_NO_ERROR, "Graceful close");
+    const QuicTime close_start_time = epoll_clock.Now();
+    static const auto close_timeout = QuicTime::Delta::FromSeconds(10);
+    while (client->connected()) {
+      client->epoll_network_helper()->RunEventLoop();
+      if (epoll_clock.Now() - close_start_time >= close_timeout) {
+        QUIC_LOG(ERROR) << "Timed out waiting for connection close";
+        return features;
+      }
+    }
+    const QuicErrorCode received_error = client->session()->error();
+    if (received_error == QUIC_NO_ERROR ||
+        received_error == QUIC_PUBLIC_RESET) {
+      features.insert(Feature::kConnectionClose);
+    } else {
+      QUIC_LOG(ERROR) << "Received error " << client->session()->error() << " "
+                      << client->session()->error_details();
+    }
   }
 
-  // TODO(nharper): Properly check that we actually sent stream data and
-  // received ACKs for it.
-  features.insert(Feature::kStreamData);
-  // TODO(nharper): Check that we sent/received (which one?) a CONNECTION_CLOSE
-  // with error code 0.
-  features.insert(Feature::kConnectionClose);
   return features;
 }
 
@@ -127,11 +203,13 @@ std::set<Feature> ServerSupport(std::string host, int port) {
   versions_with_negotiation.insert(versions_with_negotiation.begin(),
                                    QuicVersionReservedForNegotiation());
   auto supported_features =
-      AttemptRequest(addr, authority, server_id, versions_with_negotiation);
+      AttemptRequest(addr, authority, server_id, versions_with_negotiation,
+                     /*attempt_rebind=*/true);
   if (!supported_features.empty()) {
     supported_features.insert(Feature::kVersionNegotiation);
   } else {
-    supported_features = AttemptRequest(addr, authority, server_id, versions);
+    supported_features = AttemptRequest(addr, authority, server_id, versions,
+                                        /*attempt_rebind=*/true);
   }
   return supported_features;
 }
@@ -140,24 +218,46 @@ std::set<Feature> ServerSupport(std::string host, int port) {
 
 int main(int argc, char* argv[]) {
   QuicSystemEventLoop event_loop("quic_client");
-  const char* usage = "Usage: quic_client_interop_test [options]";
+  const char* usage = "Usage: quic_client_interop_test [options] [url]";
 
   std::vector<std::string> args =
       quic::QuicParseCommandLineFlags(usage, argc, argv);
-  if (!args.empty()) {
+  if (args.size() > 1) {
     quic::QuicPrintCommandLineFlagHelp(usage);
     exit(1);
   }
   std::string host = GetQuicFlag(FLAGS_host);
   int port = GetQuicFlag(FLAGS_port);
-  if (host.empty() || port == 0) {
+
+  if (!args.empty()) {
+    quic::QuicUrl url(args[0], "https");
+    if (host.empty()) {
+      host = url.host();
+    }
+    if (port == 0) {
+      port = url.port();
+    }
+  }
+  if (port == 0) {
+    port = 443;
+  }
+  if (host.empty()) {
     quic::QuicPrintCommandLineFlagHelp(usage);
     exit(1);
   }
 
   auto supported_features = quic::ServerSupport(host, port);
-  std::cout << "Supported features: ";
+  std::cout << "Results for " << host << ":" << port << std::endl;
+  int current_row = 1;
   for (auto feature : supported_features) {
+    if (current_row < 2 && feature >= quic::Feature::kRebinding) {
+      std::cout << std::endl;
+      current_row = 2;
+    }
+    if (current_row < 3 && feature >= quic::Feature::kHttp3) {
+      std::cout << std::endl;
+      current_row = 3;
+    }
     std::cout << MatrixLetter(feature);
   }
   std::cout << std::endl;
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_client_test.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_client_test.cc
index e2d7f1413c8..e460de495a2 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_client_test.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_client_test.cc
@@ -8,6 +8,7 @@
 #include <sys/types.h>
 
 #include <memory>
+#include <utility>
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_epoll.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_port_utils.h"
@@ -69,7 +70,7 @@ class QuicClientTest : public QuicTest {
     QuicSocketAddress server_address(QuicSocketAddress(TestLoopback(), port));
     QuicServerId server_id("hostname", server_address.port(), false);
     ParsedQuicVersionVector versions = AllSupportedVersions();
-    auto client = QuicMakeUnique<QuicClient>(
+    auto client = std::make_unique<QuicClient>(
         server_address, server_id, versions, &epoll_server_,
         crypto_test_utils::ProofVerifierForTesting());
     EXPECT_TRUE(client->Initialize());
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_epoll_client_factory.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_epoll_client_factory.cc
index 7cfb00a62b2..113958f548f 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_epoll_client_factory.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_epoll_client_factory.cc
@@ -8,6 +8,8 @@
 #include <sys/socket.h>
 #include <sys/types.h>
 
+#include <utility>
+
 #include "net/third_party/quiche/src/quic/core/quic_server_id.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
 #include "net/third_party/quiche/src/quic/tools/quic_client.h"
@@ -27,8 +29,8 @@ std::unique_ptr<QuicSpdyClientBase> QuicEpollClientFactory::CreateClient(
     return nullptr;
   }
   QuicServerId server_id(host_for_handshake, port, false);
-  return QuicMakeUnique<QuicClient>(addr, server_id, versions, &epoll_server_,
-                                    std::move(verifier));
+  return std::make_unique<QuicClient>(addr, server_id, versions, &epoll_server_,
+                                      std::move(verifier));
 }
 
 }  // namespace quic
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_epoll_server_factory.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_epoll_server_factory.cc
index f0c206a5d3f..d216cd1d3ae 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_epoll_server_factory.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_epoll_server_factory.cc
@@ -4,15 +4,18 @@
 
 #include "net/third_party/quiche/src/quic/tools/quic_epoll_server_factory.h"
 
+#include <utility>
+
 #include "net/third_party/quiche/src/quic/tools/quic_server.h"
 
 namespace quic {
 
 std::unique_ptr<quic::QuicSpdyServerBase> QuicEpollServerFactory::CreateServer(
     quic::QuicSimpleServerBackend* backend,
-    std::unique_ptr<quic::ProofSource> proof_source) {
-  return quic::QuicMakeUnique<quic::QuicServer>(std::move(proof_source),
-                                                backend);
+    std::unique_ptr<quic::ProofSource> proof_source,
+    const quic::ParsedQuicVersionVector& supported_versions) {
+  return std::make_unique<quic::QuicServer>(std::move(proof_source), backend,
+                                            supported_versions);
 }
 
 }  // namespace quic
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_epoll_server_factory.h b/chromium/net/third_party/quiche/src/quic/tools/quic_epoll_server_factory.h
index 391f3cd8d12..90702918452 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_epoll_server_factory.h
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_epoll_server_factory.h
@@ -15,7 +15,8 @@ class QuicEpollServerFactory : public QuicToyServer::ServerFactory {
  public:
   std::unique_ptr<QuicSpdyServerBase> CreateServer(
       QuicSimpleServerBackend* backend,
-      std::unique_ptr<ProofSource> proof_source) override;
+      std::unique_ptr<ProofSource> proof_source,
+      const quic::ParsedQuicVersionVector& supported_versions) override;
 
  private:
   QuicEpollServer epoll_server_;
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.cc
index 5943380abfe..6452d22c5ed 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.cc
@@ -11,7 +11,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_file_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
 
 using spdy::kV3LowestPriority;
@@ -137,6 +136,15 @@ const QuicBackendResponse* QuicMemoryCacheBackend::GetResponse(
 
   auto it = responses_.find(GetKey(host, path));
   if (it == responses_.end()) {
+    uint64_t ignored = 0;
+    if (generate_bytes_response_) {
+      if (QuicTextUtils::StringToUint64(
+              QuicStringPiece(path.data() + 1, path.size() - 1), &ignored)) {
+        // The actual parsed length is ignored here and will be recomputed
+        // by the caller.
+        return generate_bytes_response_.get();
+      }
+    }
     QUIC_DVLOG(1) << "Get response for resource failed: host " << host
                   << " path " << path;
     if (default_response_) {
@@ -272,10 +280,23 @@ bool QuicMemoryCacheBackend::InitializeBackend(
     MaybeAddServerPushResources(resource_file->host(), resource_file->path(),
                                 push_resources);
   }
+
   cache_initialized_ = true;
   return true;
 }
 
+void QuicMemoryCacheBackend::GenerateDynamicResponses() {
+  QuicWriterMutexLock lock(&response_mutex_);
+  // Add a generate bytes response.
+  spdy::SpdyHeaderBlock response_headers;
+  response_headers[":version"] = "HTTP/1.1";
+  response_headers[":status"] = "200";
+  generate_bytes_response_ = std::make_unique<QuicBackendResponse>();
+  generate_bytes_response_->set_headers(std::move(response_headers));
+  generate_bytes_response_->set_response_type(
+      QuicBackendResponse::GENERATE_BYTES);
+}
+
 bool QuicMemoryCacheBackend::IsBackendInitialized() const {
   return cache_initialized_;
 }
@@ -341,7 +362,7 @@ void QuicMemoryCacheBackend::AddResponseImpl(QuicStringPiece host,
     QUIC_BUG << "Response for '" << key << "' already exists!";
     return;
   }
-  auto new_response = QuicMakeUnique<QuicBackendResponse>();
+  auto new_response = std::make_unique<QuicBackendResponse>();
   new_response->set_response_type(response_type);
   new_response->set_headers(std::move(response_headers));
   new_response->set_body(response_body);
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.h b/chromium/net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.h
index 8e202c04399..e0ff400f410 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.h
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.h
@@ -137,6 +137,10 @@ class QuicMemoryCacheBackend : public QuicSimpleServerBackend {
   // |cache_cirectory| can be generated using `wget -p --save-headers <url>`.
   void InitializeFromDirectory(const std::string& cache_directory);
 
+  // Once called, URLs which have a numeric path will send a dynamically
+  // generated response of that many bytes.
+  void GenerateDynamicResponses();
+
   // Find all the server push resources associated with |request_url|.
   std::list<QuicBackendResponse::ServerPushInfo> GetServerPushResources(
       std::string request_url);
@@ -183,6 +187,10 @@ class QuicMemoryCacheBackend : public QuicSimpleServerBackend {
   std::unique_ptr<QuicBackendResponse> default_response_
       QUIC_GUARDED_BY(response_mutex_);
 
+  // The generate bytes response, if set.
+  std::unique_ptr<QuicBackendResponse> generate_bytes_response_
+      QUIC_GUARDED_BY(response_mutex_);
+
   // A map from request URL to associated server push responses (if any).
   std::multimap<std::string, QuicBackendResponse::ServerPushInfo>
       server_push_resources_ QUIC_GUARDED_BY(response_mutex_);
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_server.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_server.cc
index 46b04a5dadc..294dbc50ee7 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_server.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_server.cc
@@ -51,9 +51,16 @@ const size_t kNumSessionsToCreatePerSocketEvent = 16;
 QuicServer::QuicServer(std::unique_ptr<ProofSource> proof_source,
                        QuicSimpleServerBackend* quic_simple_server_backend)
     : QuicServer(std::move(proof_source),
+                 quic_simple_server_backend,
+                 AllSupportedVersions()) {}
+
+QuicServer::QuicServer(std::unique_ptr<ProofSource> proof_source,
+                       QuicSimpleServerBackend* quic_simple_server_backend,
+                       const ParsedQuicVersionVector& supported_versions)
+    : QuicServer(std::move(proof_source),
                  QuicConfig(),
                  QuicCryptoServerConfig::ConfigOptions(),
-                 AllSupportedVersions(),
+                 supported_versions,
                  quic_simple_server_backend,
                  kQuicDefaultConnectionIdLength) {}
 
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_server.h b/chromium/net/third_party/quiche/src/quic/tools/quic_server.h
index 755e5e3fc96..0b11be3c496 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_server.h
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_server.h
@@ -39,8 +39,11 @@ class QuicServer : public QuicSpdyServerBase,
   QuicServer(std::unique_ptr<ProofSource> proof_source,
              QuicSimpleServerBackend* quic_simple_server_backend);
   QuicServer(std::unique_ptr<ProofSource> proof_source,
+             QuicSimpleServerBackend* quic_simple_server_backend,
+             const ParsedQuicVersionVector& supported_versions);
+  QuicServer(std::unique_ptr<ProofSource> proof_source,
              const QuicConfig& config,
-             const QuicCryptoServerConfig::ConfigOptions& server_config_options,
+             const QuicCryptoServerConfig::ConfigOptions& crypto_config_options,
              const ParsedQuicVersionVector& supported_versions,
              QuicSimpleServerBackend* quic_simple_server_backend,
              uint8_t expected_server_connection_id_length);
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_simple_client_session.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_simple_client_session.cc
index 7cc875b5a63..38ff4fce343 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_simple_client_session.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_simple_client_session.cc
@@ -4,13 +4,29 @@
 
 #include "net/third_party/quiche/src/quic/tools/quic_simple_client_session.h"
 
-#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
+#include <utility>
 
 namespace quic {
 
+QuicSimpleClientSession::QuicSimpleClientSession(
+    const QuicConfig& config,
+    const ParsedQuicVersionVector& supported_versions,
+    QuicConnection* connection,
+    const QuicServerId& server_id,
+    QuicCryptoClientConfig* crypto_config,
+    QuicClientPushPromiseIndex* push_promise_index,
+    bool drop_response_body)
+    : QuicSpdyClientSession(config,
+                            supported_versions,
+                            connection,
+                            server_id,
+                            crypto_config,
+                            push_promise_index),
+      drop_response_body_(drop_response_body) {}
+
 std::unique_ptr<QuicSpdyClientStream>
 QuicSimpleClientSession::CreateClientStream() {
-  return QuicMakeUnique<QuicSimpleClientStream>(
+  return std::make_unique<QuicSimpleClientStream>(
       GetNextOutgoingBidirectionalStreamId(), this, BIDIRECTIONAL,
       drop_response_body_);
 }
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_simple_client_session.h b/chromium/net/third_party/quiche/src/quic/tools/quic_simple_client_session.h
index 1a17f3d74f3..0ebca98fa04 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_simple_client_session.h
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_simple_client_session.h
@@ -18,14 +18,7 @@ class QuicSimpleClientSession : public QuicSpdyClientSession {
                           const QuicServerId& server_id,
                           QuicCryptoClientConfig* crypto_config,
                           QuicClientPushPromiseIndex* push_promise_index,
-                          bool drop_response_body)
-      : QuicSpdyClientSession(config,
-                              supported_versions,
-                              connection,
-                              server_id,
-                              crypto_config,
-                              push_promise_index),
-        drop_response_body_(drop_response_body) {}
+                          bool drop_response_body);
 
   std::unique_ptr<QuicSpdyClientStream> CreateClientStream() override;
 
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_session.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_session.cc
index d06cd4b28a1..c60a9e229ee 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_session.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_session.cc
@@ -75,8 +75,8 @@ void QuicSimpleServerSession::PromisePushResources(
     spdy::SpdyHeaderBlock headers = SynthesizePushRequestHeaders(
         request_url, resource, original_request_headers);
     highest_promised_stream_id_ +=
-        QuicUtils::StreamIdDelta(connection()->transport_version());
-    if (VersionHasIetfQuicFrames(connection()->transport_version()) &&
+        QuicUtils::StreamIdDelta(transport_version());
+    if (VersionUsesHttp3(transport_version()) &&
         highest_promised_stream_id_ > max_allowed_push_id()) {
       return;
     }
@@ -138,7 +138,7 @@ void QuicSimpleServerSession::HandleFrameOnNonexistentOutgoingStream(
   // connection shouldn't be closed.
   // Otherwise behave in the same way as base class.
   if (highest_promised_stream_id_ ==
-          QuicUtils::GetInvalidStreamId(connection()->transport_version()) ||
+          QuicUtils::GetInvalidStreamId(transport_version()) ||
       stream_id > highest_promised_stream_id_) {
     QuicSession::HandleFrameOnNonexistentOutgoingStream(stream_id);
   }
@@ -154,12 +154,12 @@ void QuicSimpleServerSession::HandleRstOnValidNonexistentStream(
     // Since PromisedStreamInfo are queued in sequence, the corresponding
     // index for it in promised_streams_ can be calculated.
     QuicStreamId next_stream_id = next_outgoing_unidirectional_stream_id();
-    if (VersionHasIetfQuicFrames(connection()->transport_version())) {
+    if (VersionHasIetfQuicFrames(transport_version())) {
       DCHECK(!QuicUtils::IsBidirectionalStreamId(frame.stream_id));
     }
     DCHECK_GE(frame.stream_id, next_stream_id);
     size_t index = (frame.stream_id - next_stream_id) /
-                   QuicUtils::StreamIdDelta(connection()->transport_version());
+                   QuicUtils::StreamIdDelta(transport_version());
     DCHECK_LE(index, promised_streams_.size());
     promised_streams_[index].is_cancelled = true;
     control_frame_manager().WriteOrBufferRstStream(frame.stream_id,
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_session_test.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_session_test.cc
index 6cc97ed7098..a4bab0f5380 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_session_test.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_session_test.cc
@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <memory>
+#include <utility>
 
 #include "net/third_party/quiche/src/quic/core/crypto/quic_crypto_server_config.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
@@ -16,7 +17,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
@@ -82,11 +82,10 @@ class MockQuicCryptoServerStream : public QuicCryptoServerStream {
       QuicCompressedCertsCache* compressed_certs_cache,
       QuicServerSessionBase* session,
       QuicCryptoServerStream::Helper* helper)
-      : QuicCryptoServerStream(
-            crypto_config,
-            compressed_certs_cache,
-            session,
-            helper) {}
+      : QuicCryptoServerStream(crypto_config,
+                               compressed_certs_cache,
+                               session,
+                               helper) {}
   MockQuicCryptoServerStream(const MockQuicCryptoServerStream&) = delete;
   MockQuicCryptoServerStream& operator=(const MockQuicCryptoServerStream&) =
       delete;
@@ -193,7 +192,7 @@ class QuicSimpleServerSessionTest
                        KeyExchangeSource::Default()),
         compressed_certs_cache_(
             QuicCompressedCertsCache::kQuicCompressedCertsCacheSize) {
-    SetQuicFlag(FLAGS_quic_supports_tls_handshake, true);
+    SetQuicReloadableFlag(quic_supports_tls_handshake, true);
     config_.SetMaxIncomingBidirectionalStreamsToSend(kMaxStreamsForTest);
     QuicConfigPeer::SetReceivedMaxIncomingBidirectionalStreams(
         &config_, kMaxStreamsForTest);
@@ -201,9 +200,15 @@ class QuicSimpleServerSessionTest
 
     config_.SetInitialStreamFlowControlWindowToSend(
         kInitialStreamFlowControlWindowForTest);
+    config_.SetInitialMaxStreamDataBytesIncomingBidirectionalToSend(
+        kInitialStreamFlowControlWindowForTest);
+    config_.SetInitialMaxStreamDataBytesOutgoingBidirectionalToSend(
+        kInitialStreamFlowControlWindowForTest);
+    config_.SetInitialMaxStreamDataBytesUnidirectionalToSend(
+        kInitialStreamFlowControlWindowForTest);
     config_.SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
-    if (VersionUsesQpack(GetParam().transport_version)) {
+    if (VersionUsesHttp3(GetParam().transport_version)) {
       QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
           &config_, kMaxStreamsForTest + 3);
     } else {
@@ -215,7 +220,7 @@ class QuicSimpleServerSessionTest
     connection_ = new StrictMock<MockQuicConnectionWithSendStreamData>(
         &helper_, &alarm_factory_, Perspective::IS_SERVER, supported_versions);
     connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
-    session_ = QuicMakeUnique<MockQuicSimpleServerSession>(
+    session_ = std::make_unique<MockQuicSimpleServerSession>(
         config_, connection_, &owner_, &stream_helper_, &crypto_config_,
         &compressed_certs_cache_, &memory_cache_backend_);
     MockClock clock;
@@ -476,7 +481,7 @@ TEST_P(QuicSimpleServerSessionTest, CreateOutgoingDynamicStreamUptoLimit) {
   EXPECT_EQ(1u, session_->GetNumOpenIncomingStreams());
   EXPECT_EQ(0u, session_->GetNumOpenOutgoingStreams());
 
-  if (!VersionUsesQpack(connection_->transport_version())) {
+  if (!VersionUsesHttp3(connection_->transport_version())) {
     session_->UnregisterStreamPriority(
         QuicUtils::GetHeadersStreamId(connection_->transport_version()),
         /*is_static=*/true);
@@ -488,7 +493,7 @@ TEST_P(QuicSimpleServerSessionTest, CreateOutgoingDynamicStreamUptoLimit) {
                                      session_.get(), &stream_helper_);
   crypto_stream->set_encryption_established(true);
   QuicSimpleServerSessionPeer::SetCryptoStream(session_.get(), crypto_stream);
-  if (!VersionUsesQpack(connection_->transport_version())) {
+  if (!VersionUsesHttp3(connection_->transport_version())) {
     session_->RegisterStreamPriority(
         QuicUtils::GetHeadersStreamId(connection_->transport_version()),
         /*is_static=*/true,
@@ -500,7 +505,7 @@ TEST_P(QuicSimpleServerSessionTest, CreateOutgoingDynamicStreamUptoLimit) {
     QuicSpdyStream* created_stream =
         QuicSimpleServerSessionPeer::CreateOutgoingUnidirectionalStream(
             session_.get());
-    if (VersionHasStreamType(connection_->transport_version())) {
+    if (VersionUsesHttp3(connection_->transport_version())) {
       EXPECT_EQ(GetNthServerInitiatedUnidirectionalId(i + 3),
                 created_stream->id());
     } else {
@@ -556,8 +561,21 @@ class QuicSimpleServerSessionServerPushTest
 
   QuicSimpleServerSessionServerPushTest() {
     // Reset stream level flow control window to be 32KB.
-    QuicConfigPeer::SetReceivedInitialStreamFlowControlWindow(
-        &config_, kStreamFlowControlWindowSize);
+    if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
+      if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
+        QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesUnidirectional(
+            &config_, kStreamFlowControlWindowSize);
+      } else {
+        // In this version, push streams are server-initiated bidirectional
+        // streams, which are outgoing since we are the server here.
+        QuicConfigPeer::
+            SetReceivedInitialMaxStreamDataBytesOutgoingBidirectional(
+                &config_, kStreamFlowControlWindowSize);
+      }
+    } else {
+      QuicConfigPeer::SetReceivedInitialStreamFlowControlWindow(
+          &config_, kStreamFlowControlWindowSize);
+    }
     // Reset connection level flow control window to be 1.5 MB which is large
     // enough that it won't block any stream to write before stream level flow
     // control blocks it.
@@ -567,7 +585,7 @@ class QuicSimpleServerSessionServerPushTest
     ParsedQuicVersionVector supported_versions = SupportedVersions(GetParam());
     connection_ = new StrictMock<MockQuicConnectionWithSendStreamData>(
         &helper_, &alarm_factory_, Perspective::IS_SERVER, supported_versions);
-    session_ = QuicMakeUnique<MockQuicSimpleServerSession>(
+    session_ = std::make_unique<MockQuicSimpleServerSession>(
         config_, connection_, &owner_, &stream_helper_, &crypto_config_,
         &compressed_certs_cache_, &memory_cache_backend_);
     session_->Initialize();
@@ -584,7 +602,7 @@ class QuicSimpleServerSessionServerPushTest
 
     visitor_ = QuicConnectionPeer::GetVisitor(connection_);
 
-    if (!VersionUsesQpack(connection_->transport_version())) {
+    if (!VersionUsesHttp3(connection_->transport_version())) {
       session_->UnregisterStreamPriority(
           QuicUtils::GetHeadersStreamId(connection_->transport_version()),
           /*is_static=*/true);
@@ -597,7 +615,7 @@ class QuicSimpleServerSessionServerPushTest
 
     crypto_stream->set_encryption_established(true);
     QuicSimpleServerSessionPeer::SetCryptoStream(session_.get(), crypto_stream);
-    if (!VersionUsesQpack(connection_->transport_version())) {
+    if (!VersionUsesHttp3(connection_->transport_version())) {
       session_->RegisterStreamPriority(
           QuicUtils::GetHeadersStreamId(connection_->transport_version()),
           /*is_static=*/true,
@@ -626,7 +644,7 @@ class QuicSimpleServerSessionServerPushTest
     QuicByteCount data_frame_header_length = 0;
     for (unsigned int i = 1; i <= num_resources; ++i) {
       QuicStreamId stream_id;
-      if (VersionHasStreamType(connection_->transport_version())) {
+      if (VersionUsesHttp3(connection_->transport_version())) {
         stream_id = GetNthServerInitiatedUnidirectionalId(i + 2);
       } else {
         stream_id = GetNthServerInitiatedUnidirectionalId(i - 1);
@@ -638,7 +656,7 @@ class QuicSimpleServerSessionServerPushTest
       std::string body(body_size, 'a');
       std::string data;
       data_frame_header_length = 0;
-      if (VersionHasDataFrameHeader(connection_->transport_version())) {
+      if (VersionUsesHttp3(connection_->transport_version())) {
         HttpEncoder encoder;
         std::unique_ptr<char[]> buffer;
         data_frame_header_length =
@@ -662,13 +680,13 @@ class QuicSimpleServerSessionServerPushTest
         // Since flow control window is smaller than response body, not the
         // whole body will be sent.
         QuicStreamOffset offset = 0;
-        if (VersionHasStreamType(connection_->transport_version())) {
+        if (VersionUsesHttp3(connection_->transport_version())) {
           EXPECT_CALL(*connection_,
                       SendStreamData(stream_id, 1, offset, NO_FIN));
           offset++;
         }
 
-        if (VersionUsesQpack(connection_->transport_version())) {
+        if (VersionUsesHttp3(connection_->transport_version())) {
           EXPECT_CALL(*connection_,
                       SendStreamData(stream_id, kHeadersFrameHeaderLength,
                                      offset, NO_FIN));
@@ -678,7 +696,7 @@ class QuicSimpleServerSessionServerPushTest
                                      offset, NO_FIN));
           offset += kHeadersFramePayloadLength;
         }
-        if (VersionHasDataFrameHeader(connection_->transport_version())) {
+        if (VersionUsesHttp3(connection_->transport_version())) {
           EXPECT_CALL(*connection_,
                       SendStreamData(stream_id, data_frame_header_length,
                                      offset, NO_FIN));
@@ -698,7 +716,7 @@ class QuicSimpleServerSessionServerPushTest
   }
 
   void MaybeConsumeHeadersStreamData() {
-    if (!VersionUsesQpack(connection_->transport_version())) {
+    if (!VersionUsesHttp3(connection_->transport_version())) {
       QuicStreamId headers_stream_id =
           QuicUtils::GetHeadersStreamId(connection_->transport_version());
       EXPECT_CALL(*connection_, SendStreamData(headers_stream_id, _, _, _))
@@ -716,7 +734,7 @@ INSTANTIATE_TEST_SUITE_P(Tests,
 // opened and send push response.
 TEST_P(QuicSimpleServerSessionServerPushTest, TestPromisePushResources) {
   MaybeConsumeHeadersStreamData();
-  session_->set_max_allowed_push_id(kMaxQuicStreamId);
+  session_->SetMaxAllowedPushId(kMaxQuicStreamId);
   size_t num_resources = kMaxStreamsForTest + 5;
   PromisePushResources(num_resources);
   EXPECT_EQ(kMaxStreamsForTest, session_->GetNumOpenOutgoingStreams());
@@ -727,11 +745,11 @@ TEST_P(QuicSimpleServerSessionServerPushTest, TestPromisePushResources) {
 TEST_P(QuicSimpleServerSessionServerPushTest,
        HandlePromisedPushRequestsAfterStreamDraining) {
   MaybeConsumeHeadersStreamData();
-  session_->set_max_allowed_push_id(kMaxQuicStreamId);
+  session_->SetMaxAllowedPushId(kMaxQuicStreamId);
   size_t num_resources = kMaxStreamsForTest + 1;
   QuicByteCount data_frame_header_length = PromisePushResources(num_resources);
   QuicStreamId next_out_going_stream_id;
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     next_out_going_stream_id =
         GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 3);
   } else {
@@ -742,12 +760,12 @@ TEST_P(QuicSimpleServerSessionServerPushTest,
   // After an open stream is marked draining, a new stream is expected to be
   // created and a response sent on the stream.
   QuicStreamOffset offset = 0;
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(next_out_going_stream_id, 1, offset, NO_FIN));
     offset++;
   }
-  if (VersionUsesQpack(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(next_out_going_stream_id,
                                kHeadersFrameHeaderLength, offset, NO_FIN));
@@ -757,7 +775,7 @@ TEST_P(QuicSimpleServerSessionServerPushTest,
                                kHeadersFramePayloadLength, offset, NO_FIN));
     offset += kHeadersFramePayloadLength;
   }
-  if (VersionHasDataFrameHeader(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(next_out_going_stream_id,
                                data_frame_header_length, offset, NO_FIN));
@@ -781,7 +799,7 @@ TEST_P(QuicSimpleServerSessionServerPushTest,
         QuicMaxStreamsFrame(0, num_resources + 3, /*unidirectional=*/true));
   }
 
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     session_->StreamDraining(GetNthServerInitiatedUnidirectionalId(3));
   } else {
     session_->StreamDraining(GetNthServerInitiatedUnidirectionalId(0));
@@ -796,7 +814,7 @@ TEST_P(QuicSimpleServerSessionServerPushTest,
 TEST_P(QuicSimpleServerSessionServerPushTest,
        ResetPromisedStreamToCancelServerPush) {
   MaybeConsumeHeadersStreamData();
-  session_->set_max_allowed_push_id(kMaxQuicStreamId);
+  session_->SetMaxAllowedPushId(kMaxQuicStreamId);
 
   // Having two extra resources to be send later. One of them will be reset, so
   // when opened stream become close, only one will become open.
@@ -812,7 +830,7 @@ TEST_P(QuicSimpleServerSessionServerPushTest,
 
   // Reset the last stream in the queue. It should be marked cancelled.
   QuicStreamId stream_got_reset;
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     stream_got_reset =
         GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 4);
   } else {
@@ -832,7 +850,7 @@ TEST_P(QuicSimpleServerSessionServerPushTest,
   // be created. But since one of them was marked cancelled due to RST frame,
   // only one queued resource will be sent out.
   QuicStreamId stream_not_reset;
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     stream_not_reset =
         GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 3);
   } else {
@@ -841,12 +859,12 @@ TEST_P(QuicSimpleServerSessionServerPushTest,
   }
   InSequence s;
   QuicStreamOffset offset = 0;
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(stream_not_reset, 1, offset, NO_FIN));
     offset++;
   }
-  if (VersionUsesQpack(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(stream_not_reset, kHeadersFrameHeaderLength,
                                offset, NO_FIN));
@@ -856,7 +874,7 @@ TEST_P(QuicSimpleServerSessionServerPushTest,
                                offset, NO_FIN));
     offset += kHeadersFramePayloadLength;
   }
-  if (VersionHasDataFrameHeader(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(stream_not_reset, data_frame_header_length,
                                offset, NO_FIN));
@@ -885,7 +903,7 @@ TEST_P(QuicSimpleServerSessionServerPushTest,
 TEST_P(QuicSimpleServerSessionServerPushTest,
        CloseStreamToHandleMorePromisedStream) {
   MaybeConsumeHeadersStreamData();
-  session_->set_max_allowed_push_id(kMaxQuicStreamId);
+  session_->SetMaxAllowedPushId(kMaxQuicStreamId);
   size_t num_resources = kMaxStreamsForTest + 1;
   if (VersionHasIetfQuicFrames(transport_version())) {
     // V99 will send out a stream-id-blocked frame when the we desired to exceed
@@ -896,7 +914,7 @@ TEST_P(QuicSimpleServerSessionServerPushTest,
   }
   QuicByteCount data_frame_header_length = PromisePushResources(num_resources);
   QuicStreamId stream_to_open;
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     stream_to_open =
         GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 3);
   } else {
@@ -914,12 +932,12 @@ TEST_P(QuicSimpleServerSessionServerPushTest,
                 OnStreamReset(stream_got_reset, QUIC_RST_ACKNOWLEDGEMENT));
   }
   QuicStreamOffset offset = 0;
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(stream_to_open, 1, offset, NO_FIN));
     offset++;
   }
-  if (VersionUsesQpack(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(stream_to_open, kHeadersFrameHeaderLength,
                                offset, NO_FIN));
@@ -929,7 +947,7 @@ TEST_P(QuicSimpleServerSessionServerPushTest,
                                offset, NO_FIN));
     offset += kHeadersFramePayloadLength;
   }
-  if (VersionHasDataFrameHeader(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(stream_to_open, data_frame_header_length, offset,
                                NO_FIN));
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_stream.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_stream.cc
index 26ea62afc8f..f821a5d373d 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_stream.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_stream.cc
@@ -29,6 +29,7 @@ QuicSimpleServerStream::QuicSimpleServerStream(
     QuicSimpleServerBackend* quic_simple_server_backend)
     : QuicSpdyServerStreamBase(id, session, type),
       content_length_(-1),
+      generate_bytes_length_(0),
       quic_simple_server_backend_(quic_simple_server_backend) {
   DCHECK(quic_simple_server_backend_);
 }
@@ -40,6 +41,7 @@ QuicSimpleServerStream::QuicSimpleServerStream(
     QuicSimpleServerBackend* quic_simple_server_backend)
     : QuicSpdyServerStreamBase(pending, session, type),
       content_length_(-1),
+      generate_bytes_length_(0),
       quic_simple_server_backend_(quic_simple_server_backend) {
   DCHECK(quic_simple_server_backend_);
 }
@@ -107,8 +109,8 @@ void QuicSimpleServerStream::OnBodyAvailable() {
 
 void QuicSimpleServerStream::PushResponse(
     SpdyHeaderBlock push_request_headers) {
-  if (QuicUtils::IsClientInitiatedStreamId(
-          session()->connection()->transport_version(), id())) {
+  if (QuicUtils::IsClientInitiatedStreamId(session()->transport_version(),
+                                           id())) {
     QUIC_BUG << "Client initiated stream shouldn't be used as promised stream.";
     return;
   }
@@ -220,8 +222,8 @@ void QuicSimpleServerStream::OnResponseBackendComplete(
     return;
   }
 
-  if (QuicUtils::IsServerInitiatedStreamId(
-          session()->connection()->transport_version(), id())) {
+  if (QuicUtils::IsServerInitiatedStreamId(session()->transport_version(),
+                                           id())) {
     // A server initiated stream is only used for a server push response,
     // and only 200 and 30X response codes are supported for server push.
     // This behavior mirrors the HTTP/2 implementation.
@@ -260,11 +262,46 @@ void QuicSimpleServerStream::OnResponseBackendComplete(
     return;
   }
 
+  if (response->response_type() == QuicBackendResponse::GENERATE_BYTES) {
+    QUIC_DVLOG(1) << "Stream " << id() << " sending a generate bytes response.";
+    std::string path = request_headers_[":path"].as_string().substr(1);
+    if (!QuicTextUtils::StringToUint64(path, &generate_bytes_length_)) {
+      QUIC_LOG(ERROR) << "Path is not a number.";
+      SendNotFoundResponse();
+      return;
+    }
+    SpdyHeaderBlock headers = response->headers().Clone();
+    headers["content-length"] =
+        QuicTextUtils::Uint64ToString(generate_bytes_length_);
+
+    WriteHeaders(std::move(headers), false, nullptr);
+
+    WriteGeneratedBytes();
+
+    return;
+  }
+
   QUIC_DVLOG(1) << "Stream " << id() << " sending response.";
   SendHeadersAndBodyAndTrailers(response->headers().Clone(), response->body(),
                                 response->trailers().Clone());
 }
 
+void QuicSimpleServerStream::OnCanWrite() {
+  QuicSpdyStream::OnCanWrite();
+  WriteGeneratedBytes();
+}
+
+void QuicSimpleServerStream::WriteGeneratedBytes() {
+  static size_t kChunkSize = 1024;
+  while (!HasBufferedData() && generate_bytes_length_ > 0) {
+    size_t len = std::min<size_t>(kChunkSize, generate_bytes_length_);
+    std::string data(len, 'a');
+    generate_bytes_length_ -= len;
+    bool fin = generate_bytes_length_ == 0;
+    WriteOrBufferBody(data, fin);
+  }
+}
+
 void QuicSimpleServerStream::SendNotFoundResponse() {
   QUIC_DVLOG(1) << "Stream " << id() << " sending not found response.";
   SpdyHeaderBlock headers;
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_stream.h b/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_stream.h
index ace15713a0d..594ca028536 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_stream.h
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_stream.h
@@ -38,6 +38,7 @@ class QuicSimpleServerStream : public QuicSpdyServerStreamBase,
   void OnTrailingHeadersComplete(bool fin,
                                  size_t frame_len,
                                  const QuicHeaderList& header_list) override;
+  void OnCanWrite() override;
 
   // QuicStream implementation called by the sequencer when there is
   // data (or a FIN) to be read.
@@ -88,12 +89,17 @@ class QuicSimpleServerStream : public QuicSpdyServerStreamBase,
 
   const std::string& body() { return body_; }
 
+  // Writes the body bytes for the GENERATE_BYTES response type.
+  void WriteGeneratedBytes();
+
   // The parsed headers received from the client.
   spdy::SpdyHeaderBlock request_headers_;
   int64_t content_length_;
   std::string body_;
 
  private:
+  uint64_t generate_bytes_length_;
+
   QuicSimpleServerBackend* quic_simple_server_backend_;  // Not owned.
 };
 
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_stream_test.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_stream_test.cc
index 55ea842e69f..783dba0c55c 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_stream_test.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_simple_server_stream_test.cc
@@ -16,6 +16,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h"
+#include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_session_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_stream_peer.h"
@@ -28,9 +29,7 @@ using testing::_;
 using testing::AnyNumber;
 using testing::InSequence;
 using testing::Invoke;
-using testing::Return;
 using testing::StrictMock;
-using testing::ValuesIn;
 
 namespace quic {
 namespace test {
@@ -211,6 +210,17 @@ class QuicSimpleServerStreamTest : public QuicTestWithParam<ParsedQuicVersion> {
         &session_, BIDIRECTIONAL, &memory_cache_backend_);
     // Register stream_ in dynamic_stream_map_ and pass ownership to session_.
     session_.ActivateStream(QuicWrapUnique(stream_));
+    QuicConfigPeer::SetReceivedInitialSessionFlowControlWindow(
+        session_.config(), kMinimumFlowControlSendWindow);
+    QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesUnidirectional(
+        session_.config(), kMinimumFlowControlSendWindow);
+    QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesIncomingBidirectional(
+        session_.config(), kMinimumFlowControlSendWindow);
+    QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesOutgoingBidirectional(
+        session_.config(), kMinimumFlowControlSendWindow);
+    QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
+        session_.config(), 10);
+    session_.OnConfigNegotiated();
     connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
   }
 
@@ -220,8 +230,8 @@ class QuicSimpleServerStreamTest : public QuicTestWithParam<ParsedQuicVersion> {
     return (*stream_->mutable_headers())[key].as_string();
   }
 
-  bool HasFrameHeader() const {
-    return VersionHasDataFrameHeader(connection_->transport_version());
+  bool UsesHttp3() const {
+    return VersionUsesHttp3(connection_->transport_version());
   }
 
   spdy::SpdyHeaderBlock response_headers_;
@@ -243,7 +253,8 @@ class QuicSimpleServerStreamTest : public QuicTestWithParam<ParsedQuicVersion> {
 
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicSimpleServerStreamTest,
-                         ValuesIn(AllSupportedVersions()));
+                         ::testing::ValuesIn(AllSupportedVersions()),
+                         ::testing::PrintToStringParamName());
 
 TEST_P(QuicSimpleServerStreamTest, TestFraming) {
   EXPECT_CALL(session_, WritevData(_, _, _, _, _))
@@ -253,7 +264,7 @@ TEST_P(QuicSimpleServerStreamTest, TestFraming) {
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(body_.length(), &buffer);
   std::string header = std::string(buffer.get(), header_length);
-  std::string data = HasFrameHeader() ? header + body_ : body_;
+  std::string data = UsesHttp3() ? header + body_ : body_;
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
   EXPECT_EQ("11", StreamHeadersValue("content-length"));
@@ -271,7 +282,7 @@ TEST_P(QuicSimpleServerStreamTest, TestFramingOnePacket) {
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(body_.length(), &buffer);
   std::string header = std::string(buffer.get(), header_length);
-  std::string data = HasFrameHeader() ? header + body_ : body_;
+  std::string data = UsesHttp3() ? header + body_ : body_;
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
   EXPECT_EQ("11", StreamHeadersValue("content-length"));
@@ -295,17 +306,12 @@ TEST_P(QuicSimpleServerStreamTest, SendQuicRstStreamNoErrorInStopReading) {
 }
 
 TEST_P(QuicSimpleServerStreamTest, TestFramingExtraData) {
-  if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
-    // TODO(nharper, b/112643533): Figure out why this test fails when TLS is
-    // enabled and fix it.
-    return;
-  }
   InSequence seq;
   std::string large_body = "hello world!!!!!!";
 
   // We'll automatically write out an error (headers + body)
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(session_, WritevData(_, _, kDataFrameHeaderLength, _, NO_FIN));
   }
   EXPECT_CALL(session_, WritevData(_, _, kErrorLength, _, FIN));
@@ -317,7 +323,7 @@ TEST_P(QuicSimpleServerStreamTest, TestFramingExtraData) {
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(body_.length(), &buffer);
   std::string header = std::string(buffer.get(), header_length);
-  std::string data = HasFrameHeader() ? header + body_ : body_;
+  std::string data = UsesHttp3() ? header + body_ : body_;
 
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
@@ -326,7 +332,7 @@ TEST_P(QuicSimpleServerStreamTest, TestFramingExtraData) {
   header_length =
       encoder_.SerializeDataFrameHeader(large_body.length(), &buffer);
   header = std::string(buffer.get(), header_length);
-  std::string data2 = HasFrameHeader() ? header + large_body : large_body;
+  std::string data2 = UsesHttp3() ? header + large_body : large_body;
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), /*fin=*/true, data.size(), data2));
   EXPECT_EQ("11", StreamHeadersValue("content-length"));
@@ -335,11 +341,6 @@ TEST_P(QuicSimpleServerStreamTest, TestFramingExtraData) {
 }
 
 TEST_P(QuicSimpleServerStreamTest, SendResponseWithIllegalResponseStatus) {
-  if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
-    // TODO(nharper, b/112643533): Figure out why this test fails when TLS is
-    // enabled and fix it.
-    return;
-  }
   // Send an illegal response with response status not supported by HTTP/2.
   spdy::SpdyHeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = "/bar";
@@ -363,7 +364,7 @@ TEST_P(QuicSimpleServerStreamTest, SendResponseWithIllegalResponseStatus) {
 
   InSequence s;
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(session_, WritevData(_, _, header_length, _, NO_FIN));
   }
   EXPECT_CALL(session_, WritevData(_, _, kErrorLength, _, FIN));
@@ -374,11 +375,6 @@ TEST_P(QuicSimpleServerStreamTest, SendResponseWithIllegalResponseStatus) {
 }
 
 TEST_P(QuicSimpleServerStreamTest, SendResponseWithIllegalResponseStatus2) {
-  if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
-    // TODO(nharper, b/112643533): Figure out why this test fails when TLS is
-    // enabled and fix it.
-    return;
-  }
   // Send an illegal response with response status not supported by HTTP/2.
   spdy::SpdyHeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = "/bar";
@@ -403,7 +399,7 @@ TEST_P(QuicSimpleServerStreamTest, SendResponseWithIllegalResponseStatus2) {
 
   InSequence s;
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(session_, WritevData(_, _, header_length, _, NO_FIN));
   }
   EXPECT_CALL(session_, WritevData(_, _, kErrorLength, _, FIN));
@@ -445,11 +441,6 @@ TEST_P(QuicSimpleServerStreamTest, SendPushResponseWith404Response) {
 }
 
 TEST_P(QuicSimpleServerStreamTest, SendResponseWithValidHeaders) {
-  if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
-    // TODO(nharper, b/112643533): Figure out why this test fails when TLS is
-    // enabled and fix it.
-    return;
-  }
   // Add a request and response with valid headers.
   spdy::SpdyHeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = "/bar";
@@ -472,7 +463,7 @@ TEST_P(QuicSimpleServerStreamTest, SendResponseWithValidHeaders) {
 
   InSequence s;
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(session_, WritevData(_, _, header_length, _, NO_FIN));
   }
   EXPECT_CALL(session_, WritevData(_, _, body.length(), _, FIN));
@@ -483,11 +474,6 @@ TEST_P(QuicSimpleServerStreamTest, SendResponseWithValidHeaders) {
 }
 
 TEST_P(QuicSimpleServerStreamTest, SendResponseWithPushResources) {
-  if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
-    // TODO(nharper, b/112643533): Figure out why this test fails when TLS is
-    // enabled and fix it.
-    return;
-  }
   // Tests that if a response has push resources to be send, SendResponse() will
   // call PromisePushResources() to handle these resources.
 
@@ -520,7 +506,7 @@ TEST_P(QuicSimpleServerStreamTest, SendResponseWithPushResources) {
                                 connection_->transport_version(), 0),
                             _, _));
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(session_, WritevData(_, _, header_length, _, NO_FIN));
   }
   EXPECT_CALL(session_, WritevData(_, _, body.length(), _, FIN));
@@ -542,11 +528,6 @@ TEST_P(QuicSimpleServerStreamTest, PushResponseOnClientInitiatedStream) {
 }
 
 TEST_P(QuicSimpleServerStreamTest, PushResponseOnServerInitiatedStream) {
-  if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
-    // TODO(nharper, b/112643533): Figure out why this test fails when TLS is
-    // enabled and fix it.
-    return;
-  }
   // Tests that PushResponse() should take the given headers as request headers
   // and fetch response from cache, and send it out.
 
@@ -583,7 +564,7 @@ TEST_P(QuicSimpleServerStreamTest, PushResponseOnServerInitiatedStream) {
   InSequence s;
   EXPECT_CALL(*server_initiated_stream, WriteHeadersMock(false));
 
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(session_, WritevData(_, kServerInitiatedStreamId, header_length,
                                      _, NO_FIN));
   }
@@ -595,18 +576,13 @@ TEST_P(QuicSimpleServerStreamTest, PushResponseOnServerInitiatedStream) {
 }
 
 TEST_P(QuicSimpleServerStreamTest, TestSendErrorResponse) {
-  if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
-    // TODO(nharper, b/112643533): Figure out why this test fails when TLS is
-    // enabled and fix it.
-    return;
-  }
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
 
   stream_->set_fin_received(true);
 
   InSequence s;
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(session_, WritevData(_, _, kDataFrameHeaderLength, _, NO_FIN));
   }
   EXPECT_CALL(session_, WritevData(_, _, kErrorLength, _, FIN));
@@ -617,11 +593,6 @@ TEST_P(QuicSimpleServerStreamTest, TestSendErrorResponse) {
 }
 
 TEST_P(QuicSimpleServerStreamTest, InvalidMultipleContentLength) {
-  if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
-    // TODO(nharper, b/112643533): Figure out why this test fails when TLS is
-    // enabled and fix it.
-    return;
-  }
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
 
   spdy::SpdyHeaderBlock request_headers;
@@ -639,11 +610,6 @@ TEST_P(QuicSimpleServerStreamTest, InvalidMultipleContentLength) {
 }
 
 TEST_P(QuicSimpleServerStreamTest, InvalidLeadingNullContentLength) {
-  if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
-    // TODO(nharper, b/112643533): Figure out why this test fails when TLS is
-    // enabled and fix it.
-    return;
-  }
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
 
   spdy::SpdyHeaderBlock request_headers;
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_spdy_client_base.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_spdy_client_base.cc
index 09a1998a802..3cd4cbdf4cf 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_spdy_client_base.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_spdy_client_base.cc
@@ -4,12 +4,13 @@
 
 #include "net/third_party/quiche/src/quic/tools/quic_spdy_client_base.h"
 
+#include <utility>
+
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
 #include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
 #include "net/third_party/quiche/src/quic/core/quic_server_id.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
 
 using spdy::SpdyHeaderBlock;
@@ -46,7 +47,8 @@ QuicSpdyClientBase::QuicSpdyClientBase(
                      std::move(proof_verifier)),
       store_response_(false),
       latest_response_code_(-1),
-      max_allowed_push_id_(0) {}
+      max_allowed_push_id_(0),
+      disable_qpack_dynamic_table_(false) {}
 
 QuicSpdyClientBase::~QuicSpdyClientBase() {
   // We own the push promise index. We need to explicitly kill
@@ -59,10 +61,14 @@ QuicSpdyClientSession* QuicSpdyClientBase::client_session() {
 }
 
 void QuicSpdyClientBase::InitializeSession() {
+  if (disable_qpack_dynamic_table_) {
+    client_session()->set_qpack_maximum_dynamic_table_capacity(0);
+    client_session()->set_qpack_maximum_blocked_streams(0);
+  }
   client_session()->Initialize();
   client_session()->CryptoConnect();
   if (max_allowed_push_id_ > 0) {
-    client_session()->set_max_allowed_push_id(max_allowed_push_id_);
+    client_session()->SetMaxAllowedPushId(max_allowed_push_id_);
   }
 }
 
@@ -99,7 +105,7 @@ void QuicSpdyClientBase::OnClose(QuicSpdyStream* stream) {
 std::unique_ptr<QuicSession> QuicSpdyClientBase::CreateQuicClientSession(
     const quic::ParsedQuicVersionVector& supported_versions,
     QuicConnection* connection) {
-  return QuicMakeUnique<QuicSpdyClientSession>(
+  return std::make_unique<QuicSpdyClientSession>(
       *config(), supported_versions, connection, server_id(), crypto_config(),
       &push_promise_index_);
 }
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_spdy_client_base.h b/chromium/net/third_party/quiche/src/quic/tools/quic_spdy_client_base.h
index b04ba662122..2a1267fa8be 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_spdy_client_base.h
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_spdy_client_base.h
@@ -137,7 +137,11 @@ class QuicSpdyClientBase : public QuicClientBase,
   bool drop_response_body() const { return drop_response_body_; }
 
   // Set the max promise id for the client session.
-  void set_max_allowed_push_id(QuicStreamId max) { max_allowed_push_id_ = max; }
+  void SetMaxAllowedPushId(QuicStreamId max) { max_allowed_push_id_ = max; }
+
+  // Disables the use of the QPACK dynamic table and of blocked streams.
+  // Must be called before InitializeSession().
+  void disable_qpack_dynamic_table() { disable_qpack_dynamic_table_ = true; }
 
  protected:
   int GetNumSentClientHellosFromSession() override;
@@ -215,6 +219,8 @@ class QuicSpdyClientBase : public QuicClientBase,
 
   // The max promise id to set on the client session when created.
   QuicStreamId max_allowed_push_id_;
+
+  bool disable_qpack_dynamic_table_;
 };
 
 }  // namespace quic
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_toy_client.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_toy_client.cc
index 09e7a50d571..eee4e6132d7 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_toy_client.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_toy_client.cc
@@ -45,6 +45,7 @@
 #include <iostream>
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
@@ -52,7 +53,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_default_proof_providers.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
@@ -161,6 +161,12 @@ DEFINE_QUIC_COMMAND_LINE_FLAG(
     false,
     "If true, drop response body immediately after it is received.");
 
+DEFINE_QUIC_COMMAND_LINE_FLAG(
+    bool,
+    disable_port_changes,
+    false,
+    "If true, do not change local port after each request.");
+
 namespace quic {
 
 QuicToyClient::QuicToyClient(ClientFactory* client_factory)
@@ -189,7 +195,7 @@ int QuicToyClient::SendRequestsAndPrintResponses(
   } else if (!quic_version_string.empty()) {
     if (quic_version_string[0] == 'T') {
       // ParseQuicVersionString checks quic_supports_tls_handshake.
-      SetQuicFlag(FLAGS_quic_supports_tls_handshake, true);
+      SetQuicReloadableFlag(quic_supports_tls_handshake, true);
     }
     quic::ParsedQuicVersion parsed_quic_version =
         quic::ParseQuicVersionString(quic_version_string);
@@ -209,7 +215,7 @@ int QuicToyClient::SendRequestsAndPrintResponses(
   const int32_t num_requests(GetQuicFlag(FLAGS_num_requests));
   std::unique_ptr<quic::ProofVerifier> proof_verifier;
   if (GetQuicFlag(FLAGS_disable_certificate_verification)) {
-    proof_verifier = quic::QuicMakeUnique<FakeProofVerifier>();
+    proof_verifier = std::make_unique<FakeProofVerifier>();
   } else {
     proof_verifier = quic::CreateDefaultProofVerifier(url.host());
   }
@@ -218,6 +224,11 @@ int QuicToyClient::SendRequestsAndPrintResponses(
   std::unique_ptr<QuicSpdyClientBase> client = client_factory_->CreateClient(
       url.host(), host, port, versions, std::move(proof_verifier));
 
+  if (client == nullptr) {
+    std::cerr << "Failed to create client." << std::endl;
+    return 1;
+  }
+
   int32_t initial_mtu = GetQuicFlag(FLAGS_initial_mtu);
   client->set_initial_max_packet_length(
       initial_mtu != 0 ? initial_mtu : quic::kDefaultMaxPacketSize);
@@ -226,6 +237,10 @@ int QuicToyClient::SendRequestsAndPrintResponses(
     std::cerr << "Failed to initialize client." << std::endl;
     return 1;
   }
+  client->client_session()->set_qpack_maximum_dynamic_table_capacity(
+      kDefaultQpackMaxDynamicTableCapacity);
+  client->client_session()->set_qpack_maximum_blocked_streams(
+      kDefaultMaximumBlockedStreams);
   if (!client->Connect()) {
     quic::QuicErrorCode error = client->session()->error();
     if (error == quic::QUIC_INVALID_VERSION) {
@@ -338,7 +353,7 @@ int QuicToyClient::SendRequestsAndPrintResponses(
     }
 
     // Change the ephemeral port if there are more requests to do.
-    if (i + 1 < num_requests) {
+    if (!GetQuicFlag(FLAGS_disable_port_changes) && i + 1 < num_requests) {
       if (!client->ChangeEphemeralPort()) {
         std::cerr << "Failed to change ephemeral port." << std::endl;
         return 1;
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_toy_server.cc b/chromium/net/third_party/quiche/src/quic/tools/quic_toy_server.cc
index 9fb15eb87e5..fdb1bb6ce78 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_toy_server.cc
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_toy_server.cc
@@ -4,12 +4,12 @@
 
 #include "net/third_party/quiche/src/quic/tools/quic_toy_server.h"
 
+#include <utility>
 #include <vector>
 
 #include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_default_proof_providers.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
 #include "net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.h"
 
@@ -26,6 +26,13 @@ DEFINE_QUIC_COMMAND_LINE_FLAG(
     "construction to seed the cache. Cache directory can be "
     "generated using `wget -p --save-headers <url>`");
 
+DEFINE_QUIC_COMMAND_LINE_FLAG(
+    bool,
+    generate_dynamic_responses,
+    false,
+    "If true, then URLs which have a numeric path will send a dynamically "
+    "generated response of that many bytes.");
+
 DEFINE_QUIC_COMMAND_LINE_FLAG(bool,
                               quic_ietf_draft,
                               false,
@@ -36,7 +43,10 @@ namespace quic {
 
 std::unique_ptr<quic::QuicSimpleServerBackend>
 QuicToyServer::MemoryCacheBackendFactory::CreateBackend() {
-  auto memory_cache_backend = QuicMakeUnique<QuicMemoryCacheBackend>();
+  auto memory_cache_backend = std::make_unique<QuicMemoryCacheBackend>();
+  if (GetQuicFlag(FLAGS_generate_dynamic_responses)) {
+    memory_cache_backend->GenerateDynamicResponses();
+  }
   if (!GetQuicFlag(FLAGS_quic_response_cache_dir).empty()) {
     memory_cache_backend->InitializeBackend(
         GetQuicFlag(FLAGS_quic_response_cache_dir));
@@ -49,15 +59,19 @@ QuicToyServer::QuicToyServer(BackendFactory* backend_factory,
     : backend_factory_(backend_factory), server_factory_(server_factory) {}
 
 int QuicToyServer::Start() {
+  ParsedQuicVersionVector supported_versions;
   if (GetQuicFlag(FLAGS_quic_ietf_draft)) {
     QuicVersionInitializeSupportForIetfDraft();
-    quic::QuicEnableVersion(
-        quic::ParsedQuicVersion(quic::PROTOCOL_TLS1_3, quic::QUIC_VERSION_99));
+    ParsedQuicVersion version(PROTOCOL_TLS1_3, QUIC_VERSION_99);
+    QuicEnableVersion(version);
+    supported_versions = {version};
+  } else {
+    supported_versions = AllSupportedVersions();
   }
   auto proof_source = quic::CreateDefaultProofSource();
   auto backend = backend_factory_->CreateBackend();
-  auto server =
-      server_factory_->CreateServer(backend.get(), std::move(proof_source));
+  auto server = server_factory_->CreateServer(
+      backend.get(), std::move(proof_source), supported_versions);
 
   if (!server->CreateUDPSocketAndListen(quic::QuicSocketAddress(
           quic::QuicIpAddress::Any6(), GetQuicFlag(FLAGS_port)))) {
diff --git a/chromium/net/third_party/quiche/src/quic/tools/quic_toy_server.h b/chromium/net/third_party/quiche/src/quic/tools/quic_toy_server.h
index 6c5c486c493..6168b3f038d 100644
--- a/chromium/net/third_party/quiche/src/quic/tools/quic_toy_server.h
+++ b/chromium/net/third_party/quiche/src/quic/tools/quic_toy_server.h
@@ -24,7 +24,8 @@ class QuicToyServer {
     // responses, and |proof_source| for certificates.
     virtual std::unique_ptr<QuicSpdyServerBase> CreateServer(
         QuicSimpleServerBackend* backend,
-        std::unique_ptr<ProofSource> proof_source) = 0;
+        std::unique_ptr<ProofSource> proof_source,
+        const ParsedQuicVersionVector& supported_versions) = 0;
   };
 
   // A facotry for creating QuicSimpleServerBackend instances.