deprecate FLAGS_quic_disable_pre_34

net/quic/core/quic_received_packet_manager.cc

Index: net/quic/core/quic_received_packet_manager.cc
diff --git a/net/quic/core/quic_received_packet_manager.cc b/net/quic/core/quic_received_packet_manager.cc
index fdb41fc41d69d75a0215705103e9674cf776aae5..8548d6b743b31043d9ea5a18e7761d6464d716be 100644
--- a/net/quic/core/quic_received_packet_manager.cc
+++ b/net/quic/core/quic_received_packet_manager.cc
@@ -31,111 +31,12 @@ namespace {
 const size_t kMaxPacketsAfterNewMissing = 4;
 }
 
-QuicReceivedPacketManager::EntropyTracker::EntropyTracker()
-    : packets_entropy_hash_(0), first_gap_(1), largest_observed_(0) {}
-
-QuicReceivedPacketManager::EntropyTracker::~EntropyTracker() {}
-
-QuicPacketEntropyHash QuicReceivedPacketManager::EntropyTracker::EntropyHash(
-    QuicPacketNumber packet_number) const {
-  DCHECK_LE(packet_number, largest_observed_);
-  if (packet_number == largest_observed_) {
-    return packets_entropy_hash_;
-  }
-
-  DCHECK_GE(packet_number, first_gap_);
-  DCHECK_EQ(first_gap_ + packets_entropy_.size() - 1, largest_observed_);
-  QuicPacketEntropyHash hash = packets_entropy_hash_;
-  ReceivedEntropyHashes::const_reverse_iterator it = packets_entropy_.rbegin();
-  for (QuicPacketNumber i = 0; i < (largest_observed_ - packet_number);
-       ++i, ++it) {
-    hash ^= it->first;
-  }
-  return hash;
-}
-
-void QuicReceivedPacketManager::EntropyTracker::RecordPacketEntropyHash(
-    QuicPacketNumber packet_number,
-    QuicPacketEntropyHash entropy_hash) {
-  if (packet_number < first_gap_) {
-    DVLOG(1) << "Ignoring received packet entropy for packet_number:"
-             << packet_number
-             << " less than largest_peer_packet_number:" << first_gap_;
-    return;
-  }
-  // RecordPacketEntropyHash is only intended to be called once per packet.
-  DCHECK(packet_number > largest_observed_ ||
-         !packets_entropy_[packet_number - first_gap_].second);
-
-  packets_entropy_hash_ ^= entropy_hash;
-
-  // Optimize the typical case of no gaps.
-  if (packet_number == largest_observed_ + 1 && packets_entropy_.empty()) {
-    ++first_gap_;
-    largest_observed_ = packet_number;
-    return;
-  }
-  if (packet_number > largest_observed_) {
-    for (QuicPacketNumber i = 0; i < (packet_number - largest_observed_ - 1);
-         ++i) {
-      packets_entropy_.push_back(std::make_pair(0, false));
-    }
-    packets_entropy_.push_back(std::make_pair(entropy_hash, true));
-    largest_observed_ = packet_number;
-  } else {
-    packets_entropy_[packet_number - first_gap_] =
-        std::make_pair(entropy_hash, true);
-    AdvanceFirstGapAndGarbageCollectEntropyMap();
-  }
-
-  DVLOG(2) << "setting cumulative received entropy hash to: "
-           << static_cast<int>(packets_entropy_hash_)
-           << " updated with packet number " << packet_number
-           << " entropy hash: " << static_cast<int>(entropy_hash);
-}
-
-void QuicReceivedPacketManager::EntropyTracker::SetCumulativeEntropyUpTo(
-    QuicPacketNumber packet_number,
-    QuicPacketEntropyHash entropy_hash) {
-  DCHECK_LE(packet_number, largest_observed_);
-  if (packet_number < first_gap_) {
-    DVLOG(1) << "Ignoring set entropy at:" << packet_number
-             << " less than first_gap_:" << first_gap_;
-    return;
-  }
-  while (first_gap_ < packet_number) {
-    ++first_gap_;
-    if (!packets_entropy_.empty()) {
-      packets_entropy_.pop_front();
-    }
-  }
-  // Compute the current entropy by XORing in all entropies received including
-  // and since packet_number.
-  packets_entropy_hash_ = entropy_hash;
-  for (ReceivedEntropyHashes::const_iterator it = packets_entropy_.begin();
-       it != packets_entropy_.end(); ++it) {
-    packets_entropy_hash_ ^= it->first;
-  }
-
-  // Garbage collect entries from the beginning of the map.
-  AdvanceFirstGapAndGarbageCollectEntropyMap();
-}
-
-void QuicReceivedPacketManager::EntropyTracker::
-    AdvanceFirstGapAndGarbageCollectEntropyMap() {
-  while (!packets_entropy_.empty() && packets_entropy_.front().second) {
-    ++first_gap_;
-    packets_entropy_.pop_front();
-  }
-}
-
 QuicReceivedPacketManager::QuicReceivedPacketManager(QuicConnectionStats* stats)
     : peer_least_packet_awaiting_ack_(0),
       ack_frame_updated_(false),
       time_largest_observed_(QuicTime::Zero()),
       stats_(stats) {
   ack_frame_.largest_observed = 0;
-  ack_frame_.entropy_hash = 0;
 }
 
 QuicReceivedPacketManager::~QuicReceivedPacketManager() {}
