Largest received -> largest observed.

net/quic/quic_framer.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_framer.h"
 
 #include "base/hash_tables.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_data_reader.h"
@@ skipping 407 matching lines @@
     return false;
   }
   if (!ProcessReceivedInfo(&frame->received_info)) {
     return false;
   }
   visitor_->OnAckFrame(*frame);
   return true;
 }
 
 bool QuicFramer::ProcessReceivedInfo(ReceivedPacketInfo* received_info) {
-  if (!reader_->ReadUInt48(&received_info->largest_received)) {
-     set_detailed_error("Unable to read largest received.");
+  if (!reader_->ReadUInt48(&received_info->largest_observed)) {
+     set_detailed_error("Unable to read largest observed.");
      return false;
   }
 
   uint8 num_missing_packets;
   if (!reader_->ReadBytes(&num_missing_packets, 1)) {
     set_detailed_error("Unable to read num missing packets.");
     return false;
   }
 
   for (int i = 0; i < num_missing_packets; ++i) {
@@ skipping 224 matching lines @@
       len += 1;  // fin
       len += 8;  // offset
       len += 2;  // space for the 16 bit length
       len += frame.stream_frame->data.size();
       break;
     case PDU_FRAME:
       DLOG(INFO) << "PDU_FRAME not yet supported";
       break;  // Need to support this eventually :>
     case ACK_FRAME: {
       const QuicAckFrame& ack = *frame.ack_frame;
-      len += 6;  // largest received packet sequence number
+      len += 6;  // largest observed packet sequence number
       len += 1;  // num missing packets
       len += 6 * ack.received_info.missing_packets.size();
       len += 6;  // least packet sequence number awaiting an ack
       break;
     }
     case CONGESTION_FEEDBACK_FRAME: {
       const QuicCongestionFeedbackFrame& congestion_feedback =
           *frame.congestion_feedback_frame;
       len += 1;  // congestion feedback type
 
@@ skipping 61 matching lines @@
   if (!writer->WriteUInt16(frame.data.size())) {
     return false;
   }
   if (!writer->WriteBytes(frame.data.data(),
                            frame.data.size())) {
     return false;
   }
   return true;
 }
 
-// TODO(alyssar): revisit the complexity here to rch's satisfaction
-QuicPacketSequenceNumber QuicFramer::CalculateLargestReceived(
+QuicPacketSequenceNumber QuicFramer::CalculateLargestObserved(
     const SequenceSet& missing_packets,
     SequenceSet::const_iterator largest_written) {
   SequenceSet::const_iterator it = largest_written;
   QuicPacketSequenceNumber previous_missing = *it;
   ++it;
 
   // See if the next thing is a gap in the missing packets: if it's a
   // non-missing packet we can return it.
   if (it != missing_packets.end() && previous_missing + 1 != *it) {
       return *it - 1;
     }
 
-  // If we've hit the end of the list, and we're not missing any packets, try
-  // finding a gap between the largest written and the beginning of the set.
-  it = largest_written++;
-  previous_missing = *it;
-  do {
-    --it;
-    if (previous_missing - 1 != *it) {
-      return previous_missing - 1;
-    }
-    previous_missing = *it;
-  } while (it != missing_packets.begin());
-
-  // The missing packets are entirely contiguous.  Return the value of the first
-  // missing packet - 1, as that must have been seen.
-  return  *missing_packets.begin() - 1;
+  // Otherwise return the largest missing packet, as indirectly observed.
+  return *largest_written;
 }
 
 // TODO(ianswett): Use varints or another more compact approach for all deltas.
 bool QuicFramer::AppendAckFramePayload(
     const QuicAckFrame& frame,
     QuicDataWriter* writer) {
   if (!writer->WriteUInt48(frame.sent_info.least_unacked)) {
     return false;
   }
 
-  size_t largest_received_offset = writer->length();
-  if (!writer->WriteUInt48(frame.received_info.largest_received)) {
+  size_t largest_observed_offset = writer->length();
+  if (!writer->WriteUInt48(frame.received_info.largest_observed)) {
     return false;
   }
 
   // We don't check for overflowing uint8 here, because we only can fit 192 acks
   // per packet, so if we overflow we will be truncated.
   uint8 num_missing_packets = frame.received_info.missing_packets.size();
   size_t num_missing_packets_offset = writer->length();
   if (!writer->WriteBytes(&num_missing_packets, 1)) {
     return false;
   }
 
   SequenceSet::const_iterator it = frame.received_info.missing_packets.begin();
   int num_missing_packets_written = 0;
   for (; it != frame.received_info.missing_packets.end(); ++it) {
     if (!writer->WriteUInt48(*it)) {
-      // We are truncating.  Overwrite largest_received.
-      QuicPacketSequenceNumber largest_received =
-          CalculateLargestReceived(frame.received_info.missing_packets, --it);
-      writer->WriteUInt48ToOffset(largest_received, largest_received_offset);
+      // We are truncating.  Overwrite largest_observed.
+      QuicPacketSequenceNumber largest_observed =
+          CalculateLargestObserved(frame.received_info.missing_packets, --it);
+      writer->WriteUInt48ToOffset(largest_observed, largest_observed_offset);
       writer->WriteUInt8ToOffset(num_missing_packets_written,
                                  num_missing_packets_offset);
       return true;
     }
     ++num_missing_packets_written;
     DCHECK_GE(numeric_limits<uint8>::max(), num_missing_packets_written);
   }
 
   return true;
 }
@@ skipping 122 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DLOG(INFO) << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net