Remove obsolete fields in quic_protocol and their current usage in QUIC. Reorders QuicAckFrame fie…

net/quic/quic_protocol.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_protocol.h"
 
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
@@ skipping 61 matching lines @@
 QuicPacketPublicHeader::QuicPacketPublicHeader(
     const QuicPacketPublicHeader& other) = default;
 
 QuicPacketPublicHeader::~QuicPacketPublicHeader() {}
 
 QuicPacketHeader::QuicPacketHeader()
     : packet_number(0),
       path_id(kDefaultPathId),
       entropy_flag(false),
       entropy_hash(0),
-      fec_flag(false),
-      is_in_fec_group(NOT_IN_FEC_GROUP),
-      fec_group(0) {}
+      fec_flag(false) {}
 
 QuicPacketHeader::QuicPacketHeader(const QuicPacketPublicHeader& header)
     : public_header(header),
       packet_number(0),
       path_id(kDefaultPathId),
       entropy_flag(false),
       entropy_hash(0),
-      fec_flag(false),
-      is_in_fec_group(NOT_IN_FEC_GROUP),
-      fec_group(0) {}
+      fec_flag(false) {}
 
 QuicPacketHeader::QuicPacketHeader(const QuicPacketHeader& other) = default;
 
 QuicPublicResetPacket::QuicPublicResetPacket()
     : nonce_proof(0), rejected_packet_number(0) {}
 
 QuicPublicResetPacket::QuicPublicResetPacket(
     const QuicPacketPublicHeader& header)
     : public_header(header), nonce_proof(0), rejected_packet_number(0) {}
 
@@ skipping 176 matching lines @@
     }
   }
   if (header.public_header.nonce != nullptr) {
     os << ", diversification_nonce: "
        << net::QuicUtils::HexDecode(*header.public_header.nonce);
   }
   os << ", fec_flag: " << header.fec_flag
      << ", entropy_flag: " << header.entropy_flag
      << ", entropy hash: " << static_cast<int>(header.entropy_hash)
      << ", path_id: " << static_cast<int>(header.path_id)
-     << ", packet_number: " << header.packet_number
-     << ", is_in_fec_group: " << header.is_in_fec_group
-     << ", fec_group: " << header.fec_group << " }\n";
+     << ", packet_number: " << header.packet_number << " }\n";
   return os;
 }
 
 bool IsAwaitingPacket(const QuicAckFrame& ack_frame,
                       QuicPacketNumber packet_number,
                       QuicPacketNumber peer_least_packet_awaiting_ack) {
   if (ack_frame.missing) {
     return packet_number > ack_frame.largest_observed ||
            ack_frame.packets.Contains(packet_number);
   }
   return packet_number >= peer_least_packet_awaiting_ack &&
          !ack_frame.packets.Contains(packet_number);
 }
 
 QuicStopWaitingFrame::QuicStopWaitingFrame()
     : path_id(kDefaultPathId), entropy_hash(0), least_unacked(0) {}
 
 QuicStopWaitingFrame::~QuicStopWaitingFrame() {}
 
 QuicAckFrame::QuicAckFrame()
-    : path_id(kDefaultPathId),
+    : largest_observed(0),
+      ack_delay_time(QuicTime::Delta::Infinite()),
+      path_id(kDefaultPathId),
       entropy_hash(0),
       is_truncated(false),
-      largest_observed(0),
-      ack_delay_time(QuicTime::Delta::Infinite()),
       missing(true) {}
 
 QuicAckFrame::QuicAckFrame(const QuicAckFrame& other) = default;
 
 QuicAckFrame::~QuicAckFrame() {}
 
 QuicRstStreamErrorCode AdjustErrorForVersion(QuicRstStreamErrorCode error_code,
                                              QuicVersion /*version*/) {
   return error_code;
 }
@@ skipping 482 matching lines @@
       encrypted_length(encrypted_length),
       has_crypto_handshake(NOT_HANDSHAKE),
       num_padding_bytes(0),
       path_id(path_id),
       packet_number(packet_number),
       packet_number_length(packet_number_length),
       encryption_level(ENCRYPTION_NONE),
       entropy_hash(entropy_hash),
       has_ack(has_ack),
       has_stop_waiting(has_stop_waiting),
+      transmission_type(NOT_RETRANSMISSION),
       original_path_id(kInvalidPathId),
-      original_packet_number(0),
-      transmission_type(NOT_RETRANSMISSION) {}
+      original_packet_number(0) {}
 
 SerializedPacket::SerializedPacket(const SerializedPacket& other) = default;
 
 SerializedPacket::~SerializedPacket() {}
 
 TransmissionInfo::TransmissionInfo()
     : encryption_level(ENCRYPTION_NONE),
       packet_number_length(PACKET_1BYTE_PACKET_NUMBER),
       bytes_sent(0),
       sent_time(QuicTime::Zero()),
@@ skipping 20 matching lines @@
       is_unackable(false),
       has_crypto_handshake(has_crypto_handshake),
       num_padding_bytes(num_padding_bytes),
       retransmission(0) {}
 
 TransmissionInfo::TransmissionInfo(const TransmissionInfo& other) = default;
 
 TransmissionInfo::~TransmissionInfo() {}
 
 }  // namespace net