Move QuicMemSlice to third_party/quiche as QuicheMemSlice.
Also move and rename QuicMemSliceStorage, but since it does not have anything
platformized itself, put it in third_party/quiche/common rather than
third_party/quiche/common/platform.
PiperOrigin-RevId: 430769412
diff --git a/common/platform/api/quiche_mem_slice.h b/common/platform/api/quiche_mem_slice.h
new file mode 100644
index 0000000..6c4f81a
--- /dev/null
+++ b/common/platform/api/quiche_mem_slice.h
@@ -0,0 +1,92 @@
+// 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_COMMON_PLATFORM_API_QUICHE_MEM_SLICE_H_
+#define QUICHE_COMMON_PLATFORM_API_QUICHE_MEM_SLICE_H_
+
+#include <memory>
+
+#include "absl/strings/string_view.h"
+#include "common/platform/api/quiche_export.h"
+#include "net/quiche/common/platform/impl/quiche_mem_slice_impl.h"
+
+/* API_DESCRIPTION
+ QuicheMemSlice is used to wrap application data and pass to QUIC stream's write
+ interface. It refers to a memory block of data which should be around till
+ QuicheMemSlice::Reset() is called. It's upto each platform, to implement it as
+ reference counted or not.
+ API-DESCRIPTION */
+
+namespace quiche {
+
+// QuicheMemSlice is an internally reference counted data buffer used as the
+// source buffers for write operations. QuicheMemSlice implicitly maintains a
+// reference count and will free the underlying data buffer when the reference
+// count reaches zero.
+class QUICHE_EXPORT_PRIVATE QuicheMemSlice {
+ public:
+ // Constructs a empty QuicheMemSlice with no underlying data and 0 reference
+ // count.
+ QuicheMemSlice() = default;
+
+ // Constructs a QuicheMemSlice that takes ownership of |buffer|. |length|
+ // must not be zero. To construct an empty QuicheMemSlice, use the
+ // zero-argument constructor instead.
+ // TODO(vasilvv): switch all users to QuicBuffer version, and make this
+ // private.
+ QuicheMemSlice(quic::QuicUniqueBufferPtr buffer, size_t length)
+ : impl_(std::move(buffer), length) {}
+
+ // Constructs a QuicheMemSlice that takes ownership of |buffer|. The length
+ // of the |buffer| must not be zero. To construct an empty QuicheMemSlice,
+ // use the zero-argument constructor instead.
+ explicit QuicheMemSlice(quic::QuicBuffer buffer) : QuicheMemSlice() {
+ // Store the size of the buffer *before* calling buffer.Release().
+ const size_t size = buffer.size();
+ *this = QuicheMemSlice(buffer.Release(), size);
+ }
+
+ // Constructs a QuicheMemSlice that takes ownership of |buffer| allocated on
+ // heap. |length| must not be zero.
+ QuicheMemSlice(std::unique_ptr<char[]> buffer, size_t length)
+ : impl_(std::move(buffer), length) {}
+
+ // Constructs QuicheMemSlice from |impl|. It takes the reference away from
+ // |impl|.
+ explicit QuicheMemSlice(QuicheMemSliceImpl impl) : impl_(std::move(impl)) {}
+
+ QuicheMemSlice(const QuicheMemSlice& other) = delete;
+ QuicheMemSlice& operator=(const QuicheMemSlice& other) = delete;
+
+ // Move constructors. |other| will not hold a reference to the data buffer
+ // after this call completes.
+ QuicheMemSlice(QuicheMemSlice&& other) = default;
+ QuicheMemSlice& operator=(QuicheMemSlice&& other) = default;
+
+ ~QuicheMemSlice() = default;
+
+ // Release the underlying reference. Further access the memory will result in
+ // undefined behavior.
+ void Reset() { impl_.Reset(); }
+
+ // Returns a const char pointer to underlying data buffer.
+ const char* data() const { return impl_.data(); }
+ // Returns the length of underlying data buffer.
+ size_t length() const { return impl_.length(); }
+ // Returns the representation of the underlying data as a string view.
+ absl::string_view AsStringView() const {
+ return absl::string_view(data(), length());
+ }
+
+ bool empty() const { return impl_.empty(); }
+
+ QuicheMemSliceImpl* impl() { return &impl_; }
+
+ private:
+ QuicheMemSliceImpl impl_;
+};
+
+} // namespace quiche
+
+#endif // QUICHE_COMMON_PLATFORM_API_QUICHE_MEM_SLICE_H_
diff --git a/quic/platform/api/quic_mem_slice_test.cc b/common/platform/api/quiche_mem_slice_test.cc
similarity index 63%
rename from quic/platform/api/quic_mem_slice_test.cc
rename to common/platform/api/quiche_mem_slice_test.cc
index 44095df..de6adbe 100644
--- a/quic/platform/api/quic_mem_slice_test.cc
+++ b/common/platform/api/quiche_mem_slice_test.cc
@@ -2,36 +2,36 @@
// 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.h"
+#include "common/platform/api/quiche_mem_slice.h"
#include <memory>
#include "absl/strings/string_view.h"
#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_simple_buffer_allocator.h"
-#include "quic/platform/api/quic_test.h"
+#include "common/platform/api/quiche_test.h"
-namespace quic {
+namespace quiche {
namespace test {
namespace {
-class QuicMemSliceTest : public QuicTest {
+class QuicheMemSliceTest : public QuicheTest {
public:
- QuicMemSliceTest() {
+ QuicheMemSliceTest() {
size_t length = 1024;
- slice_ = QuicMemSlice(MakeUniqueBuffer(&allocator_, length), length);
+ slice_ = QuicheMemSlice(MakeUniqueBuffer(&allocator_, length), length);
orig_data_ = slice_.data();
orig_length_ = slice_.length();
}
- SimpleBufferAllocator allocator_;
- QuicMemSlice slice_;
+ quic::SimpleBufferAllocator allocator_;
+ QuicheMemSlice slice_;
const char* orig_data_;
size_t orig_length_;
};
-TEST_F(QuicMemSliceTest, MoveConstruct) {
- QuicMemSlice moved(std::move(slice_));
+TEST_F(QuicheMemSliceTest, MoveConstruct) {
+ QuicheMemSlice moved(std::move(slice_));
EXPECT_EQ(moved.data(), orig_data_);
EXPECT_EQ(moved.length(), orig_length_);
EXPECT_EQ(nullptr, slice_.data());
@@ -39,8 +39,8 @@
EXPECT_TRUE(slice_.empty());
}
-TEST_F(QuicMemSliceTest, MoveAssign) {
- QuicMemSlice moved;
+TEST_F(QuicheMemSliceTest, MoveAssign) {
+ QuicheMemSlice moved;
moved = std::move(slice_);
EXPECT_EQ(moved.data(), orig_data_);
EXPECT_EQ(moved.length(), orig_length_);
@@ -49,21 +49,21 @@
EXPECT_TRUE(slice_.empty());
}
-TEST_F(QuicMemSliceTest, SliceAllocatedOnHeap) {
+TEST_F(QuicheMemSliceTest, SliceAllocatedOnHeap) {
auto buffer = std::make_unique<char[]>(128);
char* orig_data = buffer.get();
size_t used_length = 105;
- QuicMemSlice slice = QuicMemSlice(std::move(buffer), used_length);
- QuicMemSlice moved = std::move(slice);
+ QuicheMemSlice slice = QuicheMemSlice(std::move(buffer), used_length);
+ QuicheMemSlice moved = std::move(slice);
EXPECT_EQ(moved.data(), orig_data);
EXPECT_EQ(moved.length(), used_length);
}
-TEST_F(QuicMemSliceTest, SliceFromBuffer) {
+TEST_F(QuicheMemSliceTest, SliceFromBuffer) {
const absl::string_view kTestString =
"RFC 9000 Release Celebration Memorial Test String";
- auto buffer = QuicBuffer::Copy(&allocator_, kTestString);
- QuicMemSlice slice(std::move(buffer));
+ auto buffer = quic::QuicBuffer::Copy(&allocator_, kTestString);
+ QuicheMemSlice slice(std::move(buffer));
EXPECT_EQ(buffer.data(), nullptr); // NOLINT(bugprone-use-after-move)
EXPECT_EQ(buffer.size(), 0u);
@@ -73,4 +73,4 @@
} // namespace
} // namespace test
-} // namespace quic
+} // namespace quiche
diff --git a/common/quiche_mem_slice_storage.cc b/common/quiche_mem_slice_storage.cc
new file mode 100644
index 0000000..e3e1c5a
--- /dev/null
+++ b/common/quiche_mem_slice_storage.cc
@@ -0,0 +1,36 @@
+// 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 "common/quiche_mem_slice_storage.h"
+
+#include "quic/core/quic_utils.h"
+
+namespace quiche {
+
+QuicheMemSliceStorage::QuicheMemSliceStorage(
+ const struct iovec* iov, int iov_count,
+ quic::QuicBufferAllocator* allocator,
+ const quic::QuicByteCount max_slice_len) {
+ if (iov == nullptr) {
+ return;
+ }
+ quic::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);
+ quic::QuicBuffer buffer(allocator, slice_len);
+ quic::QuicUtils::CopyToBuffer(iov, iov_count, io_offset, slice_len,
+ buffer.data());
+ storage_.push_back(QuicheMemSlice(std::move(buffer)));
+ write_len -= slice_len;
+ io_offset += slice_len;
+ }
+}
+
+} // namespace quiche
diff --git a/common/quiche_mem_slice_storage.h b/common/quiche_mem_slice_storage.h
new file mode 100644
index 0000000..6ec68bb
--- /dev/null
+++ b/common/quiche_mem_slice_storage.h
@@ -0,0 +1,44 @@
+// 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_COMMON_QUICHE_MEM_SLICE_STORAGE_H_
+#define QUICHE_COMMON_QUICHE_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_iovec.h"
+#include "common/platform/api/quiche_export.h"
+#include "common/platform/api/quiche_mem_slice.h"
+
+namespace quiche {
+
+// QuicheMemSliceStorage is a container class that store QuicheMemSlices for
+// further use cases such as turning into QuicheMemSliceSpan.
+class QUICHE_EXPORT_PRIVATE QuicheMemSliceStorage {
+ public:
+ QuicheMemSliceStorage(const struct iovec* iov, int iov_count,
+ quic::QuicBufferAllocator* allocator,
+ const quic::QuicByteCount max_slice_len);
+
+ QuicheMemSliceStorage(const QuicheMemSliceStorage& other) = default;
+ QuicheMemSliceStorage& operator=(const QuicheMemSliceStorage& other) =
+ default;
+ QuicheMemSliceStorage(QuicheMemSliceStorage&& other) = default;
+ QuicheMemSliceStorage& operator=(QuicheMemSliceStorage&& other) = default;
+
+ ~QuicheMemSliceStorage() = default;
+
+ // Return a QuicheMemSliceSpan form of the storage.
+ absl::Span<QuicheMemSlice> ToSpan() { return absl::MakeSpan(storage_); }
+
+ private:
+ std::vector<QuicheMemSlice> storage_;
+};
+
+} // namespace quiche
+
+#endif // QUICHE_COMMON_QUICHE_MEM_SLICE_STORAGE_H_
diff --git a/common/quiche_mem_slice_storage_test.cc b/common/quiche_mem_slice_storage_test.cc
new file mode 100644
index 0000000..a07c71d
--- /dev/null
+++ b/common/quiche_mem_slice_storage_test.cc
@@ -0,0 +1,61 @@
+// 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 "common/quiche_mem_slice_storage.h"
+
+#include "quic/core/quic_simple_buffer_allocator.h"
+#include "common/platform/api/quiche_test.h"
+
+namespace quiche {
+namespace test {
+namespace {
+
+class QuicheMemSliceStorageImplTest : public QuicheTest {
+ public:
+ QuicheMemSliceStorageImplTest() = default;
+};
+
+TEST_F(QuicheMemSliceStorageImplTest, EmptyIov) {
+ QuicheMemSliceStorage storage(nullptr, 0, nullptr, 1024);
+ EXPECT_TRUE(storage.ToSpan().empty());
+}
+
+TEST_F(QuicheMemSliceStorageImplTest, SingleIov) {
+ quic::SimpleBufferAllocator allocator;
+ std::string body(3, 'c');
+ struct iovec iov = {const_cast<char*>(body.data()), body.length()};
+ QuicheMemSliceStorage storage(&iov, 1, &allocator, 1024);
+ auto span = storage.ToSpan();
+ EXPECT_EQ("ccc", span[0].AsStringView());
+ EXPECT_NE(static_cast<const void*>(span[0].data()), body.data());
+}
+
+TEST_F(QuicheMemSliceStorageImplTest, MultipleIovInSingleSlice) {
+ quic::SimpleBufferAllocator allocator;
+ std::string body1(3, 'a');
+ std::string body2(4, 'b');
+ struct iovec iov[] = {{const_cast<char*>(body1.data()), body1.length()},
+ {const_cast<char*>(body2.data()), body2.length()}};
+
+ QuicheMemSliceStorage storage(iov, 2, &allocator, 1024);
+ auto span = storage.ToSpan();
+ EXPECT_EQ("aaabbbb", span[0].AsStringView());
+}
+
+TEST_F(QuicheMemSliceStorageImplTest, MultipleIovInMultipleSlice) {
+ quic::SimpleBufferAllocator allocator;
+ std::string body1(4, 'a');
+ std::string body2(4, 'b');
+ struct iovec iov[] = {{const_cast<char*>(body1.data()), body1.length()},
+ {const_cast<char*>(body2.data()), body2.length()}};
+
+ QuicheMemSliceStorage storage(iov, 2, &allocator, 4);
+ auto span = storage.ToSpan();
+ EXPECT_EQ("aaaa", span[0].AsStringView());
+ EXPECT_EQ("bbbb", span[1].AsStringView());
+}
+
+} // namespace
+} // namespace test
+} // namespace quiche
diff --git a/quic/core/frames/quic_frame.cc b/quic/core/frames/quic_frame.cc
index c31b45e..e83e422 100644
--- a/quic/core/frames/quic_frame.cc
+++ b/quic/core/frames/quic_frame.cc
@@ -11,6 +11,7 @@
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_bug_tracker.h"
#include "quic/platform/api/quic_logging.h"
+#include "common/platform/api/quiche_mem_slice.h"
namespace quic {
@@ -393,7 +394,7 @@
for (const auto& slice : frame.message_frame->message_data) {
QuicBuffer buffer = QuicBuffer::Copy(allocator, slice.AsStringView());
copy.message_frame->message_data.push_back(
- QuicMemSlice(std::move(buffer)));
+ quiche::QuicheMemSlice(std::move(buffer)));
}
break;
case NEW_TOKEN_FRAME:
diff --git a/quic/core/frames/quic_message_frame.cc b/quic/core/frames/quic_message_frame.cc
index 1ac0de6..429a3bf 100644
--- a/quic/core/frames/quic_message_frame.cc
+++ b/quic/core/frames/quic_message_frame.cc
@@ -6,7 +6,7 @@
#include "quic/core/quic_constants.h"
#include "quic/platform/api/quic_logging.h"
-#include "quic/platform/api/quic_mem_slice.h"
+#include "common/platform/api/quiche_mem_slice.h"
namespace quic {
@@ -14,9 +14,9 @@
: message_id(message_id), data(nullptr), message_length(0) {}
QuicMessageFrame::QuicMessageFrame(QuicMessageId message_id,
- absl::Span<QuicMemSlice> span)
+ absl::Span<quiche::QuicheMemSlice> span)
: message_id(message_id), data(nullptr), message_length(0) {
- for (QuicMemSlice& slice : span) {
+ for (quiche::QuicheMemSlice& slice : span) {
if (slice.empty()) {
continue;
}
@@ -24,7 +24,8 @@
message_data.push_back(std::move(slice));
}
}
-QuicMessageFrame::QuicMessageFrame(QuicMessageId message_id, QuicMemSlice slice)
+QuicMessageFrame::QuicMessageFrame(QuicMessageId message_id,
+ quiche::QuicheMemSlice slice)
: QuicMessageFrame(message_id, absl::MakeSpan(&slice, 1)) {}
QuicMessageFrame::QuicMessageFrame(const char* data, QuicPacketLength length)
diff --git a/quic/core/frames/quic_message_frame.h b/quic/core/frames/quic_message_frame.h
index 1d090c9..008a7d9 100644
--- a/quic/core/frames/quic_message_frame.h
+++ b/quic/core/frames/quic_message_frame.h
@@ -10,17 +10,18 @@
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_containers.h"
#include "quic/platform/api/quic_export.h"
-#include "quic/platform/api/quic_mem_slice.h"
+#include "common/platform/api/quiche_mem_slice.h"
namespace quic {
-using QuicMessageData = absl::InlinedVector<QuicMemSlice, 1>;
+using QuicMessageData = absl::InlinedVector<quiche::QuicheMemSlice, 1>;
struct QUIC_EXPORT_PRIVATE QuicMessageFrame {
QuicMessageFrame() = default;
explicit QuicMessageFrame(QuicMessageId message_id);
- QuicMessageFrame(QuicMessageId message_id, absl::Span<QuicMemSlice> span);
- QuicMessageFrame(QuicMessageId message_id, QuicMemSlice slice);
+ QuicMessageFrame(QuicMessageId message_id,
+ absl::Span<quiche::QuicheMemSlice> span);
+ QuicMessageFrame(QuicMessageId message_id, quiche::QuicheMemSlice slice);
QuicMessageFrame(const char* data, QuicPacketLength length);
QuicMessageFrame(const QuicMessageFrame& other) = delete;
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index cfc4729..7b63328 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -30,6 +30,7 @@
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_logging.h"
#include "quic/platform/api/quic_stack_trace.h"
+#include "common/platform/api/quiche_mem_slice.h"
#include "spdy/core/http2_frame_decoder_adapter.h"
using http2::Http2DecoderAdapter;
@@ -1690,7 +1691,7 @@
return MESSAGE_STATUS_INTERNAL_ERROR;
}
- QuicMemSlice slice(std::move(buffer));
+ quiche::QuicheMemSlice slice(std::move(buffer));
return datagram_queue()->SendOrQueueDatagram(std::move(slice));
}
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 67f2e44..b91292d 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -46,6 +46,7 @@
#include "quic/test_tools/quic_stream_peer.h"
#include "quic/test_tools/quic_stream_send_buffer_peer.h"
#include "quic/test_tools/quic_test_utils.h"
+#include "common/platform/api/quiche_mem_slice.h"
#include "common/quiche_endian.h"
#include "common/test_tools/quiche_test_utils.h"
#include "spdy/core/spdy_framer.h"
@@ -2040,7 +2041,7 @@
SpdyFramer spdy_framer(SpdyFramer::ENABLE_COMPRESSION);
SpdySerializedFrame frame = spdy_framer.SerializeFrame(priority_frame);
- const QuicMemSlice& slice =
+ const quiche::QuicheMemSlice& slice =
QuicStreamSendBufferPeer::CurrentWriteSlice(&send_buffer)->slice;
EXPECT_EQ(absl::string_view(frame.data(), frame.size()),
absl::string_view(slice.data(), slice.length()));
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index 5317137..2fcece7 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -32,7 +32,7 @@
#include "quic/platform/api/quic_flag_utils.h"
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_logging.h"
-#include "quic/platform/api/quic_mem_slice_storage.h"
+#include "common/quiche_mem_slice_storage.h"
#include "common/quiche_text_utils.h"
#include "spdy/core/spdy_protocol.h"
@@ -390,7 +390,7 @@
QuicConsumedData QuicSpdyStream::WritevBody(const struct iovec* iov, int count,
bool fin) {
- QuicMemSliceStorage storage(
+ quiche::QuicheMemSliceStorage storage(
iov, count,
session()->connection()->helper()->GetStreamSendBufferAllocator(),
GetQuicFlag(FLAGS_quic_send_buffer_max_data_slice_size));
@@ -421,7 +421,7 @@
<< header.size();
if (can_write) {
// Save one copy and allocation if send buffer can accomodate the header.
- QuicMemSlice header_slice(std::move(header));
+ quiche::QuicheMemSlice header_slice(std::move(header));
WriteMemSlices(absl::MakeSpan(&header_slice, 1), false);
} else {
QUICHE_DCHECK(force_write);
@@ -431,7 +431,7 @@
}
QuicConsumedData QuicSpdyStream::WriteBodySlices(
- absl::Span<QuicMemSlice> slices, bool fin) {
+ absl::Span<quiche::QuicheMemSlice> slices, bool fin) {
if (!VersionUsesHttp3(transport_version()) || slices.empty()) {
return WriteMemSlices(slices, fin);
}
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index 14ac2f2..1df1485 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -35,6 +35,7 @@
#include "quic/platform/api/quic_export.h"
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_socket_address.h"
+#include "common/platform/api/quiche_mem_slice.h"
#include "spdy/core/spdy_framer.h"
#include "spdy/core/spdy_header_block.h"
@@ -154,7 +155,8 @@
// Does the same thing as WriteOrBufferBody except this method takes
// memslicespan as the data input. Right now it only calls WriteMemSlices.
- QuicConsumedData WriteBodySlices(absl::Span<QuicMemSlice> slices, bool fin);
+ QuicConsumedData WriteBodySlices(absl::Span<quiche::QuicheMemSlice> slices,
+ bool fin);
// Marks the trailers as consumed. This applies to the case where this object
// receives headers and trailers as QuicHeaderLists via calls to
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index c8146e1..cb00c2a 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -37,6 +37,7 @@
#include "quic/test_tools/quic_spdy_stream_peer.h"
#include "quic/test_tools/quic_stream_peer.h"
#include "quic/test_tools/quic_test_utils.h"
+#include "common/quiche_mem_slice_storage.h"
using spdy::kV3HighestPriority;
using spdy::kV3LowestPriority;
@@ -1980,10 +1981,10 @@
std::string body2(100, 'x');
struct iovec body1_iov = {const_cast<char*>(body1.data()), body1.length()};
struct iovec body2_iov = {const_cast<char*>(body2.data()), body2.length()};
- QuicMemSliceStorage storage(&body1_iov, 1,
- helper_.GetStreamSendBufferAllocator(), 1024);
- QuicMemSliceStorage storage2(&body2_iov, 1,
- helper_.GetStreamSendBufferAllocator(), 1024);
+ quiche::QuicheMemSliceStorage storage(
+ &body1_iov, 1, helper_.GetStreamSendBufferAllocator(), 1024);
+ quiche::QuicheMemSliceStorage storage2(
+ &body2_iov, 1, helper_.GetStreamSendBufferAllocator(), 1024);
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).Times(AtLeast(1));
stream_->WriteBodySlices(storage.ToSpan(), false);
stream_->WriteBodySlices(storage2.ToSpan(), true);
diff --git a/quic/core/http/web_transport_http3.cc b/quic/core/http/web_transport_http3.cc
index c2d02f0..f4e8040 100644
--- a/quic/core/http/web_transport_http3.cc
+++ b/quic/core/http/web_transport_http3.cc
@@ -280,7 +280,8 @@
return stream->interface();
}
-MessageStatus WebTransportHttp3::SendOrQueueDatagram(QuicMemSlice datagram) {
+MessageStatus WebTransportHttp3::SendOrQueueDatagram(
+ quiche::QuicheMemSlice datagram) {
return connect_stream_->SendHttp3Datagram(
context_id_, absl::string_view(datagram.data(), datagram.length()));
}
diff --git a/quic/core/http/web_transport_http3.h b/quic/core/http/web_transport_http3.h
index 542b941..f6f94cd 100644
--- a/quic/core/http/web_transport_http3.h
+++ b/quic/core/http/web_transport_http3.h
@@ -16,6 +16,7 @@
#include "quic/core/quic_stream.h"
#include "quic/core/quic_types.h"
#include "quic/core/web_transport_interface.h"
+#include "common/platform/api/quiche_mem_slice.h"
#include "spdy/core/spdy_header_block.h"
namespace quic {
@@ -84,7 +85,7 @@
WebTransportStream* OpenOutgoingBidirectionalStream() override;
WebTransportStream* OpenOutgoingUnidirectionalStream() override;
- MessageStatus SendOrQueueDatagram(QuicMemSlice datagram) override;
+ MessageStatus SendOrQueueDatagram(quiche::QuicheMemSlice datagram) override;
QuicByteCount GetMaxDatagramSize() const override;
void SetDatagramMaxTimeInQueue(QuicTime::Delta max_time_in_queue) override;
diff --git a/quic/core/http/web_transport_stream_adapter.cc b/quic/core/http/web_transport_stream_adapter.cc
index bea1377..eb42fd8 100644
--- a/quic/core/http/web_transport_stream_adapter.cc
+++ b/quic/core/http/web_transport_stream_adapter.cc
@@ -6,6 +6,7 @@
#include "quic/core/http/web_transport_http3.h"
#include "quic/core/quic_error_codes.h"
+#include "common/platform/api/quiche_mem_slice.h"
namespace quic {
@@ -45,7 +46,7 @@
return false;
}
- QuicMemSlice memslice(QuicBuffer::Copy(
+ quiche::QuicheMemSlice memslice(QuicBuffer::Copy(
session_->connection()->helper()->GetStreamSendBufferAllocator(), data));
QuicConsumedData consumed =
stream_->WriteMemSlices(absl::MakeSpan(&memslice, 1), /*fin=*/false);
@@ -76,7 +77,7 @@
return false;
}
- QuicMemSlice empty;
+ quiche::QuicheMemSlice empty;
QuicConsumedData consumed =
stream_->WriteMemSlices(absl::MakeSpan(&empty, 1), /*fin=*/true);
QUICHE_DCHECK_EQ(consumed.bytes_consumed, 0u);
diff --git a/quic/core/quic_buffer_allocator.h b/quic/core/quic_buffer_allocator.h
index d3905e7..de69ca2 100644
--- a/quic/core/quic_buffer_allocator.h
+++ b/quic/core/quic_buffer_allocator.h
@@ -57,9 +57,9 @@
QuicBufferDeleter(allocator));
}
-// QuicUniqueBufferPtr with a length attached to it. Similar to QuicMemSlice,
-// except unlike QuicMemSlice, QuicBuffer is mutable and is not
-// platform-specific. Also unlike QuicMemSlice, QuicBuffer can be empty.
+// QuicUniqueBufferPtr with a length attached to it. Similar to QuicheMemSlice,
+// except unlike QuicheMemSlice, QuicBuffer is mutable and is not
+// platform-specific. Also unlike QuicheMemSlice, QuicBuffer can be empty.
class QUIC_EXPORT_PRIVATE QuicBuffer {
public:
QuicBuffer() : buffer_(nullptr, QuicBufferDeleter(nullptr)), size_(0) {}
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 9db7965..58daa88 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -5705,9 +5705,9 @@
uber_received_packet_manager_.ResetAckStates(encryption_level_);
}
-MessageStatus QuicConnection::SendMessage(QuicMessageId message_id,
- absl::Span<QuicMemSlice> message,
- bool flush) {
+MessageStatus QuicConnection::SendMessage(
+ QuicMessageId message_id, absl::Span<quiche::QuicheMemSlice> message,
+ bool flush) {
if (!VersionSupportsMessageFrames(transport_version())) {
QUIC_BUG(quic_bug_10511_38)
<< "MESSAGE frame is not supported for version " << transport_version();
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 129d8bf..42b4358 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -58,6 +58,7 @@
#include "quic/platform/api/quic_export.h"
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_socket_address.h"
+#include "common/platform/api/quiche_mem_slice.h"
#include "common/quiche_circular_deque.h"
namespace quic {
@@ -985,7 +986,7 @@
// If |flush| is false, this will return a MESSAGE_STATUS_BLOCKED
// when the connection is deemed unwritable.
virtual MessageStatus SendMessage(QuicMessageId message_id,
- absl::Span<QuicMemSlice> message,
+ absl::Span<quiche::QuicheMemSlice> message,
bool flush);
// Returns the largest payload that will fit into a single MESSAGE frame.
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 5845769..f563fde 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -1069,7 +1069,7 @@
MessageStatus SendMessage(absl::string_view message) {
connection_.SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
- QuicMemSlice slice(QuicBuffer::Copy(
+ quiche::QuicheMemSlice slice(QuicBuffer::Copy(
connection_.helper()->GetStreamSendBufferAllocator(), message));
return connection_.SendMessage(1, absl::MakeSpan(&slice, 1), false);
}
@@ -8705,7 +8705,7 @@
connection_.SetFromConfig(config);
}
std::string message(connection_.GetCurrentLargestMessagePayload() * 2, 'a');
- QuicMemSlice slice;
+ quiche::QuicheMemSlice slice;
{
QuicConnection::ScopedPacketFlusher flusher(&connection_);
connection_.SendStreamData3();
diff --git a/quic/core/quic_datagram_queue.cc b/quic/core/quic_datagram_queue.cc
index ebd7483..0851878 100644
--- a/quic/core/quic_datagram_queue.cc
+++ b/quic/core/quic_datagram_queue.cc
@@ -25,7 +25,8 @@
clock_(session->connection()->clock()),
observer_(std::move(observer)) {}
-MessageStatus QuicDatagramQueue::SendOrQueueDatagram(QuicMemSlice datagram) {
+MessageStatus QuicDatagramQueue::SendOrQueueDatagram(
+ quiche::QuicheMemSlice datagram) {
// If the queue is non-empty, always queue the daragram. This ensures that
// the datagrams are sent in the same order that they were sent by the
// application.
diff --git a/quic/core/quic_datagram_queue.h b/quic/core/quic_datagram_queue.h
index 4d3aa2f..6374a64 100644
--- a/quic/core/quic_datagram_queue.h
+++ b/quic/core/quic_datagram_queue.h
@@ -10,7 +10,7 @@
#include "absl/types/optional.h"
#include "quic/core/quic_time.h"
#include "quic/core/quic_types.h"
-#include "quic/platform/api/quic_mem_slice.h"
+#include "common/platform/api/quiche_mem_slice.h"
#include "common/quiche_circular_deque.h"
namespace quic {
@@ -44,7 +44,7 @@
// Adds the datagram to the end of the queue. May send it immediately; if
// not, MESSAGE_STATUS_BLOCKED is returned.
- MessageStatus SendOrQueueDatagram(QuicMemSlice datagram);
+ MessageStatus SendOrQueueDatagram(quiche::QuicheMemSlice datagram);
// Attempts to send a single datagram from the queue. Returns the result of
// SendMessage(), or nullopt if there were no unexpired datagrams to send.
@@ -69,7 +69,7 @@
private:
struct QUIC_EXPORT_PRIVATE Datagram {
- QuicMemSlice datagram;
+ quiche::QuicheMemSlice datagram;
QuicTime expiry;
};
diff --git a/quic/core/quic_datagram_queue_test.cc b/quic/core/quic_datagram_queue_test.cc
index 68a876b..8449e15 100644
--- a/quic/core/quic_datagram_queue_test.cc
+++ b/quic/core/quic_datagram_queue_test.cc
@@ -12,10 +12,10 @@
#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_time.h"
#include "quic/core/quic_types.h"
-#include "quic/platform/api/quic_mem_slice.h"
#include "quic/platform/api/quic_reference_counted.h"
#include "quic/platform/api/quic_test.h"
#include "quic/test_tools/quic_test_utils.h"
+#include "common/platform/api/quiche_mem_slice.h"
namespace quic {
namespace test {
@@ -70,11 +70,11 @@
~QuicDatagramQueueTestBase() = default;
- QuicMemSlice CreateMemSlice(absl::string_view data) {
+ quiche::QuicheMemSlice CreateMemSlice(absl::string_view data) {
QuicUniqueBufferPtr buffer =
MakeUniqueBuffer(helper_.GetStreamSendBufferAllocator(), data.size());
memcpy(buffer.get(), data.data(), data.size());
- return QuicMemSlice(std::move(buffer), data.size());
+ return quiche::QuicheMemSlice(std::move(buffer), data.size());
}
MockQuicConnectionHelper helper_;
@@ -176,7 +176,7 @@
std::vector<std::string> messages;
EXPECT_CALL(*connection_, SendMessage(_, _, _))
.WillRepeatedly([&messages](QuicMessageId /*id*/,
- absl::Span<QuicMemSlice> message,
+ absl::Span<quiche::QuicheMemSlice> message,
bool /*flush*/) {
messages.push_back(std::string(message[0].AsStringView()));
return MESSAGE_STATUS_SUCCESS;
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index 5042d66..d34d1e6 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -1605,7 +1605,7 @@
}
MessageStatus QuicPacketCreator::AddMessageFrame(
- QuicMessageId message_id, absl::Span<QuicMemSlice> message) {
+ QuicMessageId message_id, absl::Span<quiche::QuicheMemSlice> message) {
QUIC_BUG_IF(quic_bug_10752_33, !flusher_attached_)
<< ENDPOINT
<< "Packet flusher is not attached when "
diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h
index 9cc4bca..b32be86 100644
--- a/quic/core/quic_packet_creator.h
+++ b/quic/core/quic_packet_creator.h
@@ -30,6 +30,7 @@
#include "quic/core/quic_packets.h"
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_export.h"
+#include "common/platform/api/quiche_mem_slice.h"
#include "common/quiche_circular_deque.h"
namespace quic {
@@ -421,7 +422,7 @@
// Tries to add a message frame containing |message| and returns the status.
MessageStatus AddMessageFrame(QuicMessageId message_id,
- absl::Span<QuicMemSlice> message);
+ absl::Span<quiche::QuicheMemSlice> message);
// Returns the largest payload that will fit into a single MESSAGE frame.
QuicPacketLength GetCurrentLargestMessagePayload() const;
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index 5538564..c7b7dcb 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -2448,7 +2448,7 @@
}
MessageStatus AddMessageFrame(QuicMessageId message_id,
- QuicMemSlice message) {
+ quiche::QuicheMemSlice message) {
if (!has_ack() && delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
NOT_HANDSHAKE)) {
EXPECT_CALL(*delegate_, MaybeBundleAckOpportunistically()).Times(1);
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index 8b4ceac..cceceb7 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -18,6 +18,7 @@
#include "quic/test_tools/quic_config_peer.h"
#include "quic/test_tools/quic_sent_packet_manager_peer.h"
#include "quic/test_tools/quic_test_utils.h"
+#include "common/platform/api/quiche_mem_slice.h"
using testing::_;
using testing::AnyNumber;
@@ -4440,7 +4441,7 @@
QuicMessageFrame* message_frame = nullptr;
{
- QuicMemSlice slice(MakeUniqueBuffer(&allocator_, 1024), 1024);
+ quiche::QuicheMemSlice slice(MakeUniqueBuffer(&allocator_, 1024), 1024);
message_frame = new QuicMessageFrame(/*message_id=*/1, std::move(slice));
EXPECT_FALSE(message_frame->message_data.empty());
EXPECT_EQ(message_frame->message_length, 1024);
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index fe2955b..89fa564 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -2464,16 +2464,17 @@
connection_->SetTransmissionType(type);
}
-MessageResult QuicSession::SendMessage(absl::Span<QuicMemSlice> message) {
+MessageResult QuicSession::SendMessage(
+ absl::Span<quiche::QuicheMemSlice> message) {
return SendMessage(message, /*flush=*/false);
}
-MessageResult QuicSession::SendMessage(QuicMemSlice message) {
+MessageResult QuicSession::SendMessage(quiche::QuicheMemSlice message) {
return SendMessage(absl::MakeSpan(&message, 1), /*flush=*/false);
}
-MessageResult QuicSession::SendMessage(absl::Span<QuicMemSlice> message,
- bool flush) {
+MessageResult QuicSession::SendMessage(
+ absl::Span<quiche::QuicheMemSlice> message, bool flush) {
QUICHE_DCHECK(connection_->connected())
<< ENDPOINT << "Try to write messages when connection is closed.";
if (!IsEncryptionEstablished()) {
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 88ae992..2734c6e 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -42,8 +42,8 @@
#include "quic/core/uber_quic_stream_id_manager.h"
#include "quic/platform/api/quic_export.h"
#include "quic/platform/api/quic_flags.h"
-#include "quic/platform/api/quic_mem_slice.h"
#include "quic/platform/api/quic_socket_address.h"
+#include "common/platform/api/quiche_mem_slice.h"
#include "common/quiche_linked_hash_map.h"
namespace quic {
@@ -234,15 +234,16 @@
// SendMessage flushes the current packet even it is not full; if the
// application needs to bundle other data in the same packet, consider using
// QuicConnection::ScopedPacketFlusher around the relevant write operations.
- MessageResult SendMessage(absl::Span<QuicMemSlice> message);
+ MessageResult SendMessage(absl::Span<quiche::QuicheMemSlice> message);
// Same as above SendMessage, except caller can specify if the given |message|
// should be flushed even if the underlying connection is deemed unwritable.
- MessageResult SendMessage(absl::Span<QuicMemSlice> message, bool flush);
+ MessageResult SendMessage(absl::Span<quiche::QuicheMemSlice> message,
+ bool flush);
// Single-slice version of SendMessage(). Unlike the version above, this
// version always takes ownership of the slice.
- MessageResult SendMessage(QuicMemSlice message);
+ MessageResult SendMessage(quiche::QuicheMemSlice message);
// Called when message with |message_id| gets acked.
virtual void OnMessageAcked(QuicMessageId message_id,
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index b62f2a9..68ae9f9 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -28,7 +28,6 @@
#include "quic/core/quic_versions.h"
#include "quic/platform/api/quic_expect_bug.h"
#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/test_tools/mock_quic_session_visitor.h"
#include "quic/test_tools/quic_config_peer.h"
@@ -39,6 +38,7 @@
#include "quic/test_tools/quic_stream_peer.h"
#include "quic/test_tools/quic_stream_send_buffer_peer.h"
#include "quic/test_tools/quic_test_utils.h"
+#include "common/quiche_mem_slice_storage.h"
using spdy::kV3HighestPriority;
using spdy::SpdyPriority;
@@ -2700,7 +2700,7 @@
.Times(1);
std::string body(100, '.');
struct iovec iov = {const_cast<char*>(body.data()), body.length()};
- QuicMemSliceStorage storage(
+ quiche::QuicheMemSliceStorage storage(
&iov, 1, session_.connection()->helper()->GetStreamSendBufferAllocator(),
1024);
stream4->WriteMemSlices(storage.ToSpan(), false);
@@ -2716,7 +2716,7 @@
QUIC_TRY_TO_WRITE_DATA_ON_READ_UNIDIRECTIONAL_STREAM, _, _))
.Times(1);
std::string data(1024, 'a');
- std::vector<QuicMemSlice> buffers;
+ std::vector<quiche::QuicheMemSlice> buffers;
buffers.push_back(MemSliceFromString(data));
buffers.push_back(MemSliceFromString(data));
stream4->WriteMemSlices(absl::MakeSpan(buffers), false);
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index 6237dae..f8e00b4 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -20,8 +20,8 @@
#include "quic/platform/api/quic_flag_utils.h"
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_logging.h"
-#include "quic/platform/api/quic_mem_slice.h"
#include "common/platform/api/quiche_logging.h"
+#include "common/platform/api/quiche_mem_slice.h"
using spdy::SpdyPriority;
@@ -759,12 +759,13 @@
}
}
-QuicConsumedData QuicStream::WriteMemSlice(QuicMemSlice span, bool fin) {
+QuicConsumedData QuicStream::WriteMemSlice(quiche::QuicheMemSlice span,
+ bool fin) {
return WriteMemSlices(absl::MakeSpan(&span, 1), fin);
}
-QuicConsumedData QuicStream::WriteMemSlices(absl::Span<QuicMemSlice> span,
- bool fin) {
+QuicConsumedData QuicStream::WriteMemSlices(
+ absl::Span<quiche::QuicheMemSlice> span, bool fin) {
QuicConsumedData consumed_data(0, false);
if (span.empty() && !fin) {
QUIC_BUG(quic_bug_10586_6) << "span.empty() && !fin";
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index dc129a2..4a6acca 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -35,8 +35,8 @@
#include "quic/core/session_notifier_interface.h"
#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_reference_counted.h"
+#include "common/platform/api/quiche_mem_slice.h"
#include "spdy/core/spdy_protocol.h"
namespace quic {
@@ -365,8 +365,9 @@
// 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.
- QuicConsumedData WriteMemSlices(absl::Span<QuicMemSlice> span, bool fin);
- QuicConsumedData WriteMemSlice(QuicMemSlice span, bool fin);
+ QuicConsumedData WriteMemSlices(absl::Span<quiche::QuicheMemSlice> span,
+ bool fin);
+ QuicConsumedData WriteMemSlice(quiche::QuicheMemSlice span, bool fin);
// Returns true if any stream data is lost (including fin) and needs to be
// retransmitted.
diff --git a/quic/core/quic_stream_send_buffer.cc b/quic/core/quic_stream_send_buffer.cc
index b2ac6bf..2c68dc1 100644
--- a/quic/core/quic_stream_send_buffer.cc
+++ b/quic/core/quic_stream_send_buffer.cc
@@ -2,17 +2,18 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include "quic/core/quic_stream_send_buffer.h"
+
#include <algorithm>
#include "quic/core/quic_data_writer.h"
#include "quic/core/quic_interval.h"
-#include "quic/core/quic_stream_send_buffer.h"
#include "quic/core/quic_utils.h"
#include "quic/platform/api/quic_bug_tracker.h"
#include "quic/platform/api/quic_flag_utils.h"
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_logging.h"
-#include "quic/platform/api/quic_mem_slice.h"
+#include "common/platform/api/quiche_mem_slice.h"
namespace quic {
@@ -26,7 +27,8 @@
} // namespace
-BufferedSlice::BufferedSlice(QuicMemSlice mem_slice, QuicStreamOffset offset)
+BufferedSlice::BufferedSlice(quiche::QuicheMemSlice mem_slice,
+ QuicStreamOffset offset)
: slice(std::move(mem_slice)), offset(offset) {}
BufferedSlice::BufferedSlice(BufferedSlice&& other) = default;
@@ -68,13 +70,13 @@
QuicUniqueBufferPtr buffer = MakeUniqueBuffer(allocator_, slice_len);
QuicUtils::CopyToBuffer(iov, iov_count, iov_offset, slice_len,
buffer.get());
- SaveMemSlice(QuicMemSlice(std::move(buffer), slice_len));
+ SaveMemSlice(quiche::QuicheMemSlice(std::move(buffer), slice_len));
data_length -= slice_len;
iov_offset += slice_len;
}
}
-void QuicStreamSendBuffer::SaveMemSlice(QuicMemSlice slice) {
+void QuicStreamSendBuffer::SaveMemSlice(quiche::QuicheMemSlice slice) {
QUIC_DVLOG(2) << "Save slice offset " << stream_offset_ << " length "
<< slice.length();
if (slice.empty()) {
@@ -93,9 +95,9 @@
}
QuicByteCount QuicStreamSendBuffer::SaveMemSliceSpan(
- absl::Span<QuicMemSlice> span) {
+ absl::Span<quiche::QuicheMemSlice> span) {
QuicByteCount total = 0;
- for (QuicMemSlice& slice : span) {
+ for (quiche::QuicheMemSlice& slice : span) {
if (slice.length() == 0) {
// Skip empty slices.
continue;
diff --git a/quic/core/quic_stream_send_buffer.h b/quic/core/quic_stream_send_buffer.h
index bf50217..2069e8b 100644
--- a/quic/core/quic_stream_send_buffer.h
+++ b/quic/core/quic_stream_send_buffer.h
@@ -11,7 +11,7 @@
#include "quic/core/quic_interval_set.h"
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_iovec.h"
-#include "quic/platform/api/quic_mem_slice.h"
+#include "common/platform/api/quiche_mem_slice.h"
#include "common/quiche_circular_deque.h"
namespace quic {
@@ -28,7 +28,7 @@
// stream data is saved in send buffer and is removed when stream data is fully
// acked. It is move-only.
struct QUIC_EXPORT_PRIVATE BufferedSlice {
- BufferedSlice(QuicMemSlice mem_slice, QuicStreamOffset offset);
+ BufferedSlice(quiche::QuicheMemSlice mem_slice, QuicStreamOffset offset);
BufferedSlice(BufferedSlice&& other);
BufferedSlice& operator=(BufferedSlice&& other);
@@ -40,7 +40,7 @@
QuicInterval<std::size_t> interval() const;
// Stream data of this data slice.
- QuicMemSlice slice;
+ quiche::QuicheMemSlice slice;
// Location of this data slice in the stream.
QuicStreamOffset offset;
};
@@ -76,10 +76,10 @@
QuicByteCount data_length);
// Save |slice| to send buffer.
- void SaveMemSlice(QuicMemSlice slice);
+ void SaveMemSlice(quiche::QuicheMemSlice slice);
// Save all slices in |span| to send buffer. Return total bytes saved.
- QuicByteCount SaveMemSliceSpan(absl::Span<QuicMemSlice> span);
+ QuicByteCount SaveMemSliceSpan(absl::Span<quiche::QuicheMemSlice> span);
// Called when |bytes_consumed| bytes has been consumed by the stream.
void OnStreamDataConsumed(size_t bytes_consumed);
diff --git a/quic/core/quic_stream_send_buffer_test.cc b/quic/core/quic_stream_send_buffer_test.cc
index 9aaec4d..15e0d3f 100644
--- a/quic/core/quic_stream_send_buffer_test.cc
+++ b/quic/core/quic_stream_send_buffer_test.cc
@@ -40,10 +40,10 @@
QuicBuffer buffer1(&allocator_, 1024);
memset(buffer1.data(), 'c', buffer1.size());
- QuicMemSlice slice1(std::move(buffer1));
+ quiche::QuicheMemSlice slice1(std::move(buffer1));
QuicBuffer buffer2(&allocator_, 768);
memset(buffer2.data(), 'd', buffer2.size());
- QuicMemSlice slice2(std::move(buffer2));
+ quiche::QuicheMemSlice slice2(std::move(buffer2));
// The stream offset should be 0 since nothing is written.
EXPECT_EQ(0u, QuicStreamSendBufferPeer::EndOffset(&send_buffer_));
@@ -310,7 +310,7 @@
EXPECT_EQ(3840u, QuicStreamSendBufferPeer::EndOffset(&send_buffer_));
QuicBuffer buffer(&allocator_, 60);
memset(buffer.data(), 'e', buffer.size());
- QuicMemSlice slice(std::move(buffer));
+ quiche::QuicheMemSlice slice(std::move(buffer));
send_buffer_.SaveMemSlice(std::move(slice));
EXPECT_EQ(3840u, QuicStreamSendBufferPeer::EndOffset(&send_buffer_));
@@ -321,7 +321,7 @@
QuicStreamSendBuffer send_buffer(&allocator);
std::string data(1024, 'a');
- std::vector<QuicMemSlice> buffers;
+ std::vector<quiche::QuicheMemSlice> buffers;
for (size_t i = 0; i < 10; ++i) {
buffers.push_back(MemSliceFromString(data));
}
@@ -335,7 +335,7 @@
QuicStreamSendBuffer send_buffer(&allocator);
std::string data(1024, 'a');
- std::vector<QuicMemSlice> buffers;
+ std::vector<quiche::QuicheMemSlice> buffers;
for (size_t i = 0; i < 10; ++i) {
buffers.push_back(MemSliceFromString(data));
}
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index 9d48b1f..7c97ce9 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -24,7 +24,6 @@
#include "quic/platform/api/quic_expect_bug.h"
#include "quic/platform/api/quic_flags.h"
#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/test_tools/quic_config_peer.h"
#include "quic/test_tools/quic_connection_peer.h"
@@ -33,6 +32,7 @@
#include "quic/test_tools/quic_stream_peer.h"
#include "quic/test_tools/quic_stream_sequencer_peer.h"
#include "quic/test_tools/quic_test_utils.h"
+#include "common/quiche_mem_slice_storage.h"
using testing::_;
using testing::AnyNumber;
@@ -1171,7 +1171,7 @@
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(Return(QuicConsumedData(0, false)));
struct iovec iov = {const_cast<char*>(data.data()), data.length()};
- QuicMemSliceStorage storage(
+ quiche::QuicheMemSliceStorage storage(
&iov, 1, session_->connection()->helper()->GetStreamSendBufferAllocator(),
1024);
QuicConsumedData consumed = stream_->WriteMemSlices(storage.ToSpan(), false);
@@ -1184,7 +1184,7 @@
EXPECT_FALSE(stream_->CanWriteNewData());
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).Times(0);
- QuicMemSliceStorage storage2(
+ quiche::QuicheMemSliceStorage storage2(
&iov, 1, session_->connection()->helper()->GetStreamSendBufferAllocator(),
1024);
consumed = stream_->WriteMemSlices(storage2.ToSpan(), false);
@@ -1210,7 +1210,7 @@
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).Times(0);
// All data can be consumed as buffered data is below upper limit.
- QuicMemSliceStorage storage3(
+ quiche::QuicheMemSliceStorage storage3(
&iov, 1, session_->connection()->helper()->GetStreamSendBufferAllocator(),
1024);
consumed = stream_->WriteMemSlices(storage3.ToSpan(), false);
@@ -1229,13 +1229,13 @@
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(Invoke(session_.get(), &MockQuicSession::ConsumeData));
struct iovec iov = {const_cast<char*>(data.data()), 5u};
- QuicMemSliceStorage storage(
+ quiche::QuicheMemSliceStorage storage(
&iov, 1, session_->connection()->helper()->GetStreamSendBufferAllocator(),
1024);
QuicConsumedData consumed = stream_->WriteMemSlices(storage.ToSpan(), false);
EXPECT_EQ(data.length(), consumed.bytes_consumed);
struct iovec iov2 = {const_cast<char*>(data.data()), 1u};
- QuicMemSliceStorage storage2(
+ quiche::QuicheMemSliceStorage storage2(
&iov2, 1,
session_->connection()->helper()->GetStreamSendBufferAllocator(), 1024);
EXPECT_CALL(*connection_, CloseConnection(QUIC_STREAM_LENGTH_OVERFLOW, _, _));
@@ -1251,14 +1251,14 @@
constexpr QuicByteCount kDataSize = 1024;
QuicBufferAllocator* allocator =
connection_->helper()->GetStreamSendBufferAllocator();
- std::vector<QuicMemSlice> vector1;
- vector1.push_back(QuicMemSlice(QuicBuffer(allocator, kDataSize)));
- vector1.push_back(QuicMemSlice(QuicBuffer(allocator, kDataSize)));
- std::vector<QuicMemSlice> vector2;
- vector2.push_back(QuicMemSlice(QuicBuffer(allocator, kDataSize)));
- vector2.push_back(QuicMemSlice(QuicBuffer(allocator, kDataSize)));
- absl::Span<QuicMemSlice> span1(vector1);
- absl::Span<QuicMemSlice> span2(vector2);
+ std::vector<quiche::QuicheMemSlice> vector1;
+ vector1.push_back(quiche::QuicheMemSlice(QuicBuffer(allocator, kDataSize)));
+ vector1.push_back(quiche::QuicheMemSlice(QuicBuffer(allocator, kDataSize)));
+ std::vector<quiche::QuicheMemSlice> vector2;
+ vector2.push_back(quiche::QuicheMemSlice(QuicBuffer(allocator, kDataSize)));
+ vector2.push_back(quiche::QuicheMemSlice(QuicBuffer(allocator, kDataSize)));
+ absl::Span<quiche::QuicheMemSlice> span1(vector1);
+ absl::Span<quiche::QuicheMemSlice> span2(vector2);
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
@@ -1314,7 +1314,7 @@
Initialize();
QuicStreamPeer::SetStreamBytesWritten(kMaxStreamLength - 5u, stream_);
std::vector<std::pair<char*, size_t>> buffers;
- QuicMemSlice slice1 = MemSliceFromString("12345");
+ quiche::QuicheMemSlice slice1 = MemSliceFromString("12345");
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this]() {
return session_->ConsumeData(stream_->id(), 5u, 0u, NO_FIN,
@@ -1324,7 +1324,7 @@
QuicConsumedData consumed = stream_->WriteMemSlice(std::move(slice1), false);
EXPECT_EQ(5u, consumed.bytes_consumed);
- QuicMemSlice slice2 = MemSliceFromString("6");
+ quiche::QuicheMemSlice slice2 = MemSliceFromString("6");
EXPECT_CALL(*connection_, CloseConnection(QUIC_STREAM_LENGTH_OVERFLOW, _, _));
EXPECT_QUIC_BUG(stream_->WriteMemSlice(std::move(slice2), false),
"Write too many data via stream");
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index 021fe24..caffd7f 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -22,8 +22,8 @@
#include "quic/platform/api/quic_bug_tracker.h"
#include "quic/platform/api/quic_flag_utils.h"
#include "quic/platform/api/quic_flags.h"
-#include "quic/platform/api/quic_mem_slice.h"
#include "common/platform/api/quiche_logging.h"
+#include "common/platform/api/quiche_mem_slice.h"
#include "common/platform/api/quiche_prefetch.h"
#include "common/quiche_endian.h"
@@ -729,9 +729,9 @@
QuicUtils::IsClientInitiatedStreamId(version.transport_version, id);
}
-QuicByteCount MemSliceSpanTotalSize(absl::Span<QuicMemSlice> span) {
+QuicByteCount MemSliceSpanTotalSize(absl::Span<quiche::QuicheMemSlice> span) {
QuicByteCount total = 0;
- for (const QuicMemSlice& slice : span) {
+ for (const quiche::QuicheMemSlice& slice : span) {
total += slice.length();
}
return total;
diff --git a/quic/core/quic_utils.h b/quic/core/quic_utils.h
index 9b5c6ff..43e6470 100644
--- a/quic/core/quic_utils.h
+++ b/quic/core/quic_utils.h
@@ -22,8 +22,8 @@
#include "quic/core/quic_versions.h"
#include "quic/platform/api/quic_export.h"
#include "quic/platform/api/quic_iovec.h"
-#include "quic/platform/api/quic_mem_slice.h"
#include "quic/platform/api/quic_socket_address.h"
+#include "common/platform/api/quiche_mem_slice.h"
namespace quic {
@@ -254,7 +254,7 @@
bool IsValidWebTransportSessionId(WebTransportSessionId id,
ParsedQuicVersion transport_version);
-QuicByteCount MemSliceSpanTotalSize(absl::Span<QuicMemSlice> span);
+QuicByteCount MemSliceSpanTotalSize(absl::Span<quiche::QuicheMemSlice> span);
// Computes a SHA-256 hash and returns the raw bytes of the hash.
QUIC_EXPORT_PRIVATE std::string RawSha256(absl::string_view input);
diff --git a/quic/core/web_transport_interface.h b/quic/core/web_transport_interface.h
index 102fd1f..6f2941e 100644
--- a/quic/core/web_transport_interface.h
+++ b/quic/core/web_transport_interface.h
@@ -16,6 +16,7 @@
#include "quic/core/quic_datagram_queue.h"
#include "quic/core/quic_types.h"
#include "quic/platform/api/quic_export.h"
+#include "common/platform/api/quiche_mem_slice.h"
#include "spdy/core/spdy_header_block.h"
namespace quic {
@@ -137,7 +138,8 @@
virtual WebTransportStream* OpenOutgoingBidirectionalStream() = 0;
virtual WebTransportStream* OpenOutgoingUnidirectionalStream() = 0;
- virtual MessageStatus SendOrQueueDatagram(QuicMemSlice datagram) = 0;
+ virtual MessageStatus SendOrQueueDatagram(
+ quiche::QuicheMemSlice datagram) = 0;
// Returns a conservative estimate of the largest datagram size that the
// session would be able to send.
virtual QuicByteCount GetMaxDatagramSize() const = 0;
diff --git a/quic/masque/masque_compression_engine.cc b/quic/masque/masque_compression_engine.cc
index 035b9f9..ca9ed93 100644
--- a/quic/masque/masque_compression_engine.cc
+++ b/quic/masque/masque_compression_engine.cc
@@ -15,6 +15,7 @@
#include "quic/core/quic_types.h"
#include "quic/core/quic_versions.h"
#include "quic/platform/api/quic_containers.h"
+#include "common/platform/api/quiche_mem_slice.h"
#include "common/quiche_text_utils.h"
namespace quic {
@@ -281,7 +282,7 @@
}
MessageResult message_result =
- masque_session_->SendMessage(QuicMemSlice(std::move(buffer)));
+ masque_session_->SendMessage(quiche::QuicheMemSlice(std::move(buffer)));
QUIC_DVLOG(1) << "Sent packet compressed with flow ID " << flow_id
<< " and got message result " << message_result;
diff --git a/quic/platform/api/quic_mem_slice.h b/quic/platform/api/quic_mem_slice.h
deleted file mode 100644
index adc03d4..0000000
--- a/quic/platform/api/quic_mem_slice.h
+++ /dev/null
@@ -1,92 +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_H_
-#define QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_H_
-
-#include <memory>
-
-#include "absl/strings/string_view.h"
-#include "quic/platform/api/quic_export.h"
-#include "net/quic/platform/impl/quic_mem_slice_impl.h"
-
-/* API_DESCRIPTION
- QuicMemSlice is used to wrap application data and pass to QUIC stream's write
- interface. It refers to a memory block of data which should be around till
- QuicMemSlice::Reset() is called. It's upto each platform, to implement it as
- reference counted or not.
- API-DESCRIPTION */
-
-namespace quic {
-
-// QuicMemSlice is an internally reference counted data buffer used as the
-// source buffers for write operations. QuicMemSlice implicitly maintains a
-// reference count and will free the underlying data buffer when the reference
-// count reaches zero.
-class QUIC_EXPORT_PRIVATE QuicMemSlice {
- public:
- // Constructs a empty QuicMemSlice with no underlying data and 0 reference
- // count.
- QuicMemSlice() = default;
-
- // Constructs a QuicMemSlice that takes ownership of |buffer|. |length| must
- // not be zero. To construct an empty QuicMemSlice, use the zero-argument
- // constructor instead.
- // TODO(vasilvv): switch all users to QuicBuffer version, and make this
- // private.
- QuicMemSlice(QuicUniqueBufferPtr buffer, size_t length)
- : impl_(std::move(buffer), length) {}
-
- // Constructs a QuicMemSlice that takes ownership of |buffer|. The length of
- // the |buffer| must not be zero. To construct an empty QuicMemSlice, use the
- // zero-argument constructor instead.
- explicit QuicMemSlice(QuicBuffer buffer) : QuicMemSlice() {
- // Store the size of the buffer *before* calling buffer.Release().
- const size_t size = buffer.size();
- *this = QuicMemSlice(buffer.Release(), size);
- }
-
- // Constructs a QuicMemSlice that takes ownership of |buffer| allocated on
- // heap. |length| must not be zero.
- QuicMemSlice(std::unique_ptr<char[]> buffer, size_t length)
- : impl_(std::move(buffer), length) {}
-
- // Constructs QuicMemSlice from |impl|. It takes the reference away from
- // |impl|.
- explicit QuicMemSlice(QuicMemSliceImpl impl) : impl_(std::move(impl)) {}
-
- QuicMemSlice(const QuicMemSlice& other) = delete;
- QuicMemSlice& operator=(const QuicMemSlice& other) = delete;
-
- // Move constructors. |other| will not hold a reference to the data buffer
- // after this call completes.
- QuicMemSlice(QuicMemSlice&& other) = default;
- QuicMemSlice& operator=(QuicMemSlice&& other) = default;
-
- ~QuicMemSlice() = default;
-
- // Release the underlying reference. Further access the memory will result in
- // undefined behavior.
- void Reset() { impl_.Reset(); }
-
- // Returns a const char pointer to underlying data buffer.
- const char* data() const { return impl_.data(); }
- // Returns the length of underlying data buffer.
- size_t length() const { return impl_.length(); }
- // Returns the representation of the underlying data as a string view.
- absl::string_view AsStringView() const {
- return absl::string_view(data(), length());
- }
-
- bool empty() const { return impl_.empty(); }
-
- QuicMemSliceImpl* impl() { return &impl_; }
-
- private:
- QuicMemSliceImpl impl_;
-};
-
-} // namespace quic
-
-#endif // QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_H_
diff --git a/quic/platform/api/quic_mem_slice_storage.cc b/quic/platform/api/quic_mem_slice_storage.cc
deleted file mode 100644
index 87bce7f..0000000
--- a/quic/platform/api/quic_mem_slice_storage.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-// 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
deleted file mode 100644
index 4cccee3..0000000
--- a/quic/platform/api/quic_mem_slice_storage.h
+++ /dev/null
@@ -1,43 +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_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 "quic/platform/api/quic_iovec.h"
-#include "quic/platform/api/quic_mem_slice.h"
-
-namespace quic {
-
-// QuicMemSliceStorage is a container class that store QuicMemSlices for further
-// use cases such as turning into QuicMemSliceSpan.
-class QUIC_EXPORT_PRIVATE QuicMemSliceStorage {
- public:
- QuicMemSliceStorage(const struct iovec* iov, int iov_count,
- QuicBufferAllocator* allocator,
- const QuicByteCount max_slice_len);
-
- QuicMemSliceStorage(const QuicMemSliceStorage& other) = default;
- QuicMemSliceStorage& operator=(const QuicMemSliceStorage& other) = default;
- QuicMemSliceStorage(QuicMemSliceStorage&& other) = default;
- QuicMemSliceStorage& operator=(QuicMemSliceStorage&& other) = default;
-
- ~QuicMemSliceStorage() = default;
-
- // Return a QuicMemSliceSpan form of the storage.
- absl::Span<QuicMemSlice> ToSpan() { return absl::MakeSpan(storage_); }
-
- private:
- std::vector<QuicMemSlice> storage_;
-};
-
-} // namespace quic
-
-#endif // QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_STORAGE_H_
diff --git a/quic/platform/api/quic_mem_slice_storage_test.cc b/quic/platform/api/quic_mem_slice_storage_test.cc
deleted file mode 100644
index 4bef774..0000000
--- a/quic/platform/api/quic_mem_slice_storage_test.cc
+++ /dev/null
@@ -1,61 +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_storage.h"
-
-#include "quic/core/quic_simple_buffer_allocator.h"
-#include "quic/platform/api/quic_test.h"
-
-namespace quic {
-namespace test {
-namespace {
-
-class QuicMemSliceStorageImplTest : public QuicTest {
- public:
- QuicMemSliceStorageImplTest() = default;
-};
-
-TEST_F(QuicMemSliceStorageImplTest, EmptyIov) {
- QuicMemSliceStorage storage(nullptr, 0, nullptr, 1024);
- EXPECT_TRUE(storage.ToSpan().empty());
-}
-
-TEST_F(QuicMemSliceStorageImplTest, SingleIov) {
- SimpleBufferAllocator allocator;
- std::string body(3, 'c');
- struct iovec iov = {const_cast<char*>(body.data()), body.length()};
- QuicMemSliceStorage storage(&iov, 1, &allocator, 1024);
- auto span = storage.ToSpan();
- EXPECT_EQ("ccc", span[0].AsStringView());
- EXPECT_NE(static_cast<const void*>(span[0].data()), body.data());
-}
-
-TEST_F(QuicMemSliceStorageImplTest, MultipleIovInSingleSlice) {
- SimpleBufferAllocator allocator;
- std::string body1(3, 'a');
- std::string body2(4, 'b');
- struct iovec iov[] = {{const_cast<char*>(body1.data()), body1.length()},
- {const_cast<char*>(body2.data()), body2.length()}};
-
- QuicMemSliceStorage storage(iov, 2, &allocator, 1024);
- auto span = storage.ToSpan();
- EXPECT_EQ("aaabbbb", span[0].AsStringView());
-}
-
-TEST_F(QuicMemSliceStorageImplTest, MultipleIovInMultipleSlice) {
- SimpleBufferAllocator allocator;
- std::string body1(4, 'a');
- std::string body2(4, 'b');
- struct iovec iov[] = {{const_cast<char*>(body1.data()), body1.length()},
- {const_cast<char*>(body2.data()), body2.length()}};
-
- QuicMemSliceStorage storage(iov, 2, &allocator, 4);
- auto span = storage.ToSpan();
- EXPECT_EQ("aaaa", span[0].AsStringView());
- EXPECT_EQ("bbbb", span[1].AsStringView());
-}
-
-} // namespace
-} // namespace test
-} // namespace quic
diff --git a/quic/qbone/qbone_session_base.cc b/quic/qbone/qbone_session_base.cc
index 702f185..a5e8a2d 100644
--- a/quic/qbone/qbone_session_base.cc
+++ b/quic/qbone/qbone_session_base.cc
@@ -19,6 +19,7 @@
#include "quic/qbone/platform/icmp_packet.h"
#include "quic/qbone/qbone_constants.h"
#include "common/platform/api/quiche_command_line_flags.h"
+#include "common/platform/api/quiche_mem_slice.h"
DEFINE_QUICHE_COMMAND_LINE_FLAG(
bool, qbone_close_ephemeral_frames, true,
@@ -139,7 +140,7 @@
}
if (send_packets_as_messages_) {
- QuicMemSlice slice(QuicBuffer::Copy(
+ quiche::QuicheMemSlice slice(QuicBuffer::Copy(
connection()->helper()->GetStreamSendBufferAllocator(), packet));
switch (SendMessage(absl::MakeSpan(&slice, 1), /*flush=*/true).status) {
case MESSAGE_STATUS_SUCCESS:
diff --git a/quic/quic_transport/quic_transport_client_session.h b/quic/quic_transport/quic_transport_client_session.h
index 8785457..f5374de 100644
--- a/quic/quic_transport/quic_transport_client_session.h
+++ b/quic/quic_transport/quic_transport_client_session.h
@@ -28,6 +28,7 @@
#include "quic/quic_transport/quic_transport_protocol.h"
#include "quic/quic_transport/quic_transport_session_interface.h"
#include "quic/quic_transport/quic_transport_stream.h"
+#include "common/platform/api/quiche_mem_slice.h"
namespace quic {
@@ -99,7 +100,7 @@
QuicTransportStream* OpenOutgoingBidirectionalStream() override;
QuicTransportStream* OpenOutgoingUnidirectionalStream() override;
- MessageStatus SendOrQueueDatagram(QuicMemSlice datagram) override {
+ MessageStatus SendOrQueueDatagram(quiche::QuicheMemSlice datagram) override {
return datagram_queue()->SendOrQueueDatagram(std::move(datagram));
}
void SetDatagramMaxTimeInQueue(QuicTime::Delta max_time_in_queue) override {
diff --git a/quic/test_tools/quic_test_backend.cc b/quic/test_tools/quic_test_backend.cc
index 3cfe927..12f530a 100644
--- a/quic/test_tools/quic_test_backend.cc
+++ b/quic/test_tools/quic_test_backend.cc
@@ -13,7 +13,6 @@
#include "quic/core/quic_buffer_allocator.h"
#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/web_transport_interface.h"
-#include "quic/platform/api/quic_mem_slice.h"
#include "quic/test_tools/web_transport_resets_backend.h"
#include "quic/tools/web_transport_test_visitors.h"
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index 1149721..52eafed 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -1310,13 +1310,13 @@
: default_type;
}
-QuicMemSlice MemSliceFromString(absl::string_view data) {
+quiche::QuicheMemSlice MemSliceFromString(absl::string_view data) {
if (data.empty()) {
- return QuicMemSlice();
+ return quiche::QuicheMemSlice();
}
static SimpleBufferAllocator* allocator = new SimpleBufferAllocator();
- return QuicMemSlice(QuicBuffer::Copy(allocator, data));
+ return quiche::QuicheMemSlice(QuicBuffer::Copy(allocator, data));
}
bool TaggingEncrypter::EncryptPacket(uint64_t /*packet_number*/,
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 8d12d16..705f951 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -33,7 +33,6 @@
#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/quic_types.h"
#include "quic/core/quic_utils.h"
-#include "quic/platform/api/quic_mem_slice_storage.h"
#include "quic/platform/api/quic_socket_address.h"
#include "quic/platform/api/quic_test.h"
#include "quic/test_tools/mock_clock.h"
@@ -41,6 +40,7 @@
#include "quic/test_tools/mock_random.h"
#include "quic/test_tools/quic_framer_peer.h"
#include "quic/test_tools/simple_quic_framer.h"
+#include "common/quiche_mem_slice_storage.h"
namespace quic {
@@ -645,7 +645,8 @@
(override));
MOCK_METHOD(bool, SendControlFrame, (const QuicFrame& frame), (override));
MOCK_METHOD(MessageStatus, SendMessage,
- (QuicMessageId, absl::Span<QuicMemSlice>, bool), (override));
+ (QuicMessageId, absl::Span<quiche::QuicheMemSlice>, bool),
+ (override));
MOCK_METHOD(bool, SendPathChallenge,
(const QuicPathFrameBuffer&, const QuicSocketAddress&,
const QuicSocketAddress&, const QuicSocketAddress&,
@@ -1534,7 +1535,7 @@
// Creates a MemSlice using a singleton trivial buffer allocator. Performs a
// copy.
-QuicMemSlice MemSliceFromString(absl::string_view data);
+quiche::QuicheMemSlice MemSliceFromString(absl::string_view data);
// Used to compare ReceivedPacketInfo.
MATCHER_P(ReceivedPacketInfoEquals, info, "") {
diff --git a/quic/tools/quic_transport_simple_server_session.cc b/quic/tools/quic_transport_simple_server_session.cc
index bc7ef19..f4496fa 100644
--- a/quic/tools/quic_transport_simple_server_session.cc
+++ b/quic/tools/quic_transport_simple_server_session.cc
@@ -16,6 +16,7 @@
#include "quic/quic_transport/quic_transport_protocol.h"
#include "quic/quic_transport/quic_transport_stream.h"
#include "quic/tools/web_transport_test_visitors.h"
+#include "common/platform/api/quiche_mem_slice.h"
namespace quic {
@@ -131,7 +132,7 @@
connection()->helper()->GetStreamSendBufferAllocator(), message.size());
memcpy(buffer.get(), message.data(), message.size());
datagram_queue()->SendOrQueueDatagram(
- QuicMemSlice(std::move(buffer), message.size()));
+ quiche::QuicheMemSlice(std::move(buffer), message.size()));
}
void QuicTransportSimpleServerSession::MaybeEchoStreamsBack() {
diff --git a/quic/tools/web_transport_test_visitors.h b/quic/tools/web_transport_test_visitors.h
index b1f2246..9451ba7 100644
--- a/quic/tools/web_transport_test_visitors.h
+++ b/quic/tools/web_transport_test_visitors.h
@@ -10,6 +10,7 @@
#include "quic/core/quic_simple_buffer_allocator.h"
#include "quic/core/web_transport_interface.h"
#include "quic/platform/api/quic_logging.h"
+#include "common/platform/api/quiche_mem_slice.h"
#include "common/quiche_circular_deque.h"
namespace quic {
@@ -220,7 +221,7 @@
void OnDatagramReceived(absl::string_view datagram) override {
auto buffer = MakeUniqueBuffer(&allocator_, datagram.size());
memcpy(buffer.get(), datagram.data(), datagram.size());
- QuicMemSlice slice(std::move(buffer), datagram.size());
+ quiche::QuicheMemSlice slice(std::move(buffer), datagram.size());
session_->SendOrQueueDatagram(std::move(slice));
}
