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

package/third_party/quiche/quiche/quic/masque/masque_server_session.cc

@@ -174,32 +174,23 @@ std::unique_ptr<QuicBackendResponse> MasqueServerSession::HandleMasqueRequest(
                      << "\"";
     return CreateBackendErrorResponse("400", "Bad protocol");
   }
-  absl::optional<QuicDatagramStreamId> flow_id;
-  if (http_datagram_support() == HttpDatagramSupport::kDraft00) {
-    flow_id = SpdyUtils::ParseDatagramFlowIdHeader(request_headers);
-    if (!flow_id.has_value()) {
-      QUIC_DLOG(ERROR)
-          << "MASQUE request with bad or missing DatagramFlowId header";
-      return CreateBackendErrorResponse("400",
-                                        "Bad or missing DatagramFlowId header");
-    }
-  }
   // Extract target host and port from path using default template.
   std::vector<absl::string_view> path_split = absl::StrSplit(path, '/');
-  if (path_split.size() != 4 || !path_split[0].empty() ||
-      path_split[1].empty() || path_split[2].empty() ||
-      !path_split[3].empty()) {
+  if (path_split.size() != 7 || !path_split[0].empty() ||
+      path_split[1] != ".well-known" || path_split[2] != "masque" ||
+      path_split[3] != "udp" || path_split[4].empty() ||
+      path_split[5].empty() || !path_split[6].empty()) {
     QUIC_DLOG(ERROR) << "MASQUE request with bad path \"" << path << "\"";
     return CreateBackendErrorResponse("400", "Bad path");
   }
-  absl::optional<std::string> host = quiche::AsciiUrlDecode(path_split[1]);
+  absl::optional<std::string> host = quiche::AsciiUrlDecode(path_split[4]);
   if (!host.has_value()) {
-    QUIC_DLOG(ERROR) << "Failed to decode host \"" << path_split[1] << "\"";
+    QUIC_DLOG(ERROR) << "Failed to decode host \"" << path_split[4] << "\"";
     return CreateBackendErrorResponse("500", "Failed to decode host");
   }
-  absl::optional<std::string> port = quiche::AsciiUrlDecode(path_split[2]);
+  absl::optional<std::string> port = quiche::AsciiUrlDecode(path_split[5]);
   if (!port.has_value()) {
-    QUIC_DLOG(ERROR) << "Failed to decode port \"" << path_split[2] << "\"";
+    QUIC_DLOG(ERROR) << "Failed to decode port \"" << path_split[5] << "\"";
     return CreateBackendErrorResponse("500", "Failed to decode port");
   }
 
@@ -221,10 +212,8 @@ std::unique_ptr<QuicBackendResponse> MasqueServerSession::HandleMasqueRequest(
   QuicSocketAddress target_server_address(info_list->ai_addr,
                                           info_list->ai_addrlen);
   QUIC_DLOG(INFO) << "Got CONNECT_UDP request on stream ID "
-                  << request_handler->stream_id() << " flow_id="
-                  << (flow_id.has_value() ? absl::StrCat(*flow_id) : "none")
-                  << " target_server_address=\"" << target_server_address
-                  << "\"";
+                  << request_handler->stream_id() << " target_server_address=\""
+                  << target_server_address << "\"";
 
   FdWrapper fd_wrapper(target_server_address.host().AddressFamilyToInt());
   if (fd_wrapper.fd() == kQuicInvalidSocketFd) {
@@ -250,23 +239,11 @@ std::unique_ptr<QuicBackendResponse> MasqueServerSession::HandleMasqueRequest(
         << request_handler->stream_id();
     return CreateBackendErrorResponse("500", "Bad stream type");
   }
-  if (flow_id.has_value()) {
-    stream->RegisterHttp3DatagramFlowId(*flow_id);
-  }
   connect_udp_server_states_.push_back(ConnectUdpServerState(
       stream, target_server_address, fd_wrapper.extract_fd(), this));
 
-  if (http_datagram_support() == HttpDatagramSupport::kDraft00) {
-    // TODO(b/181256914) remove this when we drop support for
-    // draft-ietf-masque-h3-datagram-00 in favor of later drafts.
-    stream->RegisterHttp3DatagramVisitor(&connect_udp_server_states_.back());
-  }
-
   spdy::Http2HeaderBlock response_headers;
   response_headers[":status"] = "200";
-  if (flow_id.has_value()) {
-    SpdyUtils::AddDatagramFlowIdHeader(&response_headers, *flow_id);
-  }
   auto response = std::make_unique<QuicBackendResponse>();
   response->set_response_type(QuicBackendResponse::INCOMPLETE_RESPONSE);
   response->set_headers(std::move(response_headers));
@@ -307,11 +284,12 @@ void MasqueServerSession::OnEvent(QuicUdpSocketFd fd, QuicEpollEvent* event) {
                 << " server " << expected_target_server_address;
   QuicUdpSocketApi socket_api;
   BitMask64 packet_info_interested(QuicUdpPacketInfoBit::PEER_ADDRESS);
-  char packet_buffer[kMaxIncomingPacketSize];
+  char packet_buffer[1 + kMaxIncomingPacketSize];
+  packet_buffer[0] = 0;  // context ID.
   char control_buffer[kDefaultUdpPacketControlBufferSize];
   while (true) {
     QuicUdpSocketApi::ReadPacketResult read_result;
-    read_result.packet_buffer = {packet_buffer, sizeof(packet_buffer)};
+    read_result.packet_buffer = {packet_buffer + 1, sizeof(packet_buffer) - 1};
     read_result.control_buffer = {control_buffer, sizeof(control_buffer)};
     socket_api.ReadPacket(fd, packet_info_interested, &read_result);
     if (!read_result.ok) {
@@ -340,9 +318,9 @@ void MasqueServerSession::OnEvent(QuicUdpSocketFd fd, QuicEpollEvent* event) {
       return;
     }
     // The packet is valid, send it to the client in a DATAGRAM frame.
-    MessageStatus message_status = it->stream()->SendHttp3Datagram(
-        absl::string_view(read_result.packet_buffer.buffer,
-                          read_result.packet_buffer.buffer_len));
+    MessageStatus message_status =
+        it->stream()->SendHttp3Datagram(absl::string_view(
+            packet_buffer, read_result.packet_buffer.buffer_len + 1));
     QUIC_DVLOG(1) << "Sent UDP packet from " << expected_target_server_address
                   << " of length " << read_result.packet_buffer.buffer_len
                   << " with stream ID " << it->stream()->id()
@@ -433,12 +411,24 @@ MasqueServerSession::ConnectUdpServerState::operator=(
 void MasqueServerSession::ConnectUdpServerState::OnHttp3Datagram(
     QuicStreamId stream_id, absl::string_view payload) {
   QUICHE_DCHECK_EQ(stream_id, stream()->id());
+  QuicDataReader reader(payload);
+  uint64_t context_id;
+  if (!reader.ReadVarInt62(&context_id)) {
+    QUIC_DLOG(ERROR) << "Failed to read context ID";
+    return;
+  }
+  if (context_id != 0) {
+    QUIC_DLOG(ERROR) << "Ignoring HTTP Datagram with unexpected context ID "
+                     << context_id;
+    return;
+  }
+  absl::string_view http_payload = reader.ReadRemainingPayload();
   QuicUdpSocketApi socket_api;
   QuicUdpPacketInfo packet_info;
   packet_info.SetPeerAddress(target_server_address_);
   WriteResult write_result = socket_api.WritePacket(
-      fd_, payload.data(), payload.length(), packet_info);
-  QUIC_DVLOG(1) << "Wrote packet of length " << payload.length() << " to "
+      fd_, http_payload.data(), http_payload.length(), packet_info);
+  QUIC_DVLOG(1) << "Wrote packet of length " << http_payload.length() << " to "
                 << target_server_address_ << " with result " << write_result;
 }
 

package/third_party/quiche/quiche/quic/masque/masque_server_session.h

@@ -97,7 +97,7 @@ class QUIC_NO_EXPORT MasqueServerSession
   // From QuicSpdySession.
   bool OnSettingsFrame(const SettingsFrame& frame) override;
   HttpDatagramSupport LocalHttpDatagramSupport() override {
-    return HttpDatagramSupport::kDraft00And04;
+    return HttpDatagramSupport::kDraft09;
   }
 
   MasqueServerBackend* masque_server_backend_;  // Unowned.

package/third_party/quiche/quiche/quic/platform/api/quic_export.h

@@ -5,17 +5,17 @@
 #ifndef QUICHE_QUIC_PLATFORM_API_QUIC_EXPORT_H_
 #define QUICHE_QUIC_PLATFORM_API_QUIC_EXPORT_H_
 
-#include "quiche_platform_impl/quiche_export_impl.h"
+#include "quiche/common/platform/api/quiche_export.h"
 
 // QUIC_EXPORT is not meant to be used.
-#define QUIC_EXPORT QUICHE_EXPORT_IMPL
+#define QUIC_EXPORT QUICHE_EXPORT
 
 // QUIC_EXPORT_PRIVATE is meant for QUIC functionality that is built in Chromium
 // as part of //net, and not fully contained in headers.
-#define QUIC_EXPORT_PRIVATE QUICHE_EXPORT_PRIVATE_IMPL
+#define QUIC_EXPORT_PRIVATE QUICHE_EXPORT_PRIVATE
 
 // QUIC_NO_EXPORT is meant for QUIC functionality that is either fully defined
 // in a header, or is built in Chromium as part of tests or tools.
-#define QUIC_NO_EXPORT QUICHE_NO_EXPORT_IMPL
+#define QUIC_NO_EXPORT QUICHE_NO_EXPORT
 
 #endif  // QUICHE_QUIC_PLATFORM_API_QUIC_EXPORT_H_

package/third_party/quiche/quiche/quic/platform/api/quic_flags.h

@@ -8,7 +8,6 @@
 #include <string>
 #include <vector>
 
-#include "quiche_platform_impl/quic_flags_impl.h"
 #include "quiche/common/platform/api/quiche_flags.h"
 
 #define GetQuicReloadableFlag(flag) GetQuicheReloadableFlag(quic, flag)

package/third_party/quiche/quiche/quic/platform/api/quic_logging.h

@@ -22,12 +22,6 @@
 #define QUIC_LOG_EVERY_N_SEC QUICHE_LOG_EVERY_N_SEC
 #define QUIC_LOG_IF QUICHE_LOG_IF
 
-#define QUIC_PREDICT_FALSE QUICHE_PREDICT_FALSE
-#define QUIC_PREDICT_TRUE QUICHE_PREDICT_TRUE
-
-// This is a noop in release build.
-#define QUIC_NOTREACHED QUICHE_NOTREACHED
-
 #define QUIC_PLOG QUICHE_PLOG
 
 #define QUIC_DLOG_INFO_IS_ON QUICHE_DLOG_INFO_IS_ON

package/third_party/quiche/quiche/quic/platform/api/quic_test.h

@@ -8,15 +8,16 @@
 #include "quiche/quic/platform/api/quic_logging.h"
 #include "quiche/common/platform/api/quiche_test.h"
 
-using QuicFlagSaver = QuicheFlagSaver;
+namespace quic::test {
+
+using QuicFlagSaver = quiche::test::QuicheFlagSaver;
 
 // Defines the base classes to be used in QUIC tests.
-using QuicTest = QuicheTest;
+using QuicTest = quiche::test::QuicheTest;
 template <class T>
-using QuicTestWithParam = QuicheTestWithParam<T>;
+using QuicTestWithParam = quiche::test::QuicheTestWithParam<T>;
 
-// Class which needs to be instantiated in tests which use threads.
-using ScopedEnvironmentForThreads = ScopedEnvironmentForThreadsImpl;
+}  // namespace quic::test
 
 #define QUIC_TEST_DISABLED_IN_CHROME(name) QUICHE_TEST_DISABLED_IN_CHROME(name)
 

package/third_party/quiche/quiche/quic/qbone/bonnet/icmp_reachable_test.cc

@@ -12,7 +12,7 @@
 #include "quiche/quic/platform/api/quic_test.h"
 #include "quiche/quic/qbone/platform/mock_kernel.h"
 
-namespace quic {
+namespace quic::test {
 namespace {
 
 using ::testing::_;
@@ -263,4 +263,4 @@ TEST_F(IcmpReachableTest, HandlesReadErrors) {
 }
 
 }  // namespace
-}  // namespace quic
+}  // namespace quic::test

package/third_party/quiche/quiche/quic/qbone/bonnet/mock_qbone_tunnel.h

@@ -36,6 +36,8 @@ class MockQboneTunnel : public QboneTunnelInterface {
   MOCK_METHOD(State, state, ());
 
   MOCK_METHOD(std::string, HealthString, ());
+
+  MOCK_METHOD(std::string, ServerRegionString, ());
 };
 
 }  // namespace quic

package/third_party/quiche/quiche/quic/qbone/bonnet/qbone_tunnel_interface.h

@@ -61,6 +61,8 @@ class QboneTunnelInterface : public quic::QboneClientControlStream::Handler {
   virtual State state() = 0;
 
   virtual std::string HealthString() = 0;
+
+  virtual std::string ServerRegionString() = 0;
 };
 
 }  // namespace quic

package/third_party/quiche/quiche/quic/qbone/bonnet/tun_device_controller_test.cc

@@ -14,7 +14,7 @@
 
 ABSL_DECLARE_FLAG(bool, qbone_tun_device_replace_default_routing_rules);
 
-namespace quic {
+namespace quic::test {
 namespace {
 using ::testing::Eq;
 
@@ -255,4 +255,4 @@ TEST_F(DisabledTunDeviceControllerTest, UpdateAddressIsNop) {
 }
 
 }  // namespace
-}  // namespace quic
+}  // namespace quic::test

package/third_party/quiche/quiche/quic/qbone/bonnet/tun_device_packet_exchanger_test.cc

@@ -9,7 +9,7 @@
 #include "quiche/quic/qbone/mock_qbone_client.h"
 #include "quiche/quic/qbone/platform/mock_kernel.h"
 
-namespace quic {
+namespace quic::test {
 namespace {
 
 const size_t kMtu = 1000;
@@ -116,4 +116,4 @@ TEST_F(TunDevicePacketExchangerTest,
 }
 
 }  // namespace
-}  // namespace quic
+}  // namespace quic::test

package/third_party/quiche/quiche/quic/qbone/bonnet/tun_device_test.cc

@@ -11,7 +11,7 @@
 #include "quiche/quic/platform/api/quic_test.h"
 #include "quiche/quic/qbone/platform/mock_kernel.h"
 
-namespace quic {
+namespace quic::test {
 namespace {
 
 using ::testing::_;
@@ -208,4 +208,4 @@ TEST_F(TunDeviceTest, FailToUp) {
 }
 
 }  // namespace
-}  // namespace quic
+}  // namespace quic::test

package/third_party/quiche/quiche/quic/qbone/platform/netlink_test.cc

@@ -12,7 +12,7 @@
 #include "quiche/quic/qbone/platform/mock_kernel.h"
 #include "quiche/quic/qbone/qbone_constants.h"
 
-namespace quic {
+namespace quic::test {
 namespace {
 
 using ::testing::_;
@@ -761,4 +761,4 @@ TEST_F(NetlinkTest, ChangeRouteReplace) {
 }
 
 }  // namespace
-}  // namespace quic
+}  // namespace quic::test

package/third_party/quiche/quiche/quic/qbone/platform/tcp_packet.cc

@@ -6,6 +6,7 @@
 
 #include <netinet/ip6.h>
 
+#include "absl/base/optimization.h"
 #include "absl/strings/string_view.h"
 #include "quiche/quic/platform/api/quic_logging.h"
 #include "quiche/quic/qbone/platform/internet_checksum.h"
@@ -35,17 +36,17 @@ void CreateTcpResetPacket(absl::string_view original_packet,
   // By the time this method is called, original_packet should be fairly
   // strongly validated. However, it's better to be more paranoid than not, so
   // here are a bunch of very obvious checks.
-  if (QUIC_PREDICT_FALSE(original_packet.size() < sizeof(ip6_hdr))) {
+  if (ABSL_PREDICT_FALSE(original_packet.size() < sizeof(ip6_hdr))) {
     return;
   }
   auto* ip6_header = reinterpret_cast<const ip6_hdr*>(original_packet.data());
-  if (QUIC_PREDICT_FALSE(ip6_header->ip6_vfc >> 4 != 6)) {
+  if (ABSL_PREDICT_FALSE(ip6_header->ip6_vfc >> 4 != 6)) {
     return;
   }
-  if (QUIC_PREDICT_FALSE(ip6_header->ip6_nxt != IPPROTO_TCP)) {
+  if (ABSL_PREDICT_FALSE(ip6_header->ip6_nxt != IPPROTO_TCP)) {
     return;
   }
-  if (QUIC_PREDICT_FALSE(quiche::QuicheEndian::NetToHost16(
+  if (ABSL_PREDICT_FALSE(quiche::QuicheEndian::NetToHost16(
                              ip6_header->ip6_plen) < sizeof(tcphdr))) {
     return;
   }

package/third_party/quiche/quiche/quic/qbone/qbone_client_session.cc

@@ -58,7 +58,8 @@ void QboneClientSession::Initialize() {
   QboneSessionBase::Initialize();
   static_cast<QuicCryptoClientStreamBase*>(GetMutableCryptoStream())
       ->CryptoConnect();
-  if (!GetQuicFlag(FLAGS_qbone_client_defer_control_stream_creation)) {
+  if (!quiche::GetQuicheCommandLineFlag(
+          FLAGS_qbone_client_defer_control_stream_creation)) {
     CreateControlStream();
   }
 }
@@ -66,7 +67,8 @@ void QboneClientSession::Initialize() {
 void QboneClientSession::SetDefaultEncryptionLevel(
     quic::EncryptionLevel level) {
   QboneSessionBase::SetDefaultEncryptionLevel(level);
-  if (GetQuicFlag(FLAGS_qbone_client_defer_control_stream_creation) &&
+  if (quiche::GetQuicheCommandLineFlag(
+          FLAGS_qbone_client_defer_control_stream_creation) &&
       level == quic::ENCRYPTION_FORWARD_SECURE) {
     CreateControlStream();
   }

package/third_party/quiche/quiche/quic/qbone/qbone_packet_processor.cc

@@ -6,6 +6,7 @@
 
 #include <cstring>
 
+#include "absl/base/optimization.h"
 #include "absl/strings/string_view.h"
 #include "quiche/quic/platform/api/quic_bug_tracker.h"
 #include "quiche/quic/platform/api/quic_ip_address_family.h"
@@ -62,7 +63,7 @@ QbonePacketProcessor::Filter::FilterPacket(Direction direction,
 
 void QbonePacketProcessor::ProcessPacket(std::string* packet,
                                          Direction direction) {
-  if (QUIC_PREDICT_FALSE(!IsValid())) {
+  if (ABSL_PREDICT_FALSE(!IsValid())) {
     QUIC_BUG(quic_bug_11024_1)
         << "QuicPacketProcessor is invoked in an invalid state.";
     stats_->OnPacketDroppedSilently(direction);

package/third_party/quiche/quiche/quic/qbone/qbone_packet_processor_test.cc

@@ -10,7 +10,7 @@
 #include "quiche/quic/platform/api/quic_test.h"
 #include "quiche/quic/qbone/qbone_packet_processor_test_tools.h"
 
-namespace quic {
+namespace quic::test {
 namespace {
 
 using Direction = QbonePacketProcessor::Direction;
@@ -277,4 +277,4 @@ TEST_F(QbonePacketProcessorTest, FilterHelperFunctions) {
 }
 
 }  // namespace
-}  // namespace quic
+}  // namespace quic::test

package/third_party/quiche/quiche/quic/qbone/qbone_server_session.cc

@@ -79,7 +79,8 @@ QuicStream* QboneServerSession::CreateControlStreamFromPendingStream(
 
 void QboneServerSession::Initialize() {
   QboneSessionBase::Initialize();
-  if (!GetQuicFlag(FLAGS_qbone_server_defer_control_stream_creation)) {
+  if (!quiche::GetQuicheCommandLineFlag(
+          FLAGS_qbone_server_defer_control_stream_creation)) {
     CreateControlStream();
   }
 }
@@ -87,7 +88,8 @@ void QboneServerSession::Initialize() {
 void QboneServerSession::SetDefaultEncryptionLevel(
     quic::EncryptionLevel level) {
   QboneSessionBase::SetDefaultEncryptionLevel(level);
-  if (GetQuicFlag(FLAGS_qbone_server_defer_control_stream_creation) &&
+  if (quiche::GetQuicheCommandLineFlag(
+          FLAGS_qbone_server_defer_control_stream_creation) &&
       level == quic::ENCRYPTION_FORWARD_SECURE) {
     CreateControlStream();
   }

package/third_party/quiche/quiche/quic/qbone/qbone_session_base.cc

@@ -18,6 +18,7 @@
 #include "quiche/quic/qbone/platform/icmp_packet.h"
 #include "quiche/quic/qbone/qbone_constants.h"
 #include "quiche/common/platform/api/quiche_command_line_flags.h"
+#include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_mem_slice.h"
 #include "quiche/common/quiche_buffer_allocator.h"
 
@@ -74,7 +75,7 @@ void QboneSessionBase::OnStreamFrame(const QuicStreamFrame& frame) {
     flow_controller()->AddBytesConsumed(frame.data_length);
     // TODO(b/147817422): Add a counter for how many streams were actually
     // closed here.
-    if (GetQuicFlag(FLAGS_qbone_close_ephemeral_frames)) {
+    if (quiche::GetQuicheCommandLineFlag(FLAGS_qbone_close_ephemeral_frames)) {
       ResetStream(frame.stream_id, QUIC_STREAM_CANCELLED);
     }
     return;
@@ -92,7 +93,7 @@ QuicStream* QboneSessionBase::CreateIncomingStream(QuicStreamId id) {
 }
 
 QuicStream* QboneSessionBase::CreateIncomingStream(PendingStream* /*pending*/) {
-  QUIC_NOTREACHED();
+  QUICHE_NOTREACHED();
   return nullptr;
 }
 

package/third_party/quiche/quiche/quic/qbone/qbone_stream.cc

@@ -22,8 +22,8 @@ QboneWriteOnlyStream::QboneWriteOnlyStream(QuicStreamId id,
     : QuicStream(id, session, /*is_static=*/false, WRITE_UNIDIRECTIONAL) {
   // QBONE uses a LIFO queue to try to always make progress. An individual
   // packet may persist for upto to qbone_stream_ttl_secs seconds in memory.
-  MaybeSetTtl(
-      QuicTime::Delta::FromSeconds(GetQuicFlag(FLAGS_qbone_stream_ttl_secs)));
+  MaybeSetTtl(QuicTime::Delta::FromSeconds(
+      quiche::GetQuicheCommandLineFlag(FLAGS_qbone_stream_ttl_secs)));
 }
 
 void QboneWriteOnlyStream::WritePacketToQuicStream(absl::string_view packet) {
@@ -39,8 +39,8 @@ QboneReadOnlyStream::QboneReadOnlyStream(QuicStreamId id,
       session_(session) {
   // QBONE uses a LIFO queue to try to always make progress. An individual
   // packet may persist for upto to qbone_stream_ttl_secs seconds in memory.
-  MaybeSetTtl(
-      QuicTime::Delta::FromSeconds(GetQuicFlag(FLAGS_qbone_stream_ttl_secs)));
+  MaybeSetTtl(QuicTime::Delta::FromSeconds(
+      quiche::GetQuicheCommandLineFlag(FLAGS_qbone_stream_ttl_secs)));
 }
 
 void QboneReadOnlyStream::OnDataAvailable() {

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

@@ -146,7 +146,7 @@ QuicAlarm* QuicConnectionPeer::GetAckAlarm(QuicConnection* connection) {
 
 // static
 QuicAlarm* QuicConnectionPeer::GetPingAlarm(QuicConnection* connection) {
-  if (GetQuicReloadableFlag(quic_use_ping_manager)) {
+  if (GetQuicReloadableFlag(quic_use_ping_manager2)) {
     return connection->ping_manager_.alarm_.get();
   }
   return connection->ping_alarm_.get();

package/third_party/quiche/quiche/quic/test_tools/quic_http_response_cache_data/test.example.com/index.html

@@ -0,0 +1,63 @@
+HTTP/1.1 200 OK
+Date: Tue, 28 Aug 2012 15:08:56 GMT
+Server: Apache/2.2.3 (CentOS)
+X-Powered-By: PHP/5.1.6
+Set-Cookie: bblastvisit=1346166536; expires=Wed, 28-Aug-2013 15:08:56 GMT; path=/; domain=.nasioc.com
+Set-Cookie: bblastactivity=0; expires=Wed, 28-Aug-2013 15:08:56 GMT; path=/; domain=.nasioc.com
+Expires: 0
+Cache-Control: private, post-check=0, pre-check=0, max-age=0
+Pragma: no-cache
+X-UA-Compatible: IE=7
+Connection: close
+Content-Type: text/html; charset=ISO-8859-1
+
+<!doctype html>
+<html>
+<head>
+    <title>Example Domain</title>
+
+    <meta charset="utf-8" />
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <style type="text/css">
+    body {
+        background-color: #f0f0f2;
+        margin: 0;
+        padding: 0;
+        font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
+        
+    }
+    div {
+        width: 600px;
+        margin: 5em auto;
+        padding: 50px;
+        background-color: #fff;
+        border-radius: 1em;
+    }
+    a:link, a:visited {
+        color: #38488f;
+        text-decoration: none;
+    }
+    @media (max-width: 700px) {
+        body {
+            background-color: #fff;
+        }
+        div {
+            width: auto;
+            margin: 0 auto;
+            border-radius: 0;
+            padding: 1em;
+        }
+    }
+    </style>    
+</head>
+
+<body>
+<div>
+    <h1>Example Domain</h1>
+    <p>This domain is established to be used for illustrative examples in documents. You may use this
+    domain in examples without prior coordination or asking for permission.</p>
+    <p><a href="http://www.iana.org/domains/example">More information...</a></p>
+</div>
+</body>
+</html>

package/third_party/quiche/quiche/quic/test_tools/quic_http_response_cache_data/test.example.com/map.html

@@ -0,0 +1,65 @@
+HTTP/1.1 200 OK
+Date: Tue, 28 Aug 2012 15:08:56 GMT
+Server: Apache/2.2.3 (CentOS)
+X-Powered-By: PHP/5.1.6
+Set-Cookie: bblastvisit=1346166536; expires=Wed, 28-Aug-2013 15:08:56 GMT; path=/; domain=.nasioc.com
+Set-Cookie: bblastactivity=0; expires=Wed, 28-Aug-2013 15:08:56 GMT; path=/; domain=.nasioc.com
+Expires: 0
+Cache-Control: private, post-check=0, pre-check=0, max-age=0
+Pragma: no-cache
+X-UA-Compatible: IE=7
+Connection: close
+Content-Type: text/html; charset=ISO-8859-1
+X-Original-Url: http://test.example.com/site_map.html
+
+
+<!doctype html>
+<html>
+<head>
+    <title>Example Domain</title>
+
+    <meta charset="utf-8" />
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <style type="text/css">
+    body {
+        background-color: #f0f0f2;
+        margin: 0;
+        padding: 0;
+        font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
+        
+    }
+    div {
+        width: 600px;
+        margin: 5em auto;
+        padding: 50px;
+        background-color: #fff;
+        border-radius: 1em;
+    }
+    a:link, a:visited {
+        color: #38488f;
+        text-decoration: none;
+    }
+    @media (max-width: 700px) {
+        body {
+            background-color: #fff;
+        }
+        div {
+            width: auto;
+            margin: 0 auto;
+            border-radius: 0;
+            padding: 1em;
+        }
+    }
+    </style>    
+</head>
+
+<body>
+<div>
+    <h1>Example Domain</h1>
+    <p>This domain is established to be used for illustrative examples in documents. You may use this
+    domain in examples without prior coordination or asking for permission.</p>
+    <p><a href="http://www.iana.org/domains/example">More information...</a></p>
+</div>
+</body>
+</html>

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

@@ -657,9 +657,10 @@ MockQuicSpdySession::MockQuicSpdySession(QuicConnection* connection,
         return QuicSpdySession::SendWindowUpdate(id, byte_offset);
       });
 
-  ON_CALL(*this, SendBlocked(_)).WillByDefault([this](QuicStreamId id) {
-    return QuicSpdySession::SendBlocked(id);
-  });
+  ON_CALL(*this, SendBlocked(_, _))
+      .WillByDefault([this](QuicStreamId id, QuicStreamOffset byte_offset) {
+        return QuicSpdySession::SendBlocked(id, byte_offset);
+      });
 
   ON_CALL(*this, OnCongestionWindowChange(_)).WillByDefault(testing::Return());
 }

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

@@ -779,6 +779,8 @@ class MockQuicSession : public QuicSession {
               (override));
   MOCK_METHOD(void, MaybeSendStopSendingFrame,
               (QuicStreamId stream_id, QuicResetStreamError error), (override));
+  MOCK_METHOD(void, SendBlocked,
+              (QuicStreamId stream_id, QuicStreamOffset offset), (override));
 
   MOCK_METHOD(bool, ShouldKeepConnectionAlive, (), (const, override));
   MOCK_METHOD(std::vector<std::string>, GetAlpnsToOffer, (), (const, override));
@@ -859,6 +861,20 @@ class MockQuicCryptoStream : public QuicCryptoStream {
       quic::EncryptionLevel level) const override {
     return level != ENCRYPTION_ZERO_RTT;
   }
+  EncryptionLevel GetEncryptionLevelToSendCryptoDataOfSpace(
+      PacketNumberSpace space) const override {
+    switch (space) {
+      case INITIAL_DATA:
+        return ENCRYPTION_INITIAL;
+      case HANDSHAKE_DATA:
+        return ENCRYPTION_HANDSHAKE;
+      case APPLICATION_DATA:
+        return ENCRYPTION_FORWARD_SECURE;
+      default:
+        QUICHE_DCHECK(false);
+        return NUM_ENCRYPTION_LEVELS;
+    }
+  }
 
  private:
   quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
@@ -914,7 +930,8 @@ class MockQuicSpdySession : public QuicSpdySession {
               (QuicStreamId stream_id, QuicResetStreamError error), (override));
   MOCK_METHOD(void, SendWindowUpdate,
               (QuicStreamId id, QuicStreamOffset byte_offset), (override));
-  MOCK_METHOD(void, SendBlocked, (QuicStreamId id), (override));
+  MOCK_METHOD(void, SendBlocked,
+              (QuicStreamId id, QuicStreamOffset byte_offset), (override));
   MOCK_METHOD(void, OnStreamHeadersPriority,
               (QuicStreamId stream_id,
                const spdy::SpdyStreamPrecedence& precedence),