@fails-components/webtransport 0.0.1-rc.0 → 0.0.1-rc.1

package/third_party/quiche/quiche/quic/test_tools/simulator/quic_endpoint_test.cc

@@ -28,7 +28,7 @@ const QuicByteCount kDefaultBdp = kDefaultBandwidth * kDefaultPropagationDelay;
 
 // A simple test harness where all hosts are connected to a switch with
 // identical links.
-class QuicEndpointTest : public QuicTest {
+class QuicEndpointTest : public quic::test::QuicTest {
  public:
   QuicEndpointTest()
       : simulator_(), switch_(&simulator_, "Switch", 8, kDefaultBdp * 2) {}

package/third_party/quiche/quiche/quic/test_tools/simulator/simulator_test.cc

@@ -47,7 +47,7 @@ class Counter : public Actor {
   QuicTime::Delta period_;
 };
 
-class SimulatorTest : public QuicTest {};
+class SimulatorTest : public quic::test::QuicTest {};
 
 // Test that the basic event handling works, and that Actors can be created and
 // destroyed mid-simulation.

package/third_party/quiche/quiche/quic/test_tools/test_ticket_crypter.cc

@@ -55,7 +55,7 @@ std::vector<uint8_t> TestTicketCrypter::Decrypt(absl::string_view in) {
 
 void TestTicketCrypter::Decrypt(
     absl::string_view in,
-    std::unique_ptr<ProofSource::DecryptCallback> callback) {
+    std::shared_ptr<ProofSource::DecryptCallback> callback) {
   auto decrypted_ticket = Decrypt(in);
   if (run_async_) {
     pending_callbacks_.push_back({std::move(callback), decrypted_ticket});

package/third_party/quiche/quiche/quic/test_tools/test_ticket_crypter.h

@@ -22,7 +22,7 @@ class TestTicketCrypter : public ProofSource::TicketCrypter {
   std::vector<uint8_t> Encrypt(absl::string_view in,
                                absl::string_view encryption_key) override;
   void Decrypt(absl::string_view in,
-               std::unique_ptr<ProofSource::DecryptCallback> callback) override;
+               std::shared_ptr<ProofSource::DecryptCallback> callback) override;
 
   void SetRunCallbacksAsync(bool run_async);
   size_t NumPendingCallbacks();
@@ -36,7 +36,7 @@ class TestTicketCrypter : public ProofSource::TicketCrypter {
   std::vector<uint8_t> Decrypt(absl::string_view in);
 
   struct PendingCallback {
-    std::unique_ptr<ProofSource::DecryptCallback> callback;
+    std::shared_ptr<ProofSource::DecryptCallback> callback;
     std::vector<uint8_t> decrypted_ticket;
   };
 

package/third_party/quiche/quiche/quic/tools/quic_client_interop_test_bin.cc

@@ -395,9 +395,9 @@ int main(int argc, char* argv[]) {
     quiche::QuichePrintCommandLineFlagHelp(usage);
     exit(1);
   }
-  std::string dns_host = GetQuicFlag(FLAGS_host);
+  std::string dns_host = quiche::GetQuicheCommandLineFlag(FLAGS_host);
   std::string url_host = "";
-  int port = GetQuicFlag(FLAGS_port);
+  int port = quiche::GetQuicheCommandLineFlag(FLAGS_port);
 
   if (!args.empty()) {
     quic::QuicUrl url(args[0], "https");
@@ -423,7 +423,8 @@ int main(int argc, char* argv[]) {
   // Pick QUIC version to use.
   quic::QuicVersionInitializeSupportForIetfDraft();
   quic::ParsedQuicVersion version = quic::UnsupportedQuicVersion();
-  std::string quic_version_string = GetQuicFlag(FLAGS_quic_version);
+  std::string quic_version_string =
+      quiche::GetQuicheCommandLineFlag(FLAGS_quic_version);
   if (!quic_version_string.empty()) {
     version = quic::ParseQuicVersionString(quic_version_string);
   } else {

package/third_party/quiche/quiche/quic/tools/quic_memory_cache_backend_test.cc

@@ -31,7 +31,9 @@ class QuicMemoryCacheBackendTest : public QuicTest {
     (*headers)[":scheme"] = "https";
   }
 
-  std::string CacheDirectory() { return QuicheGetTestMemoryCachePath(); }
+  std::string CacheDirectory() {
+    return quiche::test::QuicheGetTestMemoryCachePath();
+  }
 
   QuicMemoryCacheBackend cache_;
 };
@@ -96,36 +98,6 @@ TEST_F(QuicMemoryCacheBackendTest, MAYBE_ReadsCacheDir) {
   EXPECT_LT(0U, response->body().length());
 }
 
-// TODO(crbug.com/1249712) This test is failing on iOS.
-#if defined(OS_IOS)
-#define MAYBE_ReadsCacheDirWithServerPushResource \
-  DISABLED_ReadsCacheDirWithServerPushResource
-#else
-#define MAYBE_ReadsCacheDirWithServerPushResource \
-  ReadsCacheDirWithServerPushResource
-#endif
-TEST_F(QuicMemoryCacheBackendTest, MAYBE_ReadsCacheDirWithServerPushResource) {
-  cache_.InitializeBackend(CacheDirectory() + "_with_push");
-  std::list<ServerPushInfo> resources =
-      cache_.GetServerPushResources("test.example.com/");
-  ASSERT_EQ(1UL, resources.size());
-}
-
-// TODO(crbug.com/1249712) This test is failing on iOS.
-#if defined(OS_IOS)
-#define MAYBE_ReadsCacheDirWithServerPushResources \
-  DISABLED_ReadsCacheDirWithServerPushResources
-#else
-#define MAYBE_ReadsCacheDirWithServerPushResources \
-  ReadsCacheDirWithServerPushResources
-#endif
-TEST_F(QuicMemoryCacheBackendTest, MAYBE_ReadsCacheDirWithServerPushResources) {
-  cache_.InitializeBackend(CacheDirectory() + "_with_push");
-  std::list<ServerPushInfo> resources =
-      cache_.GetServerPushResources("test.example.com/index2.html");
-  ASSERT_EQ(2UL, resources.size());
-}
-
 // TODO(crbug.com/1249712) This test is failing on iOS.
 #if defined(OS_IOS)
 #define MAYBE_UsesOriginalUrl DISABLED_UsesOriginalUrl

package/third_party/quiche/quiche/quic/tools/quic_packet_printer_bin.cc

@@ -271,8 +271,8 @@ int main(int argc, char* argv[]) {
   quic::QuicTime start(quic::QuicTime::Zero());
   quic::QuicFramer framer(versions, start, perspective,
                           quic::kQuicDefaultConnectionIdLength);
-  const quic::ParsedQuicVersion& version =
-      quic::ParseQuicVersionString(GetQuicFlag(FLAGS_quic_version));
+  const quic::ParsedQuicVersion& version = quic::ParseQuicVersionString(
+      quiche::GetQuicheCommandLineFlag(FLAGS_quic_version));
   if (version != quic::ParsedQuicVersion::Unsupported()) {
     framer.set_version(version);
   }

package/third_party/quiche/quiche/quic/tools/quic_simple_server_session.h

@@ -97,7 +97,7 @@ class QuicSimpleServerSession : public QuicServerSessionBase {
   }
   HttpDatagramSupport LocalHttpDatagramSupport() override {
     if (ShouldNegotiateWebTransport()) {
-      return HttpDatagramSupport::kDraft00And04;
+      return HttpDatagramSupport::kDraft04;
     }
     return QuicServerSessionBase::LocalHttpDatagramSupport();
   }

package/third_party/quiche/quiche/quic/tools/quic_simple_server_session_test.cc

@@ -179,7 +179,7 @@ class MockQuicSimpleServerSession : public QuicSimpleServerSession {
                const spdy::Http2HeaderBlock& headers),
               ());
 
-  MOCK_METHOD(void, SendBlocked, (QuicStreamId), (override));
+  MOCK_METHOD(void, SendBlocked, (QuicStreamId, QuicStreamOffset), (override));
   MOCK_METHOD(bool, WriteControlFrame,
               (const QuicFrame& frame, TransmissionType type), (override));
 };

package/third_party/quiche/quiche/quic/tools/quic_toy_client.cc

@@ -230,18 +230,18 @@ QuicToyClient::QuicToyClient(ClientFactory* client_factory)
 int QuicToyClient::SendRequestsAndPrintResponses(
     std::vector<std::string> urls) {
   QuicUrl url(urls[0], "https");
-  std::string host = GetQuicFlag(FLAGS_host);
+  std::string host = quiche::GetQuicheCommandLineFlag(FLAGS_host);
   if (host.empty()) {
     host = url.host();
   }
-  int port = GetQuicFlag(FLAGS_port);
+  int port = quiche::GetQuicheCommandLineFlag(FLAGS_port);
   if (port == 0) {
     port = url.port();
   }
 
   quic::ParsedQuicVersionVector versions = quic::CurrentSupportedVersions();
 
-  if (GetQuicFlag(FLAGS_quic_ietf_draft)) {
+  if (quiche::GetQuicheCommandLineFlag(FLAGS_quic_ietf_draft)) {
     quic::QuicVersionInitializeSupportForIetfDraft();
     versions = {};
     for (const ParsedQuicVersion& version : AllSupportedVersions()) {
@@ -252,7 +252,8 @@ int QuicToyClient::SendRequestsAndPrintResponses(
     }
   }
 
-  std::string quic_version_string = GetQuicFlag(FLAGS_quic_version);
+  std::string quic_version_string =
+      quiche::GetQuicheCommandLineFlag(FLAGS_quic_version);
   if (!quic_version_string.empty()) {
     versions = quic::ParseQuicVersionVectorString(quic_version_string);
   }
@@ -266,36 +267,40 @@ int QuicToyClient::SendRequestsAndPrintResponses(
     quic::QuicEnableVersion(version);
   }
 
-  if (GetQuicFlag(FLAGS_force_version_negotiation)) {
+  if (quiche::GetQuicheCommandLineFlag(FLAGS_force_version_negotiation)) {
     versions.insert(versions.begin(),
                     quic::QuicVersionReservedForNegotiation());
   }
 
-  const int32_t num_requests(GetQuicFlag(FLAGS_num_requests));
+  const int32_t num_requests(
+      quiche::GetQuicheCommandLineFlag(FLAGS_num_requests));
   std::unique_ptr<quic::ProofVerifier> proof_verifier;
-  if (GetQuicFlag(FLAGS_disable_certificate_verification)) {
+  if (quiche::GetQuicheCommandLineFlag(
+          FLAGS_disable_certificate_verification)) {
     proof_verifier = std::make_unique<FakeProofVerifier>();
   } else {
     proof_verifier = quic::CreateDefaultProofVerifier(url.host());
   }
   std::unique_ptr<quic::SessionCache> session_cache;
-  if (num_requests > 1 && GetQuicFlag(FLAGS_one_connection_per_request)) {
+  if (num_requests > 1 &&
+      quiche::GetQuicheCommandLineFlag(FLAGS_one_connection_per_request)) {
     session_cache = std::make_unique<QuicClientSessionCache>();
   }
 
   QuicConfig config;
-  std::string connection_options_string = GetQuicFlag(FLAGS_connection_options);
+  std::string connection_options_string =
+      quiche::GetQuicheCommandLineFlag(FLAGS_connection_options);
   if (!connection_options_string.empty()) {
     config.SetConnectionOptionsToSend(
         ParseQuicTagVector(connection_options_string));
   }
   std::string client_connection_options_string =
-      GetQuicFlag(FLAGS_client_connection_options);
+      quiche::GetQuicheCommandLineFlag(FLAGS_client_connection_options);
   if (!client_connection_options_string.empty()) {
     config.SetClientConnectionOptions(
         ParseQuicTagVector(client_connection_options_string));
   }
-  if (GetQuicFlag(FLAGS_multi_packet_chlo)) {
+  if (quiche::GetQuicheCommandLineFlag(FLAGS_multi_packet_chlo)) {
     // Make the ClientHello span multiple packets by adding a custom transport
     // parameter.
     constexpr auto kCustomParameter =
@@ -304,13 +309,16 @@ int QuicToyClient::SendRequestsAndPrintResponses(
     config.custom_transport_parameters_to_send()[kCustomParameter] =
         custom_value;
   }
-  config.set_max_time_before_crypto_handshake(QuicTime::Delta::FromMilliseconds(
-      GetQuicFlag(FLAGS_max_time_before_crypto_handshake_ms)));
+  config.set_max_time_before_crypto_handshake(
+      QuicTime::Delta::FromMilliseconds(quiche::GetQuicheCommandLineFlag(
+          FLAGS_max_time_before_crypto_handshake_ms)));
 
   int address_family_for_lookup = AF_UNSPEC;
-  if (GetQuicFlag(FLAGS_ip_version_for_host_lookup) == "4") {
+  if (quiche::GetQuicheCommandLineFlag(FLAGS_ip_version_for_host_lookup) ==
+      "4") {
     address_family_for_lookup = AF_INET;
-  } else if (GetQuicFlag(FLAGS_ip_version_for_host_lookup) == "6") {
+  } else if (quiche::GetQuicheCommandLineFlag(
+                 FLAGS_ip_version_for_host_lookup) == "6") {
     address_family_for_lookup = AF_INET6;
   }
 
@@ -324,11 +332,13 @@ int QuicToyClient::SendRequestsAndPrintResponses(
     return 1;
   }
 
-  if (!GetQuicFlag(FLAGS_default_client_cert).empty() &&
-      !GetQuicFlag(FLAGS_default_client_cert_key).empty()) {
+  if (!quiche::GetQuicheCommandLineFlag(FLAGS_default_client_cert).empty() &&
+      !quiche::GetQuicheCommandLineFlag(FLAGS_default_client_cert_key)
+           .empty()) {
     std::unique_ptr<ClientProofSource> proof_source =
-        CreateTestClientProofSource(GetQuicFlag(FLAGS_default_client_cert),
-                                    GetQuicFlag(FLAGS_default_client_cert_key));
+        CreateTestClientProofSource(
+            quiche::GetQuicheCommandLineFlag(FLAGS_default_client_cert),
+            quiche::GetQuicheCommandLineFlag(FLAGS_default_client_cert_key));
     if (proof_source == nullptr) {
       std::cerr << "Failed to create client proof source." << std::endl;
       return 1;
@@ -336,22 +346,23 @@ int QuicToyClient::SendRequestsAndPrintResponses(
     client->crypto_config()->set_proof_source(std::move(proof_source));
   }
 
-  int32_t initial_mtu = GetQuicFlag(FLAGS_initial_mtu);
+  int32_t initial_mtu = quiche::GetQuicheCommandLineFlag(FLAGS_initial_mtu);
   client->set_initial_max_packet_length(
       initial_mtu != 0 ? initial_mtu : quic::kDefaultMaxPacketSize);
-  client->set_drop_response_body(GetQuicFlag(FLAGS_drop_response_body));
+  client->set_drop_response_body(
+      quiche::GetQuicheCommandLineFlag(FLAGS_drop_response_body));
   const int32_t server_connection_id_length =
-      GetQuicFlag(FLAGS_server_connection_id_length);
+      quiche::GetQuicheCommandLineFlag(FLAGS_server_connection_id_length);
   if (server_connection_id_length >= 0) {
     client->set_server_connection_id_length(server_connection_id_length);
   }
   const int32_t client_connection_id_length =
-      GetQuicFlag(FLAGS_client_connection_id_length);
+      quiche::GetQuicheCommandLineFlag(FLAGS_client_connection_id_length);
   if (client_connection_id_length >= 0) {
     client->set_client_connection_id_length(client_connection_id_length);
   }
   const size_t max_inbound_header_list_size =
-      GetQuicFlag(FLAGS_max_inbound_header_list_size);
+      quiche::GetQuicheCommandLineFlag(FLAGS_max_inbound_header_list_size);
   if (max_inbound_header_list_size > 0) {
     client->set_max_inbound_header_list_size(max_inbound_header_list_size);
   }
@@ -366,7 +377,8 @@ int QuicToyClient::SendRequestsAndPrintResponses(
                 << ". " << client->session()->error_details() << std::endl;
       // 0: No error.
       // 20: Failed to connect due to QUIC_INVALID_VERSION.
-      return GetQuicFlag(FLAGS_version_mismatch_ok) ? 0 : 20;
+      return quiche::GetQuicheCommandLineFlag(FLAGS_version_mismatch_ok) ? 0
+                                                                         : 20;
     }
     std::cerr << "Failed to connect to " << host << ":" << port << ". "
               << quic::QuicErrorCodeToString(error) << " "
@@ -376,11 +388,12 @@ int QuicToyClient::SendRequestsAndPrintResponses(
   std::cerr << "Connected to " << host << ":" << port << std::endl;
 
   // Construct the string body from flags, if provided.
-  std::string body = GetQuicFlag(FLAGS_body);
-  if (!GetQuicFlag(FLAGS_body_hex).empty()) {
-    QUICHE_DCHECK(GetQuicFlag(FLAGS_body).empty())
+  std::string body = quiche::GetQuicheCommandLineFlag(FLAGS_body);
+  if (!quiche::GetQuicheCommandLineFlag(FLAGS_body_hex).empty()) {
+    QUICHE_DCHECK(quiche::GetQuicheCommandLineFlag(FLAGS_body).empty())
         << "Only set one of --body and --body_hex.";
-    body = absl::HexStringToBytes(GetQuicFlag(FLAGS_body_hex));
+    body = absl::HexStringToBytes(
+        quiche::GetQuicheCommandLineFlag(FLAGS_body_hex));
   }
 
   // Construct a GET or POST request for supplied URL.
@@ -391,7 +404,7 @@ int QuicToyClient::SendRequestsAndPrintResponses(
   header_block[":path"] = url.PathParamsQuery();
 
   // Append any additional headers supplied on the command line.
-  const std::string headers = GetQuicFlag(FLAGS_headers);
+  const std::string headers = quiche::GetQuicheCommandLineFlag(FLAGS_headers);
   for (absl::string_view sp : absl::StrSplit(headers, ';')) {
     QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&sp);
     if (sp.empty()) {
@@ -412,14 +425,14 @@ int QuicToyClient::SendRequestsAndPrintResponses(
     client->SendRequestAndWaitForResponse(header_block, body, /*fin=*/true);
 
     // Print request and response details.
-    if (!GetQuicFlag(FLAGS_quiet)) {
+    if (!quiche::GetQuicheCommandLineFlag(FLAGS_quiet)) {
       std::cout << "Request:" << std::endl;
       std::cout << "headers:" << header_block.DebugString();
-      if (!GetQuicFlag(FLAGS_body_hex).empty()) {
+      if (!quiche::GetQuicheCommandLineFlag(FLAGS_body_hex).empty()) {
         // Print the user provided hex, rather than binary body.
         std::cout << "body:\n"
-                  << QuicheTextUtils::HexDump(
-                         absl::HexStringToBytes(GetQuicFlag(FLAGS_body_hex)))
+                  << QuicheTextUtils::HexDump(absl::HexStringToBytes(
+                         quiche::GetQuicheCommandLineFlag(FLAGS_body_hex)))
                   << std::endl;
       } else {
         std::cout << "body: " << body << std::endl;
@@ -436,7 +449,7 @@ int QuicToyClient::SendRequestsAndPrintResponses(
       std::cout << "headers: " << client->latest_response_headers()
                 << std::endl;
       std::string response_body = client->latest_response_body();
-      if (!GetQuicFlag(FLAGS_body_hex).empty()) {
+      if (!quiche::GetQuicheCommandLineFlag(FLAGS_body_hex).empty()) {
         // Assume response is binary data.
         std::cout << "body:\n"
                   << QuicheTextUtils::HexDump(response_body) << std::endl;
@@ -458,7 +471,7 @@ int QuicToyClient::SendRequestsAndPrintResponses(
     if (response_code >= 200 && response_code < 300) {
       std::cout << "Request succeeded (" << response_code << ")." << std::endl;
     } else if (response_code >= 300 && response_code < 400) {
-      if (GetQuicFlag(FLAGS_redirect_is_success)) {
+      if (quiche::GetQuicheCommandLineFlag(FLAGS_redirect_is_success)) {
         std::cout << "Request succeeded (redirect " << response_code << ")."
                   << std::endl;
       } else {
@@ -472,7 +485,7 @@ int QuicToyClient::SendRequestsAndPrintResponses(
     }
 
     if (i + 1 < num_requests) {  // There are more requests to perform.
-      if (GetQuicFlag(FLAGS_one_connection_per_request)) {
+      if (quiche::GetQuicheCommandLineFlag(FLAGS_one_connection_per_request)) {
         std::cout << "Disconnecting client between requests." << std::endl;
         client->Disconnect();
         if (!client->Initialize()) {
@@ -485,7 +498,8 @@ int QuicToyClient::SendRequestsAndPrintResponses(
                     << std::endl;
           return 1;
         }
-      } else if (!GetQuicFlag(FLAGS_disable_port_changes)) {
+      } else if (!quiche::GetQuicheCommandLineFlag(
+                     FLAGS_disable_port_changes)) {
         // Change the ephemeral port.
         if (!client->ChangeEphemeralPort()) {
           std::cerr << "Failed to change ephemeral port." << std::endl;

package/third_party/quiche/quiche/quic/tools/quic_toy_server.cc

@@ -45,14 +45,15 @@ namespace quic {
 std::unique_ptr<quic::QuicSimpleServerBackend>
 QuicToyServer::MemoryCacheBackendFactory::CreateBackend() {
   auto memory_cache_backend = std::make_unique<QuicMemoryCacheBackend>();
-  if (GetQuicFlag(FLAGS_generate_dynamic_responses)) {
+  if (quiche::GetQuicheCommandLineFlag(FLAGS_generate_dynamic_responses)) {
     memory_cache_backend->GenerateDynamicResponses();
   }
-  if (!GetQuicFlag(FLAGS_quic_response_cache_dir).empty()) {
+  if (!quiche::GetQuicheCommandLineFlag(FLAGS_quic_response_cache_dir)
+           .empty()) {
     memory_cache_backend->InitializeBackend(
-        GetQuicFlag(FLAGS_quic_response_cache_dir));
+        quiche::GetQuicheCommandLineFlag(FLAGS_quic_response_cache_dir));
   }
-  if (GetQuicFlag(FLAGS_enable_webtransport)) {
+  if (quiche::GetQuicheCommandLineFlag(FLAGS_enable_webtransport)) {
     memory_cache_backend->EnableWebTransport();
   }
   return memory_cache_backend;
@@ -64,7 +65,7 @@ QuicToyServer::QuicToyServer(BackendFactory* backend_factory,
 
 int QuicToyServer::Start() {
   ParsedQuicVersionVector supported_versions;
-  if (GetQuicFlag(FLAGS_quic_ietf_draft)) {
+  if (quiche::GetQuicheCommandLineFlag(FLAGS_quic_ietf_draft)) {
     QuicVersionInitializeSupportForIetfDraft();
     for (const ParsedQuicVersion& version : AllSupportedVersions()) {
       // Add all versions that supports IETF QUIC.
@@ -76,7 +77,8 @@ int QuicToyServer::Start() {
   } else {
     supported_versions = AllSupportedVersions();
   }
-  std::string versions_string = GetQuicFlag(FLAGS_quic_versions);
+  std::string versions_string =
+      quiche::GetQuicheCommandLineFlag(FLAGS_quic_versions);
   if (!versions_string.empty()) {
     supported_versions = ParseQuicVersionVectorString(versions_string);
   }
@@ -92,7 +94,8 @@ int QuicToyServer::Start() {
       backend.get(), std::move(proof_source), supported_versions);
 
   if (!server->CreateUDPSocketAndListen(quic::QuicSocketAddress(
-          quic::QuicIpAddress::Any6(), GetQuicFlag(FLAGS_port)))) {
+          quic::QuicIpAddress::Any6(),
+          quiche::GetQuicheCommandLineFlag(FLAGS_port)))) {
     return 1;
   }
 

package/third_party/quiche/quiche/quic/tools/simple_ticket_crypter.cc

@@ -87,7 +87,7 @@ std::vector<uint8_t> SimpleTicketCrypter::Decrypt(absl::string_view in) {
 
 void SimpleTicketCrypter::Decrypt(
     absl::string_view in,
-    std::unique_ptr<quic::ProofSource::DecryptCallback> callback) {
+    std::shared_ptr<quic::ProofSource::DecryptCallback> callback) {
   callback->Run(Decrypt(in));
 }
 

package/third_party/quiche/quiche/quic/tools/simple_ticket_crypter.h

@@ -28,7 +28,7 @@ class QUIC_NO_EXPORT SimpleTicketCrypter
                                absl::string_view encryption_key) override;
   void Decrypt(
       absl::string_view in,
-      std::unique_ptr<quic::ProofSource::DecryptCallback> callback) override;
+      std::shared_ptr<quic::ProofSource::DecryptCallback> callback) override;
 
  private:
   std::vector<uint8_t> Decrypt(absl::string_view in);

package/third_party/quiche/quiche/quic/tools/web_transport_test_visitors.h

@@ -9,6 +9,7 @@
 
 #include "quiche/quic/core/web_transport_interface.h"
 #include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_mem_slice.h"
 #include "quiche/common/quiche_circular_deque.h"
 #include "quiche/common/simple_buffer_allocator.h"
@@ -123,7 +124,7 @@ class WebTransportUnidirectionalEchoReadVisitor
     }
   }
 
-  void OnCanWrite() override { QUIC_NOTREACHED(); }
+  void OnCanWrite() override { QUICHE_NOTREACHED(); }
 
   void OnResetStreamReceived(WebTransportStreamError /*error*/) override {}
   void OnStopSendingReceived(WebTransportStreamError /*error*/) override {}
@@ -143,7 +144,7 @@ class WebTransportUnidirectionalEchoWriteVisitor
                                              const std::string& data)
       : stream_(stream), data_(data) {}
 
-  void OnCanRead() override { QUIC_NOTREACHED(); }
+  void OnCanRead() override { QUICHE_NOTREACHED(); }
   void OnCanWrite() override {
     if (data_.empty()) {
       return;

package/third_party/quiche/quiche/spdy/core/array_output_buffer.h

@@ -12,7 +12,7 @@
 
 namespace spdy {
 
-class QUICHE_NO_EXPORT ArrayOutputBuffer : public ZeroCopyOutputBuffer {
+class QUICHE_EXPORT_PRIVATE ArrayOutputBuffer : public ZeroCopyOutputBuffer {
  public:
   // |buffer| is pointed to the output to write to, and |size| is the capacity
   // of the output.

package/third_party/quiche/quiche/spdy/core/hpack/hpack_decoder_adapter_test.cc

@@ -112,7 +112,7 @@ const char* kCookieKey = "cookie";
 enum StartChoice { START_WITH_HANDLER, START_WITHOUT_HANDLER, NO_START };
 
 class HpackDecoderAdapterTest
-    : public QuicheTestWithParam<std::tuple<StartChoice, bool>> {
+    : public quiche::test::QuicheTestWithParam<std::tuple<StartChoice, bool>> {
  protected:
   HpackDecoderAdapterTest() : decoder_(), decoder_peer_(&decoder_) {}
 

package/third_party/quiche/quiche/spdy/core/hpack/hpack_encoder_test.cc

@@ -127,7 +127,8 @@ enum EncodeStrategy {
   kRepresentations,
 };
 
-class HpackEncoderTest : public QuicheTestWithParam<EncodeStrategy> {
+class HpackEncoderTest
+    : public quiche::test::QuicheTestWithParam<EncodeStrategy> {
  protected:
   typedef test::HpackEncoderPeer::Representations Representations;
 

package/third_party/quiche/quiche/spdy/core/hpack/hpack_header_table_test.cc

@@ -67,7 +67,7 @@ class HpackHeaderTablePeer {
 
 namespace {
 
-class HpackHeaderTableTest : public QuicheTest {
+class HpackHeaderTableTest : public quiche::test::QuicheTest {
  protected:
   typedef std::vector<HpackEntry> HpackEntryVector;
 

package/third_party/quiche/quiche/spdy/core/hpack/hpack_round_trip_test.cc

@@ -22,7 +22,8 @@ namespace {
 // Supports testing with the input split at every byte boundary.
 enum InputSizeParam { ALL_INPUT, ONE_BYTE, ZERO_THEN_ONE_BYTE };
 
-class HpackRoundTripTest : public QuicheTestWithParam<InputSizeParam> {
+class HpackRoundTripTest
+    : public quiche::test::QuicheTestWithParam<InputSizeParam> {
  protected:
   void SetUp() override {
     // Use a small table size to tickle eviction handling.

package/third_party/quiche/quiche/spdy/core/hpack/hpack_static_table_test.cc

@@ -17,7 +17,7 @@ namespace test {
 
 namespace {
 
-class HpackStaticTableTest : public QuicheTest {
+class HpackStaticTableTest : public quiche::test::QuicheTest {
  protected:
   HpackStaticTableTest() : table_() {}
 

package/third_party/quiche/quiche/spdy/core/http2_frame_decoder_adapter.cc

@@ -436,7 +436,8 @@ void Http2DecoderAdapter::OnHeadersStart(const Http2FrameHeader& header) {
     }
     on_headers_called_ = true;
     ReportReceiveCompressedFrame(header);
-    visitor()->OnHeaders(header.stream_id, kNotHasPriorityFields,
+    visitor()->OnHeaders(header.stream_id, header.payload_length,
+                         kNotHasPriorityFields,
                          0,      // priority
                          0,      // parent_stream_id
                          false,  // exclusive
@@ -460,10 +461,10 @@ void Http2DecoderAdapter::OnHeadersPriority(
         << " priority:" << priority << " frame_header:" << frame_header_;
     return;
   }
-  visitor()->OnHeaders(frame_header_.stream_id, kHasPriorityFields,
-                       priority.weight, priority.stream_dependency,
-                       priority.is_exclusive, frame_header_.IsEndStream(),
-                       frame_header_.IsEndHeaders());
+  visitor()->OnHeaders(
+      frame_header_.stream_id, frame_header_.payload_length, kHasPriorityFields,
+      priority.weight, priority.stream_dependency, priority.is_exclusive,
+      frame_header_.IsEndStream(), frame_header_.IsEndHeaders());
   CommonStartHpackBlock();
 }
 
@@ -505,7 +506,8 @@ void Http2DecoderAdapter::OnContinuationStart(const Http2FrameHeader& header) {
     frame_header_ = header;
     has_frame_header_ = true;
     ReportReceiveCompressedFrame(header);
-    visitor()->OnContinuation(header.stream_id, header.IsEndHeaders());
+    visitor()->OnContinuation(header.stream_id, header.payload_length,
+                              header.IsEndHeaders());
   }
 }
 

package/third_party/quiche/quiche/spdy/core/http2_frame_decoder_adapter.h

@@ -376,9 +376,12 @@ class QUICHE_EXPORT_PRIVATE SpdyFramerVisitorInterface {
   virtual void OnCommonHeader(SpdyStreamId /*stream_id*/, size_t /*length*/,
                               uint8_t /*type*/, uint8_t /*flags*/) {}
 
-  // Called when a data frame header is received. The frame's data
-  // payload will be provided via subsequent calls to
-  // OnStreamFrameData().
+  // Called when a data frame header is received. The frame's data payload will
+  // be provided via subsequent calls to OnStreamFrameData().
+  // |stream_id| The stream receiving data.
+  // |length| The length of the payload in this DATA frame. Includes the length
+  //     of the data itself and potential padding.
+  // |fin| Whether the END_STREAM flag is set in the frame header.
   virtual void OnDataFrameHeader(SpdyStreamId stream_id, size_t length,
                                  bool fin) = 0;
 
@@ -444,6 +447,8 @@ class QUICHE_EXPORT_PRIVATE SpdyFramerVisitorInterface {
   // Called when a HEADERS frame is received.
   // Note that header block data is not included. See OnHeaderFrameStart().
   // |stream_id| The stream receiving the header.
+  // |payload_length| The length of the payload in this HEADERS frame. Includes
+  //     the length of the encoded header block and potential padding.
   // |has_priority| Whether or not the headers frame included a priority value,
   //     and stream dependency info.
   // |weight| If |has_priority| is true, then weight (in the range [1, 256])
@@ -452,10 +457,11 @@ class QUICHE_EXPORT_PRIVATE SpdyFramerVisitorInterface {
   //     receiving stream, else 0.
   // |exclusive| If |has_priority| is true the exclusivity of dependence on the
   //     parent stream, else false.
-  // |fin| Whether FIN flag is set in frame headers.
+  // |fin| Whether the END_STREAM flag is set in the frame header.
   // |end| False if HEADERs frame is to be followed by a CONTINUATION frame,
   //     or true if not.
-  virtual void OnHeaders(SpdyStreamId stream_id, bool has_priority, int weight,
+  virtual void OnHeaders(SpdyStreamId stream_id, size_t payload_length,
+                         bool has_priority, int weight,
                          SpdyStreamId parent_stream_id, bool exclusive,
                          bool fin, bool end) = 0;
 
@@ -479,7 +485,12 @@ class QUICHE_EXPORT_PRIVATE SpdyFramerVisitorInterface {
 
   // Called when a CONTINUATION frame is received.
   // Note that header block data is not included. See OnHeaderFrameStart().
-  virtual void OnContinuation(SpdyStreamId stream_id, bool end) = 0;
+  // |stream_id| The stream receiving the CONTINUATION.
+  // |payload_length| The length of the payload in this CONTINUATION frame.
+  // |end| True if this CONTINUATION frame will not be followed by another
+  //     CONTINUATION frame.
+  virtual void OnContinuation(SpdyStreamId stream_id, size_t payload_length,
+                              bool end) = 0;
 
   // Called when an ALTSVC frame has been parsed.
   virtual void OnAltSvc(

package/third_party/quiche/quiche/spdy/core/metadata_extension.cc

@@ -101,7 +101,7 @@ void MetadataVisitor::OnSetting(SpdySettingsId id, uint32_t value) {
         on_support_(true);
       }
     } else {
-      LOG_EVERY_N_SEC(WARNING, 1)
+      QUICHE_LOG_EVERY_N_SEC(WARNING, 1)
           << "Unrecognized value for setting " << id << ": " << value;
     }
   }