Land Recent QUIC changes.

net/quic/quic_connection.cc

 // Copyright (c) 2012 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_connection.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 172 matching lines @@
   /*
   if (FLAGS_fake_packet_loss_percentage > 0) {
     int32 seed = RandomBase::WeakSeed32();
     LOG(INFO) << ENDPOINT << "Seeding packet loss with " << seed;
     random_.reset(new MTRandom(seed));
   }
   */
 }
 
 QuicConnection::~QuicConnection() {
+  STLDeleteElements(&ack_notifiers_);
   STLDeleteElements(&undecryptable_packets_);
   STLDeleteValues(&unacked_packets_);
   STLDeleteValues(&group_map_);
   for (QueuedPacketList::iterator it = queued_packets_.begin();
        it != queued_packets_.end(); ++it) {
     delete it->packet;
   }
 }
 
 bool QuicConnection::SelectMutualVersion(
@@ skipping 246 matching lines @@
   CloseFecGroupsBefore(incoming_ack.sent_info.least_unacked + 1);
 
   sent_entropy_manager_.ClearEntropyBefore(
       received_packet_manager_.least_packet_awaited_by_peer() - 1);
 
   SequenceNumberSet acked_packets;
   HandleAckForSentPackets(incoming_ack, &acked_packets);
   HandleAckForSentFecPackets(incoming_ack, &acked_packets);
   if (acked_packets.size() > 0) {
     visitor_->OnAck(acked_packets);
+
+    // Inform all the registered AckNotifiers of the new ACKs.
+    // TODO(rjshade): Make this more efficient by maintaining a mapping of
+    //                <sequence number, set<AckNotifierList>> so that OnAck
+    //                is only called on AckNotifiers that care about the
+    //                packets being ACKed.
+    AckNotifierList::iterator it = ack_notifiers_.begin();
+    while (it != ack_notifiers_.end()) {
+      if ((*it)->OnAck(acked_packets)) {
+        // The QuicAckNotifier has seen all the ACKs it was interested in, and
+        // has triggered its callback. No more use for it.
+        delete *it;
+        it = ack_notifiers_.erase(it);
+      } else {
+        ++it;
+      }
+    }
   }
   congestion_manager_.OnIncomingAckFrame(incoming_ack,
                                          time_of_last_received_packet_);
 }
 
 bool QuicConnection::OnCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& feedback) {
   DCHECK(connected_);
   if (debug_visitor_) {
     debug_visitor_->OnCongestionFeedbackFrame(feedback);
@@ skipping 345 matching lines @@
   }
   QuicConsumedData consumed_data =
       packet_generator_.ConsumeData(id, data, offset, fin);
   if (crypto_frame_while_batch_mode) {
     // Restore batch mode.
     packet_generator_.StartBatchOperations();
   }
   return consumed_data;
 }
 
+QuicConsumedData QuicConnection::SendStreamDataAndNotifyWhenAcked(
+    QuicStreamId id,
+    StringPiece data,
+    QuicStreamOffset offset,
+    bool fin,
+    QuicAckNotifier::DelegateInterface* delegate) {
+  // This notifier will be deleted in ProcessAckFrame once it has seen ACKs for
+  // all the consumed data (or below if no data was consumed).
+  QuicAckNotifier* notifier = new QuicAckNotifier(delegate);
+  QuicConsumedData consumed_data =
+      packet_generator_.ConsumeData(id, data, offset, fin, notifier);
+
+  if (consumed_data.bytes_consumed > 0) {
+    // If some data was consumed, then the delegate should be registered for
+    // notification when the data is ACKed.
+    ack_notifiers_.push_back(notifier);
+  } else {
+    // No data was consumed, delete the notifier.
+    delete notifier;
+  }
+
+  return consumed_data;
+}
+
 void QuicConnection::SendRstStream(QuicStreamId id,
                                    QuicRstStreamErrorCode error) {
   LOG(INFO) << "Sending RST_STREAM: " << id << " code: " << error;
   packet_generator_.AddControlFrame(
       QuicFrame(new QuicRstStreamFrame(id, error)));
 }
 
 const QuicConnectionStats& QuicConnection::GetStats() {
   // Update rtt and estimated bandwidth.
   stats_.rtt = congestion_manager_.SmoothedRtt().ToMicroseconds();
@@ skipping 221 matching lines @@
       packet_creator_.ReserializeAllFrames(unacked->frames(),
                                            original_sequence_number_length);
   RetransmissionInfo retransmission_info(
       serialized_packet.sequence_number,
       serialized_packet.sequence_number_length);
   retransmission_info.number_retransmissions =
       retransmission_it->second.number_retransmissions + 1;
   // Remove info with old sequence number.
   unacked_packets_.erase(unacked_it);
   retransmission_map_.erase(retransmission_it);
-  DVLOG(1) << ENDPOINT << "Retransmitting unacked packet " << sequence_number
-           << " as " << serialized_packet.sequence_number;
+  DLOG(INFO) << ENDPOINT << "Retransmitting unacked packet " << sequence_number
+             << " as " << serialized_packet.sequence_number;
   DCHECK(unacked_packets_.empty() ||
          unacked_packets_.rbegin()->first < serialized_packet.sequence_number);
   unacked_packets_.insert(make_pair(serialized_packet.sequence_number,
                                     unacked));
   retransmission_map_.insert(make_pair(serialized_packet.sequence_number,
                                        retransmission_info));
+
+  // A notifier may be waiting to hear about ACKs for the original sequence
+  // number. Inform them that the sequence number has changed.
+  for (AckNotifierList::iterator notifier_it = ack_notifiers_.begin();
+       notifier_it != ack_notifiers_.end(); ++notifier_it) {
+    (*notifier_it)->UpdateSequenceNumber(sequence_number,
+                                         serialized_packet.sequence_number);
+  }
+
   if (debug_visitor_) {
     debug_visitor_->OnPacketRetransmitted(sequence_number,
                                           serialized_packet.sequence_number);
   }
   SendOrQueuePacket(unacked->encryption_level(),
                     serialized_packet.sequence_number,
                     serialized_packet.packet,
                     serialized_packet.entropy_hash,
                     HAS_RETRANSMITTABLE_DATA);
 }
@@ skipping 646 matching lines @@
       timeout = connection_timeout;
     }
   }
 
   timeout_alarm_->Cancel();
   timeout_alarm_->Set(clock_->ApproximateNow().Add(timeout));
   return false;
 }
 
 }  // namespace net