Landing Recent QUIC changes until 2016-03-15 16:26 UTC

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 <limits>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/linked_hash_map.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_connection_stats.h"
+#include "net/quic/quic_flags.h"
 
 using std::max;
 using std::min;
 using std::numeric_limits;
 
 namespace net {
 
 namespace {
 
 // The maximum number of packets to ack immediately after a missing packet for
@@ skipping 112 matching lines @@
 }
 
 QuicReceivedPacketManager::~QuicReceivedPacketManager() {}
 
 void QuicReceivedPacketManager::RecordPacketReceived(
     QuicByteCount bytes,
     const QuicPacketHeader& header,
     QuicTime receipt_time) {
   QuicPacketNumber packet_number = header.packet_number;
   DCHECK(IsAwaitingPacket(packet_number));
+  if (FLAGS_quic_dont_copy_acks && !ack_frame_updated_) {
+    ack_frame_.received_packet_times.clear();
+  }
   ack_frame_updated_ = true;
-
   // Adds the range of packet numbers from max(largest observed + 1, least
   // awaiting ack) up to packet_number not including packet_number.
   ack_frame_.missing_packets.Add(
       max(ack_frame_.largest_observed + 1, peer_least_packet_awaiting_ack_),
       packet_number);
 
   if (ack_frame_.largest_observed > packet_number) {
     // We've gotten one of the out of order packets - remove it from our
     // "missing packets" list.
     DVLOG(1) << "Removing " << packet_number << " from missing list";
@@ skipping 37 matching lines @@
   // to express.
   bool operator()(const std::pair<QuicPacketNumber, QuicTime>& p) const {
     return largest_observed_ - p.first >= numeric_limits<uint8_t>::max();
   }
 };
 }  // namespace
 
 void QuicReceivedPacketManager::UpdateReceivedPacketInfo(
     QuicAckFrame* ack_frame,
     QuicTime approximate_now) {
+  DCHECK(!FLAGS_quic_dont_copy_acks);
   ack_frame_updated_ = false;
   *ack_frame = ack_frame_;
   ack_frame->entropy_hash = EntropyHash(ack_frame_.largest_observed);
 
   if (time_largest_observed_ == QuicTime::Zero()) {
     // We have received no packets.
     ack_frame->ack_delay_time = QuicTime::Delta::Infinite();
     return;
   }
 
   // Ensure the delta is zero if approximate now is "in the past".
   ack_frame->ack_delay_time =
       approximate_now < time_largest_observed_
           ? QuicTime::Delta::Zero()
           : approximate_now.Subtract(time_largest_observed_);
 
   // Clear all packet times if any are too far from largest observed.
   // It's expected this is extremely rare.
   for (PacketTimeVector::iterator it = ack_frame_.received_packet_times.begin();
        it != ack_frame_.received_packet_times.end();) {
     if (ack_frame_.largest_observed - it->first >=
         numeric_limits<uint8_t>::max()) {
       it = ack_frame_.received_packet_times.erase(it);
     } else {
       ++it;
     }
   }
 
-  // TODO(ianswett): Instead of transferring all the information over,
-  // consider giving the QuicPacketGenerator a reference to this ack frame
-  // and clear it afterwards.
   ack_frame->received_packet_times.clear();
   ack_frame->received_packet_times.swap(ack_frame_.received_packet_times);
 }
 
+const QuicFrame QuicReceivedPacketManager::GetUpdatedAckFrame(
+    QuicTime approximate_now) {
+  ack_frame_updated_ = false;
+  ack_frame_.entropy_hash = EntropyHash(ack_frame_.largest_observed);
+
+  if (time_largest_observed_ == QuicTime::Zero()) {
+    // We have received no packets.
+    ack_frame_.ack_delay_time = QuicTime::Delta::Infinite();
+  } else {
+    // Ensure the delta is zero if approximate now is "in the past".
+    ack_frame_.ack_delay_time =
+        approximate_now < time_largest_observed_
+            ? QuicTime::Delta::Zero()
+            : approximate_now.Subtract(time_largest_observed_);
+  }
+
+  // Clear all packet times if any are too far from largest observed.
+  // It's expected this is extremely rare.
+  for (PacketTimeVector::iterator it = ack_frame_.received_packet_times.begin();
+       it != ack_frame_.received_packet_times.end();) {
+    if (ack_frame_.largest_observed - it->first >=
+        numeric_limits<uint8_t>::max()) {
+      it = ack_frame_.received_packet_times.erase(it);
+    } else {
+      ++it;
+    }
+  }
+
+  return QuicFrame(&ack_frame_);
+}
+
 QuicPacketEntropyHash QuicReceivedPacketManager::EntropyHash(
     QuicPacketNumber packet_number) const {
   return entropy_tracker_.EntropyHash(packet_number);
 }
 
 bool QuicReceivedPacketManager::DontWaitForPacketsBefore(
     QuicPacketNumber least_unacked) {
   return ack_frame_.missing_packets.RemoveUpTo(least_unacked);
 }
 
@@ skipping 31 matching lines @@
 
 size_t QuicReceivedPacketManager::NumTrackedPackets() const {
   return entropy_tracker_.size();
 }
 
 bool QuicReceivedPacketManager::ack_frame_updated() const {
   return ack_frame_updated_;
 }
 
 }  // namespace net