Largest received -> largest observed.

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 <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 74 matching lines @@
       scheduler_(new QuicSendScheduler(clock_, kTCP)),
       packets_resent_since_last_ack_(0),
       connected_(true),
       received_truncated_ack_(false) {
   options()->max_num_packets = kMaxPacketsToSerializeAtOnce;
   helper_->SetConnection(this);
   helper_->SetTimeoutAlarm(timeout_);
   framer_.set_visitor(this);
   memset(&last_header_, 0, sizeof(last_header_));
   outgoing_ack_.sent_info.least_unacked = 0;
-  outgoing_ack_.received_info.largest_received = 0;
+  outgoing_ack_.received_info.largest_observed = 0;
 
   /*
   if (FLAGS_fake_packet_loss_percentage > 0) {
     int32 seed = RandomBase::WeakSeed32();
     LOG(INFO) << "Seeding packet loss with " << seed;
     random_.reset(new MTRandom(seed));
   }
   */
 }
 
@@ skipping 94 matching lines @@
     helper_->SetSendAlarm(delay);
   }
 }
 
 void QuicConnection::OnCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& feedback) {
   scheduler_->OnIncomingQuicCongestionFeedbackFrame(feedback);
 }
 
 bool QuicConnection::ValidateAckFrame(const QuicAckFrame& incoming_ack) {
-  if (incoming_ack.received_info.largest_received >
+  if (incoming_ack.received_info.largest_observed >
       packet_creator_.sequence_number()) {
-    DLOG(ERROR) << "Client acked unsent packet:"
-                << incoming_ack.received_info.largest_received << " vs "
+    DLOG(ERROR) << "Client observed unsent packet:"
+                << incoming_ack.received_info.largest_observed << " vs "
                 << packet_creator_.sequence_number();
     // We got an error for data we have not sent.  Error out.
     return false;
   }
 
   // We can't have too many unacked packets, or our ack frames go over
   // kMaxPacketSize.
   DCHECK_LE(incoming_ack.received_info.missing_packets.size(),
             kMaxUnackedPackets);
 
@@ skipping 15 matching lines @@
   }
 
   return true;
 }
 
 void QuicConnection::UpdatePacketInformationReceivedByPeer(
     const QuicAckFrame& incoming_ack) {
   QuicConnectionVisitorInterface::AckedPackets acked_packets;
 
   // Initialize the lowest unacked packet to the lower of the next outgoing
-  // sequence number and the largest received packed in the incoming ack.
+  // sequence number and the largest observed packet in the incoming ack.
   QuicPacketSequenceNumber lowest_unacked = min(
       packet_creator_.sequence_number() + 1,
-      incoming_ack.received_info.largest_received + 1);
+      incoming_ack.received_info.largest_observed + 1);
 
   int resent_packets = 0;
 
   // Go through the packets we have not received an ack for and see if this
   // incoming_ack shows they've been seen by the peer.
   UnackedPacketMap::iterator it = unacked_packets_.begin();
   while (it != unacked_packets_.end()) {
     if (!incoming_ack.received_info.IsAwaitingPacket(it->first)) {
       // Packet was acked, so remove it from our unacked packet list.
       DVLOG(1) << "Got an ack for " << it->first;
@@ skipping 16 matching lines @@
       // seen at the time of this ack being sent out.  See if it's our new
       // lowest unacked packet.
       DVLOG(1) << "still missing " << it->first;
       if (it->first < lowest_unacked) {
         lowest_unacked = it->first;
       }
 
       // Determine if this packet is being explicitly nacked and, if so, if it
       // is worth resending.
       QuicPacketSequenceNumber resend_number = 0;
-      if (it->first < incoming_ack.received_info.largest_received) {
+      if (it->first < incoming_ack.received_info.largest_observed) {
         // The peer got packets after this sequence number.  This is an explicit
         // nack.
         ++(it->second.number_nacks);
         if (it->second.number_nacks >= kNumberOfNacksBeforeResend &&
             resent_packets < kMaxResendPerAck) {
           resend_number = it->first;
         }
       }
 
       ++it;
@@ skipping 467 matching lines @@
            << " delta:" << delta.ToMicroseconds();
   if (delta >= timeout_) {
     SendConnectionClose(QUIC_CONNECTION_TIMED_OUT);
     return true;
   }
   helper_->SetTimeoutAlarm(timeout_.Subtract(delta));
   return false;
 }
 
 }  // namespace net