@@ -149,24 +50,9 @@ void QuicReceivedPacketManager::RecordPacketReceived(
     ack_frame_.received_packet_times.clear();
   }
   ack_frame_updated_ = true;
-  if (ack_frame_.missing) {
-    // Adds the range of packet numbers from max(largest observed + 1, least
-    // awaiting ack) up to packet_number not including packet_number.
-    ack_frame_.packets.Add(
-        max(ack_frame_.largest_observed + 1, peer_least_packet_awaiting_ack_),
-        packet_number);
-  } else {
-    ack_frame_.packets.Add(header.packet_number);
-  }
+  ack_frame_.packets.Add(header.packet_number);
 
   if (ack_frame_.largest_observed > packet_number) {
-    if (ack_frame_.missing) {
-      // We've gotten one of the out of order packets - remove it from our
-      // "missing packets" list.
-      DVLOG(1) << "Removing " << packet_number << " from missing list";
-      ack_frame_.packets.Remove(packet_number);
-    }
-
     // Record how out of order stats.
     ++stats_->packets_reordered;
     stats_->max_sequence_reordering =
@@ -181,19 +67,12 @@ void QuicReceivedPacketManager::RecordPacketReceived(
     ack_frame_.largest_observed = packet_number;
     time_largest_observed_ = receipt_time;
   }
-  if (ack_frame_.missing) {
-    entropy_tracker_.RecordPacketEntropyHash(packet_number,
-                                             header.entropy_hash);
-  }
 
   ack_frame_.received_packet_times.push_back(
       std::make_pair(packet_number, receipt_time));
 }
 
 bool QuicReceivedPacketManager::IsMissing(QuicPacketNumber packet_number) {
-  if (ack_frame_.missing) {
-    return ack_frame_.packets.Contains(packet_number);
-  }
   return packet_number < ack_frame_.largest_observed &&
          !ack_frame_.packets.Contains(packet_number);
 }
@@ -220,10 +99,6 @@ struct isTooLarge {
 const QuicFrame QuicReceivedPacketManager::GetUpdatedAckFrame(
     QuicTime approximate_now) {
   ack_frame_updated_ = false;
-  if (ack_frame_.missing) {
-    ack_frame_.entropy_hash = EntropyHash(ack_frame_.largest_observed);
-  }
-
   if (time_largest_observed_ == QuicTime::Zero()) {
     // We have received no packets.
     ack_frame_.ack_delay_time = QuicTime::Delta::Infinite();
@@ -249,11 +124,6 @@ const QuicFrame QuicReceivedPacketManager::GetUpdatedAckFrame(
   return QuicFrame(&ack_frame_);
 }
 
-QuicPacketEntropyHash QuicReceivedPacketManager::EntropyHash(
-    QuicPacketNumber packet_number) const {
-  return entropy_tracker_.EntropyHash(packet_number);
-}
-
 bool QuicReceivedPacketManager::DontWaitForPacketsBefore(
     QuicPacketNumber least_unacked) {
   peer_least_packet_awaiting_ack_ = least_unacked;
@@ -267,13 +137,6 @@ void QuicReceivedPacketManager::UpdatePacketInformationSentByPeer(
   if (stop_waiting.least_unacked > peer_least_packet_awaiting_ack_) {
     bool packets_updated = DontWaitForPacketsBefore(stop_waiting.least_unacked);
     if (packets_updated) {
-      if (ack_frame_.missing) {
-        DVLOG(1) << "Updating entropy hashed since we missed packets";
-        // There were some missing packets that we won't ever get now.
-        // Recalculate the received entropy hash.
-        entropy_tracker_.SetCumulativeEntropyUpTo(stop_waiting.least_unacked,
-                                                  stop_waiting.entropy_hash);
-      }
       // Ack frame gets updated because packets set is updated because of stop
       // waiting frame.
       ack_frame_updated_ = true;
@@ -284,10 +147,6 @@ void QuicReceivedPacketManager::UpdatePacketInformationSentByPeer(
 }
 
 bool QuicReceivedPacketManager::HasMissingPackets() const {
-  if (ack_frame_.missing) {
-    return !ack_frame_.packets.Empty();
-  }
-
   return ack_frame_.packets.NumIntervals() > 1 ||
          (!ack_frame_.packets.Empty() &&
           ack_frame_.packets.Min() >
@@ -295,24 +154,10 @@ bool QuicReceivedPacketManager::HasMissingPackets() const {
 }
 
 bool QuicReceivedPacketManager::HasNewMissingPackets() const {
-  if (ack_frame_.missing) {
-    return !ack_frame_.packets.Empty() &&
-           (ack_frame_.largest_observed - ack_frame_.packets.Max()) <=
-               kMaxPacketsAfterNewMissing;
-  }
-
   return HasMissingPackets() &&
          ack_frame_.packets.LastIntervalLength() <= kMaxPacketsAfterNewMissing;
 }
 
-size_t QuicReceivedPacketManager::NumTrackedPackets() const {
-  return entropy_tracker_.size();
-}
-
-void QuicReceivedPacketManager::SetVersion(QuicVersion version) {
-  ack_frame_.missing = version <= QUIC_VERSION_33;
-}
-
 bool QuicReceivedPacketManager::ack_frame_updated() const {
   return ack_frame_updated_;
 }