summaryrefslogtreecommitdiffstats
path: root/chromium/net/quic/quic_proxy_client_socket_unittest.cc
diff options
context:
space:
mode:
Diffstat (limited to 'chromium/net/quic/quic_proxy_client_socket_unittest.cc')
-rw-r--r--chromium/net/quic/quic_proxy_client_socket_unittest.cc415
1 files changed, 308 insertions, 107 deletions
diff --git a/chromium/net/quic/quic_proxy_client_socket_unittest.cc b/chromium/net/quic/quic_proxy_client_socket_unittest.cc
index 7c741911222..0c4411f1b8d 100644
--- a/chromium/net/quic/quic_proxy_client_socket_unittest.cc
+++ b/chromium/net/quic/quic_proxy_client_socket_unittest.cc
@@ -110,11 +110,11 @@ class QuicProxyClientSocketTest
QuicProxyClientSocketTest()
: version_(std::get<0>(GetParam())),
client_data_stream_id1_(quic::QuicUtils::GetHeadersStreamId(version_) +
- 2),
+ quic::QuicUtils::StreamIdDelta(version_)),
client_headers_include_h2_stream_dependency_(std::get<1>(GetParam())),
crypto_config_(quic::test::crypto_test_utils::ProofVerifierForTesting(),
quic::TlsClientHandshaker::CreateSslCtx()),
- connection_id_(2),
+ connection_id_(quic::test::TestConnectionId(2)),
client_maker_(version_,
connection_id_,
&clock_,
@@ -323,11 +323,18 @@ class QuicProxyClientSocketTest
std::unique_ptr<quic::QuicReceivedPacket> ConstructDataPacket(
quic::QuicPacketNumber packet_number,
quic::QuicStreamOffset offset,
- const char* data,
- int length) {
+ quic::QuicStringPiece data) {
return client_maker_.MakeDataPacket(packet_number, client_data_stream_id1_,
- !kIncludeVersion, !kFin, offset,
- quic::QuicStringPiece(data, length));
+ !kIncludeVersion, !kFin, offset, data);
+ }
+
+ std::unique_ptr<quic::QuicReceivedPacket> ConstructMultipleDataFramesPacket(
+ quic::QuicPacketNumber packet_number,
+ quic::QuicStreamOffset offset,
+ const std::vector<std::string> data_writes) {
+ return client_maker_.MakeMultipleDataFramesPacket(
+ packet_number, client_data_stream_id1_, !kIncludeVersion, !kFin, offset,
+ data_writes);
}
std::unique_ptr<quic::QuicReceivedPacket> ConstructAckAndDataPacket(
@@ -336,12 +343,25 @@ class QuicProxyClientSocketTest
quic::QuicPacketNumber smallest_received,
quic::QuicPacketNumber least_unacked,
quic::QuicStreamOffset offset,
- const char* data,
- int length) {
+ quic::QuicStringPiece data) {
return client_maker_.MakeAckAndDataPacket(
packet_number, !kIncludeVersion, client_data_stream_id1_,
largest_received, smallest_received, least_unacked, !kFin, offset,
- quic::QuicStringPiece(data, length));
+ data);
+ }
+
+ std::unique_ptr<quic::QuicReceivedPacket>
+ ConstructAckAndMultipleDataFramesPacket(
+ quic::QuicPacketNumber packet_number,
+ quic::QuicPacketNumber largest_received,
+ quic::QuicPacketNumber smallest_received,
+ quic::QuicPacketNumber least_unacked,
+ quic::QuicStreamOffset offset,
+ const std::vector<std::string> data_writes) {
+ return client_maker_.MakeAckAndMultipleDataFramesPacket(
+ packet_number, !kIncludeVersion, client_data_stream_id1_,
+ largest_received, smallest_received, least_unacked, !kFin, offset,
+ data_writes);
}
std::unique_ptr<quic::QuicReceivedPacket> ConstructAckPacket(
@@ -368,21 +388,17 @@ class QuicProxyClientSocketTest
std::unique_ptr<quic::QuicReceivedPacket> ConstructServerDataPacket(
quic::QuicPacketNumber packet_number,
quic::QuicStreamOffset offset,
- const char* data,
- int length) {
+ quic::QuicStringPiece data) {
return server_maker_.MakeDataPacket(packet_number, client_data_stream_id1_,
- !kIncludeVersion, !kFin, offset,
- quic::QuicStringPiece(data, length));
+ !kIncludeVersion, !kFin, offset, data);
}
std::unique_ptr<quic::QuicReceivedPacket> ConstructServerDataFinPacket(
quic::QuicPacketNumber packet_number,
quic::QuicStreamOffset offset,
- const char* data,
- int length) {
+ quic::QuicStringPiece data) {
return server_maker_.MakeDataPacket(packet_number, client_data_stream_id1_,
- !kIncludeVersion, kFin, offset,
- quic::QuicStringPiece(data, length));
+ !kIncludeVersion, kFin, offset, data);
}
std::unique_ptr<quic::QuicReceivedPacket> ConstructServerConnectReplyPacket(
@@ -506,6 +522,16 @@ class QuicProxyClientSocketTest
spdy::SpdyString(read_buf_->data(), len));
}
+ quic::QuicString ConstructDataHeader(size_t body_len) {
+ if (version_ != quic::QUIC_VERSION_99) {
+ return "";
+ }
+ quic::HttpEncoder encoder;
+ std::unique_ptr<char[]> buffer;
+ auto header_length = encoder.SerializeDataFrameHeader(body_len, &buffer);
+ return quic::QuicString(buffer.get(), header_length);
+ }
+
const quic::QuicTransportVersion version_;
const quic::QuicStreamId client_data_stream_id1_;
const bool client_headers_include_h2_stream_dependency_;
@@ -709,7 +735,10 @@ TEST_P(QuicProxyClientSocketTest, IsConnectedAndIdle) {
mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(2, 0, kMsg1, kLen1));
+ quic::QuicString header = ConstructDataHeader(kLen1);
+ mock_quic_data_.AddRead(
+ ASYNC,
+ ConstructServerDataPacket(2, 0, header + quic::QuicString(kMsg1, kLen1)));
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1, 1));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
mock_quic_data_.AddWrite(
@@ -739,8 +768,10 @@ TEST_P(QuicProxyClientSocketTest, GetTotalReceivedBytes) {
mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerDataPacket(2, 0, kMsg333, kLen333));
+ quic::QuicString header = ConstructDataHeader(kLen333);
+ mock_quic_data_.AddRead(
+ ASYNC, ConstructServerDataPacket(
+ 2, 0, header + quic::QuicString(kMsg333, kLen333)));
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1, 1));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
mock_quic_data_.AddWrite(
@@ -763,11 +794,13 @@ TEST_P(QuicProxyClientSocketTest, GetTotalReceivedBytes) {
// two different reads.
AssertSyncReadEquals(kMsg33, kLen33);
- EXPECT_EQ((int64_t)kLen33, sock_->GetTotalReceivedBytes());
+ EXPECT_EQ((int64_t)(kLen33 + header.length()),
+ sock_->GetTotalReceivedBytes());
AssertSyncReadEquals(kMsg3, kLen3);
- EXPECT_EQ((int64_t)kLen333, sock_->GetTotalReceivedBytes());
+ EXPECT_EQ((int64_t)(kLen333 + header.length()),
+ sock_->GetTotalReceivedBytes());
}
TEST_P(QuicProxyClientSocketTest, SetStreamPriority) {
@@ -791,13 +824,32 @@ TEST_P(QuicProxyClientSocketTest, WriteSendsDataInDataFrame) {
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructConnectRequestPacket(2));
mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndDataPacket(3, 1, 1, 1, 0, kMsg1, kLen1));
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructDataPacket(4, kLen1, kMsg2, kLen2));
- mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructRstPacket(5, quic::QUIC_STREAM_CANCELLED, kLen1 + kLen2));
+ if (version_ == quic::QUIC_VERSION_99) {
+ quic::QuicString header = ConstructDataHeader(kLen1);
+ mock_quic_data_.AddWrite(
+ SYNCHRONOUS,
+ ConstructAckAndMultipleDataFramesPacket(
+ 3, 1, 1, 1, 0, {header, quic::QuicString(kMsg1, kLen1)}));
+ quic::QuicString header2 = ConstructDataHeader(kLen2);
+ mock_quic_data_.AddWrite(SYNCHRONOUS,
+ ConstructMultipleDataFramesPacket(
+ 4, kLen1 + header.length(),
+ {header2, quic::QuicString(kMsg2, kLen2)}));
+ mock_quic_data_.AddWrite(
+ SYNCHRONOUS,
+ ConstructRstPacket(5, quic::QUIC_STREAM_CANCELLED,
+ kLen1 + kLen2 + header.length() + header2.length()));
+ } else {
+ mock_quic_data_.AddWrite(
+ SYNCHRONOUS, ConstructAckAndDataPacket(3, 1, 1, 1, 0,
+ quic::QuicString(kMsg1, kLen1)));
+ mock_quic_data_.AddWrite(
+ SYNCHRONOUS,
+ ConstructDataPacket(4, kLen1, quic::QuicString(kMsg2, kLen2)));
+ mock_quic_data_.AddWrite(
+ SYNCHRONOUS,
+ ConstructRstPacket(5, quic::QUIC_STREAM_CANCELLED, kLen1 + kLen2));
+ }
Initialize();
@@ -808,32 +860,70 @@ TEST_P(QuicProxyClientSocketTest, WriteSendsDataInDataFrame) {
}
TEST_P(QuicProxyClientSocketTest, WriteSplitsLargeDataIntoMultiplePackets) {
- mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructSettingsPacket(1));
- mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructConnectRequestPacket(2));
+ int write_packet_index = 1;
+ mock_quic_data_.AddWrite(SYNCHRONOUS,
+ ConstructSettingsPacket(write_packet_index++));
+ mock_quic_data_.AddWrite(SYNCHRONOUS,
+ ConstructConnectRequestPacket(write_packet_index++));
mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndDataPacket(3, 1, 1, 1, 0, kMsg1, kLen1));
+ quic::QuicString header = ConstructDataHeader(kLen1);
+ if (version_ != quic::QUIC_VERSION_99) {
+ mock_quic_data_.AddWrite(
+ SYNCHRONOUS, ConstructAckAndDataPacket(write_packet_index++, 1, 1, 1, 0,
+ quic::QuicString(kMsg1, kLen1)));
+ } else {
+ mock_quic_data_.AddWrite(SYNCHRONOUS,
+ ConstructAckAndMultipleDataFramesPacket(
+ write_packet_index++, 1, 1, 1, 0,
+ {header, quic::QuicString(kMsg1, kLen1)}));
+ }
// Expect |kNumDataPackets| data packets, each containing the max possible
// amount of data.
- const int kNumDataPackets = 3;
- std::string data(kNumDataPackets * quic::kDefaultMaxPacketSize, 'x');
- quic::QuicStreamOffset offset = kLen1;
+ int numDataPackets = 3;
+ std::string data(numDataPackets * quic::kDefaultMaxPacketSize, 'x');
+ quic::QuicStreamOffset offset = kLen1 + header.length();
+
+ if (version_ == quic::QUIC_VERSION_99) {
+ numDataPackets++;
+ }
size_t total_data_length = 0;
- for (int i = 0; i < kNumDataPackets; ++i) {
+ for (int i = 0; i < numDataPackets; ++i) {
size_t max_packet_data_length = GetStreamFrameDataLengthFromPacketLength(
quic::kDefaultMaxPacketSize, version_, !kIncludeVersion,
!kIncludeDiversificationNonce, quic::PACKET_8BYTE_CONNECTION_ID,
quic::PACKET_1BYTE_PACKET_NUMBER, offset);
- mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructDataPacket(4 + i, offset, data.c_str(),
- max_packet_data_length));
- offset += max_packet_data_length;
- total_data_length += max_packet_data_length;
+ if (version_ == quic::QUIC_VERSION_99 && i == 0) {
+ // 3973 is the data frame length from packet length.
+ quic::QuicString header2 = ConstructDataHeader(3973);
+ mock_quic_data_.AddWrite(
+ SYNCHRONOUS,
+ ConstructMultipleDataFramesPacket(
+ write_packet_index++, offset,
+ {header2,
+ quic::QuicString(data.c_str(), max_packet_data_length - 7)}));
+ offset += max_packet_data_length - header2.length() - 1;
+ } else if (version_ == quic::QUIC_VERSION_99 && i == numDataPackets - 1) {
+ mock_quic_data_.AddWrite(
+ SYNCHRONOUS, ConstructDataPacket(write_packet_index++, offset,
+ quic::QuicString(data.c_str(), 7)));
+ offset += 7;
+ } else {
+ mock_quic_data_.AddWrite(
+ SYNCHRONOUS,
+ ConstructDataPacket(
+ write_packet_index++, offset,
+ quic::QuicString(data.c_str(), max_packet_data_length)));
+ offset += max_packet_data_length;
+ }
+ if (i != 3) {
+ total_data_length += max_packet_data_length;
+ }
}
+
mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructRstPacket(4 + kNumDataPackets,
+ SYNCHRONOUS, ConstructRstPacket(write_packet_index++,
quic::QUIC_STREAM_CANCELLED, offset));
Initialize();
@@ -858,7 +948,10 @@ TEST_P(QuicProxyClientSocketTest, ReadReadsDataInDataFrame) {
mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(2, 0, kMsg1, kLen1));
+ quic::QuicString header = ConstructDataHeader(kLen1);
+ mock_quic_data_.AddRead(
+ ASYNC,
+ ConstructServerDataPacket(2, 0, header + quic::QuicString(kMsg1, kLen1)));
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1, 1));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
mock_quic_data_.AddWrite(
@@ -878,12 +971,17 @@ TEST_P(QuicProxyClientSocketTest, ReadDataFromBufferedFrames) {
mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(2, 0, kMsg1, kLen1));
+ quic::QuicString header = ConstructDataHeader(kLen1);
+ mock_quic_data_.AddRead(
+ ASYNC,
+ ConstructServerDataPacket(2, 0, header + quic::QuicString(kMsg1, kLen1)));
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1, 1));
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerDataPacket(3, kLen1, kMsg2, kLen2));
+ quic::QuicString header2 = ConstructDataHeader(kLen2);
+ mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(
+ 3, kLen1 + header.length(),
+ header2 + quic::QuicString(kMsg2, kLen2)));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
mock_quic_data_.AddWrite(
@@ -907,10 +1005,15 @@ TEST_P(QuicProxyClientSocketTest, ReadDataMultipleBufferedFrames) {
mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(2, 0, kMsg1, kLen1));
+ quic::QuicString header = ConstructDataHeader(kLen1);
+ mock_quic_data_.AddRead(
+ ASYNC,
+ ConstructServerDataPacket(2, 0, header + quic::QuicString(kMsg1, kLen1)));
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1, 1));
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerDataPacket(3, kLen1, kMsg2, kLen2));
+ quic::QuicString header2 = ConstructDataHeader(kLen2);
+ mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(
+ 3, kLen1 + header.length(),
+ header2 + quic::QuicString(kMsg2, kLen2)));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
mock_quic_data_.AddWrite(
@@ -934,10 +1037,15 @@ TEST_P(QuicProxyClientSocketTest, LargeReadWillMergeDataFromDifferentFrames) {
mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(2, 0, kMsg3, kLen3));
+ quic::QuicString header = ConstructDataHeader(kLen3);
+ mock_quic_data_.AddRead(
+ ASYNC,
+ ConstructServerDataPacket(2, 0, header + quic::QuicString(kMsg3, kLen3)));
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1, 1));
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerDataPacket(3, kLen3, kMsg3, kLen3));
+ quic::QuicString header2 = ConstructDataHeader(kLen3);
+ mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(
+ 3, kLen3 + header.length(),
+ header2 + quic::QuicString(kMsg3, kLen3)));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
mock_quic_data_.AddWrite(
@@ -963,22 +1071,29 @@ TEST_P(QuicProxyClientSocketTest, MultipleShortReadsThenMoreRead) {
int offset = 0;
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerDataPacket(2, offset, kMsg1, kLen1));
- offset += kLen1;
+ quic::QuicString header = ConstructDataHeader(kLen1);
+ mock_quic_data_.AddRead(
+ ASYNC, ConstructServerDataPacket(
+ 2, offset, header + quic::QuicString(kMsg1, kLen1)));
+ offset += kLen1 + header.length();
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1, 1));
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerDataPacket(3, offset, kMsg3, kLen3));
- offset += kLen3;
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerDataPacket(4, offset, kMsg3, kLen3));
- offset += kLen3;
+ quic::QuicString header2 = ConstructDataHeader(kLen3);
+ mock_quic_data_.AddRead(
+ ASYNC, ConstructServerDataPacket(
+ 3, offset, header2 + quic::QuicString(kMsg3, kLen3)));
+ offset += kLen3 + header2.length();
+ mock_quic_data_.AddRead(
+ ASYNC, ConstructServerDataPacket(
+ 4, offset, header2 + quic::QuicString(kMsg3, kLen3)));
+ offset += kLen3 + header2.length();
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(4, 4, 3, 1));
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerDataPacket(5, offset, kMsg2, kLen2));
- offset += kLen2;
+ quic::QuicString header3 = ConstructDataHeader(kLen2);
+ mock_quic_data_.AddRead(
+ ASYNC, ConstructServerDataPacket(
+ 5, offset, header3 + quic::QuicString(kMsg2, kLen2)));
+ offset += kLen2 + header3.length();
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
mock_quic_data_.AddWrite(
@@ -1005,10 +1120,16 @@ TEST_P(QuicProxyClientSocketTest, ReadWillSplitDataFromLargeFrame) {
mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(2, 0, kMsg1, kLen1));
+ quic::QuicString header = ConstructDataHeader(kLen1);
+ mock_quic_data_.AddRead(
+ ASYNC,
+ ConstructServerDataPacket(2, 0, header + quic::QuicString(kMsg1, kLen1)));
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1, 1));
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerDataPacket(3, kLen1, kMsg33, kLen33));
+ quic::QuicString header2 = ConstructDataHeader(kLen33);
+ mock_quic_data_.AddRead(
+ ASYNC,
+ ConstructServerDataPacket(3, kLen1 + header.length(),
+ header2 + quic::QuicString(kMsg33, kLen33)));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
mock_quic_data_.AddWrite(
@@ -1035,8 +1156,10 @@ TEST_P(QuicProxyClientSocketTest, MultipleReadsFromSameLargeFrame) {
mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerDataPacket(2, 0, kMsg333, kLen333));
+ quic::QuicString header = ConstructDataHeader(kLen333);
+ mock_quic_data_.AddRead(
+ ASYNC, ConstructServerDataPacket(
+ 2, 0, header + quic::QuicString(kMsg333, kLen333)));
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1, 1));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
@@ -1069,10 +1192,15 @@ TEST_P(QuicProxyClientSocketTest, ReadAuthResponseBody) {
ConstructServerConnectAuthReplyPacket(1, !kFin));
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(2, 0, kMsg1, kLen1));
+ quic::QuicString header = ConstructDataHeader(kLen1);
+ mock_quic_data_.AddRead(
+ ASYNC,
+ ConstructServerDataPacket(2, 0, header + quic::QuicString(kMsg1, kLen1)));
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1, 1));
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerDataPacket(3, kLen1, kMsg2, kLen2));
+ quic::QuicString header2 = ConstructDataHeader(kLen2);
+ mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(
+ 3, kLen1 + header.length(),
+ header2 + quic::QuicString(kMsg2, kLen2)));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
mock_quic_data_.AddWrite(
@@ -1095,11 +1223,16 @@ TEST_P(QuicProxyClientSocketTest, ReadErrorResponseBody) {
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructConnectRequestPacket(2));
mock_quic_data_.AddRead(ASYNC,
ConstructServerConnectErrorReplyPacket(1, !kFin));
- mock_quic_data_.AddRead(SYNCHRONOUS,
- ConstructServerDataPacket(2, 0, kMsg1, kLen1));
+ quic::QuicString header = ConstructDataHeader(kLen1);
+ mock_quic_data_.AddRead(
+ SYNCHRONOUS,
+ ConstructServerDataPacket(2, 0, header + quic::QuicString(kMsg1, kLen1)));
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1, 1));
- mock_quic_data_.AddRead(SYNCHRONOUS,
- ConstructServerDataPacket(3, kLen1, kMsg2, kLen2));
+ quic::QuicString header2 = ConstructDataHeader(kLen2);
+ mock_quic_data_.AddRead(
+ SYNCHRONOUS,
+ ConstructServerDataPacket(3, kLen1 + header.length(),
+ header2 + quic::QuicString(kMsg2, kLen2)));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
mock_quic_data_.AddWrite(
@@ -1113,26 +1246,45 @@ TEST_P(QuicProxyClientSocketTest, ReadErrorResponseBody) {
// ----------- Reads and Writes
TEST_P(QuicProxyClientSocketTest, AsyncReadAroundWrite) {
- mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructSettingsPacket(1));
- mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructConnectRequestPacket(2));
+ int write_packet_index = 1;
+ mock_quic_data_.AddWrite(SYNCHRONOUS,
+ ConstructSettingsPacket(write_packet_index++));
+ mock_quic_data_.AddWrite(SYNCHRONOUS,
+ ConstructConnectRequestPacket(write_packet_index++));
mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(2, 0, kMsg1, kLen1));
- mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1, 1));
-
+ quic::QuicString header = ConstructDataHeader(kLen1);
+ mock_quic_data_.AddRead(
+ ASYNC,
+ ConstructServerDataPacket(2, 0, header + quic::QuicString(kMsg1, kLen1)));
mock_quic_data_.AddWrite(SYNCHRONOUS,
- ConstructDataPacket(4, 0, kMsg2, kLen2));
+ ConstructAckPacket(write_packet_index++, 2, 1, 1));
+
+ quic::QuicString header2 = ConstructDataHeader(kLen2);
+ if (version_ == quic::QUIC_VERSION_99) {
+ mock_quic_data_.AddWrite(SYNCHRONOUS,
+ ConstructMultipleDataFramesPacket(
+ write_packet_index++, 0,
+ {header2, quic::QuicString(kMsg2, kLen2)}));
+ } else {
+ mock_quic_data_.AddWrite(
+ SYNCHRONOUS, ConstructDataPacket(write_packet_index++, header2.length(),
+ quic::QuicString(kMsg2, kLen2)));
+ }
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerDataPacket(3, kLen1, kMsg3, kLen3));
+ quic::QuicString header3 = ConstructDataHeader(kLen3);
+ mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(
+ 3, kLen1 + header.length(),
+ header3 + quic::QuicString(kMsg3, kLen3)));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructAckAndRstPacket(5, quic::QUIC_STREAM_CANCELLED, 3, 3, 1, kLen2));
+ SYNCHRONOUS, ConstructAckAndRstPacket(write_packet_index++,
+ quic::QUIC_STREAM_CANCELLED, 3, 3,
+ 1, kLen2 + header2.length()));
Initialize();
@@ -1160,23 +1312,41 @@ TEST_P(QuicProxyClientSocketTest, AsyncWriteAroundReads) {
mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(2, 0, kMsg1, kLen1));
+ quic::QuicString header = ConstructDataHeader(kLen1);
+ mock_quic_data_.AddRead(
+ ASYNC,
+ ConstructServerDataPacket(2, 0, header + quic::QuicString(kMsg1, kLen1)));
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1, 1));
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC,
- ConstructServerDataPacket(3, kLen1, kMsg3, kLen3));
+ quic::QuicString header2 = ConstructDataHeader(kLen3);
+ mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(
+ 3, kLen1 + header.length(),
+ header2 + quic::QuicString(kMsg3, kLen3)));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
mock_quic_data_.AddWrite(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddWrite(ASYNC, ConstructDataPacket(4, 0, kMsg2, kLen2));
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndDataPacket(5, 3, 3, 1, kLen2, kMsg2, kLen2));
+ quic::QuicString header3 = ConstructDataHeader(kLen2);
+ if (version_ != quic::QUIC_VERSION_99) {
+ mock_quic_data_.AddWrite(
+ ASYNC, ConstructDataPacket(4, 0, quic::QuicString(kMsg2, kLen2)));
+ mock_quic_data_.AddWrite(
+ SYNCHRONOUS, ConstructAckAndDataPacket(5, 3, 3, 1, kLen2,
+ quic::QuicString(kMsg2, kLen2)));
+ } else {
+ mock_quic_data_.AddWrite(
+ ASYNC, ConstructMultipleDataFramesPacket(
+ 4, 0, {header3, quic::QuicString(kMsg2, kLen2)}));
+ mock_quic_data_.AddWrite(
+ ASYNC,
+ ConstructAckAndDataPacket(5, 3, 3, 1, header3.length() + kLen2,
+ header3 + quic::QuicString(kMsg2, kLen2)));
+ }
mock_quic_data_.AddWrite(
- SYNCHRONOUS,
- ConstructRstPacket(6, quic::QUIC_STREAM_CANCELLED, kLen2 + kLen2));
+ SYNCHRONOUS, ConstructRstPacket(6, quic::QUIC_STREAM_CANCELLED,
+ kLen2 + kLen2 + 2 * header3.length()));
Initialize();
@@ -1274,8 +1444,10 @@ TEST_P(QuicProxyClientSocketTest, ReadAfterFinReceivedReturnsBufferedData) {
mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
+ quic::QuicString header = ConstructDataHeader(kLen1);
mock_quic_data_.AddRead(ASYNC,
- ConstructServerDataFinPacket(2, 0, kMsg1, kLen1));
+ ConstructServerDataFinPacket(
+ 2, 0, header + quic::QuicString(kMsg1, kLen1)));
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1, 1));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
mock_quic_data_.AddWrite(
@@ -1438,11 +1610,23 @@ TEST_P(QuicProxyClientSocketTest, RstWithReadAndWritePending) {
mock_quic_data_.AddRead(
ASYNC, ConstructServerRstPacket(2, quic::QUIC_STREAM_CANCELLED, 0));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- ASYNC, ConstructAckAndDataPacket(3, 1, 1, 1, 0, kMsg2, kLen2));
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(4, quic::QUIC_RST_ACKNOWLEDGEMENT,
- 2, 2, 1, kLen2));
+ quic::QuicString header = ConstructDataHeader(kLen2);
+ if (version_ != quic::QUIC_VERSION_99) {
+ mock_quic_data_.AddWrite(
+ ASYNC, ConstructAckAndDataPacket(3, 1, 1, 1, 0,
+ quic::QuicString(kMsg2, kLen2)));
+ mock_quic_data_.AddWrite(
+ SYNCHRONOUS, ConstructAckAndRstPacket(4, quic::QUIC_RST_ACKNOWLEDGEMENT,
+ 2, 2, 1, kLen2));
+ } else {
+ mock_quic_data_.AddWrite(
+ ASYNC, ConstructAckAndMultipleDataFramesPacket(
+ 3, 1, 1, 1, 0, {header, quic::QuicString(kMsg2, kLen2)}));
+ mock_quic_data_.AddWrite(
+ SYNCHRONOUS,
+ ConstructAckAndRstPacket(4, quic::QUIC_RST_ACKNOWLEDGEMENT, 2, 2, 1,
+ header.length() + kLen2));
+ }
Initialize();
@@ -1458,6 +1642,7 @@ TEST_P(QuicProxyClientSocketTest, RstWithReadAndWritePending) {
// is write-blocked. Therefore, at least two writes need to be called on
// |sock_| to get an asynchronous one.
AssertWriteReturns(kMsg2, kLen2, kLen2);
+
AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
ResumeAndRun();
@@ -1474,7 +1659,10 @@ TEST_P(QuicProxyClientSocketTest, NetLog) {
mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
- mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(2, 0, kMsg1, kLen1));
+ quic::QuicString header = ConstructDataHeader(kLen1);
+ mock_quic_data_.AddRead(
+ ASYNC,
+ ConstructServerDataPacket(2, 0, header + quic::QuicString(kMsg1, kLen1)));
mock_quic_data_.AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1, 1));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
mock_quic_data_.AddWrite(
@@ -1557,11 +1745,23 @@ TEST_P(QuicProxyClientSocketTest, RstWithReadAndWritePendingDelete) {
mock_quic_data_.AddRead(
ASYNC, ConstructServerRstPacket(2, quic::QUIC_STREAM_CANCELLED, 0));
mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
- mock_quic_data_.AddWrite(
- ASYNC, ConstructAckAndDataPacket(3, 1, 1, 1, 0, kMsg1, kLen1));
- mock_quic_data_.AddWrite(
- SYNCHRONOUS, ConstructAckAndRstPacket(4, quic::QUIC_RST_ACKNOWLEDGEMENT,
- 2, 2, 1, kLen1));
+ if (version_ != quic::QUIC_VERSION_99) {
+ mock_quic_data_.AddWrite(
+ ASYNC, ConstructAckAndDataPacket(3, 1, 1, 1, 0,
+ quic::QuicString(kMsg1, kLen1)));
+ mock_quic_data_.AddWrite(
+ SYNCHRONOUS, ConstructAckAndRstPacket(4, quic::QUIC_RST_ACKNOWLEDGEMENT,
+ 2, 2, 1, kLen1));
+ } else {
+ quic::QuicString header = ConstructDataHeader(kLen1);
+ mock_quic_data_.AddWrite(
+ ASYNC, ConstructAckAndMultipleDataFramesPacket(
+ 3, 1, 1, 1, 0, {header, quic::QuicString(kMsg1, kLen1)}));
+ mock_quic_data_.AddWrite(
+ SYNCHRONOUS,
+ ConstructAckAndRstPacket(4, quic::QUIC_RST_ACKNOWLEDGEMENT, 2, 2, 1,
+ header.length() + kLen1));
+ }
Initialize();
@@ -1579,6 +1779,7 @@ TEST_P(QuicProxyClientSocketTest, RstWithReadAndWritePendingDelete) {
// is write-blocked. Therefore, at least two writes need to be called on
// |sock_| to get an asynchronous one.
AssertWriteReturns(kMsg1, kLen1, kLen1);
+
AssertWriteReturns(kMsg1, kLen1, ERR_IO_PENDING);
ResumeAndRun();
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-09 20:10:06 +0000