Move least_packet_awaited_by_peer_ from QuicReceivedPacketManager to

net/quic/quic_connection.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_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 #include <algorithm>
 #include <iterator>
@@ skipping 540 matching lines @@
     SendConnectionClose(QUIC_INVALID_ACK_DATA);
     return false;
   }
 
   last_ack_frames_.push_back(incoming_ack);
   return connected_;
 }
 
 void QuicConnection::ProcessAckFrame(const QuicAckFrame& incoming_ack) {
   largest_seen_packet_with_ack_ = last_header_.packet_sequence_number;
-  received_packet_manager_.UpdatePacketInformationReceivedByPeer(incoming_ack);
-
-  sent_entropy_manager_.ClearEntropyBefore(
-      received_packet_manager_.least_packet_awaited_by_peer() - 1);
-
   sent_packet_manager_.OnIncomingAck(incoming_ack,
                                      time_of_last_received_packet_);
+  sent_entropy_manager_.ClearEntropyBefore(
+      sent_packet_manager_.least_packet_awaited_by_peer() - 1);
   if (sent_packet_manager_.HasPendingRetransmissions()) {
     WriteIfNotBlocked();
   }
 
   // Always reset the retransmission alarm when an ack comes in, since we now
   // have a better estimate of the current rtt than when it was set.
-  QuicTime retransmission_time =
-      sent_packet_manager_.GetRetransmissionTime();
+  QuicTime retransmission_time = sent_packet_manager_.GetRetransmissionTime();
   retransmission_alarm_->Update(retransmission_time,
                                 QuicTime::Delta::FromMilliseconds(1));
 }
 
 void QuicConnection::ProcessStopWaitingFrame(
     const QuicStopWaitingFrame& stop_waiting) {
   largest_seen_packet_with_stop_waiting_ = last_header_.packet_sequence_number;
   received_packet_manager_.UpdatePacketInformationSentByPeer(stop_waiting);
   // Possibly close any FecGroups which are now irrelevant.
   CloseFecGroupsBefore(stop_waiting.least_unacked + 1);
@@ skipping 41 matching lines @@
 
 bool QuicConnection::ValidateAckFrame(const QuicAckFrame& incoming_ack) {
   if (incoming_ack.largest_observed > packet_generator_.sequence_number()) {
     DLOG(ERROR) << ENDPOINT << "Peer's observed unsent packet:"
                 << incoming_ack.largest_observed << " vs "
                 << packet_generator_.sequence_number();
     // We got an error for data we have not sent.  Error out.
     return false;
   }
 
-  if (incoming_ack.largest_observed <
-          received_packet_manager_.peer_largest_observed_packet()) {
+  if (incoming_ack.largest_observed < sent_packet_manager_.largest_observed()) {
     DLOG(ERROR) << ENDPOINT << "Peer's largest_observed packet decreased:"
                 << incoming_ack.largest_observed << " vs "
-                << received_packet_manager_.peer_largest_observed_packet();
+                << sent_packet_manager_.largest_observed();
     // A new ack has a diminished largest_observed value.  Error out.
     // If this was an old packet, we wouldn't even have checked.
     return false;
   }
 
   if (!incoming_ack.missing_packets.empty() &&
       *incoming_ack.missing_packets.rbegin() > incoming_ack.largest_observed) {
     DLOG(ERROR) << ENDPOINT << "Peer sent missing packet: "
                 << *incoming_ack.missing_packets.rbegin()
                 << " which is greater than largest observed: "
                 << incoming_ack.largest_observed;
     return false;
   }
 
   if (!incoming_ack.missing_packets.empty() &&
       *incoming_ack.missing_packets.begin() <
-      received_packet_manager_.least_packet_awaited_by_peer()) {
+      sent_packet_manager_.least_packet_awaited_by_peer()) {
     DLOG(ERROR) << ENDPOINT << "Peer sent missing packet: "
                 << *incoming_ack.missing_packets.begin()
                 << " which is smaller than least_packet_awaited_by_peer_: "
-                << received_packet_manager_.least_packet_awaited_by_peer();
+                << sent_packet_manager_.least_packet_awaited_by_peer();
     return false;
   }
 
   if (!sent_entropy_manager_.IsValidEntropy(
           incoming_ack.largest_observed,
           incoming_ack.missing_packets,
           incoming_ack.entropy_hash)) {
     DLOG(ERROR) << ENDPOINT << "Peer sent invalid entropy.";
     return false;
   }
@@ skipping 824 matching lines @@
   if (transmission_type == NOT_RETRANSMISSION) {
     time_of_last_sent_new_packet_ = now;
   }
   SetPingAlarm();
   DVLOG(1) << ENDPOINT << "time of last sent packet: "
            << now.ToDebuggingValue();
 
   // TODO(ianswett): Change the sequence number length and other packet creator
   // options by a more explicit API than setting a struct value directly.
   packet_generator_.UpdateSequenceNumberLength(
-      received_packet_manager_.least_packet_awaited_by_peer(),
+      sent_packet_manager_.least_packet_awaited_by_peer(),
       sent_packet_manager_.GetCongestionWindow());
 
   bool reset_retransmission_alarm =
       sent_packet_manager_.OnPacketSent(sequence_number, now, length,
                                         transmission_type, retransmittable);
 
   if (reset_retransmission_alarm || !retransmission_alarm_->IsSet()) {
     QuicTime retransmission_time = sent_packet_manager_.GetRetransmissionTime();
     retransmission_alarm_->Update(retransmission_time,
                                   QuicTime::Delta::FromMilliseconds(1));
@@ skipping 496 matching lines @@
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
   }
   DCHECK_EQ(already_in_batch_mode_,
             connection_->packet_generator_.InBatchMode());
 }
 
 }  // namespace net