Remove QuicMemSliceSpan and TestQuicMemSliceVector.
Also deprecate --gfe2_restart_flag_quic_use_new_mem_slice_span2
PiperOrigin-RevId: 389885783
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index bc23474..0f0c7dc 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -391,7 +391,7 @@
if (can_write) {
// Save one copy and allocation if send buffer can accomodate the header.
QuicMemSlice header_slice(std::move(header));
- WriteMemSlices(QuicMemSliceSpan(&header_slice), false);
+ WriteMemSlices(absl::MakeSpan(&header_slice, 1), false);
} else {
QUICHE_DCHECK(force_write);
WriteOrBufferData(header.AsStringView(), false, nullptr);
@@ -399,23 +399,6 @@
return true;
}
-QuicConsumedData QuicSpdyStream::WriteBodySlices(QuicMemSliceSpan slices,
- bool fin) {
- if (!VersionUsesHttp3(transport_version()) || slices.empty()) {
- return WriteMemSlices(slices, fin);
- }
-
- QuicConnection::ScopedPacketFlusher flusher(spdy_session_->connection());
- if (!WriteDataFrameHeader(slices.total_length(), /*force_write=*/false)) {
- return {0, false};
- }
-
- QUIC_DLOG(INFO) << ENDPOINT << "Stream " << id()
- << " is writing DATA frame payload of length "
- << slices.total_length();
- return WriteMemSlices(slices, fin);
-}
-
QuicConsumedData QuicSpdyStream::WriteBodySlices(
absl::Span<QuicMemSlice> slices,
bool fin) {
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index 4df1196..9042698 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -161,7 +161,6 @@
// Does the same thing as WriteOrBufferBody except this method takes
// memslicespan as the data input. Right now it only calls WriteMemSlices.
- QuicConsumedData WriteBodySlices(QuicMemSliceSpan slices, bool fin);
QuicConsumedData WriteBodySlices(absl::Span<QuicMemSlice> slices, bool fin);
// Marks the trailers as consumed. This applies to the case where this object
diff --git a/quic/core/quic_datagram_queue.cc b/quic/core/quic_datagram_queue.cc
index e6f3e6f..ebd7483 100644
--- a/quic/core/quic_datagram_queue.cc
+++ b/quic/core/quic_datagram_queue.cc
@@ -9,7 +9,6 @@
#include "quic/core/quic_session.h"
#include "quic/core/quic_time.h"
#include "quic/core/quic_types.h"
-#include "quic/platform/api/quic_mem_slice_span.h"
namespace quic {
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 84b9e2e..10d57c3 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -29,7 +29,6 @@
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_mem_slice_storage.h"
#include "quic/platform/api/quic_test.h"
-#include "quic/platform/api/quic_test_mem_slice_vector.h"
#include "quic/test_tools/mock_quic_session_visitor.h"
#include "quic/test_tools/quic_config_peer.h"
#include "quic/test_tools/quic_connection_peer.h"
@@ -2571,12 +2570,11 @@
CloseConnection(
QUIC_TRY_TO_WRITE_DATA_ON_READ_UNIDIRECTIONAL_STREAM, _, _))
.Times(1);
- char data[1024];
- std::vector<std::pair<char*, size_t>> buffers;
- buffers.push_back(std::make_pair(data, ABSL_ARRAYSIZE(data)));
- buffers.push_back(std::make_pair(data, ABSL_ARRAYSIZE(data)));
- QuicTestMemSliceVector vector(buffers);
- stream4->WriteMemSlices(vector.span(), false);
+ std::string data(1024, 'a');
+ std::vector<QuicMemSlice> buffers;
+ buffers.push_back(MemSliceFromString(data));
+ buffers.push_back(MemSliceFromString(data));
+ stream4->WriteMemSlices(absl::MakeSpan(buffers), false);
}
// Test code that tests that an incoming stream frame with a new (not previously
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index cde50ef..8654ebf 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -740,17 +740,12 @@
}
}
-QuicConsumedData QuicStream::WriteMemSlices(QuicMemSliceSpan span, bool fin) {
- return WriteMemSlicesInner(MemSliceSpanWrapper(span), fin);
+QuicConsumedData QuicStream::WriteMemSlice(QuicMemSlice span, bool fin) {
+ return WriteMemSlices(absl::MakeSpan(&span, 1), fin);
}
QuicConsumedData QuicStream::WriteMemSlices(absl::Span<QuicMemSlice> span,
bool fin) {
- return WriteMemSlicesInner(MemSliceSpanWrapper(span), fin);
-}
-
-QuicConsumedData QuicStream::WriteMemSlicesInner(MemSliceSpanWrapper span,
- bool fin) {
QuicConsumedData consumed_data(0, false);
if (span.empty() && !fin) {
QUIC_BUG(quic_bug_10586_6) << "span.empty() && !fin";
@@ -778,7 +773,7 @@
if (!span.empty()) {
// Buffer all data if buffered data size is below limit.
QuicStreamOffset offset = send_buffer_.stream_offset();
- consumed_data.bytes_consumed = span.SaveTo(send_buffer_);
+ 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_;
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index 6374d8a..1b35e7f 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -34,7 +34,6 @@
#include "quic/core/stream_delegate_interface.h"
#include "quic/platform/api/quic_export.h"
#include "quic/platform/api/quic_mem_slice.h"
-#include "quic/platform/api/quic_mem_slice_span.h"
#include "quic/platform/api/quic_reference_counted.h"
#include "spdy/core/spdy_protocol.h"
@@ -349,9 +348,8 @@
// the wire. This method has all-or-nothing semantics: if the write buffer is
// not full, all of the memslices in |span| are moved into it; otherwise,
// nothing happens.
- // TODO(vasilvv): deprecate and remove QuicMemSliceSpan version.
- QuicConsumedData WriteMemSlices(QuicMemSliceSpan span, bool fin);
QuicConsumedData WriteMemSlices(absl::Span<QuicMemSlice> span, bool fin);
+ QuicConsumedData WriteMemSlice(QuicMemSlice span, bool fin);
// Returns true if any stream data is lost (including fin) and needs to be
// retransmitted.
@@ -470,26 +468,6 @@
friend class test::QuicStreamPeer;
friend class QuicStreamUtils;
- // Wraps around either QuicMemSliceSpan or absl::Span<QuicMemSlice>.
- // TODO(vasilvv): delete this after QuicMemSliceSpan is gone.
- class QUIC_EXPORT_PRIVATE MemSliceSpanWrapper {
- public:
- explicit MemSliceSpanWrapper(QuicMemSliceSpan span) : old_(span) {}
- explicit MemSliceSpanWrapper(absl::Span<QuicMemSlice> span) : new_(span) {}
-
- bool empty() { return old_.has_value() ? old_->empty() : new_.empty(); }
- QuicByteCount SaveTo(QuicStreamSendBuffer& send_buffer) {
- if (old_.has_value()) {
- return send_buffer.SaveMemSliceSpan(*old_);
- }
- return send_buffer.SaveMemSliceSpan(new_);
- }
-
- private:
- absl::optional<QuicMemSliceSpan> old_;
- absl::Span<QuicMemSlice> new_;
- };
-
QuicStream(QuicStreamId id,
QuicSession* session,
QuicStreamSequencer sequencer,
@@ -518,8 +496,6 @@
// Returns true if deadline_ has passed.
bool HasDeadlinePassed() const;
- QuicConsumedData WriteMemSlicesInner(MemSliceSpanWrapper span, bool fin);
-
QuicStreamSequencer sequencer_;
QuicStreamId id_;
// Pointer to the owning QuicSession object.
diff --git a/quic/core/quic_stream_send_buffer.cc b/quic/core/quic_stream_send_buffer.cc
index 1e32e54..b2ac6bf 100644
--- a/quic/core/quic_stream_send_buffer.cc
+++ b/quic/core/quic_stream_send_buffer.cc
@@ -92,11 +92,6 @@
stream_offset_ += length;
}
-QuicByteCount QuicStreamSendBuffer::SaveMemSliceSpan(QuicMemSliceSpan span) {
- return span.ConsumeAll(
- [&](QuicMemSlice slice) { SaveMemSlice(std::move(slice)); });
-}
-
QuicByteCount QuicStreamSendBuffer::SaveMemSliceSpan(
absl::Span<QuicMemSlice> span) {
QuicByteCount total = 0;
diff --git a/quic/core/quic_stream_send_buffer.h b/quic/core/quic_stream_send_buffer.h
index f91e476..bf50217 100644
--- a/quic/core/quic_stream_send_buffer.h
+++ b/quic/core/quic_stream_send_buffer.h
@@ -12,7 +12,6 @@
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_iovec.h"
#include "quic/platform/api/quic_mem_slice.h"
-#include "quic/platform/api/quic_mem_slice_span.h"
#include "common/quiche_circular_deque.h"
namespace quic {
@@ -80,7 +79,6 @@
void SaveMemSlice(QuicMemSlice slice);
// Save all slices in |span| to send buffer. Return total bytes saved.
- QuicByteCount SaveMemSliceSpan(QuicMemSliceSpan span);
QuicByteCount SaveMemSliceSpan(absl::Span<QuicMemSlice> span);
// Called when |bytes_consumed| bytes has been consumed by the stream.
diff --git a/quic/core/quic_stream_send_buffer_test.cc b/quic/core/quic_stream_send_buffer_test.cc
index e1a2358..9aaec4d 100644
--- a/quic/core/quic_stream_send_buffer_test.cc
+++ b/quic/core/quic_stream_send_buffer_test.cc
@@ -13,7 +13,6 @@
#include "quic/platform/api/quic_expect_bug.h"
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_test.h"
-#include "quic/platform/api/quic_test_mem_slice_vector.h"
#include "quic/test_tools/quic_stream_send_buffer_peer.h"
#include "quic/test_tools/quic_test_utils.h"
@@ -321,14 +320,13 @@
SimpleBufferAllocator allocator;
QuicStreamSendBuffer send_buffer(&allocator);
- char data[1024];
- std::vector<std::pair<char*, size_t>> buffers;
+ std::string data(1024, 'a');
+ std::vector<QuicMemSlice> buffers;
for (size_t i = 0; i < 10; ++i) {
- buffers.push_back(std::make_pair(data, 1024));
+ buffers.push_back(MemSliceFromString(data));
}
- QuicTestMemSliceVector vector(buffers);
- EXPECT_EQ(10 * 1024u, send_buffer.SaveMemSliceSpan(vector.span()));
+ EXPECT_EQ(10 * 1024u, send_buffer.SaveMemSliceSpan(absl::MakeSpan(buffers)));
EXPECT_EQ(10u, send_buffer.size());
}
@@ -336,15 +334,13 @@
SimpleBufferAllocator allocator;
QuicStreamSendBuffer send_buffer(&allocator);
- char data[1024];
- std::vector<std::pair<char*, size_t>> buffers;
+ std::string data(1024, 'a');
+ std::vector<QuicMemSlice> buffers;
for (size_t i = 0; i < 10; ++i) {
- buffers.push_back(std::make_pair(data, 1024));
+ buffers.push_back(MemSliceFromString(data));
}
- buffers.push_back(std::make_pair(nullptr, 0));
- QuicTestMemSliceVector vector(buffers);
- EXPECT_EQ(10 * 1024u, send_buffer.SaveMemSliceSpan(vector.span()));
+ EXPECT_EQ(10 * 1024u, send_buffer.SaveMemSliceSpan(absl::MakeSpan(buffers)));
// Verify the empty slice does not get saved.
EXPECT_EQ(10u, send_buffer.size());
}
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index e69b657..b36bd95 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -26,7 +26,6 @@
#include "quic/platform/api/quic_logging.h"
#include "quic/platform/api/quic_mem_slice_storage.h"
#include "quic/platform/api/quic_test.h"
-#include "quic/platform/api/quic_test_mem_slice_vector.h"
#include "quic/test_tools/quic_config_peer.h"
#include "quic/test_tools/quic_connection_peer.h"
#include "quic/test_tools/quic_flow_controller_peer.h"
@@ -1243,26 +1242,20 @@
TEST_P(QuicStreamTest, WriteMemSlicesReachStreamLimit) {
Initialize();
QuicStreamPeer::SetStreamBytesWritten(kMaxStreamLength - 5u, stream_);
- char data[5];
std::vector<std::pair<char*, size_t>> buffers;
- buffers.push_back(std::make_pair(data, ABSL_ARRAYSIZE(data)));
- QuicTestMemSliceVector vector1(buffers);
- QuicMemSliceSpan span1 = vector1.span();
+ QuicMemSlice slice1 = MemSliceFromString("12345");
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
return session_->ConsumeData(stream_->id(), 5u, 0u, NO_FIN,
NOT_RETRANSMISSION, absl::nullopt);
}));
// There is no buffered data before, all data should be consumed.
- QuicConsumedData consumed = stream_->WriteMemSlices(span1, false);
+ QuicConsumedData consumed = stream_->WriteMemSlice(std::move(slice1), false);
EXPECT_EQ(5u, consumed.bytes_consumed);
- std::vector<std::pair<char*, size_t>> buffers2;
- buffers2.push_back(std::make_pair(data, 1u));
- QuicTestMemSliceVector vector2(buffers);
- QuicMemSliceSpan span2 = vector2.span();
+ QuicMemSlice slice2 = MemSliceFromString("6");
EXPECT_CALL(*connection_, CloseConnection(QUIC_STREAM_LENGTH_OVERFLOW, _, _));
- EXPECT_QUIC_BUG(stream_->WriteMemSlices(span2, false),
+ EXPECT_QUIC_BUG(stream_->WriteMemSlice(std::move(slice2), false),
"Write too many data via stream");
}
diff --git a/quic/core/web_transport_stream_adapter.cc b/quic/core/web_transport_stream_adapter.cc
index 2470aac..171a3c0 100644
--- a/quic/core/web_transport_stream_adapter.cc
+++ b/quic/core/web_transport_stream_adapter.cc
@@ -45,7 +45,7 @@
QuicMemSlice memslice(QuicBuffer::Copy(
session_->connection()->helper()->GetStreamSendBufferAllocator(), data));
QuicConsumedData consumed =
- stream_->WriteMemSlices(QuicMemSliceSpan(&memslice), /*fin=*/false);
+ stream_->WriteMemSlices(absl::MakeSpan(&memslice, 1), /*fin=*/false);
if (consumed.bytes_consumed == data.size()) {
return true;
@@ -75,7 +75,7 @@
QuicMemSlice empty;
QuicConsumedData consumed =
- stream_->WriteMemSlices(QuicMemSliceSpan(&empty), /*fin=*/true);
+ stream_->WriteMemSlices(absl::MakeSpan(&empty, 1), /*fin=*/true);
QUICHE_DCHECK_EQ(consumed.bytes_consumed, 0u);
return consumed.fin_consumed;
}
diff --git a/quic/platform/api/quic_mem_slice_span.h b/quic/platform/api/quic_mem_slice_span.h
deleted file mode 100644
index c33707a..0000000
--- a/quic/platform/api/quic_mem_slice_span.h
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2017 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_PLATFORM_API_QUIC_MEM_SLICE_SPAN_H_
-#define QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_SPAN_H_
-
-#include "absl/strings/string_view.h"
-#include "quic/platform/api/quic_export.h"
-#include "net/quic/platform/impl/quic_mem_slice_span_impl.h"
-
-namespace quic {
-
-// QuicMemSliceSpan is effectively wrapper around an array of data structures
-// used as QuicMemSlice. So it could implemented with:
-// QuicMemSlice* slices_;
-// size_t num_slices_;
-// But for efficiency reasons, the actual implementation is an array of
-// platform-specific objects. This could avoid the translation from
-// platform-specific object to QuicMemSlice.
-// QuicMemSliceSpan does not own the underling data buffers.
-class QUIC_EXPORT_PRIVATE QuicMemSliceSpan {
- public:
- explicit QuicMemSliceSpan(QuicMemSliceSpanImpl impl) : impl_(impl) {}
-
- // Constructs a span with a single QuicMemSlice.
- explicit QuicMemSliceSpan(QuicMemSlice* slice) : impl_(slice->impl()) {}
-
- QuicMemSliceSpan(const QuicMemSliceSpan& other) = default;
- QuicMemSliceSpan& operator=(const QuicMemSliceSpan& other) = default;
- QuicMemSliceSpan(QuicMemSliceSpan&& other) = default;
- QuicMemSliceSpan& operator=(QuicMemSliceSpan&& other) = default;
-
- ~QuicMemSliceSpan() = default;
-
- template <typename ConsumeFunction>
- QuicByteCount ConsumeAll(ConsumeFunction consume) {
- return impl_.ConsumeAll(consume);
- }
-
- // Return data of the span at |index| by the form of a
- // absl::string_view.
- absl::string_view GetData(int index) { return impl_.GetData(index); }
-
- // Return the total length of the data inside the span.
- QuicByteCount total_length() { return impl_.total_length(); }
-
- // Return total number of slices in the span.
- size_t NumSlices() { return impl_.NumSlices(); }
-
- bool empty() const { return impl_.empty(); }
-
- private:
- QuicMemSliceSpanImpl impl_;
-};
-
-} // namespace quic
-
-#endif // QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_SPAN_H_
diff --git a/quic/platform/api/quic_mem_slice_span_test.cc b/quic/platform/api/quic_mem_slice_span_test.cc
deleted file mode 100644
index 99a11df..0000000
--- a/quic/platform/api/quic_mem_slice_span_test.cc
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2017 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 "quic/platform/api/quic_mem_slice_span.h"
-
-#include "quic/core/quic_simple_buffer_allocator.h"
-#include "quic/core/quic_types.h"
-#include "quic/platform/api/quic_flags.h"
-#include "quic/platform/api/quic_test.h"
-#include "quic/platform/api/quic_test_mem_slice_vector.h"
-
-namespace quic {
-namespace test {
-namespace {
-
-class QuicMemSliceSpanImplTest : public QuicTest {
- public:
- QuicMemSliceSpanImplTest() {
- for (size_t i = 0; i < 10; ++i) {
- buffers_.push_back(std::make_pair(data_, 1024));
- }
- }
-
- char data_[1024];
- std::vector<std::pair<char*, size_t>> buffers_;
-};
-
-TEST_F(QuicMemSliceSpanImplTest, ConsumeAll) {
- SimpleBufferAllocator allocator;
- QuicTestMemSliceVector vector(buffers_);
-
- int num_slices = 0;
- QuicByteCount bytes_consumed =
- vector.span().ConsumeAll([&](QuicMemSlice slice) {
- EXPECT_EQ(data_, slice.data());
- EXPECT_EQ(1024u, slice.length());
- ++num_slices;
- });
-
- EXPECT_EQ(10 * 1024u, bytes_consumed);
- EXPECT_EQ(10, num_slices);
-}
-
-} // namespace
-} // namespace test
-} // namespace quic
diff --git a/quic/platform/api/quic_mem_slice_storage.cc b/quic/platform/api/quic_mem_slice_storage.cc
new file mode 100644
index 0000000..87bce7f
--- /dev/null
+++ b/quic/platform/api/quic_mem_slice_storage.cc
@@ -0,0 +1,35 @@
+// Copyright 2021 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 "quic/platform/api/quic_mem_slice_storage.h"
+
+#include "quic/core/quic_utils.h"
+
+namespace quic {
+
+QuicMemSliceStorage::QuicMemSliceStorage(const struct iovec* iov, int iov_count,
+ QuicBufferAllocator* allocator,
+ const QuicByteCount max_slice_len) {
+ if (iov == nullptr) {
+ return;
+ }
+ QuicByteCount write_len = 0;
+ for (int i = 0; i < iov_count; ++i) {
+ write_len += iov[i].iov_len;
+ }
+ QUICHE_DCHECK_LT(0u, write_len);
+
+ size_t io_offset = 0;
+ while (write_len > 0) {
+ size_t slice_len = std::min(write_len, max_slice_len);
+ QuicBuffer buffer(allocator, slice_len);
+ QuicUtils::CopyToBuffer(iov, iov_count, io_offset, slice_len,
+ buffer.data());
+ storage_.push_back(QuicMemSlice(std::move(buffer)));
+ write_len -= slice_len;
+ io_offset += slice_len;
+ }
+}
+
+} // namespace quic
diff --git a/quic/platform/api/quic_mem_slice_storage.h b/quic/platform/api/quic_mem_slice_storage.h
index 3ec1fc4..4cccee3 100644
--- a/quic/platform/api/quic_mem_slice_storage.h
+++ b/quic/platform/api/quic_mem_slice_storage.h
@@ -5,8 +5,14 @@
#ifndef QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_STORAGE_H_
#define QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_STORAGE_H_
+#include <vector>
+
+#include "absl/types/span.h"
+#include "quic/core/quic_buffer_allocator.h"
+#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_export.h"
-#include "net/quic/platform/impl/quic_mem_slice_storage_impl.h"
+#include "quic/platform/api/quic_iovec.h"
+#include "quic/platform/api/quic_mem_slice.h"
namespace quic {
@@ -14,11 +20,9 @@
// use cases such as turning into QuicMemSliceSpan.
class QUIC_EXPORT_PRIVATE QuicMemSliceStorage {
public:
- QuicMemSliceStorage(const struct iovec* iov,
- int iov_count,
+ QuicMemSliceStorage(const struct iovec* iov, int iov_count,
QuicBufferAllocator* allocator,
- const QuicByteCount max_slice_len)
- : impl_(iov, iov_count, allocator, max_slice_len) {}
+ const QuicByteCount max_slice_len);
QuicMemSliceStorage(const QuicMemSliceStorage& other) = default;
QuicMemSliceStorage& operator=(const QuicMemSliceStorage& other) = default;
@@ -28,12 +32,10 @@
~QuicMemSliceStorage() = default;
// Return a QuicMemSliceSpan form of the storage.
- QuicMemSliceSpan ToSpan() { return impl_.ToSpan(); }
-
- void Append(QuicMemSlice slice) { impl_.Append(std::move(*slice.impl())); }
+ absl::Span<QuicMemSlice> ToSpan() { return absl::MakeSpan(storage_); }
private:
- QuicMemSliceStorageImpl impl_;
+ std::vector<QuicMemSlice> storage_;
};
} // namespace quic
diff --git a/quic/platform/api/quic_mem_slice_storage_test.cc b/quic/platform/api/quic_mem_slice_storage_test.cc
index 086e218..4bef774 100644
--- a/quic/platform/api/quic_mem_slice_storage_test.cc
+++ b/quic/platform/api/quic_mem_slice_storage_test.cc
@@ -6,7 +6,6 @@
#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/platform/api/quic_test.h"
-#include "quic/platform/api/quic_test_mem_slice_vector.h"
namespace quic {
namespace test {
@@ -28,8 +27,8 @@
struct iovec iov = {const_cast<char*>(body.data()), body.length()};
QuicMemSliceStorage storage(&iov, 1, &allocator, 1024);
auto span = storage.ToSpan();
- EXPECT_EQ("ccc", span.GetData(0));
- EXPECT_NE(static_cast<const void*>(span.GetData(0).data()), body.data());
+ EXPECT_EQ("ccc", span[0].AsStringView());
+ EXPECT_NE(static_cast<const void*>(span[0].data()), body.data());
}
TEST_F(QuicMemSliceStorageImplTest, MultipleIovInSingleSlice) {
@@ -41,7 +40,7 @@
QuicMemSliceStorage storage(iov, 2, &allocator, 1024);
auto span = storage.ToSpan();
- EXPECT_EQ("aaabbbb", span.GetData(0));
+ EXPECT_EQ("aaabbbb", span[0].AsStringView());
}
TEST_F(QuicMemSliceStorageImplTest, MultipleIovInMultipleSlice) {
@@ -53,26 +52,8 @@
QuicMemSliceStorage storage(iov, 2, &allocator, 4);
auto span = storage.ToSpan();
- EXPECT_EQ("aaaa", span.GetData(0));
- EXPECT_EQ("bbbb", span.GetData(1));
-}
-
-TEST_F(QuicMemSliceStorageImplTest, AppendMemSlices) {
- std::string body1(3, 'a');
- std::string body2(4, 'b');
- std::vector<std::pair<char*, size_t>> buffers;
- buffers.push_back(
- std::make_pair(const_cast<char*>(body1.data()), body1.length()));
- buffers.push_back(
- std::make_pair(const_cast<char*>(body2.data()), body2.length()));
- QuicTestMemSliceVector mem_slices(buffers);
-
- QuicMemSliceStorage storage(nullptr, 0, nullptr, 0);
- mem_slices.span().ConsumeAll(
- [&storage](QuicMemSlice slice) { storage.Append(std::move(slice)); });
-
- EXPECT_EQ("aaa", storage.ToSpan().GetData(0));
- EXPECT_EQ("bbbb", storage.ToSpan().GetData(1));
+ EXPECT_EQ("aaaa", span[0].AsStringView());
+ EXPECT_EQ("bbbb", span[1].AsStringView());
}
} // namespace
diff --git a/quic/platform/api/quic_test_mem_slice_vector.h b/quic/platform/api/quic_test_mem_slice_vector.h
deleted file mode 100644
index 17d5853..0000000
--- a/quic/platform/api/quic_test_mem_slice_vector.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2017 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_PLATFORM_API_QUIC_TEST_MEM_SLICE_VECTOR_H_
-#define QUICHE_QUIC_PLATFORM_API_QUIC_TEST_MEM_SLICE_VECTOR_H_
-
-#include <utility>
-
-#include "quic/platform/api/quic_mem_slice_span.h"
-#include "net/quic/platform/impl/quic_test_mem_slice_vector_impl.h"
-
-namespace quic {
-namespace test {
-// QuicTestMemSliceVector is a test only class which creates a vector of
-// platform-specific data structure (used as QuicMemSlice) from an array of data
-// buffers. QuicTestMemSliceVector does not own the underlying data buffer.
-// Tests using QuicTestMemSliceVector need to make sure the actual data buffers
-// outlive QuicTestMemSliceVector, and QuicTestMemSliceVector outlive the
-// returned QuicMemSliceSpan.
-class QUIC_NO_EXPORT QuicTestMemSliceVector {
- public:
- explicit QuicTestMemSliceVector(std::vector<std::pair<char*, size_t>> buffers)
- : impl_(std::move(buffers)) {}
-
- QuicMemSliceSpan span() { return QuicMemSliceSpan(impl_.span()); }
-
- private:
- QuicTestMemSliceVectorImpl impl_;
-};
-
-} // namespace test
-} // namespace quic
-
-#endif // QUICHE_QUIC_PLATFORM_API_QUIC_TEST_MEM_SLICE_VECTOR_H_
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index 126b87e..9a7fd85 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -1312,20 +1312,6 @@
: default_type;
}
-QuicMemSliceSpan MakeSpan(QuicBufferAllocator* allocator,
- absl::string_view message_data,
- QuicMemSliceStorage* storage) {
- if (message_data.length() == 0) {
- *storage =
- QuicMemSliceStorage(nullptr, 0, allocator, kMaxOutgoingPacketSize);
- return storage->ToSpan();
- }
- struct iovec iov = {const_cast<char*>(message_data.data()),
- message_data.length()};
- *storage = QuicMemSliceStorage(&iov, 1, allocator, kMaxOutgoingPacketSize);
- return storage->ToSpan();
-}
-
QuicMemSlice MemSliceFromString(absl::string_view data) {
if (data.empty()) {
return QuicMemSlice();
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 06f3eec..39320e1 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -1823,12 +1823,6 @@
bool is_incoming,
StreamType default_type);
-// Utility function that stores message_data in |storage| and returns a
-// QuicMemSliceSpan.
-QuicMemSliceSpan MakeSpan(QuicBufferAllocator* allocator,
- absl::string_view message_data,
- QuicMemSliceStorage* storage);
-
// Creates a MemSlice using a singleton trivial buffer allocator. Performs a
// copy.
QuicMemSlice MemSliceFromString(absl::string_view data);
