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/frames/quic_frame.cc b/quic/core/frames/quic_frame.cc
index 95fee41..dbc2ff6 100644
--- a/quic/core/frames/quic_frame.cc
+++ b/quic/core/frames/quic_frame.cc
@@ -51,10 +51,10 @@
QuicFrame::QuicFrame(QuicRetireConnectionIdFrame* frame)
: type(RETIRE_CONNECTION_ID_FRAME), retire_connection_id_frame(frame) {}
-QuicFrame::QuicFrame(QuicMaxStreamIdFrame frame) : max_stream_id_frame(frame) {}
+QuicFrame::QuicFrame(QuicMaxStreamsFrame frame) : max_streams_frame(frame) {}
-QuicFrame::QuicFrame(QuicStreamIdBlockedFrame frame)
- : stream_id_blocked_frame(frame) {}
+QuicFrame::QuicFrame(QuicStreamsBlockedFrame frame)
+ : streams_blocked_frame(frame) {}
QuicFrame::QuicFrame(QuicPathResponseFrame* frame)
: type(PATH_RESPONSE_FRAME), path_response_frame(frame) {}
@@ -84,9 +84,9 @@
case PADDING_FRAME:
case MTU_DISCOVERY_FRAME:
case PING_FRAME:
- case MAX_STREAM_ID_FRAME:
+ case MAX_STREAMS_FRAME:
case STOP_WAITING_FRAME:
- case STREAM_ID_BLOCKED_FRAME:
+ case STREAMS_BLOCKED_FRAME:
case STREAM_FRAME:
break;
case ACK_FRAME:
@@ -154,8 +154,8 @@
case GOAWAY_FRAME:
case WINDOW_UPDATE_FRAME:
case BLOCKED_FRAME:
- case STREAM_ID_BLOCKED_FRAME:
- case MAX_STREAM_ID_FRAME:
+ case STREAMS_BLOCKED_FRAME:
+ case MAX_STREAMS_FRAME:
case PING_FRAME:
case STOP_SENDING_FRAME:
return true;
@@ -174,10 +174,10 @@
return frame.window_update_frame->control_frame_id;
case BLOCKED_FRAME:
return frame.blocked_frame->control_frame_id;
- case STREAM_ID_BLOCKED_FRAME:
- return frame.stream_id_blocked_frame.control_frame_id;
- case MAX_STREAM_ID_FRAME:
- return frame.max_stream_id_frame.control_frame_id;
+ case STREAMS_BLOCKED_FRAME:
+ return frame.streams_blocked_frame.control_frame_id;
+ case MAX_STREAMS_FRAME:
+ return frame.max_streams_frame.control_frame_id;
case PING_FRAME:
return frame.ping_frame.control_frame_id;
case STOP_SENDING_FRAME:
@@ -204,11 +204,11 @@
case PING_FRAME:
frame->ping_frame.control_frame_id = control_frame_id;
return;
- case STREAM_ID_BLOCKED_FRAME:
- frame->stream_id_blocked_frame.control_frame_id = control_frame_id;
+ case STREAMS_BLOCKED_FRAME:
+ frame->streams_blocked_frame.control_frame_id = control_frame_id;
return;
- case MAX_STREAM_ID_FRAME:
- frame->max_stream_id_frame.control_frame_id = control_frame_id;
+ case MAX_STREAMS_FRAME:
+ frame->max_streams_frame.control_frame_id = control_frame_id;
return;
case STOP_SENDING_FRAME:
frame->stop_sending_frame->control_frame_id = control_frame_id;
@@ -240,11 +240,11 @@
case STOP_SENDING_FRAME:
copy = QuicFrame(new QuicStopSendingFrame(*frame.stop_sending_frame));
break;
- case STREAM_ID_BLOCKED_FRAME:
- copy = QuicFrame(QuicStreamIdBlockedFrame(frame.stream_id_blocked_frame));
+ case STREAMS_BLOCKED_FRAME:
+ copy = QuicFrame(QuicStreamsBlockedFrame(frame.streams_blocked_frame));
break;
- case MAX_STREAM_ID_FRAME:
- copy = QuicFrame(QuicMaxStreamIdFrame(frame.max_stream_id_frame));
+ case MAX_STREAMS_FRAME:
+ copy = QuicFrame(QuicMaxStreamsFrame(frame.max_streams_frame));
break;
default:
QUIC_BUG << "Try to copy a non-retransmittable control frame: " << frame;
@@ -308,11 +308,11 @@
os << "type { RETIRE_CONNECTION_ID } "
<< *(frame.retire_connection_id_frame);
break;
- case MAX_STREAM_ID_FRAME:
- os << "type { MAX_STREAM_ID } " << frame.max_stream_id_frame;
+ case MAX_STREAMS_FRAME:
+ os << "type { MAX_STREAMS } " << frame.max_streams_frame;
break;
- case STREAM_ID_BLOCKED_FRAME:
- os << "type { STREAM_ID_BLOCKED } " << frame.stream_id_blocked_frame;
+ case STREAMS_BLOCKED_FRAME:
+ os << "type { STREAMS_BLOCKED } " << frame.streams_blocked_frame;
break;
case PATH_RESPONSE_FRAME:
os << "type { PATH_RESPONSE } " << *(frame.path_response_frame);
diff --git a/quic/core/frames/quic_frame.h b/quic/core/frames/quic_frame.h
index c452bf4..caa5fce 100644
--- a/quic/core/frames/quic_frame.h
+++ b/quic/core/frames/quic_frame.h
@@ -13,7 +13,7 @@
#include "net/third_party/quiche/src/quic/core/frames/quic_connection_close_frame.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_crypto_frame.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_goaway_frame.h"
-#include "net/third_party/quiche/src/quic/core/frames/quic_max_stream_id_frame.h"
+#include "net/third_party/quiche/src/quic/core/frames/quic_max_streams_frame.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_message_frame.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_mtu_discovery_frame.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_new_connection_id_frame.h"
@@ -27,7 +27,7 @@
#include "net/third_party/quiche/src/quic/core/frames/quic_stop_sending_frame.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_stop_waiting_frame.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_stream_frame.h"
-#include "net/third_party/quiche/src/quic/core/frames/quic_stream_id_blocked_frame.h"
+#include "net/third_party/quiche/src/quic/core/frames/quic_streams_blocked_frame.h"
#include "net/third_party/quiche/src/quic/core/frames/quic_window_update_frame.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
@@ -41,9 +41,9 @@
explicit QuicFrame(QuicPaddingFrame padding_frame);
explicit QuicFrame(QuicMtuDiscoveryFrame frame);
explicit QuicFrame(QuicPingFrame frame);
- explicit QuicFrame(QuicMaxStreamIdFrame frame);
+ explicit QuicFrame(QuicMaxStreamsFrame frame);
explicit QuicFrame(QuicStopWaitingFrame frame);
- explicit QuicFrame(QuicStreamIdBlockedFrame frame);
+ explicit QuicFrame(QuicStreamsBlockedFrame frame);
explicit QuicFrame(QuicStreamFrame stream_frame);
explicit QuicFrame(QuicAckFrame* frame);
@@ -72,9 +72,9 @@
QuicPaddingFrame padding_frame;
QuicMtuDiscoveryFrame mtu_discovery_frame;
QuicPingFrame ping_frame;
- QuicMaxStreamIdFrame max_stream_id_frame;
+ QuicMaxStreamsFrame max_streams_frame;
QuicStopWaitingFrame stop_waiting_frame;
- QuicStreamIdBlockedFrame stream_id_blocked_frame;
+ QuicStreamsBlockedFrame streams_blocked_frame;
QuicStreamFrame stream_frame;
// Out of line frames.
diff --git a/quic/core/frames/quic_frames_test.cc b/quic/core/frames/quic_frames_test.cc
index c432657..bf60b7b 100644
--- a/quic/core/frames/quic_frames_test.cc
+++ b/quic/core/frames/quic_frames_test.cc
@@ -101,33 +101,37 @@
EXPECT_TRUE(IsControlFrame(frame.type));
}
-TEST_F(QuicFramesTest, StreamIdBlockedFrameToString) {
- QuicStreamIdBlockedFrame stream_id_blocked;
- QuicFrame frame(stream_id_blocked);
+TEST_F(QuicFramesTest, StreamsBlockedFrameToString) {
+ QuicStreamsBlockedFrame streams_blocked;
+ QuicFrame frame(streams_blocked);
SetControlFrameId(1, &frame);
EXPECT_EQ(1u, GetControlFrameId(frame));
- // QuicStreamIdBlocked is copied into a QuicFrame (as opposed to putting a
+ // QuicStreamsBlocked is copied into a QuicFrame (as opposed to putting a
// pointer to it into QuicFrame) so need to work with the copy in |frame| and
- // not the original one, stream_id_blocked.
- frame.stream_id_blocked_frame.stream_id = 321;
+ // not the original one, streams_blocked.
+ frame.streams_blocked_frame.stream_count = 321;
+ frame.streams_blocked_frame.unidirectional = false;
std::ostringstream stream;
- stream << frame.stream_id_blocked_frame;
- EXPECT_EQ("{ control_frame_id: 1, stream id: 321 }\n", stream.str());
+ stream << frame.streams_blocked_frame;
+ EXPECT_EQ("{ control_frame_id: 1, stream count: 321, bidirectional }\n",
+ stream.str());
EXPECT_TRUE(IsControlFrame(frame.type));
}
-TEST_F(QuicFramesTest, MaxStreamIdFrameToString) {
- QuicMaxStreamIdFrame max_stream_id;
- QuicFrame frame(max_stream_id);
+TEST_F(QuicFramesTest, MaxStreamsFrameToString) {
+ QuicMaxStreamsFrame max_streams;
+ QuicFrame frame(max_streams);
SetControlFrameId(1, &frame);
EXPECT_EQ(1u, GetControlFrameId(frame));
- // QuicMaxStreamId is copied into a QuicFrame (as opposed to putting a
+ // QuicMaxStreams is copied into a QuicFrame (as opposed to putting a
// pointer to it into QuicFrame) so need to work with the copy in |frame| and
- // not the original one, max_stream_id.
- frame.max_stream_id_frame.max_stream_id = 321;
+ // not the original one, max_streams.
+ frame.max_streams_frame.stream_count = 321;
+ frame.max_streams_frame.unidirectional = true;
std::ostringstream stream;
- stream << frame.max_stream_id_frame;
- EXPECT_EQ("{ control_frame_id: 1, stream_id: 321 }\n", stream.str());
+ stream << frame.max_streams_frame;
+ EXPECT_EQ("{ control_frame_id: 1, stream_count: 321, unidirectional }\n",
+ stream.str());
EXPECT_TRUE(IsControlFrame(frame.type));
}
diff --git a/quic/core/frames/quic_max_streams_frame.cc b/quic/core/frames/quic_max_streams_frame.cc
new file mode 100644
index 0000000..21dce5b
--- /dev/null
+++ b/quic/core/frames/quic_max_streams_frame.cc
@@ -0,0 +1,30 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/third_party/quiche/src/quic/core/frames/quic_max_streams_frame.h"
+
+namespace quic {
+
+QuicMaxStreamsFrame::QuicMaxStreamsFrame()
+ : QuicInlinedFrame(MAX_STREAMS_FRAME),
+ control_frame_id(kInvalidControlFrameId),
+ unidirectional(false) {}
+
+QuicMaxStreamsFrame::QuicMaxStreamsFrame(QuicControlFrameId control_frame_id,
+ QuicStreamCount stream_count,
+ bool unidirectional)
+ : QuicInlinedFrame(MAX_STREAMS_FRAME),
+ control_frame_id(control_frame_id),
+ stream_count(stream_count),
+ unidirectional(unidirectional) {}
+
+std::ostream& operator<<(std::ostream& os, const QuicMaxStreamsFrame& frame) {
+ os << "{ control_frame_id: " << frame.control_frame_id
+ << ", stream_count: " << frame.stream_count
+ << ((frame.unidirectional) ? ", unidirectional }\n"
+ : ", bidirectional }\n");
+ return os;
+}
+
+} // namespace quic
diff --git a/quic/core/frames/quic_max_streams_frame.h b/quic/core/frames/quic_max_streams_frame.h
new file mode 100644
index 0000000..f8c78f9
--- /dev/null
+++ b/quic/core/frames/quic_max_streams_frame.h
@@ -0,0 +1,43 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_CORE_FRAMES_QUIC_MAX_STREAMS_FRAME_H_
+#define QUICHE_QUIC_CORE_FRAMES_QUIC_MAX_STREAMS_FRAME_H_
+
+#include <ostream>
+
+#include "net/third_party/quiche/src/quic/core/frames/quic_inlined_frame.h"
+#include "net/third_party/quiche/src/quic/core/quic_constants.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+
+namespace quic {
+
+// IETF format MAX_STREAMS frame.
+// This frame is used by the sender to inform the peer of the number of
+// streams that the peer may open and that the sender will accept.
+struct QUIC_EXPORT_PRIVATE QuicMaxStreamsFrame
+ : public QuicInlinedFrame<QuicMaxStreamsFrame> {
+ QuicMaxStreamsFrame();
+ QuicMaxStreamsFrame(QuicControlFrameId control_frame_id,
+ QuicStreamCount stream_count,
+ bool unidirectional);
+
+ friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ std::ostream& os,
+ const QuicMaxStreamsFrame& frame);
+
+ // A unique identifier of this control frame. 0 when this frame is received,
+ // and non-zero when sent.
+ QuicControlFrameId control_frame_id;
+
+ // The number of streams that may be opened.
+ QuicStreamCount stream_count;
+ // Whether uni- or bi-directional streams
+ bool unidirectional;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_CORE_FRAMES_QUIC_MAX_STREAMS_FRAME_H_
diff --git a/quic/core/frames/quic_streams_blocked_frame.cc b/quic/core/frames/quic_streams_blocked_frame.cc
new file mode 100644
index 0000000..f0579c5
--- /dev/null
+++ b/quic/core/frames/quic_streams_blocked_frame.cc
@@ -0,0 +1,33 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/third_party/quiche/src/quic/core/frames/quic_streams_blocked_frame.h"
+
+namespace quic {
+
+QuicStreamsBlockedFrame::QuicStreamsBlockedFrame()
+ : QuicInlinedFrame(STREAMS_BLOCKED_FRAME),
+ control_frame_id(kInvalidControlFrameId),
+ unidirectional(false) {}
+
+QuicStreamsBlockedFrame::QuicStreamsBlockedFrame(
+ QuicControlFrameId control_frame_id,
+ QuicStreamCount stream_count,
+ bool unidirectional)
+ : QuicInlinedFrame(STREAMS_BLOCKED_FRAME),
+ control_frame_id(control_frame_id),
+ stream_count(stream_count),
+ unidirectional(unidirectional) {}
+
+std::ostream& operator<<(std::ostream& os,
+ const QuicStreamsBlockedFrame& frame) {
+ os << "{ control_frame_id: " << frame.control_frame_id
+ << ", stream count: " << frame.stream_count
+ << ((frame.unidirectional) ? ", unidirectional }\n"
+ : ", bidirectional }\n");
+
+ return os;
+}
+
+} // namespace quic
diff --git a/quic/core/frames/quic_streams_blocked_frame.h b/quic/core/frames/quic_streams_blocked_frame.h
new file mode 100644
index 0000000..ff7c7f4
--- /dev/null
+++ b/quic/core/frames/quic_streams_blocked_frame.h
@@ -0,0 +1,44 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_CORE_FRAMES_QUIC_STREAMS_BLOCKED_FRAME_H_
+#define QUICHE_QUIC_CORE_FRAMES_QUIC_STREAMS_BLOCKED_FRAME_H_
+
+#include <ostream>
+
+#include "net/third_party/quiche/src/quic/core/frames/quic_inlined_frame.h"
+#include "net/third_party/quiche/src/quic/core/quic_constants.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+
+namespace quic {
+
+// IETF format STREAMS_BLOCKED frame.
+// The sender uses this to inform the peer that the sender wished to
+// open a new stream, exceeding the limit on the number of streams.
+struct QUIC_EXPORT_PRIVATE QuicStreamsBlockedFrame
+ : public QuicInlinedFrame<QuicStreamsBlockedFrame> {
+ QuicStreamsBlockedFrame();
+ QuicStreamsBlockedFrame(QuicControlFrameId control_frame_id,
+ QuicStreamCount stream_count,
+ bool unidirectional);
+
+ friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+ std::ostream& os,
+ const QuicStreamsBlockedFrame& frame);
+
+ // A unique identifier of this control frame. 0 when this frame is received,
+ // and non-zero when sent.
+ QuicControlFrameId control_frame_id;
+
+ // The number of streams that the sender wishes to exceed
+ QuicStreamCount stream_count;
+
+ // Whether uni- or bi-directional streams
+ bool unidirectional;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_CORE_FRAMES_QUIC_STREAMS_BLOCKED_FRAME_H_
