Use new SendBuffer everywhere in the codebase.
Test-only uses are directly switched to the new implementation; the other uses are flag-protected.
Also add "Old" suffix to the old implementation to make sure I covered all references.
Protected by FLAGS_quic_reloadable_flag_quic_use_inlining_send_buffer_everywhere.
PiperOrigin-RevId: 840820884
diff --git a/quiche/common/quiche_feature_flags_list.h b/quiche/common/quiche_feature_flags_list.h
index a34aa63..372ed84 100755
--- a/quiche/common/quiche_feature_flags_list.h
+++ b/quiche/common/quiche_feature_flags_list.h
@@ -60,6 +60,7 @@
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_buffer_everywhere, false, false, "Use QuicStreamSendBufferInlining consistently everywhere in the codebase.")
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_reloadable_flag_reset_content_length_status_when_removing_content_length_header, false, false, "If true, the content_length_status field in balsa_headers will always be reset when the Content-Length header is removed, no matter if the Transfer-Encoding header is chuncked or not.")
diff --git a/quiche/quic/core/quic_buffered_packet_store.cc b/quiche/quic/core/quic_buffered_packet_store.cc
index ba8e00c..45173d8 100644
--- a/quiche/quic/core/quic_buffered_packet_store.cc
+++ b/quiche/quic/core/quic_buffered_packet_store.cc
@@ -27,6 +27,8 @@
#include "quiche/quic/core/quic_packet_creator.h"
#include "quiche/quic/core/quic_packet_number.h"
#include "quiche/quic/core/quic_packets.h"
+#include "quiche/quic/core/quic_stream_send_buffer.h"
+#include "quiche/quic/core/quic_stream_send_buffer_inlining.h"
#include "quiche/quic/core/quic_time.h"
#include "quiche/quic/core/quic_types.h"
#include "quiche/quic/core/quic_versions.h"
@@ -622,4 +624,16 @@
return true;
}
+static std::unique_ptr<QuicStreamSendBufferBase> CreateSendBuffer(
+ quiche::QuicheBufferAllocator* allocator) {
+ if (GetQuicReloadableFlag(quic_use_inlining_send_buffer_everywhere)) {
+ QUIC_RELOADABLE_FLAG_COUNT_N(quic_use_inlining_send_buffer_everywhere, 2,
+ 2);
+ return std::make_unique<QuicStreamSendBufferInlining>(allocator);
+ }
+ return std::make_unique<QuicStreamSendBufferOld>(allocator);
+}
+
+PacketCollector::PacketCollector(quiche::QuicheBufferAllocator* allocator)
+ : send_buffer_(CreateSendBuffer(allocator)) {}
} // namespace quic
diff --git a/quiche/quic/core/quic_buffered_packet_store.h b/quiche/quic/core/quic_buffered_packet_store.h
index 28b9355..3e6a208 100644
--- a/quiche/quic/core/quic_buffered_packet_store.h
+++ b/quiche/quic/core/quic_buffered_packet_store.h
@@ -29,6 +29,7 @@
#include "quiche/quic/core/quic_packets.h"
#include "quiche/quic/core/quic_stream_frame_data_producer.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_time.h"
#include "quiche/quic/core/quic_types.h"
#include "quiche/quic/core/quic_versions.h"
@@ -347,8 +348,7 @@
: public QuicPacketCreator::DelegateInterface,
public QuicStreamFrameDataProducer {
public:
- explicit PacketCollector(quiche::QuicheBufferAllocator* allocator)
- : send_buffer_(allocator) {}
+ explicit PacketCollector(quiche::QuicheBufferAllocator* allocator);
~PacketCollector() override = default;
// QuicPacketCreator::DelegateInterface methods:
@@ -394,7 +394,7 @@
QuicStreamOffset offset,
QuicByteCount data_length,
QuicDataWriter* writer) override {
- if (send_buffer_.WriteStreamData(offset, data_length, writer)) {
+ if (send_buffer_->WriteStreamData(offset, data_length, writer)) {
return WRITE_SUCCESS;
}
return WRITE_FAILED;
@@ -402,7 +402,7 @@
bool WriteCryptoData(EncryptionLevel /*level*/, QuicStreamOffset offset,
QuicByteCount data_length,
QuicDataWriter* writer) override {
- return send_buffer_.WriteStreamData(offset, data_length, writer);
+ return send_buffer_->WriteStreamData(offset, data_length, writer);
}
std::vector<std::unique_ptr<QuicEncryptedPacket>>* packets() {
@@ -413,7 +413,7 @@
std::vector<std::unique_ptr<QuicEncryptedPacket>> packets_;
// This is only needed until the packets are encrypted. Once packets are
// encrypted, the stream data is no longer required.
- QuicStreamSendBuffer send_buffer_;
+ const std::unique_ptr<QuicStreamSendBufferBase> send_buffer_;
};
} // namespace quic
diff --git a/quiche/quic/core/quic_crypto_stream.cc b/quiche/quic/core/quic_crypto_stream.cc
index 328b156..181a056 100644
--- a/quiche/quic/core/quic_crypto_stream.cc
+++ b/quiche/quic/core/quic_crypto_stream.cc
@@ -5,7 +5,7 @@
#include "quiche/quic/core/quic_crypto_stream.h"
#include <algorithm>
-#include <optional>
+#include <memory>
#include <string>
#include "absl/strings/str_cat.h"
@@ -15,11 +15,15 @@
#include "quiche/quic/core/quic_connection.h"
#include "quiche/quic/core/quic_error_codes.h"
#include "quiche/quic/core/quic_session.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_types.h"
#include "quiche/quic/core/quic_utils.h"
#include "quiche/quic/platform/api/quic_flag_utils.h"
#include "quiche/quic/platform/api/quic_flags.h"
#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/common/quiche_buffer_allocator.h"
namespace quic {
@@ -141,8 +145,8 @@
return;
}
const bool had_buffered_data = HasBufferedCryptoFrames();
- QuicStreamSendBuffer* send_buffer =
- &substreams_[QuicUtils::GetPacketNumberSpace(level)].send_buffer;
+ QuicStreamSendBufferBase* send_buffer =
+ substreams_[QuicUtils::GetPacketNumberSpace(level)].send_buffer.get();
QuicStreamOffset offset = send_buffer->stream_offset();
// Ensure this data does not cause the send buffer for this encryption level
@@ -195,8 +199,8 @@
QuicTime::Delta /*ack_delay_time*/) {
QuicByteCount newly_acked_length = 0;
if (!substreams_[QuicUtils::GetPacketNumberSpace(frame.level)]
- .send_buffer.OnStreamDataAcked(frame.offset, frame.data_length,
- &newly_acked_length)) {
+ .send_buffer->OnStreamDataAcked(frame.offset, frame.data_length,
+ &newly_acked_length)) {
OnUnrecoverableError(QUIC_INTERNAL_ERROR,
"Trying to ack unsent crypto data.");
return false;
@@ -223,8 +227,8 @@
}
return;
}
- QuicStreamSendBuffer* send_buffer =
- &substreams_[QuicUtils::GetPacketNumberSpace(level)].send_buffer;
+ QuicStreamSendBufferBase* send_buffer =
+ substreams_[QuicUtils::GetPacketNumberSpace(level)].send_buffer.get();
// TODO(nharper): Consider adding a Clear() method to QuicStreamSendBuffer
// to replace the following code.
QuicIntervalSet<QuicStreamOffset> to_ack = send_buffer->bytes_acked();
@@ -253,7 +257,7 @@
return false;
}
for (const auto& substream : substreams_) {
- if (substream.send_buffer.HasPendingRetransmission()) {
+ if (substream.send_buffer->HasPendingRetransmission()) {
return true;
}
}
@@ -266,8 +270,8 @@
<< "Versions less than 47 don't write CRYPTO frames";
for (uint8_t i = INITIAL_DATA; i <= APPLICATION_DATA; ++i) {
auto packet_number_space = static_cast<PacketNumberSpace>(i);
- QuicStreamSendBuffer* send_buffer =
- &substreams_[packet_number_space].send_buffer;
+ QuicStreamSendBufferBase* send_buffer =
+ substreams_[packet_number_space].send_buffer.get();
while (send_buffer->HasPendingRetransmission()) {
auto pending = send_buffer->NextPendingRetransmission();
size_t bytes_consumed = stream_delegate()->SendCryptoData(
@@ -382,7 +386,7 @@
uint64_t QuicCryptoStream::BytesSentOnLevel(EncryptionLevel level) const {
return substreams_[QuicUtils::GetPacketNumberSpace(level)]
- .send_buffer.stream_bytes_written();
+ .send_buffer->stream_bytes_written();
}
bool QuicCryptoStream::WriteCryptoFrame(EncryptionLevel level,
@@ -393,7 +397,7 @@
!VersionIsIetfQuic(session()->transport_version()))
<< "Versions less than 47 don't write CRYPTO frames (2)";
return substreams_[QuicUtils::GetPacketNumberSpace(level)]
- .send_buffer.WriteStreamData(offset, data_length, writer);
+ .send_buffer->WriteStreamData(offset, data_length, writer);
}
void QuicCryptoStream::OnCryptoFrameLost(QuicCryptoFrame* crypto_frame) {
@@ -401,8 +405,8 @@
!VersionIsIetfQuic(session()->transport_version()))
<< "Versions less than 47 don't lose CRYPTO frames";
substreams_[QuicUtils::GetPacketNumberSpace(crypto_frame->level)]
- .send_buffer.OnStreamDataLost(crypto_frame->offset,
- crypto_frame->data_length);
+ .send_buffer->OnStreamDataLost(crypto_frame->offset,
+ crypto_frame->data_length);
}
bool QuicCryptoStream::RetransmitData(QuicCryptoFrame* crypto_frame,
@@ -412,9 +416,9 @@
<< "Versions less than 47 don't retransmit CRYPTO frames";
QuicIntervalSet<QuicStreamOffset> retransmission(
crypto_frame->offset, crypto_frame->offset + crypto_frame->data_length);
- QuicStreamSendBuffer* send_buffer =
- &substreams_[QuicUtils::GetPacketNumberSpace(crypto_frame->level)]
- .send_buffer;
+ QuicStreamSendBufferBase* send_buffer =
+ substreams_[QuicUtils::GetPacketNumberSpace(crypto_frame->level)]
+ .send_buffer.get();
retransmission.Difference(send_buffer->bytes_acked());
if (retransmission.Empty()) {
return true;
@@ -443,8 +447,8 @@
<< "Versions less than 47 don't use CRYPTO frames";
for (uint8_t i = INITIAL_DATA; i <= APPLICATION_DATA; ++i) {
auto packet_number_space = static_cast<PacketNumberSpace>(i);
- QuicStreamSendBuffer* send_buffer =
- &substreams_[packet_number_space].send_buffer;
+ QuicStreamSendBufferBase* send_buffer =
+ substreams_[packet_number_space].send_buffer.get();
const size_t data_length =
send_buffer->stream_offset() - send_buffer->stream_bytes_written();
if (data_length == 0) {
@@ -467,7 +471,7 @@
!VersionIsIetfQuic(session()->transport_version()))
<< "Versions less than 47 don't use CRYPTO frames";
for (const CryptoSubstream& substream : substreams_) {
- const QuicStreamSendBuffer& send_buffer = substream.send_buffer;
+ const QuicStreamSendBufferBase& send_buffer = *substream.send_buffer;
QUICHE_DCHECK_GE(send_buffer.stream_offset(),
send_buffer.stream_bytes_written());
if (send_buffer.stream_offset() > send_buffer.stream_bytes_written()) {
@@ -489,7 +493,7 @@
return false;
}
return substreams_[QuicUtils::GetPacketNumberSpace(level)]
- .send_buffer.IsStreamDataOutstanding(offset, length);
+ .send_buffer->IsStreamDataOutstanding(offset, length);
}
bool QuicCryptoStream::IsWaitingForAcks() const {
@@ -497,20 +501,29 @@
return QuicStream::IsWaitingForAcks();
}
for (const CryptoSubstream& substream : substreams_) {
- if (substream.send_buffer.stream_bytes_outstanding()) {
+ if (substream.send_buffer->stream_bytes_outstanding()) {
return true;
}
}
return false;
}
+static std::unique_ptr<QuicStreamSendBufferBase> CreateSendBuffer(
+ QuicSession* session) {
+ quiche::QuicheBufferAllocator* allocator =
+ session->connection()->helper()->GetStreamSendBufferAllocator();
+ if (GetQuicReloadableFlag(quic_use_inlining_send_buffer_everywhere)) {
+ QUIC_RELOADABLE_FLAG_COUNT_N(quic_use_inlining_send_buffer_everywhere, 1,
+ 2);
+ return std::make_unique<QuicStreamSendBufferInlining>(allocator);
+ }
+ return std::make_unique<QuicStreamSendBufferOld>(allocator);
+}
+
QuicCryptoStream::CryptoSubstream::CryptoSubstream(
QuicCryptoStream* crypto_stream)
: sequencer(crypto_stream),
- send_buffer(crypto_stream->session()
- ->connection()
- ->helper()
- ->GetStreamSendBufferAllocator()) {}
+ send_buffer(CreateSendBuffer(crypto_stream->session())) {}
#undef ENDPOINT // undef for jumbo builds
} // namespace quic
diff --git a/quiche/quic/core/quic_crypto_stream.h b/quiche/quic/core/quic_crypto_stream.h
index 191aa57..cf294a8 100644
--- a/quiche/quic/core/quic_crypto_stream.h
+++ b/quiche/quic/core/quic_crypto_stream.h
@@ -7,6 +7,7 @@
#include <array>
#include <cstddef>
+#include <memory>
#include <string>
#include "absl/strings/string_view.h"
@@ -17,6 +18,7 @@
#include "quiche/quic/core/quic_config.h"
#include "quiche/quic/core/quic_packets.h"
#include "quiche/quic/core/quic_stream.h"
+#include "quiche/quic/core/quic_stream_send_buffer_base.h"
#include "quiche/quic/core/quic_types.h"
#include "quiche/quic/platform/api/quic_export.h"
@@ -263,7 +265,7 @@
CryptoSubstream(QuicCryptoStream* crypto_stream);
QuicStreamSequencer sequencer;
- QuicStreamSendBuffer send_buffer;
+ const std::unique_ptr<QuicStreamSendBufferBase> send_buffer;
};
// Consumed data according to encryption levels.
diff --git a/quiche/quic/core/quic_stream_send_buffer.cc b/quiche/quic/core/quic_stream_send_buffer.cc
index a1b9779..32c5e35 100644
--- a/quiche/quic/core/quic_stream_send_buffer.cc
+++ b/quiche/quic/core/quic_stream_send_buffer.cc
@@ -49,11 +49,11 @@
return QuicInterval<uint64_t>(offset, offset + length);
}
-QuicStreamSendBuffer::QuicStreamSendBuffer(
+QuicStreamSendBufferOld::QuicStreamSendBufferOld(
quiche::QuicheBufferAllocator* allocator)
: allocator_(allocator) {}
-void QuicStreamSendBuffer::SaveStreamData(absl::string_view data) {
+void QuicStreamSendBufferOld::SaveStreamData(absl::string_view data) {
QUIC_DVLOG(2) << "Save stream data offset " << stream_offset_ << " length "
<< data.length();
QUICHE_DCHECK(!data.empty());
@@ -72,7 +72,7 @@
}
}
-void QuicStreamSendBuffer::SaveMemSlice(quiche::QuicheMemSlice slice) {
+void QuicStreamSendBufferOld::SaveMemSlice(quiche::QuicheMemSlice slice) {
QUIC_DVLOG(2) << "Save slice offset " << stream_offset_ << " length "
<< slice.length();
if (slice.empty()) {
@@ -85,7 +85,7 @@
stream_offset_ += length;
}
-QuicByteCount QuicStreamSendBuffer::SaveMemSliceSpan(
+QuicByteCount QuicStreamSendBufferOld::SaveMemSliceSpan(
absl::Span<quiche::QuicheMemSlice> span) {
QuicByteCount total = 0;
for (quiche::QuicheMemSlice& slice : span) {
@@ -99,9 +99,9 @@
return total;
}
-bool QuicStreamSendBuffer::WriteStreamData(QuicStreamOffset offset,
- QuicByteCount data_length,
- QuicDataWriter* writer) {
+bool QuicStreamSendBufferOld::WriteStreamData(QuicStreamOffset offset,
+ QuicByteCount data_length,
+ QuicDataWriter* writer) {
// The iterator returned from |interval_deque_| will automatically advance
// the internal write index for the QuicIntervalDeque. The incrementing is
// done in operator++.
@@ -126,8 +126,8 @@
return data_length == 0;
}
-bool QuicStreamSendBuffer::FreeMemSlices(QuicStreamOffset start,
- QuicStreamOffset end) {
+bool QuicStreamSendBufferOld::FreeMemSlices(QuicStreamOffset start,
+ QuicStreamOffset end) {
auto it = interval_deque_.DataBegin();
if (it == interval_deque_.DataEnd() || it->slice.empty()) {
QUIC_BUG(quic_bug_10853_4)
@@ -161,21 +161,22 @@
return true;
}
-void QuicStreamSendBuffer::CleanUpBufferedSlices() {
+void QuicStreamSendBufferOld::CleanUpBufferedSlices() {
while (!interval_deque_.Empty() &&
interval_deque_.DataBegin()->slice.empty()) {
interval_deque_.PopFront();
}
}
-size_t QuicStreamSendBuffer::size() const { return interval_deque_.Size(); }
+size_t QuicStreamSendBufferOld::size() const { return interval_deque_.Size(); }
-void QuicStreamSendBuffer::SetStreamOffsetForTest(QuicStreamOffset new_offset) {
+void QuicStreamSendBufferOld::SetStreamOffsetForTest(
+ QuicStreamOffset new_offset) {
QuicStreamSendBufferBase::SetStreamOffsetForTest(new_offset);
stream_offset_ = new_offset;
}
-absl::string_view QuicStreamSendBuffer::LatestWriteForTest() {
+absl::string_view QuicStreamSendBufferOld::LatestWriteForTest() {
absl::string_view last_slice = "";
for (auto it = interval_deque_.DataBegin(); it != interval_deque_.DataEnd();
++it) {
@@ -184,7 +185,7 @@
return last_slice;
}
-QuicByteCount QuicStreamSendBuffer::TotalDataBufferedForTest() {
+QuicByteCount QuicStreamSendBufferOld::TotalDataBufferedForTest() {
QuicByteCount length = 0;
for (auto slice = interval_deque_.DataBegin();
slice != interval_deque_.DataEnd(); ++slice) {
diff --git a/quiche/quic/core/quic_stream_send_buffer.h b/quiche/quic/core/quic_stream_send_buffer.h
index 85caec6..e21277a 100644
--- a/quiche/quic/core/quic_stream_send_buffer.h
+++ b/quiche/quic/core/quic_stream_send_buffer.h
@@ -55,9 +55,9 @@
// it cannot be written after it is marked as acked. Stream data can be written
// out-of-order within those bounds, but note that in-order wites are O(1)
// whereas out-of-order writes are O(log(n)), see QuicIntervalDeque for details.
-class QUICHE_EXPORT QuicStreamSendBuffer : public QuicStreamSendBufferBase {
+class QUICHE_EXPORT QuicStreamSendBufferOld : public QuicStreamSendBufferBase {
public:
- explicit QuicStreamSendBuffer(quiche::QuicheBufferAllocator* allocator);
+ explicit QuicStreamSendBufferOld(quiche::QuicheBufferAllocator* allocator);
// Save |data| to send buffer.
void SaveStreamData(absl::string_view data) override;
diff --git a/quiche/quic/core/quic_stream_send_buffer_test.cc b/quiche/quic/core/quic_stream_send_buffer_test.cc
index c44f1c1..059bca6 100644
--- a/quiche/quic/core/quic_stream_send_buffer_test.cc
+++ b/quiche/quic/core/quic_stream_send_buffer_test.cc
@@ -35,7 +35,7 @@
// gone.
class QuicStreamSendBufferPeer {
public:
- static int32_t write_index(QuicStreamSendBuffer* send_buffer) {
+ static int32_t write_index(QuicStreamSendBufferOld* send_buffer) {
return QuicIntervalDequePeer::GetCachedIndex(&send_buffer->interval_deque_);
}
};
@@ -98,7 +98,7 @@
std::unique_ptr<QuicStreamSendBufferBase> CreateBuffer() {
switch (GetParam()) {
case SendBufferType::kDefault:
- return std::make_unique<QuicStreamSendBuffer>(&allocator_);
+ return std::make_unique<QuicStreamSendBufferOld>(&allocator_);
case SendBufferType::kInlining:
return std::make_unique<QuicStreamSendBufferInlining>(&allocator_);
}
@@ -175,14 +175,16 @@
QuicDataWriter writer(6000, buf, quiche::HOST_BYTE_ORDER);
// Write more than one slice.
if (GetParam() == SendBufferType::kDefault) {
- EXPECT_EQ(0, QuicStreamSendBufferPeer::write_index(
- static_cast<QuicStreamSendBuffer*>(send_buffer_.get())));
+ EXPECT_EQ(0,
+ QuicStreamSendBufferPeer::write_index(
+ static_cast<QuicStreamSendBufferOld*>(send_buffer_.get())));
}
ASSERT_TRUE(send_buffer_->WriteStreamData(0, 1024, &writer));
EXPECT_EQ(copy1, absl::string_view(buf, 1024));
if (GetParam() == SendBufferType::kDefault) {
- EXPECT_EQ(1, QuicStreamSendBufferPeer::write_index(
- static_cast<QuicStreamSendBuffer*>(send_buffer_.get())));
+ EXPECT_EQ(1,
+ QuicStreamSendBufferPeer::write_index(
+ static_cast<QuicStreamSendBufferOld*>(send_buffer_.get())));
}
// Retransmit the first frame and also send new data.
diff --git a/quiche/quic/test_tools/simple_data_producer.cc b/quiche/quic/test_tools/simple_data_producer.cc
index 30e4646..3337c3e 100644
--- a/quiche/quic/test_tools/simple_data_producer.cc
+++ b/quiche/quic/test_tools/simple_data_producer.cc
@@ -10,6 +10,7 @@
#include "absl/strings/string_view.h"
#include "quiche/quic/core/quic_data_writer.h"
+#include "quiche/quic/core/quic_stream_send_buffer_inlining.h"
#include "quiche/quic/platform/api/quic_bug_tracker.h"
#include "quiche/quic/platform/api/quic_flags.h"
@@ -27,7 +28,8 @@
return;
}
if (!send_buffer_map_.contains(id)) {
- send_buffer_map_[id] = std::make_unique<QuicStreamSendBuffer>(&allocator_);
+ send_buffer_map_[id] =
+ std::make_unique<QuicStreamSendBufferInlining>(&allocator_);
}
send_buffer_map_[id]->SaveStreamData(data);
}
diff --git a/quiche/quic/test_tools/simple_data_producer.h b/quiche/quic/test_tools/simple_data_producer.h
index 96952d7..1d70a57 100644
--- a/quiche/quic/test_tools/simple_data_producer.h
+++ b/quiche/quic/test_tools/simple_data_producer.h
@@ -9,6 +9,7 @@
#include "absl/strings/string_view.h"
#include "quiche/quic/core/quic_stream_frame_data_producer.h"
#include "quiche/quic/core/quic_stream_send_buffer.h"
+#include "quiche/quic/core/quic_stream_send_buffer_inlining.h"
#include "quiche/common/simple_buffer_allocator.h"
namespace quic {
@@ -41,7 +42,8 @@
private:
using SendBufferMap =
- absl::flat_hash_map<QuicStreamId, std::unique_ptr<QuicStreamSendBuffer>>;
+ absl::flat_hash_map<QuicStreamId,
+ std::unique_ptr<QuicStreamSendBufferInlining>>;
using CryptoBufferMap =
absl::flat_hash_map<std::pair<EncryptionLevel, QuicStreamOffset>,
