Add QuicStreamsBlockedFrame and QuicMaxStreamsFrame classes
There are two main parts to this work
1) connecting up the new frames, replacing the old ones, to move data around the
system. This also entails a lot of editorial changes (just changing names, comments,
and so on, without notable logic chanages -- eg, "OnMaxStreamIdFrame" becomes
"OnMaxStreamsFrame".
2) the second, and more complex, task is revising the stream id manager to work entirely
with stream counts rather than stream-ids. For example, the logic to check whether a
new stream can be created checks if the current-stream-count is less than the limit
or not, rather than if the next stream id to hand out is above the limit or not.
For all intents and purposes, this completely rewrote the stream ID manager.
Another big change resulting from keeping track solely of stream counts is that the
stream ID manager doesn't care whether it is doing unidirectional or bidirectional
streams, nor does it care whether stream ids are client- or server- initiated.
gfe-relnote: N/A, all changes are for V99/IETF QUIC code only.
LOG_STORAGE_INCREASE(GB/week): 0
TMPLOG_STORAGE_INCREASE(GB): 0
This change neither adds nor deletes data stored. It adds two new codepoints to the QUIC FrameType enum. These new enums reflect two new frames defined in IETF QUIC, which replace two now-deprecated frames (and their associated type codepoints). This is a name change/type codepoint extension; data is neither added nor deleted.
PiperOrigin-RevId: 244661277
Change-Id: I07cdb79db6bd15e1d5ece97b3aa2d67e94ccf00b
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 7a49700..603cd48 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -1527,9 +1527,15 @@
server_config_.SetMaxIncomingDynamicStreamsToSend(
kServerMaxIncomingDynamicStreams);
ASSERT_TRUE(Initialize());
+ if (GetParam().negotiated_version.transport_version == QUIC_VERSION_99) {
+ // Do not run this test for version 99/IETF QUIC. Note that the test needs
+ // to be here, after calling Initialize(), because all tests end up calling
+ // EndToEndTest::TearDown(), which asserts that Initialize has been called
+ // and then proceeds to tear things down -- which fails if they are not
+ // properly set up.
+ return;
+ }
EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
- QuicConnection* client_connection =
- client_->client()->client_session()->connection();
// Make the client misbehave after negotiation.
const int kServerMaxStreams = kMaxStreamsMinimumIncrement + 1;
@@ -1549,16 +1555,10 @@
client_->SendMessage(headers, "", /*fin=*/false);
}
client_->WaitForResponse();
- if (client_connection->transport_version() != QUIC_VERSION_99) {
- EXPECT_TRUE(client_->connected());
- EXPECT_EQ(QUIC_REFUSED_STREAM, client_->stream_error());
- EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
- } else {
- // Version 99 disconnects the connection if we exceed the stream limit.
- EXPECT_FALSE(client_->connected());
- EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
- EXPECT_EQ(QUIC_INVALID_STREAM_ID, client_->connection_error());
- }
+
+ EXPECT_TRUE(client_->connected());
+ EXPECT_EQ(QUIC_REFUSED_STREAM, client_->stream_error());
+ EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
}
TEST_P(EndToEndTest, SetIndependentMaxIncomingDynamicStreamsLimits) {
@@ -1574,10 +1574,19 @@
// The client has received the server's limit and vice versa.
QuicSpdyClientSession* client_session = client_->client()->client_session();
+ // The value returned by max_allowed... includes the Crypto and Header
+ // stream (created as a part of initialization). The config. values,
+ // above, are treated as "number of requests/responses" - that is, they do
+ // not include the static Crypto and Header streams. Reduce the value
+ // returned by max_allowed... by 2 to remove the static streams from the
+ // count.
size_t client_max_open_outgoing_bidirectional_streams =
client_session->connection()->transport_version() == QUIC_VERSION_99
? QuicSessionPeer::v99_streamid_manager(client_session)
- ->max_allowed_outgoing_bidirectional_streams()
+ ->max_allowed_outgoing_bidirectional_streams() -
+ QuicSessionPeer::v99_bidirectional_stream_id_manager(
+ client_session)
+ ->outgoing_static_stream_count()
: QuicSessionPeer::GetStreamIdManager(client_session)
->max_open_outgoing_streams();
size_t client_max_open_outgoing_unidirectional_streams =
@@ -3911,6 +3920,37 @@
EXPECT_EQ(QUIC_PACKET_WRITE_ERROR, client_->connection_error());
}
+// Test that the stream id manager closes the connection if a stream
+// in excess of the allowed maximum.
+TEST_P(EndToEndTest, TooBigStreamIdClosesConnection) {
+ // Has to be before version test, see EndToEndTest::TearDown()
+ ASSERT_TRUE(Initialize());
+ if (negotiated_version_.transport_version != QUIC_VERSION_99) {
+ // Only runs for IETF QUIC.
+ return;
+ }
+ EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
+
+ std::string body(kMaxOutgoingPacketSize, 'a');
+ SpdyHeaderBlock headers;
+ headers[":method"] = "POST";
+ headers[":path"] = "/foo";
+ headers[":scheme"] = "https";
+ headers[":authority"] = server_hostname_;
+
+ // Force the client to write with a stream ID that exceeds the limit.
+ QuicSpdySession* session = client_->client()->client_session();
+ QuicStreamIdManager* stream_id_manager =
+ QuicSessionPeer::v99_bidirectional_stream_id_manager(session);
+ QuicStreamCount max_number_of_streams =
+ stream_id_manager->outgoing_max_streams();
+ QuicSessionPeer::SetNextOutgoingBidirectionalStreamId(
+ session, GetNthClientInitiatedBidirectionalId(max_number_of_streams + 1));
+ client_->SendCustomSynchronousRequest(headers, body);
+ EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
+ EXPECT_EQ(QUIC_INVALID_STREAM_ID, client_->connection_error());
+}
+
} // namespace
} // namespace test
} // namespace quic
