Introduce the concept of STOP_SENDING in gQUIC.
gQUIC uses to have RST(QUIC_STREAM_NO_ERROR) to achieve STOP_SENDING semantics. This change would unify this behavior with IETF STOP_SENDING.
Protected by quic_reloadable_flag_quic_split_up_send_rst.
PiperOrigin-RevId: 336959906
Change-Id: Ie1daa4a96bcdd627354b1425bd736a91f153beab
diff --git a/quic/core/http/quic_spdy_server_stream_base.cc b/quic/core/http/quic_spdy_server_stream_base.cc
index 2e2e2ec..aee5045 100644
--- a/quic/core/http/quic_spdy_server_stream_base.cc
+++ b/quic/core/http/quic_spdy_server_stream_base.cc
@@ -28,7 +28,11 @@
DCHECK(fin_sent() || !session()->connection()->connected());
// Tell the peer to stop sending further data.
QUIC_DVLOG(1) << " Server: Send QUIC_STREAM_NO_ERROR on stream " << id();
- Reset(QUIC_STREAM_NO_ERROR);
+ if (session()->split_up_send_rst()) {
+ MaybeSendStopSending(QUIC_STREAM_NO_ERROR);
+ } else {
+ Reset(QUIC_STREAM_NO_ERROR);
+ }
}
QuicSpdyStream::CloseWriteSide();
@@ -40,7 +44,11 @@
DCHECK(fin_sent());
// Tell the peer to stop sending further data.
QUIC_DVLOG(1) << " Server: Send QUIC_STREAM_NO_ERROR on stream " << id();
- Reset(QUIC_STREAM_NO_ERROR);
+ if (session()->split_up_send_rst()) {
+ MaybeSendStopSending(QUIC_STREAM_NO_ERROR);
+ } else {
+ Reset(QUIC_STREAM_NO_ERROR);
+ }
}
QuicSpdyStream::StopReading();
}
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 1d08da3..64184a7 100644
--- a/quic/core/http/quic_spdy_server_stream_base_test.cc
+++ b/quic/core/http/quic_spdy_server_stream_base_test.cc
@@ -50,7 +50,19 @@
TEST_F(QuicSpdyServerStreamBaseTest,
SendQuicRstStreamNoErrorWithEarlyResponse) {
stream_->StopReading();
- EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _, _)).Times(1);
+
+ if (!session_.split_up_send_rst()) {
+ EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _, _))
+ .Times(1);
+ } else {
+ if (session_.version().UsesHttp3()) {
+ EXPECT_CALL(session_, MaybeSendStopSendingFrame(_, QUIC_STREAM_NO_ERROR))
+ .Times(1);
+ } else {
+ EXPECT_CALL(session_, MaybeSendRstStreamFrame(_, QUIC_STREAM_NO_ERROR, _))
+ .Times(1);
+ }
+ }
QuicStreamPeer::SetFinSent(stream_);
stream_->CloseWriteSide();
}
@@ -61,14 +73,25 @@
EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _, _)).Times(0);
- EXPECT_CALL(
- session_,
- SendRstStream(_,
+ if (!session_.split_up_send_rst()) {
+ EXPECT_CALL(
+ session_,
+ SendRstStream(_,
+ VersionHasIetfQuicFrames(session_.transport_version())
+ ? QUIC_STREAM_CANCELLED
+ : QUIC_RST_ACKNOWLEDGEMENT,
+ _, _))
+ .Times(1);
+ } else {
+ EXPECT_CALL(session_,
+ MaybeSendRstStreamFrame(
+ _,
VersionHasIetfQuicFrames(session_.transport_version())
? QUIC_STREAM_CANCELLED
: QUIC_RST_ACKNOWLEDGEMENT,
- _, _))
- .Times(1);
+ _))
+ .Times(1);
+ }
QuicRstStreamFrame rst_frame(kInvalidControlFrameId, stream_->id(),
QUIC_STREAM_CANCELLED, 1234);
stream_->OnStreamReset(rst_frame);
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index 4adbaab..03afd72 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -514,8 +514,13 @@
stream_->OnStreamHeadersPriority(
spdy::SpdyStreamPrecedence(kV3HighestPriority));
- EXPECT_CALL(*session_,
- SendRstStream(stream_->id(), QUIC_HEADERS_TOO_LARGE, 0, _));
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_,
+ SendRstStream(stream_->id(), QUIC_HEADERS_TOO_LARGE, 0, _));
+ } else {
+ EXPECT_CALL(*session_, MaybeSendRstStreamFrame(
+ stream_->id(), QUIC_HEADERS_TOO_LARGE, 0));
+ }
stream_->OnStreamHeaderList(false, 1 << 20, headers);
EXPECT_THAT(stream_->stream_error(), IsStreamError(QUIC_HEADERS_TOO_LARGE));
@@ -530,8 +535,15 @@
QuicStreamFrame frame(stream_->id(), false, 0, headers);
- EXPECT_CALL(*session_,
- SendRstStream(stream_->id(), QUIC_HEADERS_TOO_LARGE, 0, _));
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_,
+ SendRstStream(stream_->id(), QUIC_HEADERS_TOO_LARGE, 0, _));
+ } else {
+ EXPECT_CALL(*session_, MaybeSendStopSendingFrame(stream_->id(),
+ QUIC_HEADERS_TOO_LARGE));
+ EXPECT_CALL(*session_, MaybeSendRstStreamFrame(stream_->id(),
+ QUIC_HEADERS_TOO_LARGE, 0));
+ }
auto qpack_decoder_stream =
QuicSpdySessionPeer::GetQpackDecoderSendStream(session_.get());
@@ -667,8 +679,11 @@
ConnectionCloseSource source) {
session_->ReallyOnConnectionClosed(frame, source);
}));
- EXPECT_CALL(*session_, SendRstStream(_, _, _, _));
- EXPECT_CALL(*session_, SendRstStream(_, _, _, _));
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_, SendRstStream(_, _, _, _)).Times(2);
+ } else {
+ EXPECT_CALL(*session_, MaybeSendRstStreamFrame(_, _, _)).Times(2);
+ }
stream_->OnStreamFrame(frame);
}
@@ -2097,8 +2112,11 @@
ConnectionCloseSource source) {
session_->ReallyOnConnectionClosed(frame, source);
}));
- EXPECT_CALL(*session_, SendRstStream(_, _, _, _));
- EXPECT_CALL(*session_, SendRstStream(_, _, _, _));
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_, SendRstStream(_, _, _, _)).Times(2);
+ } else {
+ EXPECT_CALL(*session_, MaybeSendRstStreamFrame(_, _, _)).Times(2);
+ }
stream_->OnStreamFrame(frame);
}
@@ -2136,8 +2154,13 @@
session_->ReallyOnConnectionClosed(frame, source);
}));
}
- EXPECT_CALL(*session_, SendRstStream(stream_->id(), _, _, _));
- EXPECT_CALL(*session_, SendRstStream(stream2_->id(), _, _, _));
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_, SendRstStream(stream_->id(), _, _, _));
+ EXPECT_CALL(*session_, SendRstStream(stream2_->id(), _, _, _));
+ } else {
+ EXPECT_CALL(*session_, MaybeSendRstStreamFrame(stream_->id(), _, _));
+ EXPECT_CALL(*session_, MaybeSendRstStreamFrame(stream2_->id(), _, _));
+ }
// Invalid headers: Required Insert Count is zero, but the header block
// contains a dynamic table reference.
@@ -2456,8 +2479,15 @@
/* offset = */ 1, _, _, _));
// Reset stream.
- EXPECT_CALL(*session_,
- SendRstStream(stream_->id(), QUIC_STREAM_CANCELLED, _, _));
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_,
+ SendRstStream(stream_->id(), QUIC_STREAM_CANCELLED, _, _));
+ } else {
+ EXPECT_CALL(*session_, MaybeSendStopSendingFrame(stream_->id(),
+ QUIC_STREAM_CANCELLED));
+ EXPECT_CALL(*session_, MaybeSendRstStreamFrame(stream_->id(),
+ QUIC_STREAM_CANCELLED, _));
+ }
stream_->Reset(QUIC_STREAM_CANCELLED);
if (!GetQuicReloadableFlag(quic_abort_qpack_on_stream_close)) {
@@ -2917,8 +2947,15 @@
EXPECT_CALL(*session_,
WritevData(qpack_decoder_stream->id(), /* write_length = */ 1,
/* offset = */ 1, _, _, _));
- EXPECT_CALL(*session_,
- SendRstStream(stream_->id(), QUIC_STREAM_CANCELLED, 0, _));
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_,
+ SendRstStream(stream_->id(), QUIC_STREAM_CANCELLED, _, _));
+ } else {
+ EXPECT_CALL(*session_, MaybeSendStopSendingFrame(stream_->id(),
+ QUIC_STREAM_CANCELLED));
+ EXPECT_CALL(*session_, MaybeSendRstStreamFrame(stream_->id(),
+ QUIC_STREAM_CANCELLED, _));
+ }
stream_->Reset(QUIC_STREAM_CANCELLED);
}
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 34489e0..84f0a7f 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -804,15 +804,26 @@
QuicRstStreamErrorCode error,
QuicStreamOffset bytes_written,
bool send_rst_only) {
- if (connection()->connected()) {
- QuicConnection::ScopedPacketFlusher flusher(connection());
- MaybeSendRstStreamFrame(id, error, bytes_written);
- if (!send_rst_only) {
- MaybeSendStopSendingFrame(id, error);
- }
-
- connection_->OnStreamReset(id, error);
+ DCHECK(!split_up_send_rst());
+ if (!connection()->connected()) {
+ return;
}
+
+ QuicConnection::ScopedPacketFlusher flusher(connection());
+ if (!VersionHasIetfQuicFrames(transport_version()) ||
+ QuicUtils::GetStreamType(id, perspective(), IsIncomingStream(id),
+ version()) != READ_UNIDIRECTIONAL) {
+ control_frame_manager_.WriteOrBufferRstStream(id, error, bytes_written);
+ }
+ if (!send_rst_only) {
+ if (VersionHasIetfQuicFrames(transport_version()) &&
+ QuicUtils::GetStreamType(id, perspective(), IsIncomingStream(id),
+ version()) != WRITE_UNIDIRECTIONAL) {
+ control_frame_manager_.WriteOrBufferStopSending(error, id);
+ }
+ }
+
+ connection_->OnStreamReset(id, error);
}
void QuicSession::ResetStream(QuicStreamId id, QuicRstStreamErrorCode error) {
@@ -829,23 +840,37 @@
return;
}
- SendRstStream(id, error, 0, /*send_rst_only = */ false);
+ if (split_up_send_rst()) {
+ QuicConnection::ScopedPacketFlusher flusher(connection());
+ MaybeSendStopSendingFrame(id, error);
+ MaybeSendRstStreamFrame(id, error, 0);
+ } else {
+ SendRstStream(id, error, 0, /*send_rst_only = */ false);
+ }
}
void QuicSession::MaybeSendRstStreamFrame(QuicStreamId id,
QuicRstStreamErrorCode error,
QuicStreamOffset bytes_written) {
- DCHECK(connection()->connected());
+ DCHECK(split_up_send_rst());
+ if (!connection()->connected()) {
+ return;
+ }
if (!VersionHasIetfQuicFrames(transport_version()) ||
QuicUtils::GetStreamType(id, perspective(), IsIncomingStream(id),
version()) != READ_UNIDIRECTIONAL) {
control_frame_manager_.WriteOrBufferRstStream(id, error, bytes_written);
}
+
+ connection_->OnStreamReset(id, error);
}
void QuicSession::MaybeSendStopSendingFrame(QuicStreamId id,
QuicRstStreamErrorCode error) {
- DCHECK(connection()->connected());
+ DCHECK(split_up_send_rst());
+ if (!connection()->connected()) {
+ return;
+ }
if (VersionHasIetfQuicFrames(transport_version()) &&
QuicUtils::GetStreamType(id, perspective(), IsIncomingStream(id),
version()) != WRITE_UNIDIRECTIONAL) {
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 8f26290..e84124e 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -34,6 +34,7 @@
#include "net/third_party/quiche/src/quic/core/uber_quic_stream_id_manager.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
namespace quic {
@@ -216,6 +217,8 @@
// Called by stream to send RST_STREAM (and STOP_SENDING in IETF QUIC).
// if |send_rst_only|, STOP_SENDING will not be sent for IETF QUIC.
+ // TODO(b/170233449): Delete this method when flag quic_split_up_send_rst is
+ // deprecated.
virtual void SendRstStream(QuicStreamId id,
QuicRstStreamErrorCode error,
QuicStreamOffset bytes_written,
@@ -332,6 +335,8 @@
return connection_->connection_id();
}
+ bool split_up_send_rst() const { return split_up_send_rst_; }
+
// Returns the number of currently open streams, excluding static streams, and
// never counting unfinished streams.
size_t GetNumActiveStreams() const;
@@ -473,6 +478,16 @@
return true;
}
+ // Does actual work of sending RESET_STREAM, if the stream type allows.
+ // Also informs the connection so that pending stream frames can be flushed.
+ virtual void MaybeSendRstStreamFrame(QuicStreamId id,
+ QuicRstStreamErrorCode error,
+ QuicStreamOffset bytes_written);
+
+ // Sends a STOP_SENDING frame if the stream type allows.
+ virtual void MaybeSendStopSendingFrame(QuicStreamId id,
+ QuicRstStreamErrorCode error);
+
const absl::optional<std::string> user_agent_id() const {
return user_agent_id_;
}
@@ -715,14 +730,6 @@
// stream.
void PendingStreamOnRstStream(const QuicRstStreamFrame& frame);
- // Does actual work of sending RESET_STREAM, if the stream type allows.
- void MaybeSendRstStreamFrame(QuicStreamId id,
- QuicRstStreamErrorCode error,
- QuicStreamOffset bytes_written);
-
- // Sends a STOP_SENDING frame if the stream type allows.
- void MaybeSendStopSendingFrame(QuicStreamId id, QuicRstStreamErrorCode error);
-
// Keep track of highest received byte offset of locally closed streams, while
// waiting for a definitive final highest offset from the peer.
QuicHashMap<QuicStreamId, QuicStreamOffset>
@@ -835,6 +842,8 @@
// This indicates a liveness testing is in progress, and push back the
// creation of new outgoing bidirectional streams.
bool liveness_testing_in_progress_;
+
+ const bool split_up_send_rst_ = GetQuicReloadableFlag(quic_split_up_send_rst);
};
} // namespace quic
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index be2136b..5161977 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -3031,24 +3031,21 @@
.Times(1)
.WillOnce(Invoke(&ClearControlFrame));
EXPECT_CALL(*connection_, OnStreamReset(read_only, _));
- session_.SendRstStream(read_only, QUIC_STREAM_CANCELLED, 0,
- /*send_rst_only = */ false);
+ session_.ResetStream(read_only, QUIC_STREAM_CANCELLED);
QuicStreamId write_only = GetNthServerInitiatedUnidirectionalId(0);
EXPECT_CALL(*connection_, SendControlFrame(_))
.Times(1)
.WillOnce(Invoke(&ClearControlFrame));
EXPECT_CALL(*connection_, OnStreamReset(write_only, _));
- session_.SendRstStream(write_only, QUIC_STREAM_CANCELLED, 0,
- /*send_rst_only = */ false);
+ session_.ResetStream(write_only, QUIC_STREAM_CANCELLED);
QuicStreamId bidirectional = GetNthClientInitiatedBidirectionalId(0);
EXPECT_CALL(*connection_, SendControlFrame(_))
.Times(2)
.WillRepeatedly(Invoke(&ClearControlFrame));
EXPECT_CALL(*connection_, OnStreamReset(bidirectional, _));
- session_.SendRstStream(bidirectional, QUIC_STREAM_CANCELLED, 0,
- /*send_rst_only = */ false);
+ session_.ResetStream(bidirectional, QUIC_STREAM_CANCELLED);
}
TEST_P(QuicSessionTestServer, DecryptionKeyAvailableBeforeEncryptionKey) {
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index f84df2b..e9daac7 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -342,6 +342,7 @@
fin_received_(fin_received),
rst_sent_(false),
rst_received_(false),
+ stop_sending_sent_(false),
flow_controller_(std::move(flow_controller)),
connection_flow_controller_(connection_flow_controller),
stream_contributes_to_connection_flow_control_(true),
@@ -504,10 +505,15 @@
stream_error_ = code;
- session()->SendRstStream(id(), code, stream_bytes_written(),
- /*send_rst_only = */ true);
- rst_sent_ = true;
- CloseWriteSide();
+ if (session()->split_up_send_rst()) {
+ QUIC_RELOADABLE_FLAG_COUNT_N(quic_split_up_send_rst, 1, 3);
+ MaybeSendRstStream(code);
+ } else {
+ session()->SendRstStream(id(), code, stream_bytes_written(),
+ /*send_rst_only = */ true);
+ rst_sent_ = true;
+ CloseWriteSide();
+ }
return true;
}
@@ -593,15 +599,23 @@
void QuicStream::Reset(QuicRstStreamErrorCode error) {
stream_error_ = error;
- session()->SendRstStream(id(), error, stream_bytes_written(),
- /*send_rst_only = */ false);
- rst_sent_ = true;
+ if (session()->split_up_send_rst()) {
+ QUIC_RELOADABLE_FLAG_COUNT_N(quic_split_up_send_rst, 2, 3);
+ MaybeSendStopSending(error);
+ MaybeSendRstStream(error);
+ } else {
+ session()->SendRstStream(id(), error, stream_bytes_written(),
+ /*send_rst_only = */ false);
+ rst_sent_ = true;
+ }
if (read_side_closed_ && write_side_closed_ && !IsWaitingForAcks()) {
session()->MaybeCloseZombieStream(id_);
return;
}
- CloseReadSide();
- CloseWriteSide();
+ if (!session()->split_up_send_rst()) {
+ CloseReadSide();
+ CloseWriteSide();
+ }
}
void QuicStream::OnUnrecoverableError(QuicErrorCode error,
@@ -812,6 +826,44 @@
}
}
+void QuicStream::MaybeSendStopSending(QuicRstStreamErrorCode error) {
+ DCHECK(session()->split_up_send_rst());
+ if (stop_sending_sent_) {
+ return;
+ }
+
+ if (!session()->version().UsesHttp3() && error != QUIC_STREAM_NO_ERROR) {
+ // In gQUIC, RST with error closes both read and write side.
+ return;
+ }
+
+ if (session()->version().UsesHttp3()) {
+ session()->MaybeSendStopSendingFrame(id(), error);
+ } else {
+ DCHECK_EQ(QUIC_STREAM_NO_ERROR, error);
+ session()->MaybeSendRstStreamFrame(id(), QUIC_STREAM_NO_ERROR,
+ stream_bytes_written());
+ }
+ stop_sending_sent_ = true;
+ CloseReadSide();
+}
+
+void QuicStream::MaybeSendRstStream(QuicRstStreamErrorCode error) {
+ DCHECK(session()->split_up_send_rst());
+ if (rst_sent_) {
+ return;
+ }
+
+ if (!session()->version().UsesHttp3()) {
+ QUIC_BUG_IF(error == QUIC_STREAM_NO_ERROR);
+ stop_sending_sent_ = true;
+ CloseReadSide();
+ }
+ session()->MaybeSendRstStreamFrame(id(), error, stream_bytes_written());
+ rst_sent_ = true;
+ CloseWriteSide();
+}
+
bool QuicStream::HasBufferedData() const {
DCHECK_GE(send_buffer_.stream_offset(), stream_bytes_written());
return send_buffer_.stream_offset() > stream_bytes_written();
@@ -834,14 +886,25 @@
DCHECK(read_side_closed_ && write_side_closed_);
if (!fin_sent_ && !rst_sent_) {
- // For flow control accounting, tell the peer how many bytes have been
- // written on this stream before termination. Done here if needed, using a
- // RST_STREAM frame.
- QUIC_DLOG(INFO) << ENDPOINT << "Sending RST_STREAM in OnClose: " << id();
- session_->SendRstStream(id(), QUIC_RST_ACKNOWLEDGEMENT,
- stream_bytes_written(), /*send_rst_only = */ false);
- session_->MaybeCloseZombieStream(id_);
- rst_sent_ = true;
+ if (!session()->split_up_send_rst()) {
+ // For flow control accounting, tell the peer how many bytes have been
+ // written on this stream before termination. Done here if needed, using a
+ // RST_STREAM frame.
+ QUIC_DLOG(INFO) << ENDPOINT << "Sending RST_STREAM in OnClose: " << id();
+ session_->SendRstStream(id(), QUIC_RST_ACKNOWLEDGEMENT,
+ stream_bytes_written(),
+ /*send_rst_only = */ false);
+ session_->MaybeCloseZombieStream(id_);
+ rst_sent_ = true;
+ } else {
+ QUIC_RELOADABLE_FLAG_COUNT_N(quic_split_up_send_rst, 3, 3);
+ QUIC_BUG_IF(session()->connection()->connected() &&
+ session()->version().UsesHttp3())
+ << "The stream should've already sent RST in response to "
+ "STOP_SENDING";
+ MaybeSendRstStream(QUIC_RST_ACKNOWLEDGEMENT);
+ session_->MaybeCloseZombieStream(id_);
+ }
}
if (!flow_controller_.has_value() ||
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index 89178c4..467cca9 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -403,6 +403,12 @@
// empty.
void SetFinSent();
+ // Send STOP_SENDING if it hasn't been sent yet.
+ void MaybeSendStopSending(QuicRstStreamErrorCode error);
+
+ // Send RESET_STREAM if it hasn't been sent yet.
+ void MaybeSendRstStream(QuicRstStreamErrorCode error);
+
// Close the write side of the socket. Further writes will fail.
// Can be called by the subclass or internally.
// Does not send a FIN. May cause the stream to be closed.
@@ -509,6 +515,9 @@
// True if this stream has received a RST_STREAM frame.
bool rst_received_;
+ // True if the stream has sent STOP_SENDING to the session.
+ bool stop_sending_sent_;
+
absl::optional<QuicFlowController> flow_controller_;
// The connection level flow controller. Not owned.
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index 29bbaf5..fcd0d28 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -72,6 +72,7 @@
using QuicStream::CanWriteNewDataAfterData;
using QuicStream::CloseWriteSide;
using QuicStream::fin_buffered;
+ using QuicStream::MaybeSendStopSending;
using QuicStream::OnClose;
using QuicStream::WriteMemSlices;
using QuicStream::WriteOrBufferData;
@@ -112,8 +113,15 @@
// session_ now owns stream_.
session_->ActivateStream(QuicWrapUnique(stream_));
// Ignore resetting when session_ is terminated.
- EXPECT_CALL(*session_, SendRstStream(kTestStreamId, _, _, _))
- .Times(AnyNumber());
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_, SendRstStream(kTestStreamId, _, _, _))
+ .Times(AnyNumber());
+ } else {
+ EXPECT_CALL(*session_, MaybeSendStopSendingFrame(kTestStreamId, _))
+ .Times(AnyNumber());
+ EXPECT_CALL(*session_, MaybeSendRstStreamFrame(kTestStreamId, _, _))
+ .Times(AnyNumber());
+ }
write_blocked_list_ =
QuicSessionPeer::GetWriteBlockedStreams(session_.get());
}
@@ -421,13 +429,21 @@
TEST_P(QuicStreamTest, ConnectionCloseAfterStreamClose) {
Initialize();
- QuicStreamPeer::CloseReadSide(stream_);
- stream_->CloseWriteSide();
- EXPECT_THAT(stream_->stream_error(), IsQuicStreamNoError());
+ QuicRstStreamFrame rst_frame(kInvalidControlFrameId, stream_->id(),
+ QUIC_STREAM_CANCELLED, 1234);
+ stream_->OnStreamReset(rst_frame);
+ 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(),
+ QUIC_STREAM_CANCELLED);
+ session_->OnStopSendingFrame(stop_sending);
+ }
+ EXPECT_THAT(stream_->stream_error(), IsStreamError(QUIC_STREAM_CANCELLED));
EXPECT_THAT(stream_->connection_error(), IsQuicNoError());
stream_->OnConnectionClosed(QUIC_INTERNAL_ERROR,
ConnectionCloseSource::FROM_SELF);
- EXPECT_THAT(stream_->stream_error(), IsQuicStreamNoError());
+ EXPECT_THAT(stream_->stream_error(), IsStreamError(QUIC_STREAM_CANCELLED));
EXPECT_THAT(stream_->connection_error(), IsQuicNoError());
}
@@ -452,9 +468,21 @@
EXPECT_FALSE(rst_sent());
// Now close the stream, and expect that we send a RST.
- EXPECT_CALL(*session_, SendRstStream(_, _, _, _));
- QuicStreamPeer::CloseReadSide(stream_);
- stream_->CloseWriteSide();
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_, SendRstStream(kTestStreamId, _, _, _));
+ } else {
+ EXPECT_CALL(*session_, MaybeSendRstStreamFrame(kTestStreamId, _, _));
+ }
+ QuicRstStreamFrame rst_frame(kInvalidControlFrameId, stream_->id(),
+ QUIC_STREAM_CANCELLED, 1234);
+ stream_->OnStreamReset(rst_frame);
+ 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(),
+ QUIC_STREAM_CANCELLED);
+ session_->OnStopSendingFrame(stop_sending);
+ }
EXPECT_FALSE(session_->HasUnackedStreamData());
EXPECT_FALSE(fin_sent());
EXPECT_TRUE(rst_sent());
@@ -497,8 +525,12 @@
EXPECT_FALSE(rst_sent());
// Reset the stream.
- const int expected_resets = 1;
- EXPECT_CALL(*session_, SendRstStream(_, _, _, _)).Times(expected_resets);
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_, SendRstStream(kTestStreamId, _, _, _)).Times(1);
+ } else {
+ EXPECT_CALL(*session_, MaybeSendRstStreamFrame(kTestStreamId, _, _))
+ .Times(1);
+ }
stream_->Reset(QUIC_STREAM_CANCELLED);
EXPECT_FALSE(fin_sent());
EXPECT_TRUE(rst_sent());
@@ -639,8 +671,6 @@
CloseConnection(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, _, _));
stream_->OnStreamReset(rst_frame);
EXPECT_TRUE(stream_->HasReceivedFinalOffset());
- QuicStreamPeer::CloseReadSide(stream_);
- stream_->CloseWriteSide();
}
TEST_P(QuicStreamTest, FinalByteOffsetFromZeroLengthStreamFrame) {
@@ -910,7 +940,11 @@
EXPECT_TRUE(session_->HasUnackedStreamData());
EXPECT_EQ(1u, QuicStreamPeer::SendBuffer(stream_).size());
// Cancel stream.
- stream_->Reset(QUIC_STREAM_NO_ERROR);
+ if (session_->split_up_send_rst()) {
+ stream_->MaybeSendStopSending(QUIC_STREAM_NO_ERROR);
+ } else {
+ stream_->Reset(QUIC_STREAM_NO_ERROR);
+ }
// stream still waits for acks as the error code is QUIC_STREAM_NO_ERROR, and
// data is going to be retransmitted.
EXPECT_TRUE(stream_->IsWaitingForAcks());
@@ -920,12 +954,21 @@
EXPECT_CALL(*connection_, SendControlFrame(_))
.Times(AtLeast(1))
.WillRepeatedly(Invoke(&ClearControlFrame));
- EXPECT_CALL(*session_,
- SendRstStream(stream_->id(), QUIC_STREAM_CANCELLED, 9, _))
- .WillOnce(InvokeWithoutArgs([this]() {
- session_->ReallySendRstStream(stream_->id(), QUIC_STREAM_CANCELLED,
- stream_->stream_bytes_written(), false);
- }));
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_,
+ SendRstStream(stream_->id(), QUIC_STREAM_CANCELLED, 9, _))
+ .WillOnce(InvokeWithoutArgs([this]() {
+ session_->ReallySendRstStream(stream_->id(), QUIC_STREAM_CANCELLED,
+ stream_->stream_bytes_written(), false);
+ }));
+ } else {
+ EXPECT_CALL(*session_, MaybeSendRstStreamFrame(_, _, _))
+ .WillOnce(InvokeWithoutArgs([this]() {
+ session_->ReallyMaybeSendRstStreamFrame(
+ stream_->id(), QUIC_STREAM_CANCELLED,
+ stream_->stream_bytes_written());
+ }));
+ }
stream_->Reset(QUIC_STREAM_CANCELLED);
EXPECT_EQ(1u, QuicStreamPeer::SendBuffer(stream_).size());
@@ -956,8 +999,14 @@
// RST_STREAM received.
QuicRstStreamFrame rst_frame(kInvalidControlFrameId, stream_->id(),
QUIC_STREAM_CANCELLED, 9);
- EXPECT_CALL(*session_,
- SendRstStream(stream_->id(), QUIC_RST_ACKNOWLEDGEMENT, 9, _));
+
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_,
+ SendRstStream(stream_->id(), QUIC_RST_ACKNOWLEDGEMENT, 9, _));
+ } else {
+ EXPECT_CALL(*session_, MaybeSendRstStreamFrame(
+ stream_->id(), QUIC_RST_ACKNOWLEDGEMENT, 9));
+ }
stream_->OnStreamReset(rst_frame);
EXPECT_EQ(1u, QuicStreamPeer::SendBuffer(stream_).size());
// Stream stops waiting for acks as it does not finish sending and rst is
@@ -1000,8 +1049,14 @@
stream_->WriteOrBufferData(kData1, false, nullptr);
EXPECT_TRUE(stream_->IsWaitingForAcks());
EXPECT_TRUE(session_->HasUnackedStreamData());
- EXPECT_CALL(*session_,
- SendRstStream(stream_->id(), QUIC_RST_ACKNOWLEDGEMENT, 9, _));
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_,
+ SendRstStream(stream_->id(), QUIC_RST_ACKNOWLEDGEMENT, 9, _));
+ } else {
+ EXPECT_CALL(*session_, MaybeSendRstStreamFrame(
+ stream_->id(), QUIC_RST_ACKNOWLEDGEMENT, 9));
+ }
+ QuicConnectionPeer::SetConnectionClose(connection_);
stream_->OnConnectionClosed(QUIC_INTERNAL_ERROR,
ConnectionCloseSource::FROM_SELF);
EXPECT_EQ(1u, QuicStreamPeer::SendBuffer(stream_).size());
@@ -1525,8 +1580,19 @@
connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
// Verify stream gets reset because TTL expires.
- EXPECT_CALL(*session_, SendRstStream(_, QUIC_STREAM_TTL_EXPIRED, _, _))
- .Times(1);
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_, SendRstStream(_, QUIC_STREAM_TTL_EXPIRED, _, _))
+ .Times(1);
+ } else {
+ if (session_->version().UsesHttp3()) {
+ EXPECT_CALL(*session_,
+ MaybeSendStopSendingFrame(_, QUIC_STREAM_TTL_EXPIRED))
+ .Times(1);
+ }
+ EXPECT_CALL(*session_,
+ MaybeSendRstStreamFrame(_, QUIC_STREAM_TTL_EXPIRED, _))
+ .Times(1);
+ }
stream_->OnCanWrite();
}
@@ -1544,8 +1610,19 @@
connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
// Verify stream gets reset because TTL expires.
- EXPECT_CALL(*session_, SendRstStream(_, QUIC_STREAM_TTL_EXPIRED, _, _))
- .Times(1);
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_, SendRstStream(_, QUIC_STREAM_TTL_EXPIRED, _, _))
+ .Times(1);
+ } else {
+ if (session_->version().UsesHttp3()) {
+ EXPECT_CALL(*session_,
+ MaybeSendStopSendingFrame(_, QUIC_STREAM_TTL_EXPIRED))
+ .Times(1);
+ }
+ EXPECT_CALL(*session_,
+ MaybeSendRstStreamFrame(_, QUIC_STREAM_TTL_EXPIRED, _))
+ .Times(1);
+ }
stream_->RetransmitStreamData(0, 100, false, PTO_RETRANSMISSION);
}
diff --git a/quic/qbone/qbone_stream_test.cc b/quic/qbone/qbone_stream_test.cc
index c2b28ca..17cd2e1 100644
--- a/quic/qbone/qbone_stream_test.cc
+++ b/quic/qbone/qbone_stream_test.cc
@@ -65,6 +65,16 @@
SendRstStream,
(QuicStreamId, QuicRstStreamErrorCode, QuicStreamOffset, bool),
(override));
+ MOCK_METHOD(void,
+ MaybeSendRstStreamFrame,
+ (QuicStreamId stream_id,
+ QuicRstStreamErrorCode error,
+ QuicStreamOffset bytes_written),
+ (override));
+ MOCK_METHOD(void,
+ MaybeSendStopSendingFrame,
+ (QuicStreamId stream_id, QuicRstStreamErrorCode error),
+ (override));
// Sets whether data is written to buffer, or else if this is write blocked.
void set_writable(bool writable) { writable_ = writable; }
@@ -237,8 +247,15 @@
CreateReliableQuicStream();
std::string packet = "0123456789";
int iterations = (QboneConstants::kMaxQbonePacketBytes / packet.size()) + 2;
- EXPECT_CALL(*session_,
- SendRstStream(kStreamId, QUIC_BAD_APPLICATION_PAYLOAD, _, _));
+ if (!session_->split_up_send_rst()) {
+ EXPECT_CALL(*session_,
+ SendRstStream(kStreamId, QUIC_BAD_APPLICATION_PAYLOAD, _, _));
+ } else {
+ EXPECT_CALL(*session_, MaybeSendStopSendingFrame(
+ kStreamId, QUIC_BAD_APPLICATION_PAYLOAD));
+ EXPECT_CALL(*session_, MaybeSendRstStreamFrame(
+ kStreamId, QUIC_BAD_APPLICATION_PAYLOAD, _));
+ }
for (int i = 0; i < iterations; ++i) {
QuicStreamFrame frame(kStreamId, i == (iterations - 1), i * packet.size(),
packet);
diff --git a/quic/test_tools/quic_connection_peer.cc b/quic/test_tools/quic_connection_peer.cc
index 1f4e0c8..6b092c8 100644
--- a/quic/test_tools/quic_connection_peer.cc
+++ b/quic/test_tools/quic_connection_peer.cc
@@ -384,5 +384,9 @@
return connection->pending_path_challenge_payloads_;
}
+void QuicConnectionPeer::SetConnectionClose(QuicConnection* connection) {
+ connection->connected_ = false;
+}
+
} // namespace test
} // namespace quic
diff --git a/quic/test_tools/quic_connection_peer.h b/quic/test_tools/quic_connection_peer.h
index 783b055..bf404fb 100644
--- a/quic/test_tools/quic_connection_peer.h
+++ b/quic/test_tools/quic_connection_peer.h
@@ -159,6 +159,8 @@
static const QuicCircularDeque<
std::pair<QuicPathFrameBuffer, QuicSocketAddress>>&
pending_path_challenge_payloads(QuicConnection* connection);
+
+ static void SetConnectionClose(QuicConnection* connection);
};
} // namespace test
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index b0052d8..f2ad3be 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -836,6 +836,16 @@
QuicStreamOffset bytes_written,
bool send_rst_only),
(override));
+ MOCK_METHOD(void,
+ MaybeSendRstStreamFrame,
+ (QuicStreamId stream_id,
+ QuicRstStreamErrorCode error,
+ QuicStreamOffset bytes_written),
+ (override));
+ MOCK_METHOD(void,
+ MaybeSendStopSendingFrame,
+ (QuicStreamId stream_id, QuicRstStreamErrorCode error),
+ (override));
MOCK_METHOD(bool, ShouldKeepConnectionAlive, (), (const, override));
MOCK_METHOD(void,
@@ -867,6 +877,12 @@
QuicSession::SendRstStream(id, error, bytes_written, send_rst_only);
}
+ void ReallyMaybeSendRstStreamFrame(QuicStreamId id,
+ QuicRstStreamErrorCode error,
+ QuicStreamOffset bytes_written) {
+ QuicSession::MaybeSendRstStreamFrame(id, error, bytes_written);
+ }
+
private:
std::unique_ptr<QuicCryptoStream> crypto_stream_;
};
@@ -968,6 +984,16 @@
bool send_rst_only),
(override));
MOCK_METHOD(void,
+ MaybeSendRstStreamFrame,
+ (QuicStreamId stream_id,
+ QuicRstStreamErrorCode error,
+ QuicStreamOffset bytes_written),
+ (override));
+ MOCK_METHOD(void,
+ MaybeSendStopSendingFrame,
+ (QuicStreamId stream_id, QuicRstStreamErrorCode error),
+ (override));
+ MOCK_METHOD(void,
SendWindowUpdate,
(QuicStreamId id, QuicStreamOffset byte_offset),
(override));
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index c5d989a..251f02d 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -12,6 +12,7 @@
#include "absl/types/optional.h"
#include "net/third_party/quiche/src/quic/core/http/http_encoder.h"
#include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
+#include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
@@ -158,6 +159,16 @@
QuicStreamOffset bytes_written,
bool send_rst_only),
(override));
+ MOCK_METHOD(void,
+ MaybeSendRstStreamFrame,
+ (QuicStreamId stream_id,
+ QuicRstStreamErrorCode error,
+ QuicStreamOffset bytes_written),
+ (override));
+ MOCK_METHOD(void,
+ MaybeSendStopSendingFrame,
+ (QuicStreamId stream_id, QuicRstStreamErrorCode error),
+ (override));
// Matchers cannot be used on non-copyable types like SpdyHeaderBlock.
void PromisePushResources(
const std::string& request_url,
@@ -341,7 +352,18 @@
QuicStreamPeer::SetFinSent(stream_);
stream_->CloseWriteSide();
- EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _, _)).Times(1);
+ if (!session_.split_up_send_rst()) {
+ EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _, _))
+ .Times(1);
+ } else {
+ if (session_.version().UsesHttp3()) {
+ EXPECT_CALL(session_, MaybeSendStopSendingFrame(_, QUIC_STREAM_NO_ERROR))
+ .Times(1);
+ } else {
+ EXPECT_CALL(session_, MaybeSendRstStreamFrame(_, QUIC_STREAM_NO_ERROR, _))
+ .Times(1);
+ }
+ }
stream_->StopReading();
}
@@ -469,8 +491,16 @@
std::move(response_headers_), body);
InSequence s;
- EXPECT_CALL(session_, SendRstStream(promised_stream->id(),
- QUIC_STREAM_CANCELLED, 0, _));
+ if (!session_.split_up_send_rst()) {
+ EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_CANCELLED, 0, _));
+ } else {
+ if (session_.version().UsesHttp3()) {
+ EXPECT_CALL(session_, MaybeSendStopSendingFrame(promised_stream->id(),
+ QUIC_STREAM_CANCELLED));
+ }
+ EXPECT_CALL(session_, MaybeSendRstStreamFrame(promised_stream->id(),
+ QUIC_STREAM_CANCELLED, 0));
+ }
promised_stream->DoSendResponse();
}
@@ -674,7 +704,6 @@
TEST_P(QuicSimpleServerStreamTest,
DoNotSendQuicRstStreamNoErrorWithRstReceived) {
- InSequence s;
EXPECT_FALSE(stream_->reading_stopped());
EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _, _)).Times(0);
@@ -687,16 +716,33 @@
EXPECT_CALL(session_, WritevData(qpack_decoder_stream->id(), _, _, _, _, _))
.Times(AnyNumber());
}
- EXPECT_CALL(session_, SendRstStream(_, QUIC_RST_ACKNOWLEDGEMENT, _, _))
- .Times(1);
+
+ if (!session_.split_up_send_rst()) {
+ EXPECT_CALL(session_, SendRstStream(_,
+ session_.version().UsesHttp3()
+ ? QUIC_STREAM_CANCELLED
+ : QUIC_RST_ACKNOWLEDGEMENT,
+ _, _))
+ .Times(1);
+ } else {
+ EXPECT_CALL(session_,
+ MaybeSendRstStreamFrame(_,
+ session_.version().UsesHttp3()
+ ? QUIC_STREAM_CANCELLED
+ : QUIC_RST_ACKNOWLEDGEMENT,
+ _))
+ .Times(1);
+ }
QuicRstStreamFrame rst_frame(kInvalidControlFrameId, stream_->id(),
QUIC_STREAM_CANCELLED, 1234);
stream_->OnStreamReset(rst_frame);
if (VersionHasIetfQuicFrames(connection_->transport_version())) {
- // For V99 receiving a RST_STREAM causes a 1-way close; the test requires
- // a full close. A CloseWriteSide closes the other half of the stream.
- // Everything should then work properly.
- stream_->CloseWriteSide();
+ EXPECT_CALL(session_owner_, OnStopSendingReceived(_));
+ // 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(),
+ QUIC_STREAM_CANCELLED);
+ session_.OnStopSendingFrame(stop_sending);
}
EXPECT_TRUE(stream_->reading_stopped());
EXPECT_TRUE(stream_->write_side_closed());
