Add a proper API to create memslices from the QUIC code. Current API provides an (allocator, size) constructor. However, this just creates a buffer with random data in it and no way to change it, since memslices are read-only. Current code uses const_cast; this CL creates a proper API and updates all existing call sites to use it. gfe-relnote: n/a (no functional change) PiperOrigin-RevId: 287072774 Change-Id: Ie4dd2eae6db2ec91b087f5d41887ea3948ee411a

diff --git a/quic/masque/masque_compression_engine.cc b/quic/masque/masque_compression_engine.cc
index 804a8cf..dbc4580 100644
--- a/quic/masque/masque_compression_engine.cc
+++ b/quic/masque/masque_compression_engine.cc

@@ -6,6 +6,7 @@
 
 #include <cstdint>
 
+#include "net/third_party/quiche/src/quic/core/quic_buffer_allocator.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_reader.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
 #include "net/third_party/quiche/src/quic/core/quic_framer.h"
@@ -102,33 +103,32 @@
     uint8_t first_byte,
     bool long_header,
     QuicDataReader* reader,
-    QuicMemSlice* slice) {
-  QuicDataWriter writer(slice->length(), const_cast<char*>(slice->data()));
+    QuicDataWriter* writer) {
   if (validated) {
     QUIC_DVLOG(1) << "Compressing using validated flow_id " << flow_id;
-    if (!writer.WriteVarInt62(flow_id)) {
+    if (!writer->WriteVarInt62(flow_id)) {
       QUIC_BUG << "Failed to write flow_id";
       return false;
     }
   } else {
     QUIC_DVLOG(1) << "Compressing using unvalidated flow_id " << flow_id;
-    if (!writer.WriteVarInt62(kFlowId0)) {
+    if (!writer->WriteVarInt62(kFlowId0)) {
       QUIC_BUG << "Failed to write kFlowId0";
       return false;
     }
-    if (!writer.WriteVarInt62(flow_id)) {
+    if (!writer->WriteVarInt62(flow_id)) {
       QUIC_BUG << "Failed to write flow_id";
       return false;
     }
-    if (!writer.WriteLengthPrefixedConnectionId(client_connection_id)) {
+    if (!writer->WriteLengthPrefixedConnectionId(client_connection_id)) {
       QUIC_BUG << "Failed to write client_connection_id";
       return false;
     }
-    if (!writer.WriteLengthPrefixedConnectionId(server_connection_id)) {
+    if (!writer->WriteLengthPrefixedConnectionId(server_connection_id)) {
       QUIC_BUG << "Failed to write server_connection_id";
       return false;
     }
-    if (!writer.WriteUInt16(server_address.port())) {
+    if (!writer->WriteUInt16(server_address.port())) {
       QUIC_BUG << "Failed to write port";
       return false;
     }
@@ -153,16 +153,16 @@
       QUIC_BUG << "Unexpected server_address " << server_address;
       return false;
     }
-    if (!writer.WriteUInt8(address_id)) {
+    if (!writer->WriteUInt8(address_id)) {
       QUIC_BUG << "Failed to write address_id";
       return false;
     }
-    if (!writer.WriteStringPiece(peer_ip_bytes)) {
+    if (!writer->WriteStringPiece(peer_ip_bytes)) {
       QUIC_BUG << "Failed to write IP address";
       return false;
     }
   }
-  if (!writer.WriteUInt8(first_byte)) {
+  if (!writer->WriteUInt8(first_byte)) {
     QUIC_BUG << "Failed to write first_byte";
     return false;
   }
@@ -172,7 +172,7 @@
       QUIC_DLOG(ERROR) << "Failed to read version";
       return false;
     }
-    if (!writer.WriteUInt32(version_label)) {
+    if (!writer->WriteUInt32(version_label)) {
       QUIC_BUG << "Failed to write version";
       return false;
     }
@@ -214,7 +214,7 @@
     }
   }
   quiche::QuicheStringPiece packet_payload = reader->ReadRemainingPayload();
-  if (!writer.WriteStringPiece(packet_payload)) {
+  if (!writer->WriteStringPiece(packet_payload)) {
     QUIC_BUG << "Failed to write packet_payload";
     return false;
   }
@@ -276,17 +276,19 @@
                     sizeof(server_address.port()) + sizeof(uint8_t) +
                     server_address.host().ToPackedString().length();
   }
-  QuicMemSlice slice(
+  QuicUniqueBufferPtr buffer = MakeUniqueBuffer(
       masque_session_->connection()->helper()->GetStreamSendBufferAllocator(),
       slice_length);
+  QuicDataWriter writer(slice_length, buffer.get());
 
-  if (!WriteCompressedPacketToSlice(client_connection_id, server_connection_id,
-                                    server_address, destination_connection_id,
-                                    source_connection_id, flow_id, validated,
-                                    first_byte, long_header, &reader, &slice)) {
+  if (!WriteCompressedPacketToSlice(
+          client_connection_id, server_connection_id, server_address,
+          destination_connection_id, source_connection_id, flow_id, validated,
+          first_byte, long_header, &reader, &writer)) {
     return;
   }
 
+  QuicMemSlice slice(std::move(buffer), slice_length);
   MessageResult message_result =
       masque_session_->SendMessage(QuicMemSliceSpan(&slice));
 

diff --git a/quic/masque/masque_compression_engine.h b/quic/masque/masque_compression_engine.h
index 32ffc9d..95328df 100644
--- a/quic/masque/masque_compression_engine.h
+++ b/quic/masque/masque_compression_engine.h

@@ -104,7 +104,7 @@
                                     uint8_t first_byte,
                                     bool long_header,
                                     QuicDataReader* reader,
-                                    QuicMemSlice* slice);
+                                    QuicDataWriter* writer);
 
   // Parses compression context from flow ID 0 during decompression.
   bool ParseCompressionContext(QuicDataReader* reader,