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

 // Copyright (c) 2012 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 "net/quic/core/quic_data_writer.h"
 
 #include <algorithm>
 #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() {}
 
 char* QuicDataWriter::data() {
   return buffer_;
 }
 
 bool QuicDataWriter::WriteUInt8(uint8_t value) {
   return WriteBytes(&value, sizeof(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::WriteUInt64(uint64_t 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)) {
     // Fast path: either the value is denormalized, or has exponent zero.
     // Both cases are represented by the value itself.
     result = static_cast<uint16_t>(value);
   } else if (value >= kUFloat16MaxValue) {
     // Value is out of range; clamp it to the maximum representable.
@@ skipping 18 matching lines @@
     DCHECK_LE(exponent, kUFloat16MaxExponent);
     DCHECK_GE(value, UINT64_C(1) << kUFloat16MantissaBits);
     DCHECK_LT(value, UINT64_C(1) << kUFloat16MantissaEffectiveBits);
 
     // Hidden bit (position 11) is set. We should remove it and increment the
     // exponent. Equivalently, we just add it to the exponent.
     // This hides the bit.
     result = static_cast<uint16_t>(value + (exponent << kUFloat16MantissaBits));
   }
 
+  if (endianness_ == NETWORK_BYTE_ORDER) {
+    result = QuicEndian::HostToNet16(result);
+  }
   return WriteBytes(&result, sizeof(result));
 }
 
 bool QuicDataWriter::WriteStringPiece16(QuicStringPiece val) {
   if (val.size() > std::numeric_limits<uint16_t>::max()) {
     return false;
   }
   if (!WriteUInt16(static_cast<uint16_t>(val.size()))) {
     return false;
   }
@@ skipping 51 matching lines @@
 
 bool QuicDataWriter::WritePaddingBytes(size_t count) {
   return WriteRepeatedByte(0x00, count);
 }
 
 bool QuicDataWriter::WriteConnectionId(uint64_t connection_id) {
   if (QuicUtils::IsConnectionIdWireFormatBigEndian(perspective_)) {
     connection_id = QuicEndian::HostToNet64(connection_id);
   }
 
-  return WriteUInt64(connection_id);
+  return WriteBytes(&connection_id, sizeof(connection_id));
 }
 
 bool QuicDataWriter::WriteTag(uint32_t tag) {
   return WriteBytes(&tag, sizeof(tag));
 }
 
 }  // namespace net