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"
 
 using std::max;
 
 namespace net {
 
-#define ENDPOINT (is_server_ ? "Server: " : " Client: ")
-
 QuicUnackedPacketMap::TransmissionInfo::TransmissionInfo()
     : retransmittable_frames(NULL),
       sequence_number_length(PACKET_1BYTE_SEQUENCE_NUMBER),
       sent_time(QuicTime::Zero()),
       bytes_sent(0),
       nack_count(0),
       all_transmissions(NULL),
       pending(false) { }
 
 QuicUnackedPacketMap::TransmissionInfo::TransmissionInfo(
@@ skipping 18 matching lines @@
     : retransmittable_frames(retransmittable_frames),
       sequence_number_length(sequence_number_length),
       sent_time(QuicTime::Zero()),
       bytes_sent(0),
       nack_count(0),
       all_transmissions(all_transmissions),
       pending(false) {
   all_transmissions->insert(sequence_number);
 }
 
-QuicUnackedPacketMap::QuicUnackedPacketMap(bool is_server)
+QuicUnackedPacketMap::QuicUnackedPacketMap()
     : largest_sent_packet_(0),
       bytes_in_flight_(0),
-      is_server_(is_server) {
+      pending_crypto_packet_count_(0) {
 }
 
 QuicUnackedPacketMap::~QuicUnackedPacketMap() {
   for (UnackedPacketMap::iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it) {
     delete it->second.retransmittable_frames;
     // Only delete all_transmissions once, for the newest packet.
     if (it->first == *it->second.all_transmissions->rbegin()) {
       delete it->second.all_transmissions;
     }
@@ skipping 10 matching lines @@
     LOG_IF(DFATAL, is_old_packet) << "Old packet serialized: "
                                   << serialized_packet.sequence_number
                                   << " vs: "
                                   << unacked_packets_.rbegin()->first;
   }
 
   unacked_packets_[serialized_packet.sequence_number] =
       TransmissionInfo(serialized_packet.retransmittable_frames,
                        serialized_packet.sequence_number,
                        serialized_packet.sequence_number_length);
+  if (serialized_packet.retransmittable_frames != NULL &&
+      serialized_packet.retransmittable_frames->HasCryptoHandshake()
+          == IS_HANDSHAKE) {
+    ++pending_crypto_packet_count_;
+  }
 }
 
 void QuicUnackedPacketMap::OnRetransmittedPacket(
     QuicPacketSequenceNumber old_sequence_number,
     QuicPacketSequenceNumber new_sequence_number) {
   DCHECK(ContainsKey(unacked_packets_, old_sequence_number));
   DCHECK(unacked_packets_.empty() ||
          unacked_packets_.rbegin()->first < new_sequence_number);
 
   // TODO(ianswett): Discard and lose the packet lazily instead of immediately.
@@ skipping 60 matching lines @@
   if (it == unacked_packets_.end()) {
     LOG(DFATAL) << "packet is not unacked: " << sequence_number;
     return;
   }
   const TransmissionInfo& transmission_info = it->second;
   transmission_info.all_transmissions->erase(sequence_number);
   if (transmission_info.all_transmissions->empty()) {
     delete transmission_info.all_transmissions;
   }
   if (transmission_info.retransmittable_frames != NULL) {
+    if (transmission_info.retransmittable_frames->HasCryptoHandshake()
+            == IS_HANDSHAKE) {
+      --pending_crypto_packet_count_;
+    }
     delete transmission_info.retransmittable_frames;
   }
   unacked_packets_.erase(it);
 }
 
 void QuicUnackedPacketMap::NeuterPacket(
     QuicPacketSequenceNumber sequence_number) {
   UnackedPacketMap::iterator it = unacked_packets_.find(sequence_number);
   if (it == unacked_packets_.end()) {
     LOG(DFATAL) << "packet is not unacked: " << sequence_number;
@@ skipping 95 matching lines @@
     if (it->second.pending) {
       ++num_pending;
     }
     if (num_pending > 1) {
       return true;
     }
   }
   return false;
 }
 
+bool QuicUnackedPacketMap::HasPendingCryptoPackets() const {
+  return pending_crypto_packet_count_ > 0;
+}
+
 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;
 }
 
@@ skipping 40 matching lines @@
   DCHECK(!it->second.pending);
 
   largest_sent_packet_ = max(sequence_number, largest_sent_packet_);
   bytes_in_flight_ += bytes_sent;
   it->second.sent_time = sent_time;
   it->second.bytes_sent = bytes_sent;
   it->second.pending = true;
 }
 
 }  // namespace net