Remove an impossible check in QuicConnection for when a packet is

net/quic/quic_sent_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_sent_packet_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/quic/congestion_control/pacing_sender.h"
 #include "net/quic/quic_ack_notifier_manager.h"
@@ skipping 155 matching lines @@
       transmission_info->previous_transmissions;
   if (previous_transmissions == NULL) {
     // This is the first retransmission of this packet, so create a new entry.
     previous_transmissions = new SequenceNumberSet;
     transmission_info->previous_transmissions = previous_transmissions;
     previous_transmissions->insert(old_sequence_number);
   }
   previous_transmissions->insert(new_sequence_number);
   unacked_packets_[new_sequence_number].previous_transmissions =
       previous_transmissions;
-
-  DCHECK(HasRetransmittableFrames(new_sequence_number));
 }
 
 bool QuicSentPacketManager::OnIncomingAck(
     const ReceivedPacketInfo& received_info, QuicTime ack_receive_time) {
   // We rely on delta_time_largest_observed to compute an RTT estimate, so
   // we only update rtt when the largest observed gets acked.
   bool largest_observed_acked =
       ContainsKey(unacked_packets_, received_info.largest_observed);
   MaybeUpdateRTT(received_info, ack_receive_time);
   HandleAckForSentPackets(received_info);
@@ skipping 70 matching lines @@
         --num_to_clear;
         continue;
       }
       break;
     }
     QuicPacketSequenceNumber newest_transmission =
         *previous_transmissions->rbegin();
     if (sequence_number == newest_transmission) {
       break;
     }
+    if (it->second.pending) {
+      break;
+    }
 
     DCHECK(it->second.retransmittable_frames == NULL);
     previous_transmissions->erase(sequence_number);
     if (previous_transmissions->size() == 1) {
       unacked_packets_[newest_transmission].previous_transmissions = NULL;
       delete previous_transmissions;
     }
-    DCHECK(!it->second.pending);
     unacked_packets_.erase(it++);
     --num_to_clear;
   }
 }
 
 bool QuicSentPacketManager::HasRetransmittableFrames(
     QuicPacketSequenceNumber sequence_number) const {
   const TransmissionInfo* transmission_info =
       FindOrNull(unacked_packets_, sequence_number);
   if (transmission_info == NULL) {
@@ skipping 21 matching lines @@
       } else {
         DiscardUnackedPacket(unacked_it->first);
       }
     }
   }
 }
 
 void QuicSentPacketManager::MarkForRetransmission(
     QuicPacketSequenceNumber sequence_number,
     TransmissionType transmission_type) {
-  DCHECK(ContainsKey(unacked_packets_, sequence_number));
-  DCHECK(HasRetransmittableFrames(sequence_number));
+  TransmissionInfo* transmission_info =
+      FindOrNull(unacked_packets_, sequence_number);
+  if (transmission_info == NULL) {
+    LOG(DFATAL) << "transmission_info == NULL";
+  } else {
+    if (transmission_info->retransmittable_frames == NULL) {
+      LOG(DFATAL) << "transmission_info->retransmittable_frames == NULL";
+    }
+    if (transmission_info->sent_time == QuicTime::Zero()) {
+      LOG(DFATAL) << "transmission_info->sent_time == QuicTime::Zero()";
+    }
+  }
   // TODO(ianswett): Currently the RTO can fire while there are pending NACK
   // retransmissions for the same data, which is not ideal.
   if (ContainsKey(pending_retransmissions_, sequence_number)) {
     return;
   }
 
   pending_retransmissions_[sequence_number] = transmission_type;
 }
 
 bool QuicSentPacketManager::HasPendingRetransmissions() const {
   return !pending_retransmissions_.empty();
 }
 
 QuicSentPacketManager::PendingRetransmission
     QuicSentPacketManager::NextPendingRetransmission() {
   DCHECK(!pending_retransmissions_.empty());
   QuicPacketSequenceNumber sequence_number =
       pending_retransmissions_.begin()->first;
   DCHECK(ContainsKey(unacked_packets_, sequence_number));
   const TransmissionInfo& transmission_info =
       FindOrDie(unacked_packets_, sequence_number);
   DCHECK(transmission_info.retransmittable_frames);
 
   return PendingRetransmission(sequence_number,
                                pending_retransmissions_.begin()->second,
                                *transmission_info.retransmittable_frames,
                                transmission_info.sequence_number_length);
 }
 
-bool QuicSentPacketManager::IsPreviousTransmission(
-    QuicPacketSequenceNumber sequence_number) const {
-  DCHECK(ContainsKey(unacked_packets_, sequence_number));
-
-  UnackedPacketMap::const_iterator unacked_it =
-      unacked_packets_.find(sequence_number);
-  if (unacked_it == unacked_packets_.end()) {
-    return false;
-  }
-  const TransmissionInfo* transmission_info = &unacked_it->second;
-  if (transmission_info->previous_transmissions == NULL) {
-    return false;
-  }
-
-  SequenceNumberSet* previous_transmissions =
-      transmission_info->previous_transmissions;
-  DCHECK(!previous_transmissions->empty());
-  return *previous_transmissions->rbegin() != sequence_number;
-}
-
 // static
 bool QuicSentPacketManager::HasCryptoHandshake(
     const TransmissionInfo& transmission_info) {
   if (transmission_info.retransmittable_frames == NULL) {
     return false;
   }
   return transmission_info.retransmittable_frames->HasCryptoHandshake() ==
       IS_HANDSHAKE;
 }
 
@@ skipping 123 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 size_t QuicSentPacketManager::GetNumRetransmittablePackets() const {
   size_t num_unacked_packets = 0;
   for (UnackedPacketMap::const_iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it) {
-    QuicPacketSequenceNumber sequence_number = it->first;
-    if (HasRetransmittableFrames(sequence_number)) {
+    if (it->second.retransmittable_frames != NULL) {
       ++num_unacked_packets;
     }
   }
   return num_unacked_packets;
 }
 
 QuicPacketSequenceNumber
 QuicSentPacketManager::GetLeastUnackedSentPacket() const {
   if (unacked_packets_.empty()) {
     // If there are no unacked packets, set the least unacked packet to
@@ skipping 456 matching lines @@
   }
   previous_transmissions->erase(sequence_number);
   if (previous_transmissions->size() == 1) {
     QuicPacketSequenceNumber current = *previous_transmissions->begin();
     unacked_packets_[current].previous_transmissions = NULL;
     delete previous_transmissions;
   }
 }
 
 }  // namespace net