Remove lastest_revived_packet from QuicAckFrame since FEC is gone. No functional change expected.

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 <stdint.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 1366 matching lines @@
     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;
     }
-    ack_frame->latest_revived_packet = revived_packet;
   }
 
   return true;
 }
 
 bool QuicFramer::ProcessTimestampsInAckFrame(QuicDataReader* reader,
                                              QuicAckFrame* ack_frame) {
   if (ack_frame->is_truncated) {
     return true;
   }
@@ skipping 352 matching lines @@
   QuicPacketNumberLength largest_observed_length =
       GetMinSequenceNumberLength(ack.largest_observed);
   QuicPacketNumberLength missing_packet_number_length =
       GetMinSequenceNumberLength(ack_info.max_delta);
 
   size_t ack_size = GetMinAckFrameSize(largest_observed_length);
   if (!ack_info.nack_ranges.empty()) {
     ack_size += kNumberOfNackRangesSize + kNumberOfRevivedPacketsSize;
     ack_size += min(ack_info.nack_ranges.size(), kMaxNackRanges) *
                 (missing_packet_number_length + PACKET_1BYTE_PACKET_NUMBER);
-    if (ack.latest_revived_packet != 0) {
-      ack_size += largest_observed_length;
-    }
   }
 
   // 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;
     if (ack.received_packet_times.size() > 0) {
       // 1 byte for packet number, 4 bytes for timestamp for the first
       // packet.
@@ skipping 268 matching lines @@
                                     ack_iter->second, writer)) {
       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_t num_revived_packets = frame.latest_revived_packet == 0 ? 0 : 1;
-  if (((writer->capacity() - writer->length()) / largest_observed_length) ==
-      0) {
-    num_revived_packets = 0;
-  }
+  // FEC is not supported.
+  uint8_t num_revived_packets = 0;
   if (!writer->WriteBytes(&num_revived_packets, 1)) {
     return false;
   }
 
-  if (num_revived_packets > 0) {
-    QUIC_BUG_IF(!frame.missing_packets.Contains(frame.latest_revived_packet));
-    if (!AppendPacketSequenceNumber(largest_observed_length,
-                                    frame.latest_revived_packet, writer)) {
-      return false;
-    }
-  }
-
   return true;
 }
 
 bool QuicFramer::AppendTimestampToAckFrame(const QuicAckFrame& frame,
                                            QuicDataWriter* writer) {
   DCHECK_GE(numeric_limits<uint8_t>::max(), frame.received_packet_times.size());
   // num_received_packets is only 1 byte.
   if (frame.received_packet_times.size() > numeric_limits<uint8_t>::max()) {
     return false;
   }
@@ skipping 163 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