Add span constructors to QuicDataWriter

Allow callers to provide writable buffers as spans so the buffer size
and pointer cannot become inconsistent. Support both default and
explicit endianness constructors, and cover both byte-order modes.

Originally submitted as <https://quiche-review.googlesource.com/c/quiche/+/11940>.

Bug: https://crbug.com/556304550
PiperOrigin-RevId: 993912870

quiche/quic/core/quic_data_writer.cc

diff --git a/quiche/quic/core/quic_data_writer.cc b/quiche/quic/core/quic_data_writer.cc
index 09f1923..ac500e4 100644
--- a/quiche/quic/core/quic_data_writer.cc
+++ b/quiche/quic/core/quic_data_writer.cc
@@ -19,10 +19,17 @@
 QuicDataWriter::QuicDataWriter(size_t size, char* buffer)
     : quiche::QuicheDataWriter(size, buffer) {}
 
+QuicDataWriter::QuicDataWriter(absl::Span<char> buffer)
+    : QuicDataWriter(buffer.size(), buffer.data()) {}
+
 QuicDataWriter::QuicDataWriter(size_t size, char* buffer,
                                quiche::Endianness endianness)
     : quiche::QuicheDataWriter(size, buffer, endianness) {}
 
+QuicDataWriter::QuicDataWriter(absl::Span<char> buffer,
+                               quiche::Endianness endianness)
+    : QuicDataWriter(buffer.size(), buffer.data(), endianness) {}
+
 QuicDataWriter::~QuicDataWriter() {}
 
 bool QuicDataWriter::WriteUFloat16(uint64_t value) {

quiche/quic/core/quic_data_writer.h

diff --git a/quiche/quic/core/quic_data_writer.h b/quiche/quic/core/quic_data_writer.h
index 555ba98..c4f4834 100644
--- a/quiche/quic/core/quic_data_writer.h
+++ b/quiche/quic/core/quic_data_writer.h
@@ -9,6 +9,7 @@
 #include <cstdint>
 
 #include "absl/strings/string_view.h"
+#include "absl/types/span.h"
 #include "quiche/quic/core/crypto/quic_random.h"
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/platform/api/quic_export.h"
@@ -27,9 +28,11 @@
   // Creates a QuicDataWriter where |buffer| is not owned
   // using NETWORK_BYTE_ORDER endianness.
   QuicDataWriter(size_t size, char* buffer);
+  explicit QuicDataWriter(absl::Span<char> buffer);
   // Creates a QuicDataWriter where |buffer| is not owned
   // using the specified endianness.
   QuicDataWriter(size_t size, char* buffer, quiche::Endianness endianness);
+  QuicDataWriter(absl::Span<char> buffer, quiche::Endianness endianness);
   QuicDataWriter(const QuicDataWriter&) = delete;
   QuicDataWriter& operator=(const QuicDataWriter&) = delete;
 

quiche/quic/core/quic_data_writer_test.cc

diff --git a/quiche/quic/core/quic_data_writer_test.cc b/quiche/quic/core/quic_data_writer_test.cc
index 836556c..f2ddf82 100644
--- a/quiche/quic/core/quic_data_writer_test.cc
+++ b/quiche/quic/core/quic_data_writer_test.cc
@@ -58,6 +58,27 @@
                          ::testing::ValuesIn(GetTestParams()),
                          ::testing::PrintToStringParamName());
 
+TEST_P(QuicDataWriterTest, SpanConstructors) {
+  char default_buffer[2] = {};
+  QuicDataWriter default_writer(absl::MakeSpan(default_buffer));
+  EXPECT_EQ(std::size(default_buffer), default_writer.capacity());
+  EXPECT_TRUE(default_writer.WriteUInt8(1));
+  EXPECT_EQ(1, default_buffer[0]);
+
+  char explicit_buffer[2] = {};
+  QuicDataWriter explicit_writer(absl::MakeSpan(explicit_buffer),
+                                 GetParam().endianness);
+  EXPECT_EQ(std::size(explicit_buffer), explicit_writer.capacity());
+  EXPECT_TRUE(explicit_writer.WriteUInt16(0x0102));
+  const char big_endian[] = {0x01, 0x02};
+  const char little_endian[] = {0x02, 0x01};
+  quiche::test::CompareCharArraysWithHexError(
+      "uint16_t", explicit_buffer, std::size(explicit_buffer),
+      GetParam().endianness == quiche::NETWORK_BYTE_ORDER ? big_endian
+                                                          : little_endian,
+      std::size(explicit_buffer));
+}
+
 TEST_P(QuicDataWriterTest, SanityCheckUFloat16Consts) {
   // Check the arithmetic on the constants - otherwise the values below make
   // no sense.