Change STOP_SENDING frame related APIs to use QuicRstStreamError type.
Change QuicControlFrameManager::WriteOrBufferStopSending(),
QuicSession::SendStopSending(), QuicStream::OnStopSending(), and
QuicStopSendingFrame constructor to take QuicRstStreamError arguments.
Add QuicStopSendingFrame::error_code member. Remove
QuicStopSendingFrame::application_error_code and QuicApplicationErrorCode.
Previously the error code was stored in an uint16_t, now in a
QuicRstStreamError, which has a wider underlying type of int. However, the
truncation logic for incoming STOP_SENDING frames in
QuicFramer::ProcessStopSendingFrame() is unchanged.
PiperOrigin-RevId: 329762228
Change-Id: Iab016a992e9bdde945ed96c7ba03b86276c1e968
diff --git a/quic/core/frames/quic_frames_test.cc b/quic/core/frames/quic_frames_test.cc
index 3f04c8c..2b84822 100644
--- a/quic/core/frames/quic_frames_test.cc
+++ b/quic/core/frames/quic_frames_test.cc
@@ -95,12 +95,11 @@
SetControlFrameId(1, &frame);
EXPECT_EQ(1u, GetControlFrameId(frame));
stop_sending.stream_id = 321;
- stop_sending.application_error_code = QUIC_STREAM_CANCELLED;
+ stop_sending.error_code = QUIC_STREAM_CANCELLED;
std::ostringstream stream;
stream << stop_sending;
- EXPECT_EQ(
- "{ control_frame_id: 1, stream_id: 321, application_error_code: 6 }\n",
- stream.str());
+ EXPECT_EQ("{ control_frame_id: 1, stream_id: 321, error_code: 6 }\n",
+ stream.str());
EXPECT_TRUE(IsControlFrame(frame.type));
}
diff --git a/quic/core/frames/quic_stop_sending_frame.cc b/quic/core/frames/quic_stop_sending_frame.cc
index c4d732e..d3c1cdd 100644
--- a/quic/core/frames/quic_stop_sending_frame.cc
+++ b/quic/core/frames/quic_stop_sending_frame.cc
@@ -6,18 +6,17 @@
namespace quic {
-QuicStopSendingFrame::QuicStopSendingFrame(
- QuicControlFrameId control_frame_id,
- QuicStreamId stream_id,
- QuicApplicationErrorCode application_error_code)
+QuicStopSendingFrame::QuicStopSendingFrame(QuicControlFrameId control_frame_id,
+ QuicStreamId stream_id,
+ QuicRstStreamErrorCode error_code)
: control_frame_id(control_frame_id),
stream_id(stream_id),
- application_error_code(application_error_code) {}
+ error_code(error_code) {}
std::ostream& operator<<(std::ostream& os, const QuicStopSendingFrame& frame) {
os << "{ control_frame_id: " << frame.control_frame_id
<< ", stream_id: " << frame.stream_id
- << ", application_error_code: " << frame.application_error_code << " }\n";
+ << ", error_code: " << frame.error_code << " }\n";
return os;
}
diff --git a/quic/core/frames/quic_stop_sending_frame.h b/quic/core/frames/quic_stop_sending_frame.h
index 8222067..f54ae0e 100644
--- a/quic/core/frames/quic_stop_sending_frame.h
+++ b/quic/core/frames/quic_stop_sending_frame.h
@@ -17,7 +17,7 @@
QuicStopSendingFrame() = default;
QuicStopSendingFrame(QuicControlFrameId control_frame_id,
QuicStreamId stream_id,
- QuicApplicationErrorCode application_error_code);
+ QuicRstStreamErrorCode error_code);
friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
std::ostream& os,
@@ -27,7 +27,9 @@
// and non-zero when sent.
QuicControlFrameId control_frame_id = kInvalidControlFrameId;
QuicStreamId stream_id = 0;
- QuicApplicationErrorCode application_error_code = 0;
+
+ // QuicRstStreamErrorCode associated with the frame.
+ QuicRstStreamErrorCode error_code = QUIC_STREAM_NO_ERROR;
};
} // namespace quic
diff --git a/quic/core/http/quic_send_control_stream.cc b/quic/core/http/quic_send_control_stream.cc
index 7be8ee4..a7a5349 100644
--- a/quic/core/http/quic_send_control_stream.cc
+++ b/quic/core/http/quic_send_control_stream.cc
@@ -30,7 +30,7 @@
QUIC_BUG << "OnStreamReset() called for write unidirectional stream.";
}
-bool QuicSendControlStream::OnStopSending(uint16_t /* code */) {
+bool QuicSendControlStream::OnStopSending(QuicRstStreamErrorCode /* code */) {
stream_delegate()->OnStreamError(
QUIC_HTTP_CLOSED_CRITICAL_STREAM,
"STOP_SENDING received for send control stream");
diff --git a/quic/core/http/quic_send_control_stream.h b/quic/core/http/quic_send_control_stream.h
index 6240310..25ea5b7 100644
--- a/quic/core/http/quic_send_control_stream.h
+++ b/quic/core/http/quic_send_control_stream.h
@@ -31,7 +31,7 @@
// Overriding QuicStream::OnStopSending() to make sure control stream is never
// closed before connection.
void OnStreamReset(const QuicRstStreamFrame& frame) override;
- bool OnStopSending(uint16_t code) override;
+ bool OnStopSending(QuicRstStreamErrorCode code) override;
// Send SETTINGS frame if it hasn't been sent yet. Settings frame must be the
// first frame sent on this stream.
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index 12fc297..ff3c62e 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -182,20 +182,19 @@
// would cause a close in the opposite direction. This allows tests to do the
// extra work to get a two-way (full) close where desired. Also sets up
// expects needed to ensure that the STOP_SENDING worked as expected.
- void InjectStopSendingFrame(QuicStreamId stream_id,
- QuicRstStreamErrorCode rst_stream_code) {
+ void InjectStopSendingFrame(QuicStreamId stream_id) {
if (!VersionHasIetfQuicFrames(transport_version())) {
// Only needed for version 99/IETF QUIC. Noop otherwise.
return;
}
- QuicStopSendingFrame stop_sending(
- kInvalidControlFrameId, stream_id,
- static_cast<QuicApplicationErrorCode>(rst_stream_code));
+ QuicStopSendingFrame stop_sending(kInvalidControlFrameId, stream_id,
+ QUIC_ERROR_PROCESSING_STREAM);
EXPECT_CALL(owner_, OnStopSendingReceived(_)).Times(1);
// Expect the RESET_STREAM that is generated in response to receiving a
// STOP_SENDING.
EXPECT_CALL(*connection_, SendControlFrame(_));
- EXPECT_CALL(*connection_, OnStreamReset(stream_id, rst_stream_code));
+ EXPECT_CALL(*connection_,
+ OnStreamReset(stream_id, QUIC_ERROR_PROCESSING_STREAM));
session_->OnStopSendingFrame(stop_sending);
}
@@ -258,8 +257,7 @@
// For version-99 will create and receive a stop-sending, completing
// the full-close expected by this test.
- InjectStopSendingFrame(GetNthClientInitiatedBidirectionalId(0),
- QUIC_ERROR_PROCESSING_STREAM);
+ InjectStopSendingFrame(GetNthClientInitiatedBidirectionalId(0));
EXPECT_EQ(0u, QuicSessionPeer::GetNumOpenDynamicStreams(session_.get()));
// Send the same two bytes of payload in a new packet.
@@ -288,8 +286,7 @@
// For version-99 will create and receive a stop-sending, completing
// the full-close expected by this test.
- InjectStopSendingFrame(GetNthClientInitiatedBidirectionalId(0),
- QUIC_ERROR_PROCESSING_STREAM);
+ InjectStopSendingFrame(GetNthClientInitiatedBidirectionalId(0));
EXPECT_EQ(0u, QuicSessionPeer::GetNumOpenDynamicStreams(session_.get()));
// Send two bytes of payload.
@@ -329,8 +326,7 @@
// For version-99 will create and receive a stop-sending, completing
// the full-close expected by this test.
- InjectStopSendingFrame(GetNthClientInitiatedBidirectionalId(0),
- QUIC_ERROR_PROCESSING_STREAM);
+ InjectStopSendingFrame(GetNthClientInitiatedBidirectionalId(0));
// If we were tracking, we'd probably want to reject this because it's data
// past the reset point of stream 3. As it's a closed stream we just drop the
diff --git a/quic/core/http/quic_spdy_server_stream_base_test.cc b/quic/core/http/quic_spdy_server_stream_base_test.cc
index a32de61..1d08da3 100644
--- a/quic/core/http/quic_spdy_server_stream_base_test.cc
+++ b/quic/core/http/quic_spdy_server_stream_base_test.cc
@@ -75,9 +75,8 @@
if (VersionHasIetfQuicFrames(session_.transport_version())) {
// Create and inject a STOP SENDING frame to complete the close
// of the stream. This is only needed for version 99/IETF QUIC.
- QuicStopSendingFrame stop_sending(
- kInvalidControlFrameId, stream_->id(),
- static_cast<QuicApplicationErrorCode>(QUIC_STREAM_CANCELLED));
+ QuicStopSendingFrame stop_sending(kInvalidControlFrameId, stream_->id(),
+ QUIC_STREAM_CANCELLED);
session_.OnStopSendingFrame(stop_sending);
}
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index dded232..ee846b0 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -1268,7 +1268,7 @@
return true;
}
default:
- SendStopSending(static_cast<QuicApplicationErrorCode>(
+ SendStopSending(static_cast<QuicRstStreamErrorCode>(
QuicHttp3ErrorCode::STREAM_CREATION_ERROR),
pending->id());
pending->StopReading();
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 32fc3f1..3f2387a 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -1205,9 +1205,9 @@
// one-way close.
if (VersionHasIetfQuicFrames(transport_version())) {
// Only needed for version 99/IETF QUIC.
- QuicStopSendingFrame stop_sending(
- kInvalidControlFrameId, GetNthClientInitiatedBidirectionalId(0),
- static_cast<QuicApplicationErrorCode>(QUIC_ERROR_PROCESSING_STREAM));
+ QuicStopSendingFrame stop_sending(kInvalidControlFrameId,
+ GetNthClientInitiatedBidirectionalId(0),
+ QUIC_ERROR_PROCESSING_STREAM);
// Expect the RESET_STREAM that is generated in response to receiving a
// STOP_SENDING.
EXPECT_CALL(*connection_,
@@ -1487,9 +1487,8 @@
// one-way close.
if (VersionHasIetfQuicFrames(transport_version())) {
// Only needed for version 99/IETF QUIC.
- QuicStopSendingFrame stop_sending(
- kInvalidControlFrameId, stream->id(),
- static_cast<QuicApplicationErrorCode>(QUIC_STREAM_CANCELLED));
+ QuicStopSendingFrame stop_sending(kInvalidControlFrameId, stream->id(),
+ QUIC_STREAM_CANCELLED);
// Expect the RESET_STREAM that is generated in response to receiving a
// STOP_SENDING.
EXPECT_CALL(*connection_,
@@ -2201,8 +2200,7 @@
QuicStopSendingFrame* stop_sending = frame.stop_sending_frame;
EXPECT_EQ(stream_id, stop_sending->stream_id);
EXPECT_EQ(QuicHttp3ErrorCode::STREAM_CREATION_ERROR,
- static_cast<QuicHttp3ErrorCode>(
- stop_sending->application_error_code));
+ static_cast<QuicHttp3ErrorCode>(stop_sending->error_code));
return ClearControlFrame(frame);
}));
@@ -2907,8 +2905,7 @@
ASSERT_TRUE(control_stream);
QuicStopSendingFrame stop_sending_control_stream(
- kInvalidControlFrameId, control_stream->id(),
- static_cast<QuicApplicationErrorCode>(QUIC_STREAM_CANCELLED));
+ kInvalidControlFrameId, control_stream->id(), QUIC_STREAM_CANCELLED);
EXPECT_CALL(
*connection_,
CloseConnection(QUIC_HTTP_CLOSED_CRITICAL_STREAM,
@@ -2920,8 +2917,7 @@
ASSERT_TRUE(decoder_stream);
QuicStopSendingFrame stop_sending_decoder_stream(
- kInvalidControlFrameId, decoder_stream->id(),
- static_cast<QuicApplicationErrorCode>(QUIC_STREAM_CANCELLED));
+ kInvalidControlFrameId, decoder_stream->id(), QUIC_STREAM_CANCELLED);
EXPECT_CALL(
*connection_,
CloseConnection(QUIC_HTTP_CLOSED_CRITICAL_STREAM,
@@ -2933,8 +2929,7 @@
ASSERT_TRUE(encoder_stream);
QuicStopSendingFrame stop_sending_encoder_stream(
- kInvalidControlFrameId, encoder_stream->id(),
- static_cast<QuicApplicationErrorCode>(QUIC_STREAM_CANCELLED));
+ kInvalidControlFrameId, encoder_stream->id(), QUIC_STREAM_CANCELLED);
EXPECT_CALL(
*connection_,
CloseConnection(QUIC_HTTP_CLOSED_CRITICAL_STREAM,
diff --git a/quic/core/qpack/qpack_send_stream.cc b/quic/core/qpack/qpack_send_stream.cc
index 15525b5..176c431 100644
--- a/quic/core/qpack/qpack_send_stream.cc
+++ b/quic/core/qpack/qpack_send_stream.cc
@@ -20,7 +20,7 @@
QUIC_BUG << "OnStreamReset() called for write unidirectional stream.";
}
-bool QpackSendStream::OnStopSending(uint16_t /* code */) {
+bool QpackSendStream::OnStopSending(QuicRstStreamErrorCode /* code */) {
stream_delegate()->OnStreamError(
QUIC_HTTP_CLOSED_CRITICAL_STREAM,
"STOP_SENDING received for QPACK send stream");
diff --git a/quic/core/qpack/qpack_send_stream.h b/quic/core/qpack/qpack_send_stream.h
index 50d2808..e8a4ea7 100644
--- a/quic/core/qpack/qpack_send_stream.h
+++ b/quic/core/qpack/qpack_send_stream.h
@@ -33,7 +33,7 @@
// Overriding QuicStream::OnStopSending() to make sure QPACK stream is never
// closed before connection.
void OnStreamReset(const QuicRstStreamFrame& frame) override;
- bool OnStopSending(uint16_t code) override;
+ bool OnStopSending(QuicRstStreamErrorCode code) override;
// The send QPACK stream is write unidirectional, so this method
// should never be called.
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 0a7430b..4069501 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -1476,8 +1476,7 @@
}
QUIC_DLOG(INFO) << ENDPOINT << "STOP_SENDING frame received for stream: "
- << frame.stream_id
- << " with error: " << frame.application_error_code;
+ << frame.stream_id << " with error: " << frame.error_code;
visitor_->OnStopSendingFrame(frame);
return connected_;
diff --git a/quic/core/quic_control_frame_manager.cc b/quic/core/quic_control_frame_manager.cc
index ba00015..c2fdc38 100644
--- a/quic/core/quic_control_frame_manager.cc
+++ b/quic/core/quic_control_frame_manager.cc
@@ -103,8 +103,9 @@
QuicMaxStreamsFrame(++last_control_frame_id_, count, unidirectional)));
}
-void QuicControlFrameManager::WriteOrBufferStopSending(uint16_t code,
- QuicStreamId stream_id) {
+void QuicControlFrameManager::WriteOrBufferStopSending(
+ QuicRstStreamErrorCode code,
+ QuicStreamId stream_id) {
QUIC_DVLOG(1) << "Writing STOP_SENDING_FRAME";
WriteOrBufferQuicFrame(QuicFrame(
new QuicStopSendingFrame(++last_control_frame_id_, stream_id, code)));
diff --git a/quic/core/quic_control_frame_manager.h b/quic/core/quic_control_frame_manager.h
index 7615754..d57d120 100644
--- a/quic/core/quic_control_frame_manager.h
+++ b/quic/core/quic_control_frame_manager.h
@@ -77,7 +77,8 @@
// Tries to send an IETF-QUIC STOP_SENDING frame. The frame is buffered if it
// can not be sent immediately.
- void WriteOrBufferStopSending(uint16_t code, QuicStreamId stream_id);
+ void WriteOrBufferStopSending(QuicRstStreamErrorCode code,
+ QuicStreamId stream_id);
// Tries to send an HANDSHAKE_DONE frame. The frame is buffered if it can not
// be sent immediately.
diff --git a/quic/core/quic_control_frame_manager_test.cc b/quic/core/quic_control_frame_manager_test.cc
index f8e9932..6219038 100644
--- a/quic/core/quic_control_frame_manager_test.cc
+++ b/quic/core/quic_control_frame_manager_test.cc
@@ -31,7 +31,8 @@
namespace {
const QuicStreamId kTestStreamId = 5;
-const QuicStreamId kTestStopSendingCode = 321;
+const QuicRstStreamErrorCode kTestStopSendingCode =
+ QUIC_STREAM_ENCODER_STREAM_ERROR;
class QuicControlFrameManagerTest : public QuicTest {
public:
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index c9eabcb..5bfccb2 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -621,7 +621,7 @@
// static
size_t QuicFramer::GetStopSendingFrameSize(const QuicStopSendingFrame& frame) {
return kQuicFrameTypeSize + QuicDataWriter::GetVarInt62Len(frame.stream_id) +
- QuicDataWriter::GetVarInt62Len(frame.application_error_code);
+ QuicDataWriter::GetVarInt62Len(frame.error_code);
}
// static
@@ -5914,12 +5914,13 @@
}
// TODO(fkastenholz): when error codes go to uint64_t, remove this.
if (error_code > 0xffff) {
- stop_sending_frame->application_error_code = 0xffff;
+ stop_sending_frame->error_code =
+ static_cast<QuicRstStreamErrorCode>(0xffff);
QUIC_DLOG(ERROR) << "Stop sending error code (" << error_code
<< ") > 0xffff";
} else {
- stop_sending_frame->application_error_code =
- static_cast<uint16_t>(error_code);
+ stop_sending_frame->error_code =
+ static_cast<QuicRstStreamErrorCode>(error_code);
}
return true;
}
@@ -5932,7 +5933,7 @@
return false;
}
if (!writer->WriteVarInt62(
- static_cast<uint64_t>(stop_sending_frame.application_error_code))) {
+ static_cast<uint64_t>(stop_sending_frame.error_code))) {
set_detailed_error("Can not write application error code");
return false;
}
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index c610997..b67eaf3 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -10977,7 +10977,7 @@
PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
EXPECT_EQ(kStreamId, visitor_.stop_sending_frame_.stream_id);
- EXPECT_EQ(0x7654, visitor_.stop_sending_frame_.application_error_code);
+ EXPECT_EQ(0x7654, visitor_.stop_sending_frame_.error_code);
CheckFramingBoundaries(packet99, QUIC_INVALID_STOP_SENDING_FRAME_DATA);
}
@@ -10996,7 +10996,7 @@
QuicStopSendingFrame frame;
frame.stream_id = kStreamId;
- frame.application_error_code = 0xffff;
+ frame.error_code = static_cast<QuicRstStreamErrorCode>(0xffff);
QuicFrames frames = {QuicFrame(&frame)};
// clang-format off
@@ -11260,7 +11260,7 @@
QuicFramer::GetRetransmittableControlFrameSize(
framer_.transport_version(), QuicFrame(&path_challenge_frame)));
- QuicStopSendingFrame stop_sending_frame(10, 3, 20);
+ QuicStopSendingFrame stop_sending_frame(10, 3, QUIC_STREAM_CANCELLED);
EXPECT_EQ(QuicFramer::GetStopSendingFrameSize(stop_sending_frame),
QuicFramer::GetRetransmittableControlFrameSize(
framer_.transport_version(), QuicFrame(&stop_sending_frame)));
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index cce8fa5..4a2c49b 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -262,7 +262,7 @@
return;
}
- stream->OnStopSending(frame.application_error_code);
+ stream->OnStopSending(frame.error_code);
}
void QuicSession::OnPacketDecrypted(EncryptionLevel level) {
@@ -2431,7 +2431,8 @@
return connection_->GetGuaranteedLargestMessagePayload();
}
-void QuicSession::SendStopSending(uint16_t code, QuicStreamId stream_id) {
+void QuicSession::SendStopSending(QuicRstStreamErrorCode code,
+ QuicStreamId stream_id) {
control_frame_manager_.WriteOrBufferStopSending(code, stream_id);
}
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index bb5107a..e8f3c46 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -231,7 +231,8 @@
virtual void SendWindowUpdate(QuicStreamId id, QuicStreamOffset byte_offset);
// Create and transmit a STOP_SENDING frame
- virtual void SendStopSending(uint16_t code, QuicStreamId stream_id);
+ virtual void SendStopSending(QuicRstStreamErrorCode code,
+ QuicStreamId stream_id);
// Called by stream |stream_id| when it gets closed.
virtual void OnStreamClosed(QuicStreamId stream_id);
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 38457d6..909a9f1 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -2821,7 +2821,7 @@
return;
}
// Check that "invalid" stream ids are rejected.
- QuicStopSendingFrame frame(1, -1, 123);
+ QuicStopSendingFrame frame(1, -1, QUIC_STREAM_CANCELLED);
EXPECT_CALL(
*connection_,
CloseConnection(QUIC_INVALID_STREAM_ID,
@@ -2834,7 +2834,8 @@
return;
}
// It's illegal to send STOP_SENDING with a stream ID that is read-only.
- QuicStopSendingFrame frame(1, GetNthClientInitiatedUnidirectionalId(1), 123);
+ QuicStopSendingFrame frame(1, GetNthClientInitiatedUnidirectionalId(1),
+ QUIC_STREAM_CANCELLED);
EXPECT_CALL(
*connection_,
CloseConnection(QUIC_INVALID_STREAM_ID,
@@ -2852,7 +2853,7 @@
stream_id, &session_, /*is_static*/ true, BIDIRECTIONAL);
QuicSessionPeer::ActivateStream(&session_, std::move(fake_static_stream));
// Check that a stream id in the static stream map is ignored.
- QuicStopSendingFrame frame(1, stream_id, 123);
+ QuicStopSendingFrame frame(1, stream_id, QUIC_STREAM_CANCELLED);
EXPECT_CALL(*connection_,
CloseConnection(QUIC_INVALID_STREAM_ID,
"Received STOP_SENDING for a static stream", _));
@@ -2870,7 +2871,7 @@
QuicStreamPeer::SetFinSent(stream);
stream->CloseWriteSide();
EXPECT_TRUE(stream->write_side_closed());
- QuicStopSendingFrame frame(1, stream_id, 123);
+ QuicStopSendingFrame frame(1, stream_id, QUIC_STREAM_CANCELLED);
EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
session_.OnStopSendingFrame(frame);
}
@@ -2884,7 +2885,7 @@
TestStream* stream = session_.CreateOutgoingBidirectionalStream();
QuicStreamId stream_id = stream->id();
CloseStream(stream_id);
- QuicStopSendingFrame frame(1, stream_id, 123);
+ QuicStopSendingFrame frame(1, stream_id, QUIC_STREAM_CANCELLED);
EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
session_.OnStopSendingFrame(frame);
}
@@ -2897,7 +2898,7 @@
}
QuicStopSendingFrame frame(1, GetNthServerInitiatedBidirectionalId(123456),
- 123);
+ QUIC_STREAM_CANCELLED);
EXPECT_CALL(*connection_, CloseConnection(QUIC_HTTP_STREAM_WRONG_DIRECTION,
"Data for nonexistent stream", _))
.Times(1);
@@ -2910,7 +2911,8 @@
if (!VersionHasIetfQuicFrames(transport_version())) {
return;
}
- QuicStopSendingFrame frame(1, GetNthClientInitiatedBidirectionalId(1), 123);
+ QuicStopSendingFrame frame(1, GetNthClientInitiatedBidirectionalId(1),
+ QUIC_STREAM_CANCELLED);
// A Rst will be sent as a response for STOP_SENDING.
EXPECT_CALL(*connection_, SendControlFrame(_)).Times(1);
@@ -2937,12 +2939,10 @@
EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream));
QuicStreamId stream_id = stream->id();
- QuicStopSendingFrame frame(1, stream_id, 123);
+ QuicStopSendingFrame frame(1, stream_id, QUIC_STREAM_CANCELLED);
// Expect a reset to come back out.
EXPECT_CALL(*connection_, SendControlFrame(_));
- EXPECT_CALL(
- *connection_,
- OnStreamReset(stream_id, static_cast<QuicRstStreamErrorCode>(123)));
+ EXPECT_CALL(*connection_, OnStreamReset(stream_id, QUIC_STREAM_CANCELLED));
EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
session_.OnStopSendingFrame(frame);
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index a5be981..5d64f3b 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -484,7 +484,7 @@
sequencer_.OnStreamFrame(frame);
}
-bool QuicStream::OnStopSending(uint16_t code) {
+bool QuicStream::OnStopSending(QuicRstStreamErrorCode code) {
// Do not reset the stream if all data has been sent and acknowledged.
if (write_side_closed() && !IsWaitingForAcks()) {
QUIC_DVLOG(1) << ENDPOINT
@@ -502,11 +502,10 @@
return false;
}
- stream_error_ = static_cast<QuicRstStreamErrorCode>(code);
+ stream_error_ = code;
- session()->SendRstStream(id(),
- static_cast<quic::QuicRstStreamErrorCode>(code),
- stream_bytes_written(), /*send_rst_only = */ true);
+ session()->SendRstStream(id(), code, stream_bytes_written(),
+ /*send_rst_only = */ true);
rst_sent_ = true;
CloseWriteSide();
return true;
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index f808d50..a5520bd 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -344,7 +344,7 @@
// Handle received StopSending frame. Returns true if the processing finishes
// gracefully.
- virtual bool OnStopSending(uint16_t code);
+ virtual bool OnStopSending(QuicRstStreamErrorCode code);
// Returns true if the stream is static.
bool is_static() const { return is_static_; }
diff --git a/quic/core/quic_types.h b/quic/core/quic_types.h
index 4b94152..f39ebdf 100644
--- a/quic/core/quic_types.h
+++ b/quic/core/quic_types.h
@@ -46,9 +46,6 @@
enum : size_t { kQuicPathFrameBufferSize = 8 };
using QuicPathFrameBuffer = std::array<uint8_t, kQuicPathFrameBufferSize>;
-// Application error code used in the QUIC Stop Sending frame.
-using QuicApplicationErrorCode = uint16_t;
-
// The connection id sequence number specifies the order that connection
// ids must be used in. This is also the sequence number carried in
// the IETF QUIC NEW_CONNECTION_ID and RETIRE_CONNECTION_ID frames.
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 614e958..854fc23 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -813,7 +813,7 @@
MOCK_METHOD(bool, ShouldKeepConnectionAlive, (), (const, override));
MOCK_METHOD(void,
SendStopSending,
- (uint16_t code, QuicStreamId stream_id),
+ (QuicRstStreamErrorCode code, QuicStreamId stream_id),
(override));
MOCK_METHOD(std::vector<std::string>, GetAlpnsToOffer, (), (const, override));
MOCK_METHOD(std::vector<quiche::QuicheStringPiece>::const_iterator,
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index f5dad7d..780ff9d 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -296,9 +296,8 @@
return;
}
EXPECT_CALL(owner_, OnStopSendingReceived(_)).Times(1);
- QuicStopSendingFrame stop_sending(
- kInvalidControlFrameId, stream_id,
- static_cast<QuicApplicationErrorCode>(rst_stream_code));
+ QuicStopSendingFrame stop_sending(kInvalidControlFrameId, stream_id,
+ rst_stream_code);
// Expect the RESET_STREAM that is generated in response to receiving a
// STOP_SENDING.
EXPECT_CALL(*connection_, OnStreamReset(stream_id, rst_stream_code));
