relnote: Deprecate flag quic_disable_pre_32

net/quic/core/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/core/quic_framer.h"
 
 #include <cstdint>
 #include <memory>
 #include <vector>
 
@@ skipping 1084 matching lines @@
 }
 
 bool QuicFramer::ProcessAuthenticatedHeader(QuicDataReader* reader,
                                             QuicPacketHeader* header) {
   uint8_t private_flags;
   if (!reader->ReadBytes(&private_flags, 1)) {
     set_detailed_error("Unable to read private flags.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
-  if (quic_version_ > QUIC_VERSION_31) {
-    if (private_flags > PACKET_PRIVATE_FLAGS_MAX_VERSION_32) {
-      set_detailed_error("Illegal private flags value.");
-      return RaiseError(QUIC_INVALID_PACKET_HEADER);
-    }
-  } else {
-    if (private_flags > PACKET_PRIVATE_FLAGS_MAX) {
-      set_detailed_error("Illegal private flags value.");
-      return RaiseError(QUIC_INVALID_PACKET_HEADER);
-    }
+  if (private_flags > PACKET_PRIVATE_FLAGS_MAX_VERSION_32) {
+    set_detailed_error("Illegal private flags value.");
+    return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
   header->entropy_flag = (private_flags & PACKET_PRIVATE_FLAGS_ENTROPY) != 0;
   header->fec_flag = (private_flags & PACKET_PRIVATE_FLAGS_FEC) != 0;
 
   if ((private_flags & PACKET_PRIVATE_FLAGS_FEC_GROUP) != 0) {
     uint8_t first_fec_protected_packet_offset;
     if (!reader->ReadBytes(&first_fec_protected_packet_offset, 1)) {
       set_detailed_error("Unable to read first fec protected packet offset.");
       return RaiseError(QUIC_INVALID_PACKET_HEADER);
@@ skipping 333 matching lines @@
       return false;
     }
     ack_frame->packets.Add(last_packet_number - range_length,
                            last_packet_number + 1);
     // Subtract an extra 1 to ensure ranges are represented efficiently and
     // can't overlap by 1 packet number.  This allows a missing_delta of 0
     // to represent an adjacent nack range.
     last_packet_number -= (range_length + 1);
   }
 
-  if (quic_version_ > QUIC_VERSION_31) {
-    return true;
-  }
-
-  // Parse the revived packets list.
-  // TODO(ianswett): Change the ack frame so it only expresses one revived.
-  uint8_t 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) {
-    QuicPacketNumber revived_packet = 0;
-    if (!reader->ReadBytes(&revived_packet,
-                           largest_observed_packet_number_length)) {
-      set_detailed_error("Unable to read revived packet.");
-      return false;
-    }
-  }
-
   return true;
 }
 
 bool QuicFramer::ProcessNewAckFrame(QuicDataReader* reader,
                                     uint8_t frame_type,
                                     QuicAckFrame* ack_frame) {
   // Determine the two lengths from the frame type: largest acked length,
   // ack block length.
   const QuicPacketNumberLength ack_block_length =
       ReadSequenceNumberLength(frame_type);
@@ skipping 462 matching lines @@
   if (quic_version_ <= QUIC_VERSION_33) {
     AckFrameInfo ack_info = GetAckFrameInfo(ack);
     QuicPacketNumberLength largest_observed_length =
         GetMinSequenceNumberLength(ack.largest_observed);
     QuicPacketNumberLength missing_packet_number_length =
         GetMinSequenceNumberLength(ack_info.max_delta);
 
     ack_size = GetMinAckFrameSize(quic_version_, largest_observed_length);
     if (!ack_info.nack_ranges.empty()) {
       ack_size += kNumberOfNackRangesSize;
-      if (quic_version_ <= QUIC_VERSION_31) {
-        ack_size += kNumberOfRevivedPacketsSize;
-      }
       ack_size += min(ack_info.nack_ranges.size(), kMaxNackRanges) *
                   (missing_packet_number_length + PACKET_1BYTE_PACKET_NUMBER);
     }
 
     // In version 23, if the ack will be truncated due to too many nack ranges,
     // then do not include the number of timestamps (1 byte).
     if (ack_info.nack_ranges.size() <= kMaxNackRanges) {
       // 1 byte for the number of timestamps.
       ack_size += 1;
       ack_size += GetAckFrameTimeStampSize(ack);
@@ skipping 186 matching lines @@
   AckFrameInfo ack_info = GetAckFrameInfo(frame);
   QuicPacketNumber ack_largest_observed = frame.largest_observed;
   QuicPacketNumberLength largest_observed_length =
       GetMinSequenceNumberLength(ack_largest_observed);
   QuicPacketNumberLength missing_packet_number_length =
       GetMinSequenceNumberLength(ack_info.max_delta);
   // Determine whether we need to truncate ranges.
   size_t available_range_bytes =
       writer->capacity() - writer->length() - kNumberOfNackRangesSize -
       GetMinAckFrameSize(quic_version_, largest_observed_length);
-  if (quic_version_ <= QUIC_VERSION_31) {
-    available_range_bytes -= kNumberOfRevivedPacketsSize;
-  }
   size_t max_num_ranges =
       available_range_bytes /
       (missing_packet_number_length + PACKET_1BYTE_PACKET_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 99 matching lines @@
                                     ack_iter->second, writer)) {
       QUIC_BUG << "AppendPacketSequenceNumber failed";
       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);
 
-  if (quic_version_ > QUIC_VERSION_31) {
-    return true;
-  }
-
-  // Append revived packets.
-  // FEC is not supported.
-  uint8_t num_revived_packets = 0;
-  if (!writer->WriteBytes(&num_revived_packets, 1)) {
-    QUIC_BUG << "num_revived_packets failed: " << num_revived_packets;
-    return false;
-  }
-
   return true;
 }
 
 bool QuicFramer::AppendNewAckFrameAndTypeByte(const QuicAckFrame& frame,
                                               QuicDataWriter* writer) {
   const NewAckFrameInfo new_ack_info = GetNewAckFrameInfo(frame);
   QuicPacketNumber largest_acked = frame.largest_observed;
   QuicPacketNumberLength largest_acked_length =
       GetMinSequenceNumberLength(largest_acked);
   QuicPacketNumberLength ack_block_length =
@@ skipping 312 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
 }  // namespace net