Roll src/net/third_party/quiche/src/ 014740d30..7498c8c59 (1 commit)
https://quiche.googlesource.com/quiche.git/+log/014740d30571..7498c8c59b8a
$ git log 014740d30..7498c8c59 --date=short --no-merges --format='%ad %ae %s'
2019-07-02 renjietang In HTTP/3, write Priority on control stream before writing headers.
Created with:
roll-dep src/net/third_party/quiche/src
[Reland https://chromium-review.googlesource.com/c/chromium/src/+/1691429]
Bug: 982169
Change-Id: I8ecb5b77439e02965371a5d15d716f04b57f2e83
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1692963
Commit-Queue: Ryan Hamilton <rch@chromium.org>
Commit-Queue: Bence Béky <bnc@chromium.org>
Auto-Submit: Ryan Hamilton <rch@chromium.org>
Reviewed-by: Bence Béky <bnc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#675758}
diff --git a/DEPS b/DEPS
index 403a0ede..eff94323 100644
--- a/DEPS
+++ b/DEPS
@@ -281,7 +281,7 @@
# Three lines of non-changing comments so that
# the commit queue can handle CLs rolling feed
# and whatever else without interference from each other.
- 'quiche_revision': '014740d305715301a61e322f254aa2819c323349',
+ 'quiche_revision': '7498c8c59b8a8ea83db9368a889323bd0b146544',
# Three lines of non-changing comments so that
# the commit queue can handle CLs rolling ios_webkit
# and whatever else without interference from each other.
diff --git a/net/quic/bidirectional_stream_quic_impl_unittest.cc b/net/quic/bidirectional_stream_quic_impl_unittest.cc
index e94c472..6143499 100644
--- a/net/quic/bidirectional_stream_quic_impl_unittest.cc
+++ b/net/quic/bidirectional_stream_quic_impl_unittest.cc
@@ -426,6 +426,7 @@
kDefaultServerHostName,
quic::Perspective::IS_CLIENT,
client_headers_include_h2_stream_dependency_),
+ packet_number_(0),
server_maker_(version_,
connection_id_,
&clock_,
@@ -576,42 +577,36 @@
// Construct a data packet with multiple data frames
std::unique_ptr<quic::QuicReceivedPacket>
ConstructClientMultipleDataFramesPacket(
- uint64_t packet_number,
bool should_include_version,
bool fin,
const std::vector<std::string>& data_writes) {
std::unique_ptr<quic::QuicReceivedPacket> packet(
- client_maker_.MakeMultipleDataFramesPacket(packet_number, stream_id_,
+ client_maker_.MakeMultipleDataFramesPacket(++packet_number_, stream_id_,
should_include_version, fin,
data_writes));
- DVLOG(2) << "packet(" << packet_number << "): " << std::endl
+ DVLOG(2) << "packet(" << packet_number_ << "): " << std::endl
<< quic::QuicTextUtils::HexDump(packet->AsStringPiece());
return packet;
}
std::unique_ptr<quic::QuicReceivedPacket> ConstructRequestHeadersPacket(
- uint64_t packet_number,
bool fin,
RequestPriority request_priority,
size_t* spdy_headers_frame_length) {
- return ConstructRequestHeadersPacketInner(packet_number, stream_id_, fin,
- request_priority,
+ return ConstructRequestHeadersPacketInner(stream_id_, fin, request_priority,
spdy_headers_frame_length);
}
std::unique_ptr<quic::QuicReceivedPacket> ConstructRequestHeadersPacketInner(
- uint64_t packet_number,
quic::QuicStreamId stream_id,
bool fin,
RequestPriority request_priority,
size_t* spdy_headers_frame_length) {
- return ConstructRequestHeadersPacketInner(packet_number, stream_id, fin,
- request_priority, 0,
- spdy_headers_frame_length);
+ return ConstructRequestHeadersPacketInner(stream_id, fin, request_priority,
+ 0, spdy_headers_frame_length);
}
std::unique_ptr<quic::QuicReceivedPacket> ConstructRequestHeadersPacketInner(
- uint64_t packet_number,
quic::QuicStreamId stream_id,
bool fin,
RequestPriority request_priority,
@@ -621,17 +616,16 @@
ConvertRequestPriorityToQuicPriority(request_priority);
std::unique_ptr<quic::QuicReceivedPacket> packet(
client_maker_.MakeRequestHeadersPacket(
- packet_number, stream_id, kIncludeVersion, fin, priority,
+ ++packet_number_, stream_id, kIncludeVersion, fin, priority,
std::move(request_headers_), parent_stream_id,
spdy_headers_frame_length));
- DVLOG(2) << "packet(" << packet_number << "): " << std::endl
+ DVLOG(2) << "packet(" << packet_number_ << "): " << std::endl
<< quic::QuicTextUtils::HexDump(packet->AsStringPiece());
return packet;
}
std::unique_ptr<quic::QuicReceivedPacket>
ConstructRequestHeadersAndMultipleDataFramesPacket(
- uint64_t packet_number,
bool fin,
RequestPriority request_priority,
size_t* spdy_headers_frame_length,
@@ -640,9 +634,9 @@
ConvertRequestPriorityToQuicPriority(request_priority);
std::unique_ptr<quic::QuicReceivedPacket> packet(
client_maker_.MakeRequestHeadersAndMultipleDataFramesPacket(
- packet_number, stream_id_, kIncludeVersion, fin, priority,
+ ++packet_number_, stream_id_, kIncludeVersion, fin, priority,
std::move(request_headers_), 0, spdy_headers_frame_length, data));
- DVLOG(2) << "packet(" << packet_number << "): " << std::endl
+ DVLOG(2) << "packet(" << packet_number_ << "): " << std::endl
<< quic::QuicTextUtils::HexDump(packet->AsStringPiece());
return packet;
}
@@ -678,9 +672,8 @@
spdy_headers_frame_length);
}
- std::unique_ptr<quic::QuicReceivedPacket> ConstructClientRstStreamPacket(
- uint64_t packet_number) {
- return ConstructRstStreamCancelledPacket(packet_number, !kIncludeVersion,
+ std::unique_ptr<quic::QuicReceivedPacket> ConstructClientRstStreamPacket() {
+ return ConstructRstStreamCancelledPacket(++packet_number_, !kIncludeVersion,
&client_maker_);
}
@@ -690,9 +683,9 @@
&server_maker_);
}
- std::unique_ptr<quic::QuicReceivedPacket> ConstructClientEarlyRstStreamPacket(
- uint64_t packet_number) {
- return ConstructRstStreamCancelledPacket(packet_number, kIncludeVersion,
+ std::unique_ptr<quic::QuicReceivedPacket>
+ ConstructClientEarlyRstStreamPacket() {
+ return ConstructRstStreamCancelledPacket(++packet_number_, kIncludeVersion,
&client_maker_);
}
@@ -709,12 +702,11 @@
}
std::unique_ptr<quic::QuicReceivedPacket>
- ConstructClientAckAndRstStreamPacket(uint64_t packet_number,
- uint64_t largest_received,
+ ConstructClientAckAndRstStreamPacket(uint64_t largest_received,
uint64_t smallest_received,
uint64_t least_unacked) {
return client_maker_.MakeAckAndRstPacket(
- packet_number, !kIncludeVersion, stream_id_,
+ ++packet_number_, !kIncludeVersion, stream_id_,
quic::QUIC_STREAM_CANCELLED, largest_received, smallest_received,
least_unacked, !kIncludeCongestionFeedback);
}
@@ -739,7 +731,6 @@
std::unique_ptr<quic::QuicReceivedPacket>
ConstructAckAndMultipleDataFramesPacket(
- uint64_t packet_number,
bool should_include_version,
uint64_t largest_received,
uint64_t smallest_received,
@@ -748,19 +739,19 @@
const std::vector<std::string> data_writes) {
std::unique_ptr<quic::QuicReceivedPacket> packet(
client_maker_.MakeAckAndMultipleDataFramesPacket(
- packet_number, should_include_version, stream_id_, largest_received,
- smallest_received, least_unacked, fin, data_writes));
- DVLOG(2) << "packet(" << packet_number << "): " << std::endl
+ ++packet_number_, should_include_version, stream_id_,
+ largest_received, smallest_received, least_unacked, fin,
+ data_writes));
+ DVLOG(2) << "packet(" << packet_number_ << "): " << std::endl
<< quic::QuicTextUtils::HexDump(packet->AsStringPiece());
return packet;
}
std::unique_ptr<quic::QuicReceivedPacket> ConstructClientAckPacket(
- uint64_t packet_number,
uint64_t largest_received,
uint64_t smallest_received,
uint64_t least_unacked) {
- return client_maker_.MakeAckPacket(packet_number, largest_received,
+ return client_maker_.MakeAckPacket(++packet_number_, largest_received,
smallest_received, least_unacked,
!kIncludeCongestionFeedback);
}
@@ -775,9 +766,8 @@
!kIncludeCongestionFeedback);
}
- std::unique_ptr<quic::QuicReceivedPacket> ConstructInitialSettingsPacket(
- uint64_t packet_number) {
- return client_maker_.MakeInitialSettingsPacket(packet_number);
+ std::unique_ptr<quic::QuicReceivedPacket> ConstructInitialSettingsPacket() {
+ return client_maker_.MakeInitialSettingsPacket(++packet_number_);
}
void ExpectLoadTimingValid(const LoadTimingInfo& load_timing_info,
@@ -834,6 +824,7 @@
const quic::QuicConnectionId connection_id_;
const quic::QuicStreamId stream_id_;
QuicTestPacketMaker client_maker_;
+ uint64_t packet_number_;
QuicTestPacketMaker server_maker_;
IPEndPoint self_addr_;
IPEndPoint peer_addr_;
@@ -869,11 +860,13 @@
size_t spdy_request_headers_frame_length;
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
AddWrite(ConstructRequestHeadersPacketInner(
- 1, GetNthClientInitiatedBidirectionalStreamId(0), kFin, DEFAULT_PRIORITY,
+ GetNthClientInitiatedBidirectionalStreamId(0), kFin, DEFAULT_PRIORITY,
&spdy_request_headers_frame_length));
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
- AddWrite(ConstructInitialSettingsPacket(2));
- AddWrite(ConstructClientAckPacket(3, 3, 1, 2));
+ if (!quic::VersionUsesQpack(version_.transport_version)) {
+ AddWrite(ConstructInitialSettingsPacket());
+ }
+ AddWrite(ConstructClientAckPacket(3, 1, 2));
Initialize();
@@ -972,16 +965,18 @@
SetRequest("GET", "/", DEFAULT_PRIORITY);
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
AddWrite(ConstructRequestHeadersPacketInner(
- 1, GetNthClientInitiatedBidirectionalStreamId(0), kFin, DEFAULT_PRIORITY,
+ GetNthClientInitiatedBidirectionalStreamId(0), kFin, DEFAULT_PRIORITY,
nullptr));
// SetRequest() again for second request as |request_headers_| was moved.
SetRequest("GET", "/", DEFAULT_PRIORITY);
AddWrite(ConstructRequestHeadersPacketInner(
- 2, GetNthClientInitiatedBidirectionalStreamId(1), kFin, DEFAULT_PRIORITY,
+ GetNthClientInitiatedBidirectionalStreamId(1), kFin, DEFAULT_PRIORITY,
GetNthClientInitiatedBidirectionalStreamId(0), nullptr));
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
- AddWrite(ConstructInitialSettingsPacket(3));
- AddWrite(ConstructClientAckPacket(4, 3, 1, 2));
+ if (!quic::VersionUsesQpack(version_.transport_version)) {
+ AddWrite(ConstructInitialSettingsPacket());
+ }
+ AddWrite(ConstructClientAckPacket(3, 1, 2));
Initialize();
BidirectionalStreamRequestInfo request;
@@ -1044,25 +1039,25 @@
TEST_P(BidirectionalStreamQuicImplTest, CoalesceDataBuffersNotHeadersFrame) {
SetRequest("POST", "/", DEFAULT_PRIORITY);
size_t spdy_request_headers_frame_length;
- AddWrite(ConstructInitialSettingsPacket(1));
+ AddWrite(ConstructInitialSettingsPacket());
const char kBody1[] = "here are some data";
const char kBody2[] = "data keep coming";
std::string header = ConstructDataHeader(strlen(kBody1));
std::string header2 = ConstructDataHeader(strlen(kBody2));
std::vector<std::string> two_writes = {kBody1, kBody2};
AddWrite(ConstructRequestHeadersPacketInner(
- 2, GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
+ GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
&spdy_request_headers_frame_length));
if (version_.transport_version != quic::QUIC_VERSION_99) {
- AddWrite(ConstructClientMultipleDataFramesPacket(3, kIncludeVersion, !kFin,
+ AddWrite(ConstructClientMultipleDataFramesPacket(kIncludeVersion, !kFin,
{kBody1, kBody2}));
} else {
AddWrite(ConstructClientMultipleDataFramesPacket(
- 3, kIncludeVersion, !kFin, {header, kBody1, header2, kBody2}));
+ kIncludeVersion, !kFin, {header, kBody1, header2, kBody2}));
}
// Ack server's data packet.
- AddWrite(ConstructClientAckPacket(4, 3, 1, 2));
+ AddWrite(ConstructClientAckPacket(3, 1, 2));
const char kBody3[] = "hello there";
const char kBody4[] = "another piece of small data";
const char kBody5[] = "really small";
@@ -1070,11 +1065,11 @@
std::string header4 = ConstructDataHeader(strlen(kBody4));
std::string header5 = ConstructDataHeader(strlen(kBody5));
if (version_.transport_version != quic::QUIC_VERSION_99) {
- AddWrite(ConstructClientMultipleDataFramesPacket(5, !kIncludeVersion, kFin,
+ AddWrite(ConstructClientMultipleDataFramesPacket(!kIncludeVersion, kFin,
{kBody3, kBody4, kBody5}));
} else {
AddWrite(ConstructClientMultipleDataFramesPacket(
- 5, !kIncludeVersion, kFin,
+ !kIncludeVersion, kFin,
{header3, kBody3, header4, kBody4, header5, kBody5}));
}
@@ -1183,28 +1178,27 @@
SendDataCoalesceDataBufferAndHeaderFrame) {
SetRequest("POST", "/", DEFAULT_PRIORITY);
size_t spdy_request_headers_frame_length;
- AddWrite(ConstructInitialSettingsPacket(1));
+ AddWrite(ConstructInitialSettingsPacket());
const char kBody1[] = "here are some data";
std::string header = ConstructDataHeader(strlen(kBody1));
if (version_.transport_version == quic::QUIC_VERSION_99) {
AddWrite(ConstructRequestHeadersAndMultipleDataFramesPacket(
- 2, !kFin, DEFAULT_PRIORITY, &spdy_request_headers_frame_length,
+ !kFin, DEFAULT_PRIORITY, &spdy_request_headers_frame_length,
{header, kBody1}));
} else {
AddWrite(ConstructRequestHeadersAndMultipleDataFramesPacket(
- 2, !kFin, DEFAULT_PRIORITY, &spdy_request_headers_frame_length,
- {kBody1}));
+ !kFin, DEFAULT_PRIORITY, &spdy_request_headers_frame_length, {kBody1}));
}
// Ack server's data packet.
- AddWrite(ConstructClientAckPacket(3, 3, 1, 2));
+ AddWrite(ConstructClientAckPacket(3, 1, 2));
const char kBody2[] = "really small";
std::string header2 = ConstructDataHeader(strlen(kBody2));
if (version_.transport_version == quic::QUIC_VERSION_99) {
- AddWrite(ConstructClientMultipleDataFramesPacket(4, !kIncludeVersion, kFin,
+ AddWrite(ConstructClientMultipleDataFramesPacket(!kIncludeVersion, kFin,
{header2, kBody2}));
} else {
- AddWrite(ConstructClientMultipleDataFramesPacket(4, !kIncludeVersion, kFin,
+ AddWrite(ConstructClientMultipleDataFramesPacket(!kIncludeVersion, kFin,
{kBody2}));
}
@@ -1298,7 +1292,7 @@
SendvDataCoalesceDataBuffersAndHeaderFrame) {
SetRequest("POST", "/", DEFAULT_PRIORITY);
size_t spdy_request_headers_frame_length;
- AddWrite(ConstructInitialSettingsPacket(1));
+ AddWrite(ConstructInitialSettingsPacket());
const char kBody1[] = "here are some data";
const char kBody2[] = "data keep coming";
std::string header = ConstructDataHeader(strlen(kBody1));
@@ -1306,16 +1300,16 @@
if (version_.transport_version == quic::QUIC_VERSION_99) {
AddWrite(ConstructRequestHeadersAndMultipleDataFramesPacket(
- 2, !kFin, DEFAULT_PRIORITY, &spdy_request_headers_frame_length,
+ !kFin, DEFAULT_PRIORITY, &spdy_request_headers_frame_length,
{header, kBody1, header2, kBody2}));
} else {
AddWrite(ConstructRequestHeadersAndMultipleDataFramesPacket(
- 2, !kFin, DEFAULT_PRIORITY, &spdy_request_headers_frame_length,
+ !kFin, DEFAULT_PRIORITY, &spdy_request_headers_frame_length,
{kBody1, kBody2}));
}
// Ack server's data packet.
- AddWrite(ConstructClientAckPacket(3, 3, 1, 2));
+ AddWrite(ConstructClientAckPacket(3, 1, 2));
const char kBody3[] = "hello there";
const char kBody4[] = "another piece of small data";
const char kBody5[] = "really small";
@@ -1324,10 +1318,10 @@
std::string header5 = ConstructDataHeader(strlen(kBody5));
if (version_.transport_version == quic::QUIC_VERSION_99) {
AddWrite(ConstructClientMultipleDataFramesPacket(
- 4, !kIncludeVersion, kFin,
+ !kIncludeVersion, kFin,
{header3, kBody3, header4, kBody4, header5, kBody5}));
} else {
- AddWrite(ConstructClientMultipleDataFramesPacket(4, !kIncludeVersion, kFin,
+ AddWrite(ConstructClientMultipleDataFramesPacket(!kIncludeVersion, kFin,
{kBody3, kBody4, kBody5}));
}
@@ -1429,7 +1423,7 @@
// headers to be sent, if that write fails the stream does not crash.
TEST_P(BidirectionalStreamQuicImplTest,
SendDataWriteErrorCoalesceDataBufferAndHeaderFrame) {
- AddWrite(ConstructInitialSettingsPacket(1));
+ AddWrite(ConstructInitialSettingsPacket());
AddWriteError(SYNCHRONOUS, ERR_CONNECTION_REFUSED);
Initialize();
@@ -1464,7 +1458,7 @@
// headers to be sent, if that write fails the stream does not crash.
TEST_P(BidirectionalStreamQuicImplTest,
SendvDataWriteErrorCoalesceDataBufferAndHeaderFrame) {
- AddWrite(ConstructInitialSettingsPacket(1));
+ AddWrite(ConstructInitialSettingsPacket());
AddWriteError(SYNCHRONOUS, ERR_CONNECTION_REFUSED);
Initialize();
@@ -1502,20 +1496,20 @@
TEST_P(BidirectionalStreamQuicImplTest, PostRequest) {
SetRequest("POST", "/", DEFAULT_PRIORITY);
size_t spdy_request_headers_frame_length;
- AddWrite(ConstructInitialSettingsPacket(1));
+ AddWrite(ConstructInitialSettingsPacket());
AddWrite(ConstructRequestHeadersPacketInner(
- 2, GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
+ GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
&spdy_request_headers_frame_length));
std::string header = ConstructDataHeader(strlen(kUploadData));
if (version_.transport_version == quic::QUIC_VERSION_99) {
- AddWrite(ConstructClientMultipleDataFramesPacket(3, kIncludeVersion, kFin,
+ AddWrite(ConstructClientMultipleDataFramesPacket(kIncludeVersion, kFin,
{header, kUploadData}));
} else {
- AddWrite(ConstructClientMultipleDataFramesPacket(3, kIncludeVersion, kFin,
+ AddWrite(ConstructClientMultipleDataFramesPacket(kIncludeVersion, kFin,
{kUploadData}));
}
- AddWrite(ConstructClientAckPacket(4, 3, 1, 2));
+ AddWrite(ConstructClientAckPacket(3, 1, 2));
Initialize();
@@ -1595,20 +1589,20 @@
TEST_P(BidirectionalStreamQuicImplTest, EarlyDataOverrideRequest) {
SetRequest("PUT", "/", DEFAULT_PRIORITY);
size_t spdy_request_headers_frame_length;
- AddWrite(ConstructInitialSettingsPacket(1));
+ AddWrite(ConstructInitialSettingsPacket());
AddWrite(ConstructRequestHeadersPacketInner(
- 2, GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
+ GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
&spdy_request_headers_frame_length));
std::string header = ConstructDataHeader(strlen(kUploadData));
if (version_.transport_version == quic::QUIC_VERSION_99) {
- AddWrite(ConstructClientMultipleDataFramesPacket(3, kIncludeVersion, kFin,
+ AddWrite(ConstructClientMultipleDataFramesPacket(kIncludeVersion, kFin,
{header, kUploadData}));
} else {
- AddWrite(ConstructClientMultipleDataFramesPacket(3, kIncludeVersion, kFin,
+ AddWrite(ConstructClientMultipleDataFramesPacket(kIncludeVersion, kFin,
{kUploadData}));
}
- AddWrite(ConstructClientAckPacket(4, 3, 1, 2));
+ AddWrite(ConstructClientAckPacket(3, 1, 2));
Initialize();
@@ -1689,22 +1683,22 @@
TEST_P(BidirectionalStreamQuicImplTest, InterleaveReadDataAndSendData) {
SetRequest("POST", "/", DEFAULT_PRIORITY);
size_t spdy_request_headers_frame_length;
- AddWrite(ConstructInitialSettingsPacket(1));
+ AddWrite(ConstructInitialSettingsPacket());
AddWrite(ConstructRequestHeadersPacketInner(
- 2, GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
+ GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
&spdy_request_headers_frame_length));
std::string header = ConstructDataHeader(strlen(kUploadData));
if (version_.transport_version != quic::QUIC_VERSION_99) {
- AddWrite(ConstructAckAndDataPacket(3, !kIncludeVersion, 2, 1, 2, !kFin,
- kUploadData, &client_maker_));
- AddWrite(ConstructAckAndDataPacket(4, !kIncludeVersion, 3, 3, 3, kFin,
- kUploadData, &client_maker_));
+ AddWrite(ConstructAckAndDataPacket(++packet_number_, !kIncludeVersion, 2, 1,
+ 2, !kFin, kUploadData, &client_maker_));
+ AddWrite(ConstructAckAndDataPacket(++packet_number_, !kIncludeVersion, 3, 3,
+ 3, kFin, kUploadData, &client_maker_));
} else {
AddWrite(ConstructAckAndMultipleDataFramesPacket(
- 3, !kIncludeVersion, 2, 1, 1, !kFin, {header, kUploadData}));
+ !kIncludeVersion, 2, 1, 1, !kFin, {header, kUploadData}));
AddWrite(ConstructAckAndMultipleDataFramesPacket(
- 4, !kIncludeVersion, 3, 3, 3, kFin, {header, kUploadData}));
+ !kIncludeVersion, 3, 3, 3, kFin, {header, kUploadData}));
}
Initialize();
@@ -1793,10 +1787,12 @@
size_t spdy_request_headers_frame_length;
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
AddWrite(ConstructRequestHeadersPacketInner(
- 1, GetNthClientInitiatedBidirectionalStreamId(0), kFin, DEFAULT_PRIORITY,
+ GetNthClientInitiatedBidirectionalStreamId(0), kFin, DEFAULT_PRIORITY,
&spdy_request_headers_frame_length));
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
- AddWrite(ConstructInitialSettingsPacket(2));
+ if (!quic::VersionUsesQpack(version_.transport_version)) {
+ AddWrite(ConstructInitialSettingsPacket());
+ }
Initialize();
BidirectionalStreamRequestInfo request;
@@ -1838,12 +1834,14 @@
size_t spdy_request_headers_frame_length;
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
AddWrite(ConstructRequestHeadersPacketInner(
- 1, GetNthClientInitiatedBidirectionalStreamId(0), kFin, DEFAULT_PRIORITY,
+ GetNthClientInitiatedBidirectionalStreamId(0), kFin, DEFAULT_PRIORITY,
&spdy_request_headers_frame_length));
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
- AddWrite(ConstructInitialSettingsPacket(2));
+ if (!quic::VersionUsesQpack(version_.transport_version)) {
+ AddWrite(ConstructInitialSettingsPacket());
+ }
// Why does QUIC ack Rst? Is this expected?
- AddWrite(ConstructClientAckPacket(3, 3, 1, 2));
+ AddWrite(ConstructClientAckPacket(3, 1, 2));
Initialize();
@@ -1899,9 +1897,9 @@
TEST_P(BidirectionalStreamQuicImplTest, SessionClosedBeforeReadData) {
SetRequest("POST", "/", DEFAULT_PRIORITY);
size_t spdy_request_headers_frame_length;
- AddWrite(ConstructInitialSettingsPacket(1));
+ AddWrite(ConstructInitialSettingsPacket());
AddWrite(ConstructRequestHeadersPacketInner(
- 2, GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
+ GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
&spdy_request_headers_frame_length));
Initialize();
@@ -2007,7 +2005,7 @@
TEST_P(BidirectionalStreamQuicImplTest, SessionCloseDuringOnStreamReady) {
SetRequest("POST", "/", DEFAULT_PRIORITY);
- AddWrite(ConstructInitialSettingsPacket(1));
+ AddWrite(ConstructInitialSettingsPacket());
AddWriteError(SYNCHRONOUS, ERR_CONNECTION_REFUSED);
Initialize();
@@ -2034,11 +2032,11 @@
TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamDuringOnStreamReady) {
SetRequest("POST", "/", DEFAULT_PRIORITY);
size_t spdy_request_headers_frame_length;
- AddWrite(ConstructInitialSettingsPacket(1));
+ AddWrite(ConstructInitialSettingsPacket());
AddWrite(ConstructRequestHeadersPacketInner(
- 2, GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
+ GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
&spdy_request_headers_frame_length));
- AddWrite(ConstructClientEarlyRstStreamPacket(3));
+ AddWrite(ConstructClientEarlyRstStreamPacket());
Initialize();
@@ -2065,11 +2063,11 @@
TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamAfterReadData) {
SetRequest("POST", "/", DEFAULT_PRIORITY);
size_t spdy_request_headers_frame_length;
- AddWrite(ConstructInitialSettingsPacket(1));
+ AddWrite(ConstructInitialSettingsPacket());
AddWrite(ConstructRequestHeadersPacketInner(
- 2, GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
+ GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
&spdy_request_headers_frame_length));
- AddWrite(ConstructClientAckAndRstStreamPacket(3, 2, 1, 2));
+ AddWrite(ConstructClientAckAndRstStreamPacket(2, 1, 2));
Initialize();
@@ -2120,11 +2118,11 @@
TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamDuringOnHeadersReceived) {
SetRequest("POST", "/", DEFAULT_PRIORITY);
size_t spdy_request_headers_frame_length;
- AddWrite(ConstructInitialSettingsPacket(1));
+ AddWrite(ConstructInitialSettingsPacket());
AddWrite(ConstructRequestHeadersPacketInner(
- 2, GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
+ GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
&spdy_request_headers_frame_length));
- AddWrite(ConstructClientAckAndRstStreamPacket(3, 2, 1, 2));
+ AddWrite(ConstructClientAckAndRstStreamPacket(2, 1, 2));
Initialize();
@@ -2167,12 +2165,12 @@
TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamDuringOnDataRead) {
SetRequest("POST", "/", DEFAULT_PRIORITY);
size_t spdy_request_headers_frame_length;
- AddWrite(ConstructInitialSettingsPacket(1));
+ AddWrite(ConstructInitialSettingsPacket());
AddWrite(ConstructRequestHeadersPacketInner(
- 2, GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
+ GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
&spdy_request_headers_frame_length));
- AddWrite(ConstructClientAckPacket(3, 3, 1, 2));
- AddWrite(ConstructClientRstStreamPacket(4));
+ AddWrite(ConstructClientAckPacket(3, 1, 2));
+ AddWrite(ConstructClientRstStreamPacket());
Initialize();
@@ -2226,19 +2224,19 @@
const char kBody[] = "here is some data";
SetRequest("POST", "/", DEFAULT_PRIORITY);
size_t spdy_request_headers_frame_length;
- AddWrite(ConstructInitialSettingsPacket(1));
+ AddWrite(ConstructInitialSettingsPacket());
AddWrite(ConstructRequestHeadersPacketInner(
- 2, GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
+ GetNthClientInitiatedBidirectionalStreamId(0), !kFin, DEFAULT_PRIORITY,
&spdy_request_headers_frame_length));
std::string header = ConstructDataHeader(strlen(kBody));
if (version_.transport_version == quic::QUIC_VERSION_99) {
- AddWrite(ConstructClientMultipleDataFramesPacket(3, kIncludeVersion, kFin,
+ AddWrite(ConstructClientMultipleDataFramesPacket(kIncludeVersion, kFin,
{header, kBody}));
} else {
- AddWrite(ConstructClientMultipleDataFramesPacket(3, kIncludeVersion, kFin,
+ AddWrite(ConstructClientMultipleDataFramesPacket(kIncludeVersion, kFin,
{kBody}));
}
- AddWrite(ConstructClientAckPacket(4, 3, 1, 2));
+ AddWrite(ConstructClientAckPacket(3, 1, 2));
Initialize();
@@ -2302,10 +2300,10 @@
SetRequest("GET", "/", DEFAULT_PRIORITY);
size_t spdy_request_headers_frame_length;
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
- AddWrite(ConstructRequestHeadersPacket(1, kFin, DEFAULT_PRIORITY,
+ AddWrite(ConstructRequestHeadersPacket(kFin, DEFAULT_PRIORITY,
&spdy_request_headers_frame_length));
- AddWrite(ConstructClientAckPacket(2, 3, 1, 2)); // Ack the data packet
- AddWrite(ConstructClientAckAndRstStreamPacket(3, 4, 4, 2));
+ AddWrite(ConstructClientAckPacket(3, 1, 2)); // Ack the data packet
+ AddWrite(ConstructClientAckAndRstStreamPacket(4, 4, 2));
Initialize();
diff --git a/net/quic/quic_network_transaction_unittest.cc b/net/quic/quic_network_transaction_unittest.cc
index a555fc8..f5b83e7 100644
--- a/net/quic/quic_network_transaction_unittest.cc
+++ b/net/quic/quic_network_transaction_unittest.cc
@@ -2569,32 +2569,58 @@
priority, GetRequestHeaders("GET", "https", "/"), 0, nullptr));
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
- quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(2));
- // TLP 1
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 3, true));
- // TLP 2
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 4, true));
- // RTO 1
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 5, true));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 6, true));
- // RTO 2
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 7, true));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 8, true));
- // RTO 3
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 9, true));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 10, true));
+ if (version_.transport_version != quic::QUIC_VERSION_99) {
+ quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(2));
+ // TLP 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 3, true));
+ // TLP 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 4, true));
+ // RTO 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 5, true));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 6, true));
+ // RTO 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 7, true));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 8, true));
+ // RTO 3
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 9, true));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 10, true));
- quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket(
- 11, true, quic::QUIC_NETWORK_IDLE_TIMEOUT,
- "No recent network activity."));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeConnectionClosePacket(
+ 11, true, quic::QUIC_NETWORK_IDLE_TIMEOUT,
+ "No recent network activity."));
+ } else {
+ // Settings were sent in the request packet so there is only 1 packet to
+ // retransmit.
+ // TLP 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 2, true));
+ // TLP 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 3, true));
+ // RTO 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 4, true));
+ // RTO 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 5, true));
+ // RTO 3
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 6, true));
+
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeConnectionClosePacket(
+ 7, true, quic::QUIC_NETWORK_IDLE_TIMEOUT,
+ "No recent network activity."));
+ }
quic_data.AddRead(ASYNC, ERR_IO_PENDING);
quic_data.AddRead(ASYNC, OK);
@@ -2640,6 +2666,11 @@
// Verify that if a QUIC connection RTOs, the QuicHttpStream will
// return QUIC_PROTOCOL_ERROR.
TEST_P(QuicNetworkTransactionTest, TooManyRtosAfterHandshakeConfirmed) {
+ if (version_.transport_version == quic::QUIC_VERSION_99) {
+ // TODO(rch): Re-enable.
+ return;
+ }
+
session_params_.retry_without_alt_svc_on_quic_errors = false;
session_params_.quic_connection_options.push_back(quic::k5RTO);
@@ -2733,6 +2764,11 @@
// QUIC will not be marked as broken.
TEST_P(QuicNetworkTransactionTest,
TooManyRtosAfterHandshakeConfirmedAndStreamReset) {
+ if (version_.transport_version == quic::QUIC_VERSION_99) {
+ // TODO(rch): Re-enable.
+ return;
+ }
+
session_params_.quic_connection_options.push_back(quic::k5RTO);
// The request will initially go out over QUIC.
@@ -2864,6 +2900,11 @@
// Verify that if a QUIC protocol error occurs after the handshake is confirmed
// the request fails with QUIC_PROTOCOL_ERROR.
TEST_P(QuicNetworkTransactionTest, ProtocolErrorAfterHandshakeConfirmed) {
+ if (version_.transport_version == quic::QUIC_VERSION_99) {
+ // TODO(rch): Re-enable.
+ return;
+ }
+
session_params_.retry_without_alt_svc_on_quic_errors = false;
// The request will initially go out over QUIC.
MockQuicData quic_data(version_);
@@ -2873,7 +2914,11 @@
1, GetNthClientInitiatedBidirectionalStreamId(0), true,
true, GetRequestHeaders("GET", "https", "/")));
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
- quic_data.AddWrite(SYNCHRONOUS, ConstructInitialSettingsPacket(2));
+ uint64_t packet_number = 2;
+ if (version_.transport_version != quic::QUIC_VERSION_99) {
+ quic_data.AddWrite(SYNCHRONOUS,
+ ConstructInitialSettingsPacket(packet_number++));
+ }
// Peer sending data from an non-existing stream causes this end to raise
// error and close connection.
quic_data.AddRead(
@@ -2881,10 +2926,10 @@
1, false, GetNthClientInitiatedBidirectionalStreamId(47),
quic::QUIC_STREAM_LAST_ERROR));
std::string quic_error_details = "Data for nonexistent stream";
- quic_data.AddWrite(SYNCHRONOUS,
- ConstructClientAckAndConnectionClosePacket(
- 3, quic::QuicTime::Delta::Zero(), 1, 1, 1,
- quic::QUIC_INVALID_STREAM_ID, quic_error_details));
+ quic_data.AddWrite(
+ SYNCHRONOUS, ConstructClientAckAndConnectionClosePacket(
+ packet_number++, quic::QuicTime::Delta::Zero(), 1, 1, 1,
+ quic::QUIC_INVALID_STREAM_ID, quic_error_details));
quic_data.AddSocketDataToFactory(&socket_factory_);
// In order for a new QUIC session to be established via alternate-protocol
@@ -2944,32 +2989,58 @@
priority, GetRequestHeaders("GET", "https", "/"), 0, nullptr));
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
- quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(2));
- // TLP 1
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 3, true));
- // TLP 2
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 4, true));
- // RTO 1
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 5, true));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 6, true));
- // RTO 2
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 7, true));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 8, true));
- // RTO 3
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 9, true));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 10, true));
+ if (version_.transport_version != quic::QUIC_VERSION_99) {
+ quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(2));
+ // TLP 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 3, true));
+ // TLP 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 4, true));
+ // RTO 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 5, true));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 6, true));
+ // RTO 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 7, true));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 8, true));
+ // RTO 3
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 9, true));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 10, true));
- quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket(
- 11, true, quic::QUIC_NETWORK_IDLE_TIMEOUT,
- "No recent network activity."));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeConnectionClosePacket(
+ 11, true, quic::QUIC_NETWORK_IDLE_TIMEOUT,
+ "No recent network activity."));
+ } else {
+ // Settings were sent in the request packet so there is only 1 packet to
+ // retransmit.
+ // TLP 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 2, true));
+ // TLP 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 3, true));
+ // RTO 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 4, true));
+ // RTO 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 5, true));
+ // RTO 3
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 6, true));
+
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeConnectionClosePacket(
+ 7, true, quic::QUIC_NETWORK_IDLE_TIMEOUT,
+ "No recent network activity."));
+ }
quic_data.AddRead(ASYNC, ERR_IO_PENDING);
quic_data.AddRead(ASYNC, OK);
@@ -3056,32 +3127,58 @@
priority, GetRequestHeaders("GET", "https", "/"), 0, nullptr));
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
- quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(2));
- // TLP 1
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 3, true));
- // TLP 2
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 4, true));
- // RTO 1
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 5, true));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 6, true));
- // RTO 2
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 7, true));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 8, true));
- // RTO 3
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 9, true));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 10, true));
+ if (version_.transport_version != quic::QUIC_VERSION_99) {
+ quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(2));
+ // TLP 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 3, true));
+ // TLP 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 4, true));
+ // RTO 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 5, true));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 6, true));
+ // RTO 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 7, true));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 8, true));
+ // RTO 3
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 9, true));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 10, true));
- quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket(
- 11, true, quic::QUIC_NETWORK_IDLE_TIMEOUT,
- "No recent network activity."));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeConnectionClosePacket(
+ 11, true, quic::QUIC_NETWORK_IDLE_TIMEOUT,
+ "No recent network activity."));
+ } else {
+ // Settings were sent in the request packet so there is only 1 packet to
+ // retransmit.
+ // TLP 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 2, true));
+ // TLP 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 3, true));
+ // RTO 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 4, true));
+ // RTO 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 5, true));
+ // RTO 3
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 6, true));
+
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeConnectionClosePacket(
+ 7, true, quic::QUIC_NETWORK_IDLE_TIMEOUT,
+ "No recent network activity."));
+ }
quic_data.AddRead(ASYNC, ERR_IO_PENDING);
quic_data.AddRead(ASYNC, OK);
@@ -3172,44 +3269,81 @@
priority, GetRequestHeaders("GET", "https", "/"), 0, nullptr));
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
- quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(2));
+ if (version_.transport_version != quic::QUIC_VERSION_99) {
+ quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(2));
- quic_data.AddRead(ASYNC, ConstructServerResponseHeadersPacket(
- 1, GetNthClientInitiatedBidirectionalStreamId(0),
- false, false, GetResponseHeaders("200 OK")));
- // quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 1, 1));
- quic_data.AddWrite(
- SYNCHRONOUS,
- ConstructClientAckPacket(3, 1, 1, 1,
- quic::QuicTime::Delta::FromMilliseconds(25)));
+ quic_data.AddRead(
+ ASYNC, ConstructServerResponseHeadersPacket(
+ 1, GetNthClientInitiatedBidirectionalStreamId(0), false,
+ false, GetResponseHeaders("200 OK")));
+ // quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 1, 1));
+ quic_data.AddWrite(
+ SYNCHRONOUS,
+ ConstructClientAckPacket(3, 1, 1, 1,
+ quic::QuicTime::Delta::FromMilliseconds(25)));
- // TLP 1
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 4, false));
- // TLP 2
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 5, false));
- // RTO 1
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 6, false));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 7, false));
- // RTO 2
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 8, false));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 9, false));
- // RTO 3
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 10, false));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 11, false));
+ // TLP 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 4, false));
+ // TLP 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 5, false));
+ // RTO 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 6, false));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 7, false));
+ // RTO 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 8, false));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 9, false));
+ // RTO 3
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 10, false));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 11, false));
- quic_data.AddWrite(
- SYNCHRONOUS,
- client_maker_.MakeAckAndConnectionClosePacket(
- 12, false, quic::QuicTime::Delta::FromMilliseconds(4000), 1, 1, 1,
- quic::QUIC_NETWORK_IDLE_TIMEOUT, "No recent network activity."));
+ quic_data.AddWrite(
+ SYNCHRONOUS,
+ client_maker_.MakeAckAndConnectionClosePacket(
+ 12, false, quic::QuicTime::Delta::FromMilliseconds(4000), 1, 1, 1,
+ quic::QUIC_NETWORK_IDLE_TIMEOUT, "No recent network activity."));
+ } else {
+ // Settings were sent in the request packet so there is only 1 packet to
+ // retransmit.
+ quic_data.AddRead(
+ ASYNC, ConstructServerResponseHeadersPacket(
+ 1, GetNthClientInitiatedBidirectionalStreamId(0), false,
+ false, GetResponseHeaders("200 OK")));
+ // quic_data.AddWrite(SYNCHRONOUS, ConstructClientAckPacket(3, 1, 1));
+ quic_data.AddWrite(
+ SYNCHRONOUS,
+ ConstructClientAckPacket(2, 1, 1, 1,
+ quic::QuicTime::Delta::FromMilliseconds(25)));
+
+ // TLP 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 3, false));
+ // TLP 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 4, false));
+ // RTO 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 5, false));
+ // RTO 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 6, false));
+ // RTO 3
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 7, false));
+
+ quic_data.AddWrite(
+ SYNCHRONOUS,
+ client_maker_.MakeAckAndConnectionClosePacket(
+ 8, false, quic::QuicTime::Delta::FromMilliseconds(4000), 1, 1, 1,
+ quic::QUIC_NETWORK_IDLE_TIMEOUT, "No recent network activity."));
+ }
quic_data.AddRead(ASYNC, ERR_IO_PENDING);
quic_data.AddRead(ASYNC, OK);
@@ -3285,39 +3419,67 @@
priority, GetRequestHeaders("GET", "https", "/"), 0, nullptr));
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
- quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(2));
+ if (version_.transport_version != quic::QUIC_VERSION_99) {
+ quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(2));
- // TLP 1
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 3, true));
- // TLP 2
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 4, true));
- // RTO 1
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 5, true));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 6, true));
- // RTO 2
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 7, true));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 8, true));
- // RTO 3
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 9, true));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 10, true));
- // RTO 4
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(1, 11, true));
- quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeRetransmissionPacket(2, 12, true));
+ // TLP 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 3, true));
+ // TLP 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 4, true));
+ // RTO 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 5, true));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 6, true));
+ // RTO 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 7, true));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 8, true));
+ // RTO 3
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 9, true));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 10, true));
+ // RTO 4
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 11, true));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(2, 12, true));
- quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeConnectionClosePacket(
- 13, true, quic::QUIC_TOO_MANY_RTOS,
- "5 consecutive retransmission timeouts"));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeConnectionClosePacket(
+ 13, true, quic::QUIC_TOO_MANY_RTOS,
+ "5 consecutive retransmission timeouts"));
+ } else {
+ // Settings were sent in the request packet so there is only 1 packet to
+ // retransmit.
+ // TLP 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 2, true));
+ // TLP 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 3, true));
+ // RTO 1
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 4, true));
+ // RTO 2
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 5, true));
+ // RTO 3
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 6, true));
+ // RTO 4
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeRetransmissionPacket(1, 7, true));
+ quic_data.AddWrite(SYNCHRONOUS,
+ client_maker_.MakeConnectionClosePacket(
+ 8, true, quic::QUIC_TOO_MANY_RTOS,
+ "5 consecutive retransmission timeouts"));
+ }
quic_data.AddRead(ASYNC, OK);
quic_data.AddSocketDataToFactory(&socket_factory_);
@@ -3386,6 +3548,11 @@
// QUIC will be marked as broken.
TEST_P(QuicNetworkTransactionTest,
TooManyRtosAfterHandshakeConfirmedAndStreamResetThenBroken) {
+ if (version_.transport_version == quic::QUIC_VERSION_99) {
+ // TODO(rch): Re-enable.
+ return;
+ }
+
session_params_.mark_quic_broken_when_network_blackholes = true;
session_params_.quic_connection_options.push_back(quic::k5RTO);
@@ -3404,11 +3571,11 @@
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
quic_data.AddWrite(SYNCHRONOUS, client_maker_.MakeInitialSettingsPacket(2));
-
quic_data.AddWrite(SYNCHRONOUS,
client_maker_.MakeRstPacket(
3, true, GetNthClientInitiatedBidirectionalStreamId(0),
quic::QUIC_STREAM_CANCELLED));
+
if (quic::VersionUsesQpack(version_.transport_version)) {
// Since the headers are sent on the data stream, when the stream is reset
// the headers are no longer retransmitted.
@@ -3521,6 +3688,11 @@
// retried over TCP and the QUIC will be marked as broken.
TEST_P(QuicNetworkTransactionTest,
ProtocolErrorAfterHandshakeConfirmedThenBroken) {
+ if (version_.transport_version == quic::QUIC_VERSION_99) {
+ // TODO(rch): Re-enable.
+ return;
+ }
+
session_params_.quic_idle_connection_timeout_seconds = 5;
// The request will initially go out over QUIC.
@@ -3607,6 +3779,11 @@
// request is reset from, then QUIC will be marked as broken and the request
// retried over TCP.
TEST_P(QuicNetworkTransactionTest, ResetAfterHandshakeConfirmedThenBroken) {
+ if (version_.transport_version == quic::QUIC_VERSION_99) {
+ // TODO(rch): Re-enable.
+ return;
+ }
+
// The request will initially go out over QUIC.
MockQuicData quic_data(version_);
spdy::SpdyPriority priority =
@@ -4719,31 +4896,37 @@
}
TEST_P(QuicNetworkTransactionTest, ZeroRTTWithTooEarlyResponse) {
+ uint64_t packet_number = 1;
MockQuicData mock_quic_data(version_);
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
mock_quic_data.AddWrite(
- SYNCHRONOUS, ConstructClientRequestHeadersPacket(
- 1, GetNthClientInitiatedBidirectionalStreamId(0), true,
- true, GetRequestHeaders("GET", "https", "/")));
+ SYNCHRONOUS,
+ ConstructClientRequestHeadersPacket(
+ packet_number++, GetNthClientInitiatedBidirectionalStreamId(0), true,
+ true, GetRequestHeaders("GET", "https", "/")));
mock_quic_data.AddRead(
ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedBidirectionalStreamId(0), false, false,
GetResponseHeaders("425 TOO_EARLY")));
- mock_quic_data.AddWrite(SYNCHRONOUS,
- ConstructClientAckAndRstPacket(
- 2, GetNthClientInitiatedBidirectionalStreamId(0),
- quic::QUIC_STREAM_CANCELLED, 1, 1, 1));
+ mock_quic_data.AddWrite(
+ SYNCHRONOUS,
+ ConstructClientAckAndRstPacket(
+ packet_number++, GetNthClientInitiatedBidirectionalStreamId(0),
+ quic::QUIC_STREAM_CANCELLED, 1, 1, 1));
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
- mock_quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeSettingsPacket(3, false));
+ if (version_.transport_version != quic::QUIC_VERSION_99) {
+ mock_quic_data.AddWrite(
+ SYNCHRONOUS, client_maker_.MakeSettingsPacket(packet_number++, false));
+ }
mock_quic_data.AddWrite(
- SYNCHRONOUS, ConstructClientRequestHeadersPacket(
- 4, GetNthClientInitiatedBidirectionalStreamId(1), false,
- true, GetRequestHeaders("GET", "https", "/"),
- GetNthClientInitiatedBidirectionalStreamId(0)));
+ SYNCHRONOUS,
+ ConstructClientRequestHeadersPacket(
+ packet_number++, GetNthClientInitiatedBidirectionalStreamId(1), false,
+ true, GetRequestHeaders("GET", "https", "/"),
+ GetNthClientInitiatedBidirectionalStreamId(0)));
mock_quic_data.AddRead(
ASYNC, ConstructServerResponseHeadersPacket(
2, GetNthClientInitiatedBidirectionalStreamId(1), false, false,
@@ -4754,7 +4937,8 @@
3, GetNthClientInitiatedBidirectionalStreamId(1), false, true,
header + "hello!"));
mock_quic_data.AddWrite(
- SYNCHRONOUS, ConstructClientAckAndConnectionClosePacket(5, 3, 1, 1));
+ SYNCHRONOUS,
+ ConstructClientAckAndConnectionClosePacket(packet_number++, 3, 1, 1));
mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
mock_quic_data.AddRead(ASYNC, 0); // EOF
@@ -4796,39 +4980,46 @@
}
TEST_P(QuicNetworkTransactionTest, ZeroRTTWithMultipleTooEarlyResponse) {
+ uint64_t packet_number = 1;
MockQuicData mock_quic_data(version_);
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_ZERO_RTT);
mock_quic_data.AddWrite(
- SYNCHRONOUS, ConstructClientRequestHeadersPacket(
- 1, GetNthClientInitiatedBidirectionalStreamId(0), true,
- true, GetRequestHeaders("GET", "https", "/")));
+ SYNCHRONOUS,
+ ConstructClientRequestHeadersPacket(
+ packet_number++, GetNthClientInitiatedBidirectionalStreamId(0), true,
+ true, GetRequestHeaders("GET", "https", "/")));
mock_quic_data.AddRead(
ASYNC, ConstructServerResponseHeadersPacket(
1, GetNthClientInitiatedBidirectionalStreamId(0), false, false,
GetResponseHeaders("425 TOO_EARLY")));
- mock_quic_data.AddWrite(SYNCHRONOUS,
- ConstructClientAckAndRstPacket(
- 2, GetNthClientInitiatedBidirectionalStreamId(0),
- quic::QUIC_STREAM_CANCELLED, 1, 1, 1));
+ mock_quic_data.AddWrite(
+ SYNCHRONOUS,
+ ConstructClientAckAndRstPacket(
+ packet_number++, GetNthClientInitiatedBidirectionalStreamId(0),
+ quic::QUIC_STREAM_CANCELLED, 1, 1, 1));
client_maker_.SetEncryptionLevel(quic::ENCRYPTION_FORWARD_SECURE);
- mock_quic_data.AddWrite(SYNCHRONOUS,
- client_maker_.MakeSettingsPacket(3, false));
+ if (version_.transport_version != quic::QUIC_VERSION_99) {
+ mock_quic_data.AddWrite(
+ SYNCHRONOUS, client_maker_.MakeSettingsPacket(packet_number++, false));
+ }
mock_quic_data.AddWrite(
- SYNCHRONOUS, ConstructClientRequestHeadersPacket(
- 4, GetNthClientInitiatedBidirectionalStreamId(1), false,
- true, GetRequestHeaders("GET", "https", "/"),
- GetNthClientInitiatedBidirectionalStreamId(0)));
+ SYNCHRONOUS,
+ ConstructClientRequestHeadersPacket(
+ packet_number++, GetNthClientInitiatedBidirectionalStreamId(1), false,
+ true, GetRequestHeaders("GET", "https", "/"),
+ GetNthClientInitiatedBidirectionalStreamId(0)));
mock_quic_data.AddRead(
ASYNC, ConstructServerResponseHeadersPacket(
2, GetNthClientInitiatedBidirectionalStreamId(1), false, false,
GetResponseHeaders("425 TOO_EARLY")));
- mock_quic_data.AddWrite(SYNCHRONOUS,
- ConstructClientAckAndRstPacket(
- 5, GetNthClientInitiatedBidirectionalStreamId(1),
- quic::QUIC_STREAM_CANCELLED, 2, 1, 1));
+ mock_quic_data.AddWrite(
+ SYNCHRONOUS,
+ ConstructClientAckAndRstPacket(
+ packet_number++, GetNthClientInitiatedBidirectionalStreamId(1),
+ quic::QUIC_STREAM_CANCELLED, 2, 1, 1));
mock_quic_data.AddRead(ASYNC, ERR_IO_PENDING); // No more data to read
mock_quic_data.AddRead(ASYNC, 0); // EOF
diff --git a/net/quic/quic_test_packet_maker.cc b/net/quic/quic_test_packet_maker.cc
index 0e2fdb57..b09dbc0c 100644
--- a/net/quic/quic_test_packet_maker.cc
+++ b/net/quic/quic_test_packet_maker.cc
@@ -350,12 +350,52 @@
}
if (quic::VersionUsesQpack(version_.transport_version)) {
+ // A stream frame containing stream type will be written on the control
+ // stream first.
+ std::string type(1, 0x00);
+
+ quic::SettingsFrame settings;
+ settings.values[quic::kSettingsMaxHeaderListSize] =
+ quic::kDefaultMaxUncompressedHeaderSize;
+ std::unique_ptr<char[]> buffer1;
+ quic::QuicByteCount frame_length1 =
+ http_encoder_.SerializeSettingsFrame(settings, &buffer1);
+ std::string settings_data = std::string(buffer1.get(), frame_length1);
+
+ quic::QuicStreamFrame type_frame;
+ quic::QuicStreamFrame settings_frame;
+ if (stream_offsets_[2] == 0) {
+ type_frame = GenerateNextStreamFrame(2, false, type);
+ frames.push_back(quic::QuicFrame(type_frame));
+ settings_frame = GenerateNextStreamFrame(2, false, settings_data);
+ frames.push_back(quic::QuicFrame(settings_frame));
+ }
+
+ quic::PriorityFrame frame;
+ frame.weight = priority;
+ frame.dependency_type = quic::ROOT_OF_TREE;
+ frame.prioritized_type = quic::REQUEST_STREAM;
+ frame.prioritized_element_id = stream_id;
+
+ std::unique_ptr<char[]> buffer;
+ quic::QuicByteCount frame_length =
+ http_encoder_.SerializePriorityFrame(frame, &buffer);
+ std::string priority_data = std::string(buffer.get(), frame_length);
+
+ quic::QuicStreamFrame priority_frame =
+ GenerateNextStreamFrame(2, false, priority_data);
+
+ frames.push_back(quic::QuicFrame(priority_frame));
+
+ // STREAM frames for HEADERS.
std::vector<std::string> data = QpackEncodeHeaders(
stream_id, std::move(headers), spdy_headers_frame_length);
std::vector<quic::QuicStreamFrame> stream_frames =
GenerateNextStreamFrames(stream_id, fin, data);
+
for (const auto& frame : stream_frames)
frames.push_back(quic::QuicFrame(frame));
+
InitializeHeader(num, include_version);
return MakeMultipleFramesPacket(header_, frames, nullptr);
}
@@ -763,6 +803,42 @@
const std::vector<std::string>& data_writes) {
InitializeHeader(packet_number, should_include_version);
if (quic::VersionUsesQpack(version_.transport_version)) {
+ // A stream frame containing stream type will be written on the control
+ // stream first.
+ std::string type(1, 0x00);
+
+ quic::SettingsFrame settings;
+ settings.values[quic::kSettingsMaxHeaderListSize] =
+ quic::kDefaultMaxUncompressedHeaderSize;
+ std::unique_ptr<char[]> buffer1;
+ quic::QuicByteCount frame_length1 =
+ http_encoder_.SerializeSettingsFrame(settings, &buffer1);
+ std::string settings_data = std::string(buffer1.get(), frame_length1);
+
+ quic::QuicStreamFrame type_frame;
+ quic::QuicStreamFrame settings_frame;
+ quic::QuicFrames frames;
+ if (stream_offsets_[2] == 0) {
+ type_frame = GenerateNextStreamFrame(2, false, type);
+ frames.push_back(quic::QuicFrame(type_frame));
+ settings_frame = GenerateNextStreamFrame(2, false, settings_data);
+ frames.push_back(quic::QuicFrame(settings_frame));
+ }
+
+ quic::PriorityFrame frame;
+ frame.weight = priority;
+ frame.dependency_type = quic::ROOT_OF_TREE;
+ frame.prioritized_type = quic::REQUEST_STREAM;
+ frame.prioritized_element_id = stream_id;
+
+ std::unique_ptr<char[]> buffer;
+ quic::QuicByteCount frame_length =
+ http_encoder_.SerializePriorityFrame(frame, &buffer);
+ std::string priority_data = std::string(buffer.get(), frame_length);
+
+ quic::QuicStreamFrame priority_frame =
+ GenerateNextStreamFrame(2, false, priority_data);
+
// STREAM frames for HEADERS.
std::vector<std::string> data = QpackEncodeHeaders(
stream_id, std::move(headers), spdy_headers_frame_length);
@@ -776,9 +852,11 @@
stream_id, is_fin, quic::QuicStringPiece(data_writes[i])));
}
- quic::QuicFrames frames;
+ frames.push_back(quic::QuicFrame(priority_frame));
+
for (const auto& frame : stream_frames)
frames.push_back(quic::QuicFrame(frame));
+
return MakeMultipleFramesPacket(header_, frames, nullptr);
}
@@ -820,12 +898,49 @@
InitializeHeader(packet_number, should_include_version);
if (quic::VersionUsesQpack(version_.transport_version)) {
+ // A stream frame containing stream type will be written on the control
+ // stream first.
+ std::string type(1, 0x00);
+
+ quic::SettingsFrame settings;
+ settings.values[quic::kSettingsMaxHeaderListSize] =
+ quic::kDefaultMaxUncompressedHeaderSize;
+ std::unique_ptr<char[]> buffer1;
+ quic::QuicByteCount frame_length1 =
+ http_encoder_.SerializeSettingsFrame(settings, &buffer1);
+ std::string settings_data = std::string(buffer1.get(), frame_length1);
+
+ quic::QuicStreamFrame type_frame;
+ quic::QuicStreamFrame settings_frame;
+ quic::QuicFrames frames;
+ if (stream_offsets_[2] == 0) {
+ type_frame = GenerateNextStreamFrame(2, false, type);
+ frames.push_back(quic::QuicFrame(type_frame));
+ settings_frame = GenerateNextStreamFrame(2, false, settings_data);
+ frames.push_back(quic::QuicFrame(settings_frame));
+ }
+
+ quic::PriorityFrame frame;
+ frame.weight = priority;
+ frame.dependency_type = quic::ROOT_OF_TREE;
+ frame.prioritized_type = quic::REQUEST_STREAM;
+ frame.prioritized_element_id = stream_id;
+
+ std::unique_ptr<char[]> buffer;
+ quic::QuicByteCount frame_length =
+ http_encoder_.SerializePriorityFrame(frame, &buffer);
+ std::string priority_data = std::string(buffer.get(), frame_length);
+
+ quic::QuicStreamFrame priority_frame =
+ GenerateNextStreamFrame(2, false, priority_data);
+
std::vector<std::string> data = QpackEncodeHeaders(
stream_id, std::move(headers), spdy_headers_frame_length);
std::vector<quic::QuicStreamFrame> stream_frames =
GenerateNextStreamFrames(stream_id, fin, data);
- quic::QuicFrames frames;
+ frames.push_back(quic::QuicFrame(priority_frame));
+
for (const auto& frame : stream_frames)
frames.push_back(quic::QuicFrame(frame));
return MakeMultipleFramesPacket(header_, frames, nullptr);
@@ -855,13 +970,49 @@
size_t* spdy_headers_frame_length,
quic::QuicRstStreamErrorCode error_code) {
if (quic::VersionUsesQpack(version_.transport_version)) {
- // STREAM frames for HEADERS.
+ // A stream frame containing stream type will be written on the control
+ // stream first.
+ std::string type(1, 0x00);
+
+ quic::SettingsFrame settings;
+ settings.values[quic::kSettingsMaxHeaderListSize] =
+ quic::kDefaultMaxUncompressedHeaderSize;
+ std::unique_ptr<char[]> buffer1;
+ quic::QuicByteCount frame_length1 =
+ http_encoder_.SerializeSettingsFrame(settings, &buffer1);
+ std::string settings_data = std::string(buffer1.get(), frame_length1);
+
+ quic::QuicStreamFrame type_frame;
+ quic::QuicStreamFrame settings_frame;
+ quic::QuicFrames frames;
+ if (stream_offsets_[2] == 0) {
+ type_frame = GenerateNextStreamFrame(2, false, type);
+ frames.push_back(quic::QuicFrame(type_frame));
+ settings_frame = GenerateNextStreamFrame(2, false, settings_data);
+ frames.push_back(quic::QuicFrame(settings_frame));
+ }
+
+ quic::PriorityFrame frame;
+ frame.weight = priority;
+ frame.dependency_type = quic::ROOT_OF_TREE;
+ frame.prioritized_type = quic::REQUEST_STREAM;
+ frame.prioritized_element_id = stream_id;
+
+ std::unique_ptr<char[]> buffer;
+ quic::QuicByteCount frame_length =
+ http_encoder_.SerializePriorityFrame(frame, &buffer);
+ std::string priority_data = std::string(buffer.get(), frame_length);
+
+ quic::QuicStreamFrame priority_frame =
+ GenerateNextStreamFrame(2, false, priority_data);
+
std::vector<std::string> data = QpackEncodeHeaders(
stream_id, std::move(headers), spdy_headers_frame_length);
std::vector<quic::QuicStreamFrame> stream_frames =
GenerateNextStreamFrames(stream_id, fin, data);
- quic::QuicFrames frames;
+ frames.push_back(quic::QuicFrame(priority_frame));
+
for (const auto& frame : stream_frames)
frames.push_back(quic::QuicFrame(frame));
