Landing Recent QUIC changes until 03:18 AM, May 28, UTC

net/quic/core/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/core/quic_unacked_packet_map.h"
 
 #include "net/quic/core/quic_connection_stats.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
 
 namespace net {
 
 QuicUnackedPacketMap::QuicUnackedPacketMap()
     : largest_sent_packet_(0),
       largest_sent_retransmittable_packet_(0),
       largest_observed_(0),
       least_unacked_(1),
       bytes_in_flight_(0),
-      pending_crypto_packet_count_(0) {}
+      pending_crypto_packet_count_(0),
+      stream_notifier_(nullptr) {}
 
 QuicUnackedPacketMap::~QuicUnackedPacketMap() {
   for (QuicTransmissionInfo& transmission_info : unacked_packets_) {
     DeleteFrames(&(transmission_info.retransmittable_frames));
   }
 }
 
 void QuicUnackedPacketMap::AddSentPacket(SerializedPacket* packet,
                                          QuicPacketNumber old_packet_number,
                                          TransmissionType transmission_type,
@@ skipping 65 matching lines @@
     QUIC_BUG << "Old QuicTransmissionInfo never existed for :"
              << old_packet_number << " largest_sent:" << largest_sent_packet_;
     return;
   }
   DCHECK_GE(new_packet_number, least_unacked_ + unacked_packets_.size());
   DCHECK_NE(NOT_RETRANSMISSION, transmission_type);
 
   QuicTransmissionInfo* transmission_info =
       &unacked_packets_.at(old_packet_number - least_unacked_);
   QuicFrames* frames = &transmission_info->retransmittable_frames;
+  if (stream_notifier_ != nullptr) {
+    for (const QuicFrame& frame : *frames) {
+      if (frame.type == STREAM_FRAME) {
+        stream_notifier_->OnStreamFrameRetransmitted(*frame.stream_frame);
+      }
+    }
+  }
   for (AckListenerWrapper& wrapper : transmission_info->ack_listeners) {
     wrapper.ack_listener->OnPacketRetransmitted(wrapper.length);
   }
 
   // Swap the frames and preserve num_padding_bytes and has_crypto_handshake.
   frames->swap(info->retransmittable_frames);
   info->has_crypto_handshake = transmission_info->has_crypto_handshake;
   transmission_info->has_crypto_handshake = false;
   info->num_padding_bytes = transmission_info->num_padding_bytes;
 
@@ skipping 228 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 QuicPacketNumber QuicUnackedPacketMap::GetLeastUnacked() const {
   return least_unacked_;
 }
 
+void QuicUnackedPacketMap::SetStreamNotifier(
+    StreamNotifierInterface* stream_notifier) {
+  stream_notifier_ = stream_notifier;
+}
+
+void QuicUnackedPacketMap::NotifyStreamFramesAcked(
+    const QuicTransmissionInfo& info,
+    QuicTime::Delta ack_delay) {
+  if (stream_notifier_ == nullptr) {
+    return;
+  }
+
+  for (const QuicFrame& frame : info.retransmittable_frames) {
+    if (frame.type == STREAM_FRAME) {
+      stream_notifier_->OnStreamFrameAcked(*frame.stream_frame, ack_delay);
+    }
+  }
+}
+
 }  // namespace net