Land Recent QUIC Changes.

net/quic/quic_unacked_packet_map.cc

 // Copyright 2014 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_unacked_packet_map.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/quic/quic_connection_stats.h"
 #include "net/quic/quic_utils_chromium.h"
@@ skipping 148 matching lines @@
     if (transmission_info->retransmittable_frames->HasCryptoHandshake()
             == IS_HANDSHAKE) {
       --pending_crypto_packet_count_;
     }
     delete transmission_info->retransmittable_frames;
     transmission_info->retransmittable_frames = NULL;
   }
 }
 
 // static
-bool QuicUnackedPacketMap::IsSentAndNotPending(
+bool QuicUnackedPacketMap::IsForRttOnly(
     const TransmissionInfo& transmission_info) {
   return !transmission_info.pending &&
-      transmission_info.sent_time != QuicTime::Zero() &&
-      transmission_info.bytes_sent == 0;
+      transmission_info.retransmittable_frames == NULL &&
+      transmission_info.all_transmissions->size() == 1;
 }
 
 bool QuicUnackedPacketMap::IsUnacked(
     QuicPacketSequenceNumber sequence_number) const {
   return ContainsKey(unacked_packets_, sequence_number);
 }
 
 void QuicUnackedPacketMap::SetNotPending(
     QuicPacketSequenceNumber sequence_number) {
   UnackedPacketMap::iterator it = unacked_packets_.find(sequence_number);
   if (it == unacked_packets_.end()) {
     LOG(DFATAL) << "SetNotPending called for packet that is not unacked: "
                 << sequence_number;
     return;
   }
   if (it->second.pending) {
     LOG_IF(DFATAL, bytes_in_flight_ < it->second.bytes_sent);
     bytes_in_flight_ -= it->second.bytes_sent;
     it->second.pending = false;
   }
 }
 
 bool QuicUnackedPacketMap::HasUnackedPackets() const {
   return !unacked_packets_.empty();
 }
 
 bool QuicUnackedPacketMap::HasPendingPackets() const {
-  for (UnackedPacketMap::const_reverse_iterator it =
-           unacked_packets_.rbegin(); it != unacked_packets_.rend(); ++it) {
-    if (it->second.pending) {
-      return true;
-    }
-  }
-  return false;
+  return bytes_in_flight_ > 0;
 }
 
 const TransmissionInfo& QuicUnackedPacketMap::GetTransmissionInfo(
     QuicPacketSequenceNumber sequence_number) const {
   return unacked_packets_.find(sequence_number)->second;
 }
 
 QuicTime QuicUnackedPacketMap::GetLastPacketSentTime() const {
   UnackedPacketMap::const_reverse_iterator it = unacked_packets_.rbegin();
   while (it != unacked_packets_.rend()) {
@@ skipping 46 matching lines @@
 bool QuicUnackedPacketMap::HasUnackedRetransmittableFrames() const {
   for (UnackedPacketMap::const_reverse_iterator it =
            unacked_packets_.rbegin(); it != unacked_packets_.rend(); ++it) {
     if (it->second.pending && it->second.retransmittable_frames) {
       return true;
     }
   }
   return false;
 }
 
-size_t QuicUnackedPacketMap::GetNumRetransmittablePackets() const {
-  size_t num_unacked_packets = 0;
-  for (UnackedPacketMap::const_iterator it = unacked_packets_.begin();
-       it != unacked_packets_.end(); ++it) {
-    if (it->second.retransmittable_frames != NULL) {
-      ++num_unacked_packets;
-    }
-  }
-  return num_unacked_packets;
-}
-
 QuicPacketSequenceNumber
 QuicUnackedPacketMap::GetLeastUnackedSentPacket() const {
   if (unacked_packets_.empty()) {
     // If there are no unacked packets, return 0.
     return 0;
   }
 
   return unacked_packets_.begin()->first;
 }
 
@@ skipping 13 matching lines @@
   largest_sent_packet_ = max(sequence_number, largest_sent_packet_);
   it->second.sent_time = sent_time;
   if (set_pending) {
     bytes_in_flight_ += bytes_sent;
     it->second.bytes_sent = bytes_sent;
     it->second.pending = true;
   }
 }
 
 }  // namespace net