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

net/quic/core/quic_data_reader.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_reader.h"
 
 #include "net/base/int128.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/platform/api/quic_bug_tracker.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: ")
-
 QuicDataReader::QuicDataReader(const char* data,
                                const size_t len,
-                               Perspective perspective)
-    : data_(data), len_(len), pos_(0), perspective_(perspective) {
-  QUIC_DVLOG(1) << ENDPOINT << "QuicDataReader";
+                               Perspective perspective,
+                               Endianness endianness)
+    : data_(data),
+      len_(len),
+      pos_(0),
+      perspective_(perspective),
+      endianness_(endianness) {}
+
+bool QuicDataReader::ReadUInt8(uint8_t* result) {
+  return ReadBytes(result, sizeof(*result));
 }
 
 bool QuicDataReader::ReadUInt16(uint16_t* result) {
-  return ReadBytes(result, sizeof(*result));
+  if (!ReadBytes(result, sizeof(*result))) {
+    return false;
+  }
+  if (endianness_ == NETWORK_BYTE_ORDER) {
+    *result = QuicEndian::NetToHost16(*result);
+  }
+  return true;
 }
 
 bool QuicDataReader::ReadUInt32(uint32_t* result) {
-  return ReadBytes(result, sizeof(*result));
+  if (!ReadBytes(result, sizeof(*result))) {
+    return false;
+  }
+  if (endianness_ == NETWORK_BYTE_ORDER) {
+    *result = QuicEndian::NetToHost32(*result);
+  }
+  return true;
 }
 
 bool QuicDataReader::ReadUInt64(uint64_t* result) {
-  return ReadBytes(result, sizeof(*result));
+  if (!ReadBytes(result, sizeof(*result))) {
+    return false;
+  }
+  if (endianness_ == NETWORK_BYTE_ORDER) {
+    *result = QuicEndian::NetToHost64(*result);
+  }
+  return true;
+}
+
+bool QuicDataReader::ReadBytesToUInt64(size_t num_bytes, uint64_t* result) {
+  if (num_bytes > sizeof(*result)) {
+    return false;
+  }
+  if (endianness_ == HOST_BYTE_ORDER) {
+    return ReadBytes(result, num_bytes);
+  }
+
+  if (!ReadBytes(reinterpret_cast<char*>(result) + sizeof(*result) - num_bytes,
+                 num_bytes)) {
+    return false;
+  }
+  *result = QuicEndian::NetToHost64(*result);
+  return true;
 }
 
 bool QuicDataReader::ReadUFloat16(uint64_t* result) {
   uint16_t value;
   if (!ReadUInt16(&value)) {
     return false;
   }
 
   *result = value;
   if (*result < (1 << kUFloat16MantissaEffectiveBits)) {
@@ skipping 43 matching lines @@
   // Set result.
   *result = QuicStringPiece(data_ + pos_, size);
 
   // Iterate.
   pos_ += size;
 
   return true;
 }
 
 bool QuicDataReader::ReadConnectionId(uint64_t* connection_id) {
-  if (!ReadUInt64(connection_id)) {
+  if (!ReadBytes(connection_id, sizeof(*connection_id))) {
     return false;
   }
 
   if (QuicUtils::IsConnectionIdWireFormatBigEndian(perspective_)) {
     *connection_id = QuicEndian::NetToHost64(*connection_id);
   }
 
   return true;
 }
 
@@ skipping 48 matching lines @@
 uint8_t QuicDataReader::PeekByte() const {
   if (pos_ >= len_) {
     QUIC_BUG << "Reading is done, cannot peek next byte. Tried to read pos = "
              << pos_ << " buffer length = " << len_;
     return 0;
   }
   return data_[pos_];
 }
 
 }  // namespace net