Deprecate --gfe2_reloadable_flag_quic_use_inlining_send_buffer2
I was hoping to remove the non-inlining version of the SendBuffer, but apparently we use it in places other than QuicStream, so I have to switch those separately.
PiperOrigin-RevId: 834976772
diff --git a/quiche/common/quiche_feature_flags_list.h b/quiche/common/quiche_feature_flags_list.h
index 5746907..b1e1fd0 100755
--- a/quiche/common/quiche_feature_flags_list.h
+++ b/quiche/common/quiche_feature_flags_list.h
@@ -57,7 +57,6 @@
QUICHE_FLAG(bool, quiche_reloadable_flag_quic_test_peer_addr_change_after_normalize, false, false, "If true, QuicConnection::ProcessValidatedPacket will use normalized address to test peer address changes.")
QUICHE_FLAG(bool, quiche_reloadable_flag_quic_testonly_default_false, false, false, "A testonly reloadable flag that will always default to false.")
QUICHE_FLAG(bool, quiche_reloadable_flag_quic_testonly_default_true, true, true, "A testonly reloadable flag that will always default to true.")
-QUICHE_FLAG(bool, quiche_reloadable_flag_quic_use_inlining_send_buffer2, true, true, "Uses an inlining version of QuicSendStreamBuffer.")
QUICHE_FLAG(bool, quiche_reloadable_flag_quic_use_proof_source_get_cert_chains, false, true, "When true, quic::TlsServerHandshaker will use ProofSource::GetCertChains() instead of ProofSource::GetCertChain()")
QUICHE_FLAG(bool, quiche_reloadable_flag_quic_use_received_client_addresses_cache, true, true, "If true, use a LRU cache to record client addresses of packets received on server's original address.")
QUICHE_FLAG(bool, quiche_restart_flag_quic_dispatcher_close_connection_on_invalid_ack, false, false, "An invalid ack is an ack that the peer sent for a packet that was not sent by the dispatcher. If true, the dispatcher will close the connection if it receives an invalid ack.")
diff --git a/quiche/quic/core/quic_stream.cc b/quiche/quic/core/quic_stream.cc
index f265cca..d459ce4 100644
--- a/quiche/quic/core/quic_stream.cc
+++ b/quiche/quic/core/quic_stream.cc
@@ -129,17 +129,6 @@
return DefaultFlowControlWindow(version);
}
-std::unique_ptr<QuicStreamSendBufferBase> CreateSendBuffer(
- QuicSession* session) {
- quiche::QuicheBufferAllocator* allocator =
- session->connection()->helper()->GetStreamSendBufferAllocator();
- if (GetQuicReloadableFlag(quic_use_inlining_send_buffer2)) {
- QUIC_RELOADABLE_FLAG_COUNT(quic_use_inlining_send_buffer2);
- return std::make_unique<QuicStreamSendBufferInlining>(allocator);
- }
- return std::make_unique<QuicStreamSendBuffer>(allocator);
-}
-
} // namespace
PendingStream::PendingStream(QuicStreamId id, QuicSession* session)
@@ -418,7 +407,8 @@
stream_contributes_to_connection_flow_control_(true),
busy_counter_(0),
add_random_padding_after_fin_(false),
- send_buffer_(CreateSendBuffer(session)),
+ send_buffer_(
+ session->connection()->helper()->GetStreamSendBufferAllocator()),
buffered_data_threshold_(GetQuicFlag(quic_buffered_data_threshold)),
is_static_(is_static),
deadline_(QuicTime::Zero()),
@@ -449,7 +439,7 @@
QUIC_DVLOG(1)
<< ENDPOINT << "Stream " << id_
<< " gets destroyed while waiting for acks. stream_bytes_outstanding = "
- << send_buffer_->stream_bytes_outstanding()
+ << send_buffer_.stream_bytes_outstanding()
<< ", fin_outstanding: " << fin_outstanding_;
}
if (stream_delegate_ != nullptr && type_ != CRYPTO) {
@@ -709,7 +699,7 @@
!VersionIsIetfQuic(transport_version()) || type_ == READ_UNIDIRECTIONAL) {
return false;
}
- reliable_size_ = send_buffer_->stream_offset();
+ reliable_size_ = send_buffer_.stream_offset();
return true;
}
@@ -753,7 +743,7 @@
// Notionally ack unreliable, previously consumed data so that it's not
// retransmitted, and the buffer can free the memory.
QuicByteCount newly_acked;
- send_buffer_->OnStreamDataAcked(
+ send_buffer_.OnStreamDataAcked(
reliable_size_, stream_bytes_written() - reliable_size_, &newly_acked);
fin_outstanding_ = false; // Do not wait to close until FIN is acked.
fin_lost_ = false;
@@ -846,7 +836,7 @@
// Do not respect buffered data upper limit as WriteOrBufferData guarantees
// all data to be consumed.
if (!data.empty()) {
- QuicStreamOffset offset = send_buffer_->stream_offset();
+ QuicStreamOffset offset = send_buffer_.stream_offset();
if (kMaxStreamLength - offset < data.length()) {
QUIC_BUG(quic_bug_10586_4) << "Write too many data via stream " << id_;
OnUnrecoverableError(
@@ -854,7 +844,7 @@
absl::StrCat("Write too many data via stream ", id_));
return;
}
- send_buffer_->SaveStreamData(data);
+ send_buffer_.SaveStreamData(data);
OnDataBuffered(offset, data.length(), ack_listener);
}
if (!had_buffered_data && (HasBufferedData() || fin_buffered_)) {
@@ -949,10 +939,10 @@
consumed_data.fin_consumed = fin;
if (!span.empty()) {
// Buffer all data if buffered data size is below limit.
- QuicStreamOffset offset = send_buffer_->stream_offset();
- consumed_data.bytes_consumed = send_buffer_->SaveMemSliceSpan(span);
- if (offset > send_buffer_->stream_offset() ||
- kMaxStreamLength < send_buffer_->stream_offset()) {
+ QuicStreamOffset offset = send_buffer_.stream_offset();
+ consumed_data.bytes_consumed = send_buffer_.SaveMemSliceSpan(span);
+ if (offset > send_buffer_.stream_offset() ||
+ kMaxStreamLength < send_buffer_.stream_offset()) {
QUIC_BUG(quic_bug_10586_8) << "Write too many data via stream " << id_;
OnUnrecoverableError(
QUIC_STREAM_LENGTH_OVERFLOW,
@@ -973,13 +963,13 @@
}
bool QuicStream::HasPendingRetransmission() const {
- return send_buffer_->HasPendingRetransmission() || fin_lost_;
+ return send_buffer_.HasPendingRetransmission() || fin_lost_;
}
bool QuicStream::IsStreamFrameOutstanding(QuicStreamOffset offset,
QuicByteCount data_length,
bool fin) const {
- return send_buffer_->IsStreamDataOutstanding(offset, data_length) ||
+ return send_buffer_.IsStreamDataOutstanding(offset, data_length) ||
(fin && fin_outstanding_);
}
@@ -1073,8 +1063,8 @@
}
bool QuicStream::HasBufferedData() const {
- QUICHE_DCHECK_GE(send_buffer_->stream_offset(), stream_bytes_written());
- return (send_buffer_->stream_offset() > stream_bytes_written() &&
+ QUICHE_DCHECK_GE(send_buffer_.stream_offset(), stream_bytes_written());
+ return (send_buffer_.stream_offset() > stream_bytes_written() &&
(!rst_stream_at_sent_ || reliable_size_ > stream_bytes_written()));
}
@@ -1269,8 +1259,8 @@
<< "[" << offset << ", " << offset + data_length << "]"
<< " fin = " << fin_acked;
*newly_acked_length = 0;
- if (!send_buffer_->OnStreamDataAcked(offset, data_length,
- newly_acked_length)) {
+ if (!send_buffer_.OnStreamDataAcked(offset, data_length,
+ newly_acked_length)) {
OnUnrecoverableError(QUIC_INTERNAL_ERROR, "Trying to ack unsent data.");
return false;
}
@@ -1316,7 +1306,7 @@
void QuicStream::OnStreamFrameRetransmitted(QuicStreamOffset offset,
QuicByteCount data_length,
bool fin_retransmitted) {
- send_buffer_->OnStreamDataRetransmitted(offset, data_length);
+ send_buffer_.OnStreamDataRetransmitted(offset, data_length);
if (fin_retransmitted) {
fin_lost_ = false;
}
@@ -1328,7 +1318,7 @@
<< "[" << offset << ", " << offset + data_length << "]"
<< " fin = " << fin_lost;
if (data_length > 0) {
- send_buffer_->OnStreamDataLost(offset, data_length);
+ send_buffer_.OnStreamDataLost(offset, data_length);
}
if (fin_lost && fin_outstanding_) {
fin_lost_ = true;
@@ -1393,7 +1383,7 @@
bool QuicStream::IsWaitingForAcks() const {
return (!rst_sent_ || stream_error_.ok()) &&
- (send_buffer_->stream_bytes_outstanding() || fin_outstanding_);
+ (send_buffer_.stream_bytes_outstanding() || fin_outstanding_);
}
bool QuicStream::WriteStreamData(QuicStreamOffset offset,
@@ -1402,7 +1392,7 @@
QUICHE_DCHECK_LT(0u, data_length);
QUIC_DVLOG(2) << ENDPOINT << "Write stream " << id_ << " data from offset "
<< offset << " length " << data_length;
- return send_buffer_->WriteStreamData(offset, data_length, writer);
+ return send_buffer_.WriteStreamData(offset, data_length, writer);
}
void QuicStream::WriteBufferedData(EncryptionLevel level) {
@@ -1512,8 +1502,8 @@
}
uint64_t QuicStream::BufferedDataBytes() const {
- QUICHE_DCHECK_GE(send_buffer_->stream_offset(), stream_bytes_written());
- return send_buffer_->stream_offset() - stream_bytes_written();
+ QUICHE_DCHECK_GE(send_buffer_.stream_offset(), stream_bytes_written());
+ return send_buffer_.stream_offset() - stream_bytes_written();
}
bool QuicStream::CanWriteNewData() const {
@@ -1525,21 +1515,21 @@
}
uint64_t QuicStream::stream_bytes_written() const {
- return send_buffer_->stream_bytes_written();
+ return send_buffer_.stream_bytes_written();
}
const QuicIntervalSet<QuicStreamOffset>& QuicStream::bytes_acked() const {
- return send_buffer_->bytes_acked();
+ return send_buffer_.bytes_acked();
}
void QuicStream::OnStreamDataConsumed(QuicByteCount bytes_consumed) {
- send_buffer_->OnStreamDataConsumed(bytes_consumed);
+ send_buffer_.OnStreamDataConsumed(bytes_consumed);
}
void QuicStream::WritePendingRetransmission() {
while (HasPendingRetransmission()) {
QuicConsumedData consumed(0, false);
- if (!send_buffer_->HasPendingRetransmission()) {
+ if (!send_buffer_.HasPendingRetransmission()) {
QUIC_DVLOG(1) << ENDPOINT << "stream " << id_
<< " retransmits fin only frame.";
consumed = stream_delegate_->WritevData(
@@ -1552,7 +1542,7 @@
}
} else {
StreamPendingRetransmission pending =
- send_buffer_->NextPendingRetransmission();
+ send_buffer_.NextPendingRetransmission();
// Determine whether the lost fin can be bundled with the data.
const bool can_bundle_fin =
fin_lost_ &&
diff --git a/quiche/quic/core/quic_stream.h b/quiche/quic/core/quic_stream.h
index 0636b54..39276c3 100644
--- a/quiche/quic/core/quic_stream.h
+++ b/quiche/quic/core/quic_stream.h
@@ -36,6 +36,7 @@
#include "quiche/quic/core/quic_stream_priority.h"
#include "quiche/quic/core/quic_stream_send_buffer.h"
#include "quiche/quic/core/quic_stream_send_buffer_base.h"
+#include "quiche/quic/core/quic_stream_send_buffer_inlining.h"
#include "quiche/quic/core/quic_stream_sequencer.h"
#include "quiche/quic/core/quic_types.h"
#include "quiche/quic/core/session_notifier_interface.h"
@@ -528,9 +529,9 @@
const QuicIntervalSet<QuicStreamOffset>& bytes_acked() const;
- const QuicStreamSendBufferBase& send_buffer() const { return *send_buffer_; }
+ const QuicStreamSendBufferBase& send_buffer() const { return send_buffer_; }
- QuicStreamSendBufferBase& send_buffer() { return *send_buffer_; }
+ QuicStreamSendBufferBase& send_buffer() { return send_buffer_; }
// Called when the write side of the stream is closed, and all of the outgoing
// data has been acknowledged. This corresponds to the "Data Recvd" state of
@@ -649,7 +650,7 @@
// Send buffer of this stream. Send buffer is cleaned up when data gets acked
// or discarded.
- std::unique_ptr<QuicStreamSendBufferBase> send_buffer_;
+ QuicStreamSendBufferInlining send_buffer_;
// Latched value of quic_buffered_data_threshold.
const QuicByteCount buffered_data_threshold_;
diff --git a/quiche/quic/test_tools/quic_stream_peer.cc b/quiche/quic/test_tools/quic_stream_peer.cc
index cb42642..4ff801b 100644
--- a/quiche/quic/test_tools/quic_stream_peer.cc
+++ b/quiche/quic/test_tools/quic_stream_peer.cc
@@ -23,7 +23,7 @@
// static
void QuicStreamPeer::SetStreamBytesWritten(
QuicStreamOffset stream_bytes_written, QuicStream* stream) {
- stream->send_buffer_->SetStreamOffsetForTest(stream_bytes_written);
+ stream->send_buffer_.SetStreamOffsetForTest(stream_bytes_written);
}
// static
