Move least_packet_awaited_by_peer_ from QuicReceivedPacketManager to

net/quic/quic_received_packet_manager.cc

 // Copyright 2013 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_received_packet_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/base/linked_hash_map.h"
 #include "net/quic/quic_connection_stats.h"
@@ skipping 111 matching lines @@
       break;
     }
     packets_entropy_.erase(it);
     ++first_gap_;
   }
 }
 
 QuicReceivedPacketManager::QuicReceivedPacketManager(
     CongestionFeedbackType congestion_type,
     QuicConnectionStats* stats)
-    : peer_largest_observed_packet_(0),
-      least_packet_awaited_by_peer_(1),
-      peer_least_packet_awaiting_ack_(0),
+    : peer_least_packet_awaiting_ack_(0),
       time_largest_observed_(QuicTime::Zero()),
       receive_algorithm_(ReceiveAlgorithmInterface::Create(congestion_type)),
       stats_(stats) {
   ack_frame_.largest_observed = 0;
   ack_frame_.entropy_hash = 0;
 }
 
 QuicReceivedPacketManager::~QuicReceivedPacketManager() {}
 
 void QuicReceivedPacketManager::RecordPacketReceived(
@@ skipping 77 matching lines @@
 bool QuicReceivedPacketManager::GenerateCongestionFeedback(
     QuicCongestionFeedbackFrame* feedback) {
   return receive_algorithm_->GenerateCongestionFeedback(feedback);
 }
 
 QuicPacketEntropyHash QuicReceivedPacketManager::EntropyHash(
     QuicPacketSequenceNumber sequence_number) const {
   return entropy_tracker_.EntropyHash(sequence_number);
 }
 
-void QuicReceivedPacketManager::UpdatePacketInformationReceivedByPeer(
-    const QuicAckFrame& ack_frame) {
-  // ValidateAck should fail if largest_observed ever shrinks.
-  DCHECK_LE(peer_largest_observed_packet_, ack_frame.largest_observed);
-  peer_largest_observed_packet_ = ack_frame.largest_observed;
-
-  if (ack_frame.missing_packets.empty()) {
-    least_packet_awaited_by_peer_ = peer_largest_observed_packet_ + 1;
-  } else {
-    least_packet_awaited_by_peer_ = *(ack_frame.missing_packets.begin());
-  }
-}
-
 bool QuicReceivedPacketManager::DontWaitForPacketsBefore(
     QuicPacketSequenceNumber least_unacked) {
   ack_frame_.revived_packets.erase(
       ack_frame_.revived_packets.begin(),
       ack_frame_.revived_packets.lower_bound(least_unacked));
   size_t missing_packets_count = ack_frame_.missing_packets.size();
   ack_frame_.missing_packets.erase(
       ack_frame_.missing_packets.begin(),
       ack_frame_.missing_packets.lower_bound(least_unacked));
   return missing_packets_count != ack_frame_.missing_packets.size();
@@ skipping 23 matching lines @@
   return !ack_frame_.missing_packets.empty();
 }
 
 bool QuicReceivedPacketManager::HasNewMissingPackets() {
   return HasMissingPackets() &&
       (ack_frame_.largest_observed -
        *ack_frame_.missing_packets.rbegin()) <= kMaxPacketsAfterNewMissing;
 }
 
 }  // namespace net