Inline the members of QUIC's ReceivedPacketInfo into QuicAckFrame now

net/quic/quic_framer.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/quic_framer.h"
 
 #include "base/containers/hash_tables.h"
 #include "base/stl_util.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
@@ skipping 114 matching lines @@
     case PACKET_FLAGS_2BYTE_SEQUENCE:
       return PACKET_2BYTE_SEQUENCE_NUMBER;
     case PACKET_FLAGS_1BYTE_SEQUENCE:
       return PACKET_1BYTE_SEQUENCE_NUMBER;
     default:
       LOG(DFATAL) << "Unreachable case statement.";
       return PACKET_6BYTE_SEQUENCE_NUMBER;
   }
 }
 
-bool CanTruncate(
-    QuicVersion version, const QuicFrame& frame, size_t free_bytes) {
+bool CanTruncate(const QuicFrame& frame, size_t free_bytes) {
   if ((frame.type == ACK_FRAME || frame.type == CONNECTION_CLOSE_FRAME) &&
       free_bytes >=
-          QuicFramer::GetMinAckFrameSize(version,
-                                         PACKET_6BYTE_SEQUENCE_NUMBER,
+          QuicFramer::GetMinAckFrameSize(PACKET_6BYTE_SEQUENCE_NUMBER,
                                          PACKET_6BYTE_SEQUENCE_NUMBER)) {
     return true;
   }
   return false;
 }
 
 }  // namespace
 
 bool QuicFramerVisitorInterface::OnWindowUpdateFrame(
     const QuicWindowUpdateFrame& frame) {
@@ skipping 23 matching lines @@
   DCHECK(!supported_versions.empty());
   quic_version_ = supported_versions_[0];
   decrypter_.reset(QuicDecrypter::Create(kNULL));
   encrypter_[ENCRYPTION_NONE].reset(
       QuicEncrypter::Create(kNULL));
 }
 
 QuicFramer::~QuicFramer() {}
 
 // static
-size_t QuicFramer::GetMinStreamFrameSize(QuicVersion version,
-                                         QuicStreamId stream_id,
+size_t QuicFramer::GetMinStreamFrameSize(QuicStreamId stream_id,
                                          QuicStreamOffset offset,
                                          bool last_frame_in_packet,
                                          InFecGroup is_in_fec_group) {
   bool no_stream_frame_length = last_frame_in_packet &&
                                 is_in_fec_group == NOT_IN_FEC_GROUP;
   return kQuicFrameTypeSize + GetStreamIdSize(stream_id) +
       GetStreamOffsetSize(offset) +
       (no_stream_frame_length ? 0 : kQuicStreamPayloadLengthSize);
 }
 
 // static
 size_t QuicFramer::GetMinAckFrameSize(
-    QuicVersion version,
     QuicSequenceNumberLength sequence_number_length,
     QuicSequenceNumberLength largest_observed_length) {
   return kQuicFrameTypeSize + kQuicEntropyHashSize +
       largest_observed_length + kQuicDeltaTimeLargestObservedSize;
 }
 
 // static
 size_t QuicFramer::GetStopWaitingFrameSize(
     QuicSequenceNumberLength sequence_number_length) {
   return kQuicFrameTypeSize + kQuicEntropyHashSize +
       sequence_number_length;
 }
 
 // static
-size_t QuicFramer::GetMinRstStreamFrameSize(QuicVersion quic_version) {
+size_t QuicFramer::GetMinRstStreamFrameSize() {
   return kQuicFrameTypeSize + kQuicMaxStreamIdSize +
       kQuicMaxStreamOffsetSize + kQuicErrorCodeSize +
       kQuicErrorDetailsLengthSize;
 }
 
 // static
 size_t QuicFramer::GetMinConnectionCloseFrameSize() {
   return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize;
 }
 
@@ skipping 75 matching lines @@
                          sequence_number_length);
   if (frame_len <= free_bytes) {
     // Frame fits within packet. Note that acks may be truncated.
     return frame_len;
   }
   // Only truncate the first frame in a packet, so if subsequent ones go
   // over, stop including more frames.
   if (!first_frame) {
     return 0;
   }
-  if (CanTruncate(quic_version_, frame, free_bytes)) {
+  if (CanTruncate(frame, free_bytes)) {
     // Truncate the frame so the packet will not exceed kMaxPacketSize.
     // Note that we may not use every byte of the writer in this case.
     DVLOG(1) << "Truncating large frame, free bytes: " << free_bytes;
     return free_bytes;
   }
   if (!FLAGS_quic_allow_oversized_packets_for_test) {
     return 0;
   }
   LOG(DFATAL) << "Packet size too small to fit frame.";
   return frame_len;
@@ skipping 58 matching lines @@
         }
         break;
       case STOP_WAITING_FRAME:
         if (!AppendStopWaitingFrame(
                 header, *frame.stop_waiting_frame, &writer)) {
           LOG(DFATAL) << "AppendStopWaitingFrame failed";
           return kNoPacket;
         }
         break;
       case PING_FRAME:
-        if (quic_version_ <= QUIC_VERSION_16) {
+        if (quic_version_ == QUIC_VERSION_16) {
           LOG(DFATAL) << "Attempt to add a PingFrame in "
                       << QuicVersionToString(quic_version_);
           return kNoPacket;
         }
         // Ping has no payload.
         break;
       case RST_STREAM_FRAME:
         if (!AppendRstStreamFrame(*frame.rst_stream_frame, &writer)) {
           LOG(DFATAL) << "AppendRstStreamFrame failed";
           return kNoPacket;
@@ skipping 561 matching lines @@
       return PACKET_FLAGS_6BYTE_SEQUENCE;
     default:
       LOG(DFATAL) << "Unreachable case statement.";
       return PACKET_FLAGS_6BYTE_SEQUENCE;
   }
 }
 
 // static
 QuicFramer::AckFrameInfo QuicFramer::GetAckFrameInfo(
     const QuicAckFrame& frame) {
-  const ReceivedPacketInfo& received_info = frame.received_info;
-
   AckFrameInfo ack_info;
-  if (!received_info.missing_packets.empty()) {
-    DCHECK_GE(received_info.largest_observed,
-              *received_info.missing_packets.rbegin());
+  if (!frame.missing_packets.empty()) {
+    DCHECK_GE(frame.largest_observed, *frame.missing_packets.rbegin());
     size_t cur_range_length = 0;
-    SequenceNumberSet::const_iterator iter =
-        received_info.missing_packets.begin();
+    SequenceNumberSet::const_iterator iter = frame.missing_packets.begin();
     QuicPacketSequenceNumber last_missing = *iter;
     ++iter;
-    for (; iter != received_info.missing_packets.end(); ++iter) {
+    for (; iter != frame.missing_packets.end(); ++iter) {
       if (cur_range_length != numeric_limits<uint8>::max() &&
           *iter == (last_missing + 1)) {
         ++cur_range_length;
       } else {
         ack_info.nack_ranges[last_missing - cur_range_length]
             = cur_range_length;
         cur_range_length = 0;
       }
       ack_info.max_delta = max(ack_info.max_delta, *iter - last_missing);
       last_missing = *iter;
     }
     // Include the last nack range.
     ack_info.nack_ranges[last_missing - cur_range_length] = cur_range_length;
     // Include the range to the largest observed.
     ack_info.max_delta = max(ack_info.max_delta,
-                             received_info.largest_observed - last_missing);
+                             frame.largest_observed - last_missing);
   }
   return ack_info;
 }
 
 bool QuicFramer::ProcessPacketHeader(
     QuicPacketHeader* header,
     const QuicEncryptedPacket& packet) {
   if (!ProcessPacketSequenceNumber(header->public_header.sequence_number_length,
                                    &header->packet_sequence_number)) {
     set_detailed_error("Unable to read sequence number.");
@@ skipping 90 matching lines @@
           DVLOG(1) << "Visitor asked to stop further processing.";
           // Returning true since there was no parsing error.
           return true;
         }
         continue;
       }
 
       // Ack Frame
       if (frame_type & kQuicFrameTypeAckMask) {
         QuicAckFrame frame;
-        if (!ProcessAckFrame(header, frame_type, &frame)) {
+        if (!ProcessAckFrame(frame_type, &frame)) {
           return RaiseError(QUIC_INVALID_ACK_DATA);
         }
         if (!visitor_->OnAckFrame(frame)) {
           DVLOG(1) << "Visitor asked to stop further processing.";
           // Returning true since there was no parsing error.
           return true;
         }
         continue;
       }
 
@@ skipping 96 matching lines @@
           return RaiseError(QUIC_INVALID_STOP_WAITING_DATA);
         }
         if (!visitor_->OnStopWaitingFrame(stop_waiting_frame)) {
           DVLOG(1) << "Visitor asked to stop further processing.";
           // Returning true since there was no parsing error.
           return true;
         }
         continue;
       }
       case PING_FRAME: {
-        if (quic_version_ <= QUIC_VERSION_16) {
+        if (quic_version_ == QUIC_VERSION_16) {
           LOG(DFATAL) << "Trying to read a Ping in "
                       << QuicVersionToString(quic_version_);
           return RaiseError(QUIC_INTERNAL_ERROR);
         }
         // Ping has no payload.
         QuicPingFrame ping_frame;
         if (!visitor_->OnPingFrame(ping_frame)) {
           DVLOG(1) << "Visitor asked to stop further processing.";
           // Returning true since there was no parsing error.
           return true;
@@ skipping 61 matching lines @@
   }
   // Point frame to the right data.
   frame->data.Clear();
   if (!frame_data.empty()) {
     frame->data.Append(const_cast<char*>(frame_data.data()), frame_data.size());
   }
 
   return true;
 }
 
-bool QuicFramer::ProcessAckFrame(const QuicPacketHeader& header,
-                                 uint8 frame_type,
-                                 QuicAckFrame* frame) {
-  if (!ProcessReceivedInfo(frame_type, &frame->received_info)) {
-    return false;
-  }
-  return true;
-}
-
-bool QuicFramer::ProcessReceivedInfo(uint8 frame_type,
-                                     ReceivedPacketInfo* received_info) {
+bool QuicFramer::ProcessAckFrame(uint8 frame_type, QuicAckFrame* ack_frame) {
   // Determine the three lengths from the frame type: largest observed length,
   // missing sequence number length, and missing range length.
   const QuicSequenceNumberLength missing_sequence_number_length =
       ReadSequenceNumberLength(frame_type);
   frame_type >>= kQuicSequenceNumberLengthShift;
   const QuicSequenceNumberLength largest_observed_sequence_number_length =
       ReadSequenceNumberLength(frame_type);
   frame_type >>= kQuicSequenceNumberLengthShift;
-  received_info->is_truncated = frame_type & kQuicAckTruncatedMask;
+  ack_frame->is_truncated = frame_type & kQuicAckTruncatedMask;
   frame_type >>= kQuicAckTruncatedShift;
   bool has_nacks = frame_type & kQuicHasNacksMask;
 
-  if (!reader_->ReadBytes(&received_info->entropy_hash, 1)) {
+  if (!reader_->ReadBytes(&ack_frame->entropy_hash, 1)) {
     set_detailed_error("Unable to read entropy hash for received packets.");
     return false;
   }
 
-  if (!reader_->ReadBytes(&received_info->largest_observed,
+  if (!reader_->ReadBytes(&ack_frame->largest_observed,
                           largest_observed_sequence_number_length)) {
     set_detailed_error("Unable to read largest observed.");
     return false;
   }
 
   uint64 delta_time_largest_observed_us;
   if (!reader_->ReadUFloat16(&delta_time_largest_observed_us)) {
     set_detailed_error("Unable to read delta time largest observed.");
     return false;
   }
 
   if (delta_time_largest_observed_us == kUFloat16MaxValue) {
-    received_info->delta_time_largest_observed = QuicTime::Delta::Infinite();
+    ack_frame->delta_time_largest_observed = QuicTime::Delta::Infinite();
   } else {
-    received_info->delta_time_largest_observed =
+    ack_frame->delta_time_largest_observed =
         QuicTime::Delta::FromMicroseconds(delta_time_largest_observed_us);
   }
 
   if (!has_nacks) {
     return true;
   }
 
   uint8 num_missing_ranges;
   if (!reader_->ReadBytes(&num_missing_ranges, 1)) {
     set_detailed_error("Unable to read num missing packet ranges.");
     return false;
   }
 
-  QuicPacketSequenceNumber last_sequence_number =
-      received_info->largest_observed;
+  QuicPacketSequenceNumber last_sequence_number = ack_frame->largest_observed;
   for (size_t i = 0; i < num_missing_ranges; ++i) {
     QuicPacketSequenceNumber missing_delta = 0;
     if (!reader_->ReadBytes(&missing_delta, missing_sequence_number_length)) {
       set_detailed_error("Unable to read missing sequence number delta.");
       return false;
     }
     last_sequence_number -= missing_delta;
     QuicPacketSequenceNumber range_length = 0;
     if (!reader_->ReadBytes(&range_length, PACKET_1BYTE_SEQUENCE_NUMBER)) {
       set_detailed_error("Unable to read missing sequence number range.");
       return false;
     }
     for (size_t i = 0; i <= range_length; ++i) {
-      received_info->missing_packets.insert(last_sequence_number - i);
+      ack_frame->missing_packets.insert(last_sequence_number - i);
     }
     // Subtract an extra 1 to ensure ranges are represented efficiently and
     // can't overlap by 1 sequence number.  This allows a missing_delta of 0
     // to represent an adjacent nack range.
     last_sequence_number -= (range_length + 1);
   }
 
   // Parse the revived packets list.
   uint8 num_revived_packets;
   if (!reader_->ReadBytes(&num_revived_packets, 1)) {
     set_detailed_error("Unable to read num revived packets.");
     return false;
   }
 
   for (size_t i = 0; i < num_revived_packets; ++i) {
     QuicPacketSequenceNumber revived_packet = 0;
     if (!reader_->ReadBytes(&revived_packet,
                             largest_observed_sequence_number_length)) {
       set_detailed_error("Unable to read revived packet.");
       return false;
     }
 
-    received_info->revived_packets.insert(revived_packet);
+    ack_frame->revived_packets.insert(revived_packet);
   }
 
   return true;
 }
 
 bool QuicFramer::ProcessStopWaitingFrame(const QuicPacketHeader& header,
                                          QuicStopWaitingFrame* stop_waiting) {
   if (!reader_->ReadBytes(&stop_waiting->entropy_hash, 1)) {
     set_detailed_error("Unable to read entropy hash for sent packets.");
     return false;
@@ skipping 349 matching lines @@
 
   reader_.reset(new QuicDataReader(decrypted_->data(), decrypted_->length()));
   return true;
 }
 
 size_t QuicFramer::GetAckFrameSize(
     const QuicAckFrame& ack,
     QuicSequenceNumberLength sequence_number_length) {
   AckFrameInfo ack_info = GetAckFrameInfo(ack);
   QuicSequenceNumberLength largest_observed_length =
-      GetMinSequenceNumberLength(ack.received_info.largest_observed);
+      GetMinSequenceNumberLength(ack.largest_observed);
   QuicSequenceNumberLength missing_sequence_number_length =
       GetMinSequenceNumberLength(ack_info.max_delta);
 
-  size_t ack_size = GetMinAckFrameSize(quic_version_,
-                                       sequence_number_length,
+  size_t ack_size = GetMinAckFrameSize(sequence_number_length,
                                        largest_observed_length);
   if (!ack_info.nack_ranges.empty()) {
     ack_size += kNumberOfNackRangesSize  + kNumberOfRevivedPacketsSize;
     ack_size += min(ack_info.nack_ranges.size(), kMaxNackRanges) *
       (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER);
-    ack_size += min(ack.received_info.revived_packets.size(),
+    ack_size += min(ack.revived_packets.size(),
                     kMaxRevivedPackets) * largest_observed_length;
   }
   return ack_size;
 }
 
 size_t QuicFramer::ComputeFrameLength(
     const QuicFrame& frame,
     bool last_frame_in_packet,
     InFecGroup is_in_fec_group,
     QuicSequenceNumberLength sequence_number_length) {
   switch (frame.type) {
     case STREAM_FRAME:
-      return GetMinStreamFrameSize(quic_version_,
-                                   frame.stream_frame->stream_id,
+      return GetMinStreamFrameSize(frame.stream_frame->stream_id,
                                    frame.stream_frame->offset,
                                    last_frame_in_packet,
                                    is_in_fec_group) +
           frame.stream_frame->data.TotalBufferSize();
     case ACK_FRAME: {
       return GetAckFrameSize(*frame.ack_frame, sequence_number_length);
     }
     case CONGESTION_FEEDBACK_FRAME: {
       size_t len = kQuicFrameTypeSize;
       const QuicCongestionFeedbackFrame& congestion_feedback =
@@ skipping 23 matching lines @@
           break;
       }
       return len;
     }
     case STOP_WAITING_FRAME:
       return GetStopWaitingFrameSize(sequence_number_length);
     case PING_FRAME:
       // Ping has no payload.
       return kQuicFrameTypeSize;
     case RST_STREAM_FRAME:
-      return GetMinRstStreamFrameSize(quic_version_) +
+      return GetMinRstStreamFrameSize() +
           frame.rst_stream_frame->error_details.size();
     case CONNECTION_CLOSE_FRAME:
       return GetMinConnectionCloseFrameSize() +
           frame.connection_close_frame->error_details.size();
     case GOAWAY_FRAME:
       return GetMinGoAwayFrameSize() + frame.goaway_frame->reason_phrase.size();
     case WINDOW_UPDATE_FRAME:
       return GetWindowUpdateFrameSize();
     case BLOCKED_FRAME:
       return GetBlockedFrameSize();
@@ skipping 117 matching lines @@
 void QuicFramer::set_version(const QuicVersion version) {
   DCHECK(IsSupportedVersion(version)) << QuicVersionToString(version);
   quic_version_ = version;
 }
 
 bool QuicFramer::AppendAckFrameAndTypeByte(
     const QuicPacketHeader& header,
     const QuicAckFrame& frame,
     QuicDataWriter* writer) {
   AckFrameInfo ack_info = GetAckFrameInfo(frame);
-  QuicPacketSequenceNumber ack_largest_observed =
-      frame.received_info.largest_observed;
+  QuicPacketSequenceNumber ack_largest_observed = frame.largest_observed;
   QuicSequenceNumberLength largest_observed_length =
       GetMinSequenceNumberLength(ack_largest_observed);
   QuicSequenceNumberLength missing_sequence_number_length =
       GetMinSequenceNumberLength(ack_info.max_delta);
   // Determine whether we need to truncate ranges.
   size_t available_range_bytes = writer->capacity() - writer->length() -
       kNumberOfRevivedPacketsSize - kNumberOfNackRangesSize -
-      GetMinAckFrameSize(quic_version_,
-                         header.public_header.sequence_number_length,
+      GetMinAckFrameSize(header.public_header.sequence_number_length,
                          largest_observed_length);
   size_t max_num_ranges = available_range_bytes /
       (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER);
   max_num_ranges = min(kMaxNackRanges, max_num_ranges);
   bool truncated = ack_info.nack_ranges.size() > max_num_ranges;
   DVLOG_IF(1, truncated) << "Truncating ack from "
                          << ack_info.nack_ranges.size() << " ranges to "
                          << max_num_ranges;
   // Write out the type byte by setting the low order bits and doing shifts
   // to make room for the next bit flags to be set.
@@ skipping 11 matching lines @@
   // Missing sequence number length.
   type_byte <<= kQuicSequenceNumberLengthShift;
   type_byte |= GetSequenceNumberFlags(missing_sequence_number_length);
 
   type_byte |= kQuicFrameTypeAckMask;
 
   if (!writer->WriteUInt8(type_byte)) {
     return false;
   }
 
-  const ReceivedPacketInfo& received_info = frame.received_info;
-  QuicPacketEntropyHash ack_entropy_hash = received_info.entropy_hash;
+  QuicPacketEntropyHash ack_entropy_hash = frame.entropy_hash;
   NackRangeMap::reverse_iterator ack_iter = ack_info.nack_ranges.rbegin();
   if (truncated) {
     // Skip the nack ranges which the truncated ack won't include and set
     // a correct largest observed for the truncated ack.
     for (size_t i = 1; i < (ack_info.nack_ranges.size() - max_num_ranges);
          ++i) {
       ++ack_iter;
     }
     // If the last range is followed by acks, include them.
     // If the last range is followed by another range, specify the end of the
     // range as the largest_observed.
     ack_largest_observed = ack_iter->first - 1;
     // Also update the entropy so it matches the largest observed.
     ack_entropy_hash = entropy_calculator_->EntropyHash(ack_largest_observed);
     ++ack_iter;
   }
 
   if (!writer->WriteUInt8(ack_entropy_hash)) {
     return false;
   }
 
   if (!AppendPacketSequenceNumber(largest_observed_length,
                                   ack_largest_observed, writer)) {
     return false;
   }
 
   uint64 delta_time_largest_observed_us = kUFloat16MaxValue;
-  if (!received_info.delta_time_largest_observed.IsInfinite()) {
-    DCHECK_LE(0u,
-              frame.received_info.delta_time_largest_observed.ToMicroseconds());
+  if (!frame.delta_time_largest_observed.IsInfinite()) {
+    DCHECK_LE(0u, frame.delta_time_largest_observed.ToMicroseconds());
     delta_time_largest_observed_us =
-        received_info.delta_time_largest_observed.ToMicroseconds();
+        frame.delta_time_largest_observed.ToMicroseconds();
   }
 
   if (!writer->WriteUFloat16(delta_time_largest_observed_us)) {
     return false;
   }
 
   if (ack_info.nack_ranges.empty()) {
     return true;
   }
 
@@ skipping 18 matching lines @@
       return false;
     }
     // Subtract 1 so a missing_delta of 0 means an adjacent range.
     last_sequence_written = ack_iter->first - 1;
     ++num_ranges_written;
   }
   DCHECK_EQ(num_missing_ranges, num_ranges_written);
 
   // Append revived packets.
   // If not all the revived packets fit, only mention the ones that do.
-  uint8 num_revived_packets = min(received_info.revived_packets.size(),
+  uint8 num_revived_packets = min(frame.revived_packets.size(),
                                   kMaxRevivedPackets);
   num_revived_packets = min(
       static_cast<size_t>(num_revived_packets),
       (writer->capacity() - writer->length()) / largest_observed_length);
   if (!writer->WriteBytes(&num_revived_packets, 1)) {
     return false;
   }
 
-  SequenceNumberSet::const_iterator iter =
-      received_info.revived_packets.begin();
+  SequenceNumberSet::const_iterator iter = frame.revived_packets.begin();
   for (int i = 0; i < num_revived_packets; ++i, ++iter) {
-    LOG_IF(DFATAL, !ContainsKey(received_info.missing_packets, *iter));
+    LOG_IF(DFATAL, !ContainsKey(frame.missing_packets, *iter));
     if (!AppendPacketSequenceNumber(largest_observed_length,
                                     *iter, writer)) {
       return false;
     }
   }
 
   return true;
 }
 
 bool QuicFramer::AppendCongestionFeedbackFrame(
@@ skipping 176 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net