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

net/quic/core/quic_framer.cc

Index: net/quic/core/quic_framer.cc
diff --git a/net/quic/core/quic_framer.cc b/net/quic/core/quic_framer.cc
index 0fa3442d3d398d5e0f4f21593a1655d895914714..553d52c0068858332789b225adabb125ab298180 100644
--- a/net/quic/core/quic_framer.cc
+++ b/net/quic/core/quic_framer.cc
@@ -36,12 +36,6 @@ namespace {
 #define ENDPOINT \
   (perspective_ == Perspective::IS_SERVER ? "Server: " : "Client: ")
 
-// Mask to select the lowest 48 bits of a packet number.
-const QuicPacketNumber k6ByteSequenceNumberMask = UINT64_C(0x0000FFFFFFFFFFFF);
-const QuicPacketNumber k4ByteSequenceNumberMask = UINT64_C(0x00000000FFFFFFFF);
-const QuicPacketNumber k2ByteSequenceNumberMask = UINT64_C(0x000000000000FFFF);
-const QuicPacketNumber k1ByteSequenceNumberMask = UINT64_C(0x00000000000000FF);
-
 // Number of bits the packet number length bits are shifted from the right
 // edge of the public header.
 const uint8_t kPublicHeaderSequenceNumberShift = 4;
@@ -319,7 +313,7 @@ size_t QuicFramer::BuildDataPacket(const QuicPacketHeader& header,
                                    const QuicFrames& frames,
                                    char* buffer,
                                    size_t packet_length) {
-  QuicDataWriter writer(packet_length, buffer, perspective_);
+  QuicDataWriter writer(packet_length, buffer, perspective_, HOST_BYTE_ORDER);
   if (!AppendPacketHeader(header, &writer)) {
     QUIC_BUG << "AppendPacketHeader failed";
     return 0;
@@ -436,7 +430,8 @@ std::unique_ptr<QuicEncryptedPacket> QuicFramer::BuildPublicResetPacket(
   size_t len =
       kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID + reset_serialized.length();
   std::unique_ptr<char[]> buffer(new char[len]);
-  QuicDataWriter writer(len, buffer.get(), Perspective::IS_SERVER);
+  QuicDataWriter writer(len, buffer.get(), Perspective::IS_SERVER,
+                        HOST_BYTE_ORDER);
 
   uint8_t flags = static_cast<uint8_t>(PACKET_PUBLIC_FLAGS_RST |
                                        PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID);
@@ -466,7 +461,8 @@ std::unique_ptr<QuicEncryptedPacket> QuicFramer::BuildVersionNegotiationPacket(
   DCHECK(!versions.empty());
   size_t len = GetVersionNegotiationPacketSize(versions.size());
   std::unique_ptr<char[]> buffer(new char[len]);
-  QuicDataWriter writer(len, buffer.get(), Perspective::IS_SERVER);
+  QuicDataWriter writer(len, buffer.get(), Perspective::IS_SERVER,
+                        HOST_BYTE_ORDER);
 
   uint8_t flags = static_cast<uint8_t>(
       PACKET_PUBLIC_FLAGS_VERSION | PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID |
@@ -490,7 +486,8 @@ std::unique_ptr<QuicEncryptedPacket> QuicFramer::BuildVersionNegotiationPacket(
 }
 
 bool QuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) {
-  QuicDataReader reader(packet.data(), packet.length(), perspective_);
+  QuicDataReader reader(packet.data(), packet.length(), perspective_,
+                        HOST_BYTE_ORDER);
 
   visitor_->OnPacket();
 
@@ -578,7 +575,8 @@ bool QuicFramer::ProcessDataPacket(QuicDataReader* encrypted_reader,
     return RaiseError(QUIC_DECRYPTION_FAILURE);
   }
 
-  QuicDataReader reader(decrypted_buffer, decrypted_length, perspective_);
+  QuicDataReader reader(decrypted_buffer, decrypted_length, perspective_,
+                        HOST_BYTE_ORDER);
 
   // Set the last packet number after we have decrypted the packet
   // so we are confident is not attacker controlled.
@@ -658,7 +656,7 @@ bool QuicFramer::AppendPacketHeader(const QuicPacketHeader& header,
   }
 
   public_flags |=
-      GetSequenceNumberFlags(header.public_header.packet_number_length)
+      GetPacketNumberFlags(header.public_header.packet_number_length)
       << kPublicHeaderSequenceNumberShift;
 
   if (header.public_header.nonce != nullptr) {
@@ -703,8 +701,8 @@ bool QuicFramer::AppendPacketHeader(const QuicPacketHeader& header,
     return false;
   }
 
-  if (!AppendPacketSequenceNumber(header.public_header.packet_number_length,
-                                  header.packet_number, writer)) {
+  if (!AppendPacketNumber(header.public_header.packet_number_length,
+                          header.packet_number, writer)) {
     return false;
   }
 
@@ -860,7 +858,7 @@ bool QuicFramer::ProcessPublicHeader(QuicDataReader* reader,
 }
 
 // static
-QuicPacketNumberLength QuicFramer::GetMinSequenceNumberLength(
+QuicPacketNumberLength QuicFramer::GetMinPacketNumberLength(
     QuicPacketNumber packet_number) {
   if (packet_number < 1 << (PACKET_1BYTE_PACKET_NUMBER * 8)) {
     return PACKET_1BYTE_PACKET_NUMBER;
@@ -874,7 +872,7 @@ QuicPacketNumberLength QuicFramer::GetMinSequenceNumberLength(
 }
 
 // static
-uint8_t QuicFramer::GetSequenceNumberFlags(
+uint8_t QuicFramer::GetPacketNumberFlags(
     QuicPacketNumberLength packet_number_length) {
   switch (packet_number_length) {
     case PACKET_1BYTE_PACKET_NUMBER:
@@ -926,7 +924,7 @@ bool QuicFramer::ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader,
                                               QuicPacketHeader* header) {
   QuicPacketNumber base_packet_number = largest_packet_number_;
 
-  if (!ProcessPacketSequenceNumber(
+  if (!ProcessAndCalculatePacketNumber(
           encrypted_reader, header->public_header.packet_number_length,
           base_packet_number, &header->packet_number)) {
     set_detailed_error("Unable to read packet number.");
@@ -946,13 +944,13 @@ bool QuicFramer::ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader,
   return true;
 }
 
-bool QuicFramer::ProcessPacketSequenceNumber(
+bool QuicFramer::ProcessAndCalculatePacketNumber(
     QuicDataReader* reader,
     QuicPacketNumberLength packet_number_length,
     QuicPacketNumber base_packet_number,
     QuicPacketNumber* packet_number) {
   QuicPacketNumber wire_packet_number = 0u;
-  if (!reader->ReadBytes(&wire_packet_number, packet_number_length)) {
+  if (!reader->ReadBytesToUInt64(packet_number_length, &wire_packet_number)) {
     return false;
   }
 
@@ -1157,14 +1155,15 @@ bool QuicFramer::ProcessStreamFrame(QuicDataReader* reader,
 
   frame->fin = (stream_flags & kQuicStreamFinMask) == kQuicStreamFinShift;
 
-  frame->stream_id = 0;
-  if (!reader->ReadBytes(&frame->stream_id, stream_id_length)) {
+  uint64_t stream_id = 0;
+  if (!reader->ReadBytesToUInt64(stream_id_length, &stream_id)) {
     set_detailed_error("Unable to read stream_id.");
     return false;
   }
+  frame->stream_id = static_cast<QuicStreamId>(stream_id);
 
   frame->offset = 0;
-  if (!reader->ReadBytes(&frame->offset, offset_length)) {
+  if (!reader->ReadBytesToUInt64(offset_length, &frame->offset)) {
     set_detailed_error("Unable to read offset.");
     return false;
   }
@@ -1202,7 +1201,8 @@ bool QuicFramer::ProcessAckFrame(QuicDataReader* reader,
   frame_type >>= kQuicHasMultipleAckBlocksShift;
   bool has_ack_blocks = frame_type & kQuicHasMultipleAckBlocksMask;
 
-  if (!reader->ReadBytes(&ack_frame->largest_observed, largest_acked_length)) {
+  if (!reader->ReadBytesToUInt64(largest_acked_length,
+                                 &ack_frame->largest_observed)) {
     set_detailed_error("Unable to read largest acked.");
     return false;
   }
@@ -1222,14 +1222,14 @@ bool QuicFramer::ProcessAckFrame(QuicDataReader* reader,
 
   uint8_t num_ack_blocks = 0;
   if (has_ack_blocks) {
-    if (!reader->ReadBytes(&num_ack_blocks, 1)) {
+    if (!reader->ReadUInt8(&num_ack_blocks)) {
       set_detailed_error("Unable to read num of ack blocks.");
       return false;
     }
   }
 
-  size_t first_block_length = 0;
-  if (!reader->ReadBytes(&first_block_length, ack_block_length)) {
+  uint64_t first_block_length = 0;
+  if (!reader->ReadBytesToUInt64(ack_block_length, &first_block_length)) {
     set_detailed_error("Unable to read first ack block length.");
     return false;
   }
@@ -1239,13 +1239,13 @@ bool QuicFramer::ProcessAckFrame(QuicDataReader* reader,
 
   if (num_ack_blocks > 0) {
     for (size_t i = 0; i < num_ack_blocks; ++i) {
-      size_t gap = 0;
-      if (!reader->ReadBytes(&gap, PACKET_1BYTE_PACKET_NUMBER)) {
+      uint8_t gap = 0;
+      if (!reader->ReadUInt8(&gap)) {
         set_detailed_error("Unable to read gap to next ack block.");
         return false;
       }
-      size_t current_block_length = 0;
-      if (!reader->ReadBytes(&current_block_length, ack_block_length)) {
+      uint64_t current_block_length = 0;
+      if (!reader->ReadBytesToUInt64(ack_block_length, &current_block_length)) {
         set_detailed_error("Unable to ack block length.");
         return false;
       }
@@ -1267,15 +1267,14 @@ bool QuicFramer::ProcessAckFrame(QuicDataReader* reader,
 bool QuicFramer::ProcessTimestampsInAckFrame(QuicDataReader* reader,
                                              QuicAckFrame* ack_frame) {
   uint8_t num_received_packets;
-  if (!reader->ReadBytes(&num_received_packets, 1)) {
+  if (!reader->ReadUInt8(&num_received_packets)) {
     set_detailed_error("Unable to read num received packets.");
     return false;
   }
 
   if (num_received_packets > 0) {
     uint8_t delta_from_largest_observed;
-    if (!reader->ReadBytes(&delta_from_largest_observed,
-                           PACKET_1BYTE_PACKET_NUMBER)) {
+    if (!reader->ReadUInt8(&delta_from_largest_observed)) {
       set_detailed_error("Unable to read sequence delta in received packets.");
       return false;
     }
@@ -1284,7 +1283,7 @@ bool QuicFramer::ProcessTimestampsInAckFrame(QuicDataReader* reader,
 
     // Time delta from the framer creation.
     uint32_t time_delta_us;
-    if (!reader->ReadBytes(&time_delta_us, sizeof(time_delta_us))) {
+    if (!reader->ReadUInt32(&time_delta_us)) {
       set_detailed_error("Unable to read time delta in received packets.");
       return false;
     }
@@ -1296,8 +1295,7 @@ bool QuicFramer::ProcessTimestampsInAckFrame(QuicDataReader* reader,
         std::make_pair(seq_num, creation_time_ + last_timestamp_));
 
     for (uint8_t i = 1; i < num_received_packets; ++i) {
-      if (!reader->ReadBytes(&delta_from_largest_observed,
-                             PACKET_1BYTE_PACKET_NUMBER)) {
+      if (!reader->ReadUInt8(&delta_from_largest_observed)) {
         set_detailed_error(
             "Unable to read sequence delta in received packets.");
         return false;
@@ -1325,8 +1323,8 @@ bool QuicFramer::ProcessStopWaitingFrame(QuicDataReader* reader,
                                          const QuicPacketHeader& header,
                                          QuicStopWaitingFrame* stop_waiting) {
   QuicPacketNumber least_unacked_delta = 0;
-  if (!reader->ReadBytes(&least_unacked_delta,
-                         header.public_header.packet_number_length)) {
+  if (!reader->ReadBytesToUInt64(header.public_header.packet_number_length,
+                                 &least_unacked_delta)) {
     set_detailed_error("Unable to read least unacked delta.");
     return false;
   }
@@ -1651,9 +1649,9 @@ size_t QuicFramer::GetAckFrameSize(
 
   AckFrameInfo ack_info = GetAckFrameInfo(ack);
   QuicPacketNumberLength largest_acked_length =
-      GetMinSequenceNumberLength(ack.largest_observed);
+      GetMinPacketNumberLength(ack.largest_observed);
   QuicPacketNumberLength ack_block_length =
-      GetMinSequenceNumberLength(ack_info.max_block_length);
+      GetMinPacketNumberLength(ack_info.max_block_length);
 
   ack_size = GetMinAckFrameSize(quic_version_, largest_acked_length);
   // First ack block length.
@@ -1757,32 +1755,38 @@ bool QuicFramer::AppendTypeByte(const QuicFrame& frame,
 }
 
 // static
-bool QuicFramer::AppendPacketSequenceNumber(
-    QuicPacketNumberLength packet_number_length,
-    QuicPacketNumber packet_number,
-    QuicDataWriter* writer) {
-  // Ensure the entire packet number can be written.
-  if (writer->capacity() - writer->length() <
-      static_cast<size_t>(packet_number_length)) {
+bool QuicFramer::AppendPacketNumber(QuicPacketNumberLength packet_number_length,
+                                    QuicPacketNumber packet_number,
+                                    QuicDataWriter* writer) {
+  size_t length = packet_number_length;
+  if (length != 1 && length != 2 && length != 4 && length != 6) {
+    QUIC_BUG << "Invalid packet_number_length: " << length;
     return false;
   }
-  switch (packet_number_length) {
-    case PACKET_1BYTE_PACKET_NUMBER:
-      return writer->WriteUInt8(packet_number & k1ByteSequenceNumberMask);
-      break;
-    case PACKET_2BYTE_PACKET_NUMBER:
-      return writer->WriteUInt16(packet_number & k2ByteSequenceNumberMask);
-      break;
-    case PACKET_4BYTE_PACKET_NUMBER:
-      return writer->WriteUInt32(packet_number & k4ByteSequenceNumberMask);
-      break;
-    case PACKET_6BYTE_PACKET_NUMBER:
-      return writer->WriteUInt48(packet_number & k6ByteSequenceNumberMask);
-      break;
-    default:
-      DCHECK(false) << "packet_number_length: " << packet_number_length;
-      return false;
+  return writer->WriteBytesToUInt64(packet_number_length, packet_number);
+}
+
+// static
+bool QuicFramer::AppendStreamId(size_t stream_id_length,
+                                QuicStreamId stream_id,
+                                QuicDataWriter* writer) {
+  if (stream_id_length == 0 || stream_id_length > 4) {
+    QUIC_BUG << "Invalid stream_id_length: " << stream_id_length;
+    return false;
+  }
+  return writer->WriteBytesToUInt64(stream_id_length, stream_id);
+}
+
+// static
+bool QuicFramer::AppendStreamOffset(size_t offset_length,
+                                    QuicStreamOffset offset,
+                                    QuicDataWriter* writer) {
+  if (offset_length == 1 || offset_length > 8) {
+    QUIC_BUG << "Invalid stream_offset_length: " << offset_length;
+    return false;
   }
+
+  return writer->WriteBytesToUInt64(offset_length, offset);
 }
 
 // static
@@ -1790,18 +1794,20 @@ bool QuicFramer::AppendAckBlock(uint8_t gap,
                                 QuicPacketNumberLength length_length,
                                 QuicPacketNumber length,
                                 QuicDataWriter* writer) {
-  return AppendPacketSequenceNumber(PACKET_1BYTE_PACKET_NUMBER, gap, writer) &&
-         AppendPacketSequenceNumber(length_length, length, writer);
+  return writer->WriteUInt8(gap) &&
+         AppendPacketNumber(length_length, length, writer);
 }
 
 bool QuicFramer::AppendStreamFrame(const QuicStreamFrame& frame,
                                    bool no_stream_frame_length,
                                    QuicDataWriter* writer) {
-  if (!writer->WriteBytes(&frame.stream_id, GetStreamIdSize(frame.stream_id))) {
+  if (!AppendStreamId(GetStreamIdSize(frame.stream_id), frame.stream_id,
+                      writer)) {
     QUIC_BUG << "Writing stream id size failed.";
     return false;
   }
-  if (!writer->WriteBytes(&frame.offset, GetStreamOffsetSize(frame.offset))) {
+  if (!AppendStreamOffset(GetStreamOffsetSize(frame.offset), frame.offset,
+                          writer)) {
     QUIC_BUG << "Writing offset size failed.";
     return false;
   }
@@ -1830,9 +1836,9 @@ bool QuicFramer::AppendAckFrameAndTypeByte(const QuicAckFrame& frame,
   const AckFrameInfo new_ack_info = GetAckFrameInfo(frame);
   QuicPacketNumber largest_acked = frame.largest_observed;
   QuicPacketNumberLength largest_acked_length =
-      GetMinSequenceNumberLength(largest_acked);
+      GetMinPacketNumberLength(largest_acked);
   QuicPacketNumberLength ack_block_length =
-      GetMinSequenceNumberLength(new_ack_info.max_block_length);
+      GetMinPacketNumberLength(new_ack_info.max_block_length);
   // Calculate available bytes for timestamps and ack blocks.
   int32_t available_timestamp_and_ack_block_bytes =
       writer->capacity() - writer->length() - ack_block_length -
@@ -1849,11 +1855,11 @@ bool QuicFramer::AppendAckFrameAndTypeByte(const QuicAckFrame& frame,
 
   // Largest acked length.
   type_byte <<= kQuicSequenceNumberLengthShift;
-  type_byte |= GetSequenceNumberFlags(largest_acked_length);
+  type_byte |= GetPacketNumberFlags(largest_acked_length);
 
   // Ack block length.
   type_byte <<= kQuicSequenceNumberLengthShift;
-  type_byte |= GetSequenceNumberFlags(ack_block_length);
+  type_byte |= GetPacketNumberFlags(ack_block_length);
 
   type_byte |= kQuicFrameTypeAckMask;
 
@@ -1862,8 +1868,7 @@ bool QuicFramer::AppendAckFrameAndTypeByte(const QuicAckFrame& frame,
   }
 
   // Largest acked.
-  if (!AppendPacketSequenceNumber(largest_acked_length, largest_acked,
-                                  writer)) {
+  if (!AppendPacketNumber(largest_acked_length, largest_acked, writer)) {
     return false;
   }
 
@@ -1894,8 +1899,8 @@ bool QuicFramer::AppendAckFrameAndTypeByte(const QuicAckFrame& frame,
   }
 
   // First ack block length.
-  if (!AppendPacketSequenceNumber(ack_block_length,
-                                  new_ack_info.first_block_length, writer)) {
+  if (!AppendPacketNumber(ack_block_length, new_ack_info.first_block_length,
+                          writer)) {
     return false;
   }
 
@@ -2001,8 +2006,7 @@ bool QuicFramer::AppendTimestampToAckFrame(const QuicAckFrame& frame,
     return false;
   }
 
-  if (!writer->WriteUInt8(delta_from_largest_observed &
-                          k1ByteSequenceNumberMask)) {
+  if (!writer->WriteUInt8(delta_from_largest_observed)) {
     return false;
   }
 
@@ -2011,7 +2015,7 @@ bool QuicFramer::AppendTimestampToAckFrame(const QuicAckFrame& frame,
   uint32_t time_delta_us =
       static_cast<uint32_t>((it->second - creation_time_).ToMicroseconds() &
                             (time_epoch_delta_us - 1));
-  if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) {
+  if (!writer->WriteUInt32(time_delta_us)) {
     return false;
   }
 
@@ -2025,8 +2029,7 @@ bool QuicFramer::AppendTimestampToAckFrame(const QuicAckFrame& frame,
       return false;
     }
 
-    if (!writer->WriteUInt8(delta_from_largest_observed &
-                            k1ByteSequenceNumberMask)) {
+    if (!writer->WriteUInt8(delta_from_largest_observed)) {
       return false;
     }
 
@@ -2057,8 +2060,8 @@ bool QuicFramer::AppendStopWaitingFrame(const QuicPacketHeader& header,
              << " version:" << quic_version_;
     return false;
   }
-  if (!AppendPacketSequenceNumber(header.public_header.packet_number_length,
-                                  least_unacked_delta, writer)) {
+  if (!AppendPacketNumber(header.public_header.packet_number_length,
+                          least_unacked_delta, writer)) {
     QUIC_BUG << " seq failed: " << header.public_header.packet_number_length;
     return false;
   }