Land Recent QUIC Changes.

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 "net/base/linked_hash_map.h"
 
 using std::make_pair;
 using std::max;
 using std::min;
 
 namespace net {
 
 QuicReceivedPacketManager::QuicReceivedPacketManager()
     : packets_entropy_hash_(0),
       largest_sequence_number_(0),
       peer_largest_observed_packet_(0),
       least_packet_awaited_by_peer_(1),
       peer_least_packet_awaiting_ack_(0),
       time_largest_observed_(QuicTime::Zero()) {
   received_info_.largest_observed = 0;
   received_info_.entropy_hash = 0;
 }
 
 QuicReceivedPacketManager::~QuicReceivedPacketManager() {}
 
 void QuicReceivedPacketManager::RecordPacketReceived(
-    const QuicPacketHeader& header, QuicTime receipt_time) {
+    const QuicPacketHeader& header,
+    QuicTime receipt_time) {
   QuicPacketSequenceNumber sequence_number = header.packet_sequence_number;
   DCHECK(IsAwaitingPacket(sequence_number));
 
   InsertMissingPacketsBetween(
       &received_info_,
       max(received_info_.largest_observed + 1, peer_least_packet_awaiting_ack_),
       header.packet_sequence_number);
 
   if (received_info_.largest_observed > header.packet_sequence_number) {
     // We've gotten one of the out of order packets - remove it from our
     // "missing packets" list.
     DVLOG(1) << "Removing " << sequence_number << " from missing list";
     received_info_.missing_packets.erase(sequence_number);
   }
   if (header.packet_sequence_number > received_info_.largest_observed) {
     received_info_.largest_observed = header.packet_sequence_number;
     time_largest_observed_ = receipt_time;
   }
   RecordPacketEntropyHash(sequence_number, header.entropy_hash);
 }
 
 bool QuicReceivedPacketManager::IsAwaitingPacket(
     QuicPacketSequenceNumber sequence_number) {
   return ::net::IsAwaitingPacket(received_info_, sequence_number);
 }
 
 void QuicReceivedPacketManager::UpdateReceivedPacketInfo(
-    ReceivedPacketInfo* received_info, QuicTime approximate_now) {
+    ReceivedPacketInfo* received_info,
+    QuicTime approximate_now) {
   *received_info = received_info_;
   received_info->entropy_hash = EntropyHash(received_info_.largest_observed);
+
   if (time_largest_observed_ == QuicTime::Zero()) {
-    // We have not received any new higher sequence numbers since we sent our
-    // last ACK.
+    // We have received no packets.
     received_info->delta_time_largest_observed = QuicTime::Delta::Infinite();
-  } else {
-    received_info->delta_time_largest_observed =
-        approximate_now.Subtract(time_largest_observed_);
+    return;
+  }
 
-    time_largest_observed_ = QuicTime::Zero();
+  if (approximate_now < time_largest_observed_) {
+    // Approximate now may well be "in the past".
+    received_info->delta_time_largest_observed = QuicTime::Delta::Zero();
+    return;
   }
+
+  received_info->delta_time_largest_observed =
+      approximate_now.Subtract(time_largest_observed_);
 }
 
 void QuicReceivedPacketManager::RecordPacketEntropyHash(
     QuicPacketSequenceNumber sequence_number,
     QuicPacketEntropyHash entropy_hash) {
   if (sequence_number < largest_sequence_number_) {
     DLOG(INFO) << "Ignoring received packet entropy for sequence_number:"
                << sequence_number << " less than largest_peer_sequence_number:"
                << largest_sequence_number_;
     return;
@@ skipping 104 matching lines @@
   DCHECK(received_info_.missing_packets.empty() ||
          *received_info_.missing_packets.begin() >=
              peer_least_packet_awaiting_ack_);
 }
 
 size_t QuicReceivedPacketManager::GetNumMissingPackets() {
   return received_info_.missing_packets.size();
 }
 
 }  // namespace net