Fix a bug where the packet was put into unacked packets when it was

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 284 matching lines @@
 void QuicSentPacketManager::RetransmitUnackedPackets(
     RetransmissionType retransmission_type) {
   if (unacked_packets_.empty()) {
     return;
   }
 
   for (UnackedPacketMap::iterator unacked_it = unacked_packets_.begin();
        unacked_it != unacked_packets_.end(); ++unacked_it) {
     const RetransmittableFrames* frames =
         unacked_it->second.retransmittable_frames;
-    if (frames == NULL) {
-      continue;
-    }
     if (retransmission_type == ALL_PACKETS ||
-        frames->encryption_level() == ENCRYPTION_INITIAL) {
-      // TODO(satyamshekhar): Think about congestion control here.
-      // Specifically, about the retransmission count of packets being sent
-      // proactively to achieve 0 (minimal) RTT.
-      if (unacked_it->second.retransmittable_frames) {
+        (frames != NULL && frames->encryption_level() == ENCRYPTION_INITIAL)) {
+      if (frames) {
         OnPacketAbandoned(unacked_it);
         MarkForRetransmission(unacked_it->first, NACK_RETRANSMISSION);
       } else {
         DiscardUnackedPacket(unacked_it->first);
       }
     }
   }
 }
 
 void QuicSentPacketManager::MarkForRetransmission(
@@ skipping 217 matching lines @@
   return unacked_packets;
 }
 
 bool QuicSentPacketManager::OnPacketSent(
     QuicPacketSequenceNumber sequence_number,
     QuicTime sent_time,
     QuicByteCount bytes,
     TransmissionType transmission_type,
     HasRetransmittableData has_retransmittable_data) {
   DCHECK_LT(0u, sequence_number);
-  // In some edge cases, on some platforms (such as Windows), it is possible
-  // that we were write-blocked when we tried to send a packet, and then decided
-  // not to send the packet (such as when the encryption key changes, and we
-  // "discard" the unsent packet).  In that rare case, we may indeed
-  // asynchronously (later) send the packet, calling this method, but the
-  // sequence number may already be erased from unacked_packets_ map. In that
-  // case, we can just return false since the packet will not be tracked for
-  // retransmission.
-  if (!ContainsKey(unacked_packets_, sequence_number))
+  UnackedPacketMap::iterator it = unacked_packets_.find(sequence_number);
+  // In rare circumstances, the packet could be serialized, sent, and then acked
+  // before OnPacketSent is called.
+  if (it == unacked_packets_.end()) {
     return false;
-  DCHECK(!unacked_packets_[sequence_number].pending);
-  UnackedPacketMap::iterator it = unacked_packets_.find(sequence_number);
+  }
+  DCHECK(!it->second.pending);
 
   // Only track packets the send algorithm wants us to track.
   if (!send_algorithm_->OnPacketSent(sent_time, sequence_number, bytes,
                                      transmission_type,
                                      has_retransmittable_data)) {
     DCHECK(it->second.retransmittable_frames == NULL);
     unacked_packets_.erase(it);
     // Do not reset the retransmission timer, since the packet isn't tracked.
     return false;
   }
@@ skipping 422 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