Some changes to prepare for endian change for QUIC: 1) Make data reader/write be able to read/write…

net/quic/core/quic_data_writer.cc

Index: net/quic/core/quic_data_writer.cc
diff --git a/net/quic/core/quic_data_writer.cc b/net/quic/core/quic_data_writer.cc
index 9b1c4261e084f6073d08bfaded177fa6ecd77195..3290dba471153fc718fa6342fcddba9de8c0b7e7 100644
--- a/net/quic/core/quic_data_writer.cc
+++ b/net/quic/core/quic_data_writer.cc
@@ -8,21 +8,20 @@
 #include <limits>
 
 #include "net/quic/core/quic_utils.h"
-#include "net/quic/platform/api/quic_endian.h"
 #include "net/quic/platform/api/quic_flags.h"
 #include "net/quic/platform/api/quic_logging.h"
 
 namespace net {
 
-#define ENDPOINT \
-  (perspective_ == Perspective::IS_SERVER ? "Server: " : "Client: ")
-
 QuicDataWriter::QuicDataWriter(size_t size,
                                char* buffer,
-                               Perspective perspective)
-    : buffer_(buffer), capacity_(size), length_(0), perspective_(perspective) {
-  QUIC_DVLOG(1) << ENDPOINT << "QuicDataReader";
-}
+                               Perspective perspective,
+                               Endianness endianness)
+    : buffer_(buffer),
+      capacity_(size),
+      length_(0),
+      perspective_(perspective),
+      endianness_(endianness) {}
 
 QuicDataWriter::~QuicDataWriter() {}
 
@@ -35,23 +34,39 @@ bool QuicDataWriter::WriteUInt8(uint8_t value) {
 }
 
 bool QuicDataWriter::WriteUInt16(uint16_t value) {
+  if (endianness_ == NETWORK_BYTE_ORDER) {
+    value = QuicEndian::HostToNet16(value);
+  }
   return WriteBytes(&value, sizeof(value));
 }
 
 bool QuicDataWriter::WriteUInt32(uint32_t value) {
+  if (endianness_ == NETWORK_BYTE_ORDER) {
+    value = QuicEndian::HostToNet32(value);
+  }
   return WriteBytes(&value, sizeof(value));
 }
 
-bool QuicDataWriter::WriteUInt48(uint64_t value) {
-  uint16_t hi = static_cast<uint16_t>(value >> 32);
-  uint32_t lo = static_cast<uint32_t>(value);
-  return WriteUInt32(lo) && WriteUInt16(hi);
-}
-
 bool QuicDataWriter::WriteUInt64(uint64_t value) {
+  if (endianness_ == NETWORK_BYTE_ORDER) {
+    value = QuicEndian::HostToNet64(value);
+  }
   return WriteBytes(&value, sizeof(value));
 }
 
+bool QuicDataWriter::WriteBytesToUInt64(size_t num_bytes, uint64_t value) {
+  if (num_bytes > sizeof(value)) {
+    return false;
+  }
+  if (endianness_ == HOST_BYTE_ORDER) {
+    return WriteBytes(&value, num_bytes);
+  }
+
+  value = QuicEndian::HostToNet64(value);
+  return WriteBytes(reinterpret_cast<char*>(&value) + sizeof(value) - num_bytes,
+                    num_bytes);
+}
+
 bool QuicDataWriter::WriteUFloat16(uint64_t value) {
   uint16_t result;
   if (value < (UINT64_C(1) << kUFloat16MantissaEffectiveBits)) {
@@ -88,6 +103,9 @@ bool QuicDataWriter::WriteUFloat16(uint64_t value) {
     result = static_cast<uint16_t>(value + (exponent << kUFloat16MantissaBits));
   }
 
+  if (endianness_ == NETWORK_BYTE_ORDER) {
+    result = QuicEndian::HostToNet16(result);
+  }
   return WriteBytes(&result, sizeof(result));
 }
 
@@ -159,7 +177,7 @@ bool QuicDataWriter::WriteConnectionId(uint64_t connection_id) {
     connection_id = QuicEndian::HostToNet64(connection_id);
   }
 
-  return WriteUInt64(connection_id);
+  return WriteBytes(&connection_id, sizeof(connection_id));
 }
 
 bool QuicDataWriter::WriteTag(uint32_t tag) {