Remove QuicheMemSlice(QuicUniqueBufferPtr, size_t) constructor. Always use QuicBuffer instead, since we almost never should need to pass a pointer without the length attached around. PiperOrigin-RevId: 431321090

diff --git a/common/platform/api/quiche_mem_slice.h b/common/platform/api/quiche_mem_slice.h
index 6c4f81a..c7a8fd6 100644
--- a/common/platform/api/quiche_mem_slice.h
+++ b/common/platform/api/quiche_mem_slice.h

@@ -8,6 +8,7 @@
 #include <memory>
 
 #include "absl/strings/string_view.h"
+#include "quic/core/quic_buffer_allocator.h"
 #include "common/platform/api/quiche_export.h"
 #include "net/quiche/common/platform/impl/quiche_mem_slice_impl.h"
 
@@ -30,22 +31,10 @@
   // 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);
-  }
+  explicit QuicheMemSlice(quic::QuicBuffer buffer) : impl_(std::move(buffer)) {}
 
   // Constructs a QuicheMemSlice that takes ownership of |buffer| allocated on
   // heap.  |length| must not be zero.

diff --git a/common/platform/api/quiche_mem_slice_test.cc b/common/platform/api/quiche_mem_slice_test.cc
index de6adbe..4500b5d 100644
--- a/common/platform/api/quiche_mem_slice_test.cc
+++ b/common/platform/api/quiche_mem_slice_test.cc

@@ -19,7 +19,7 @@
  public:
   QuicheMemSliceTest() {
     size_t length = 1024;
-    slice_ = QuicheMemSlice(MakeUniqueBuffer(&allocator_, length), length);
+    slice_ = QuicheMemSlice(quic::QuicBuffer(&allocator_, length));
     orig_data_ = slice_.data();
     orig_length_ = slice_.length();
   }

diff --git a/quic/core/quic_datagram_queue_test.cc b/quic/core/quic_datagram_queue_test.cc
index 8449e15..041275c 100644
--- a/quic/core/quic_datagram_queue_test.cc
+++ b/quic/core/quic_datagram_queue_test.cc

@@ -71,10 +71,8 @@
   ~QuicDatagramQueueTestBase() = default;
 
   quiche::QuicheMemSlice CreateMemSlice(absl::string_view data) {
-    QuicUniqueBufferPtr buffer =
-        MakeUniqueBuffer(helper_.GetStreamSendBufferAllocator(), data.size());
-    memcpy(buffer.get(), data.data(), data.size());
-    return quiche::QuicheMemSlice(std::move(buffer), data.size());
+    return quiche::QuicheMemSlice(
+        QuicBuffer::Copy(helper_.GetStreamSendBufferAllocator(), data));
   }
 
   MockQuicConnectionHelper helper_;

diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index 8335103..e561731 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc

@@ -4469,7 +4469,7 @@
 
   QuicMessageFrame* message_frame = nullptr;
   {
-    quiche::QuicheMemSlice slice(MakeUniqueBuffer(&allocator_, 1024), 1024);
+    quiche::QuicheMemSlice slice(QuicBuffer(&allocator_, 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_stream_send_buffer.cc b/quic/core/quic_stream_send_buffer.cc
index 2c68dc1..e1e437b 100644
--- a/quic/core/quic_stream_send_buffer.cc
+++ b/quic/core/quic_stream_send_buffer.cc

@@ -67,10 +67,10 @@
       GetQuicFlag(FLAGS_quic_send_buffer_max_data_slice_size);
   while (data_length > 0) {
     size_t slice_len = std::min(data_length, max_data_slice_size);
-    QuicUniqueBufferPtr buffer = MakeUniqueBuffer(allocator_, slice_len);
+    QuicBuffer buffer(allocator_, slice_len);
     QuicUtils::CopyToBuffer(iov, iov_count, iov_offset, slice_len,
-                            buffer.get());
-    SaveMemSlice(quiche::QuicheMemSlice(std::move(buffer), slice_len));
+                            buffer.data());
+    SaveMemSlice(quiche::QuicheMemSlice(std::move(buffer)));
     data_length -= slice_len;
     iov_offset += slice_len;
   }

diff --git a/quic/tools/quic_transport_simple_server_session.cc b/quic/tools/quic_transport_simple_server_session.cc
index f4496fa..157c16c 100644
--- a/quic/tools/quic_transport_simple_server_session.cc
+++ b/quic/tools/quic_transport_simple_server_session.cc

@@ -128,11 +128,8 @@
   if (mode_ != ECHO) {
     return;
   }
-  QuicUniqueBufferPtr buffer = MakeUniqueBuffer(
-      connection()->helper()->GetStreamSendBufferAllocator(), message.size());
-  memcpy(buffer.get(), message.data(), message.size());
-  datagram_queue()->SendOrQueueDatagram(
-      quiche::QuicheMemSlice(std::move(buffer), message.size()));
+  datagram_queue()->SendOrQueueDatagram(quiche::QuicheMemSlice(QuicBuffer::Copy(
+      connection()->helper()->GetStreamSendBufferAllocator(), message)));
 }
 
 void QuicTransportSimpleServerSession::MaybeEchoStreamsBack() {

diff --git a/quic/tools/web_transport_test_visitors.h b/quic/tools/web_transport_test_visitors.h
index 9451ba7..4fdac1c 100644
--- a/quic/tools/web_transport_test_visitors.h
+++ b/quic/tools/web_transport_test_visitors.h

@@ -219,9 +219,7 @@
   }
 
   void OnDatagramReceived(absl::string_view datagram) override {
-    auto buffer = MakeUniqueBuffer(&allocator_, datagram.size());
-    memcpy(buffer.get(), datagram.data(), datagram.size());
-    quiche::QuicheMemSlice slice(std::move(buffer), datagram.size());
+    quiche::QuicheMemSlice slice(QuicBuffer::Copy(&allocator_, datagram));
     session_->SendOrQueueDatagram(std::move(slice));
   }