This QUIC change includes:

net/quic/core/quic_session.h

 // 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.
 //
 // A QuicSession, which demuxes a single connection to individual streams.
 
 #ifndef NET_QUIC_CORE_QUIC_SESSION_H_
 #define NET_QUIC_CORE_QUIC_SESSION_H_
 
 #include <cstddef>
 #include <map>
 #include <memory>
 #include <string>
 #include <unordered_set>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "net/quic/core/quic_connection.h"
 #include "net/quic/core/quic_crypto_stream.h"
 #include "net/quic/core/quic_packet_creator.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_stream.h"
 #include "net/quic/core/quic_write_blocked_list.h"
+#include "net/quic/core/stream_notifier_interface.h"
 #include "net/quic/platform/api/quic_containers.h"
 #include "net/quic/platform/api/quic_export.h"
 #include "net/quic/platform/api/quic_socket_address.h"
 
 namespace net {
 
 class QuicCryptoStream;
 class QuicFlowController;
 class QuicStream;
 
 namespace test {
 class QuicSessionPeer;
 }  // namespace test
 
-class QUIC_EXPORT_PRIVATE QuicSession : public QuicConnectionVisitorInterface {
+class QUIC_EXPORT_PRIVATE QuicSession : public QuicConnectionVisitorInterface,
+                                        public StreamNotifierInterface {
  public:
   // An interface from the session to the entity owning the session.
   // This lets the session notify its owner (the Dispatcher) when the connection
   // is closed, blocked, or added/removed from the time-wait list.
   class Visitor {
    public:
     virtual ~Visitor() {}
 
     // Called when the connection is closed after the streams have been closed.
     virtual void OnConnectionClosed(QuicConnectionId connection_id,
@@ skipping 50 matching lines @@
   // Deletes streams that are safe to be deleted now that it's safe to do so (no
   // other operations are being done on the streams at this time).
   void PostProcessAfterData() override;
   // Adds a connection level WINDOW_UPDATE frame.
   void OnAckNeedsRetransmittableFrame() override;
   bool WillingAndAbleToWrite() const override;
   bool HasPendingHandshake() const override;
   bool HasOpenDynamicStreams() const override;
   void OnPathDegrading() override;
 
+  // StreamNotifierInterface methods:
+  void OnStreamFrameAcked(const QuicStreamFrame& frame,
+                          QuicTime::Delta ack_delay_time) override;
+  void OnStreamFrameRetransmitted(const QuicStreamFrame& frame) override;
+
   // Called on every incoming packet. Passes |packet| through to |connection_|.
   virtual void ProcessUdpPacket(const QuicSocketAddress& self_address,
                                 const QuicSocketAddress& peer_address,
                                 const QuicReceivedPacket& packet);
 
   // Called by streams when they want to write data to the peer.
   // Returns a pair with the number of bytes consumed from data, and a boolean
   // indicating if the fin bit was consumed.  This does not indicate the data
   // has been sent on the wire: it may have been turned into a packet and queued
   // if the socket was unexpectedly blocked.
@@ skipping 81 matching lines @@
   // Returns the number of "available" streams, the stream ids less than
   // largest_peer_created_stream_id_ that have not yet been opened.
   size_t GetNumAvailableStreams() const;
 
   // Add the stream to the session's write-blocked list because it is blocked by
   // connection-level flow control but not by its own stream-level flow control.
   // The stream will be given a chance to write when a connection-level
   // WINDOW_UPDATE arrives.
   void MarkConnectionLevelWriteBlocked(QuicStreamId id);
 
+  // Called by a stream when it becomes deletable.
+  void MarkStreamDeletable(QuicStreamId id);
+
   // Returns true if the session has data to be sent, either queued in the
   // connection, or in a write-blocked stream.
   bool HasDataToWrite() const;
 
   bool goaway_sent() const;
 
   bool goaway_received() const;
 
   QuicErrorCode error() const { return error_; }
 
@@ skipping 26 matching lines @@
   // Mark a stream as draining.
   virtual void StreamDraining(QuicStreamId id);
 
   // Returns true if this stream should yield writes to another blocked stream.
   bool ShouldYield(QuicStreamId stream_id);
 
   void set_respect_goaway(bool respect_goaway) {
     respect_goaway_ = respect_goaway;
   }
 
+  bool use_stream_notifier() const { return use_stream_notifier_; }
+
  protected:
   using StaticStreamMap = QuicSmallMap<QuicStreamId, QuicStream*, 2>;
 
   using DynamicStreamMap =
       QuicSmallMap<QuicStreamId, std::unique_ptr<QuicStream>, 10>;
 
   using ClosedStreams = std::vector<std::unique_ptr<QuicStream>>;
 
+  using ZombieStreamMap =
+      QuicSmallMap<QuicStreamId, std::unique_ptr<QuicStream>, 10>;
+
   // TODO(ckrasic) - For all *DynamicStream2 below, rename after
   // quic_reloadable_flag_quic_refactor_stream_creation is deprecated.
 
   // Returns true if an incoming stream can be created.
   virtual bool ShouldCreateIncomingDynamicStream2(QuicStreamId id);
 
   // Returns true if an outgoing stream can be created.
   virtual bool ShouldCreateOutgoingDynamicStream2();
 
   // Creates a new stream to handle a peer-initiated stream.
@@ skipping 65 matching lines @@
   StaticStreamMap& static_streams() { return static_stream_map_; }
   const StaticStreamMap& static_streams() const { return static_stream_map_; }
 
   DynamicStreamMap& dynamic_streams() { return dynamic_stream_map_; }
   const DynamicStreamMap& dynamic_streams() const {
     return dynamic_stream_map_;
   }
 
   ClosedStreams* closed_streams() { return &closed_streams_; }
 
+  const ZombieStreamMap& zombie_streams() const { return zombie_streams_; }
+
   void set_max_open_incoming_streams(size_t max_open_incoming_streams);
   void set_max_open_outgoing_streams(size_t max_open_outgoing_streams);
 
   void set_largest_peer_created_stream_id(
       QuicStreamId largest_peer_created_stream_id) {
     largest_peer_created_stream_id_ = largest_peer_created_stream_id;
   }
   void set_error(QuicErrorCode error) { error_ = error; }
   QuicWriteBlockedList* write_blocked_streams() {
     return &write_blocked_streams_;
@@ skipping 49 matching lines @@
   // Debug helper for |OnCanWrite()|, check that OnStreamWrite() makes
   // forward progress.  Returns false if busy loop detected.
   bool CheckStreamNotBusyLooping(QuicStream* stream,
                                  uint64_t previous_bytes_written,
                                  bool previous_fin_sent);
 
   // Called in OnConfigNegotiated for Finch trials to measure performance of
   // starting with larger flow control receive windows.
   void AdjustInitialFlowControlWindows(size_t stream_window);
 
+  // Find stream with |id|, returns nullptr if the stream does not exist or
+  // closed.
+  QuicStream* GetStream(QuicStreamId id) const;
+
   // Keep track of highest received byte offset of locally closed streams, while
   // waiting for a definitive final highest offset from the peer.
   std::map<QuicStreamId, QuicStreamOffset>
       locally_closed_streams_highest_offset_;
 
   QuicConnection* connection_;
 
   // May be null.
   Visitor* visitor_;
 
   ClosedStreams closed_streams_;
 
+  // Streams which are closed, but need to be kept alive. Currently, the only
+  // reason is the stream's sent data (including FIN) does not get fully acked.
+  ZombieStreamMap zombie_streams_;
+
   QuicConfig config_;
 
   // The maximum number of outgoing streams this connection can open.
   size_t max_open_outgoing_streams_;
 
   // The maximum number of incoming streams this connection will allow.
   size_t max_open_incoming_streams_;
 
   // Static streams, such as crypto and header streams. Owned by child classes
   // that create these streams.
@@ skipping 37 matching lines @@
 
   // The stream id which was last popped in OnCanWrite, or 0, if not under the
   // call stack of OnCanWrite.
   QuicStreamId currently_writing_stream_id_;
 
   // If this is set to false, the session will ignore peer GOAWAYs and
   // allow the creation of outgoing streams regardless of the high
   // chance they will fail.
   bool respect_goaway_;
 
+  // This session is notified on every ack or loss.
+  const bool use_stream_notifier_;
+
   DISALLOW_COPY_AND_ASSIGN(QuicSession);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_QUIC_SESSION_H_