This QUIC change includes:

net/quic/core/quic_unacked_packet_map.h

 // 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.
 
 #ifndef NET_QUIC_CORE_QUIC_UNACKED_PACKET_MAP_H_
 #define NET_QUIC_CORE_QUIC_UNACKED_PACKET_MAP_H_
 
 #include <cstddef>
 #include <deque>
 
 #include "base/macros.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_transmission_info.h"
+#include "net/quic/core/stream_notifier_interface.h"
 #include "net/quic/platform/api/quic_export.h"
 
 namespace net {
 
 // Class which tracks unacked packets for three purposes:
 // 1) Track retransmittable data, including multiple transmissions of frames.
 // 2) Track packets and bytes in flight for congestion control.
 // 3) Track sent time of packets to provide RTT measurements from acks.
 class QUIC_EXPORT_PRIVATE QuicUnackedPacketMap {
  public:
@@ skipping 19 matching lines @@
 
   // Notifies all the AckListeners attached to the |info| and
   // clears them to ensure they're not notified again.
   void NotifyAndClearListeners(std::list<AckListenerWrapper>* ack_listeners,
                                QuicTime::Delta delta_largest_observed);
 
   // Notifies all the AckListeners attached to |newest_transmission|.
   void NotifyAndClearListeners(QuicPacketNumber newest_transmission,
                                QuicTime::Delta delta_largest_observed);
 
+  // Notifies stream_notifier that stream frames have been acked.
+  void NotifyStreamFramesAcked(const QuicTransmissionInfo& info,
+                               QuicTime::Delta ack_delay);
+
   // Marks |info| as no longer in flight.
   void RemoveFromInFlight(QuicTransmissionInfo* info);
 
   // Marks |packet_number| as no longer in flight.
   void RemoveFromInFlight(QuicPacketNumber packet_number);
 
   // Marks |packet_number| as in flight.  Must not be unackable.
   void RestoreToInFlight(QuicPacketNumber packet_number);
 
   // No longer retransmit data for |stream_id|.
@@ skipping 76 matching lines @@
   void RemoveRetransmittability(QuicPacketNumber packet_number);
 
   // Increases the largest observed.  Any packets less or equal to
   // |largest_acked_packet| are discarded if they are only for the RTT purposes.
   void IncreaseLargestObserved(QuicPacketNumber largest_observed);
 
   // Remove any packets no longer needed for retransmission, congestion, or
   // RTT measurement purposes.
   void RemoveObsoletePackets();
 
+  void SetStreamNotifier(StreamNotifierInterface* stream_notifier);
+
  private:
   // Called when a packet is retransmitted with a new packet number.
   // |old_packet_number| will remain unacked, but will have no
   // retransmittable data associated with it. Retransmittable frames will be
   // transferred to |info| and all_transmissions will be populated.
   void TransferRetransmissionInfo(QuicPacketNumber old_packet_number,
                                   QuicPacketNumber new_packet_number,
                                   TransmissionType transmission_type,
                                   QuicTransmissionInfo* info);
 
@@ skipping 28 matching lines @@
   // be removed from the map and the new entry's retransmittable frames will be
   // set to nullptr.
   UnackedPacketMap unacked_packets_;
   // The packet at the 0th index of unacked_packets_.
   QuicPacketNumber least_unacked_;
 
   QuicByteCount bytes_in_flight_;
   // Number of retransmittable crypto handshake packets.
   size_t pending_crypto_packet_count_;
 
+  // Receives notifications of stream frames being retransmitted or
+  // acknowledged.
+  StreamNotifierInterface* stream_notifier_;
+
   DISALLOW_COPY_AND_ASSIGN(QuicUnackedPacketMap);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_QUIC_UNACKED_PACKET_MAP_H_