relnote: Implement server push methods in QuicSimpleServerSession. Only modify toy Quic server, not…

net/quic/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_QUIC_SESSION_H_
 #define NET_QUIC_QUIC_SESSION_H_
 
 #include <stddef.h>
@@ skipping 187 matching lines @@
 
   size_t get_max_open_streams() const { return max_open_streams_; }
 
   size_t get_max_available_streams() const {
     return max_open_streams_ * kMaxAvailableStreamsMultiplier;
   }
 
   ReliableQuicStream* GetStream(const QuicStreamId stream_id);
 
   // Mark a stream as draining.
-  void StreamDraining(QuicStreamId id);
+  virtual void StreamDraining(QuicStreamId id);
 
   // Close the connection, if it is not already closed.
   void CloseConnectionWithDetails(QuicErrorCode error, const char* details);
 
  protected:
   typedef base::hash_map<QuicStreamId, ReliableQuicStream*> StreamMap;
 
   // Creates a new stream, owned by the caller, to handle a peer-initiated
   // stream.  Returns nullptr and does error handling if the stream can not be
   // created.
@@ skipping 20 matching lines @@
   // returned. However if |stream_id| is a locally-created id and no such stream
   // exists, the connection is closed.
   ReliableQuicStream* GetOrCreateDynamicStream(QuicStreamId stream_id);
 
   // This is called after every call other than OnConnectionClose from the
   // QuicConnectionVisitor to allow post-processing once the work has been done.
   // In this case, it deletes streams given that it's safe to do so (no other
   // operations are being done on the streams at this time)
   virtual void PostProcessAfterData();
 
+  // Performs the work required to close |stream_id|.  If |locally_reset|
+  // then the stream has been reset by this endpoint, not by the peer.
+  virtual void CloseStreamInner(QuicStreamId stream_id, bool locally_reset);
+
+  // When a stream is closed locally, it may not yet know how many bytes the
+  // peer sent on that stream.
+  // When this data arrives (via stream frame w. FIN, or RST) this method
+  // is called, and correctly updates the connection level flow controller.
+  void UpdateFlowControlOnFinalReceivedByteOffset(
+      QuicStreamId id,
+      QuicStreamOffset final_byte_offset);
+
+  // Return true if given stream is peer initiated.
+  bool IsIncomingStream(QuicStreamId id) const;
+
   StreamMap& static_streams() { return static_stream_map_; }
   const StreamMap& static_streams() const { return static_stream_map_; }
 
   StreamMap& dynamic_streams() { return dynamic_stream_map_; }
   const StreamMap& dynamic_streams() const { return dynamic_stream_map_; }
 
   std::vector<ReliableQuicStream*>* closed_streams() {
     return &closed_streams_;
   }
 
@@ skipping 11 matching lines @@
   size_t GetNumDynamicOutgoingStreams() const;
 
   size_t GetNumDrainingOutgoingStreams() const;
 
   size_t num_locally_closed_incoming_streams_highest_offset() const {
     return num_locally_closed_incoming_streams_highest_offset_;
   }
 
   size_t GetNumLocallyClosedOutgoingStreamsHighestOffset() const;
 
+  QuicStreamId next_outgoing_stream_id() const {
+    return next_outgoing_stream_id_;
+  }
+
+  // Close connection when receive a frame for a locally-created nonexistant
+  // stream.
+  // Prerequisite: IsClosedStream(stream_id) == false
+  // Server session might need to override this method to allow server push
+  // stream to be promised before creating an active stream.
+  virtual void HandleFrameOnNonexistentOutgoingStream(QuicStreamId stream_id);
+
+  // If stream is a locally closed stream, this RST will update FIN offset.
+  // Otherwise stream is a preserved stream and the behavior of it depends on
+  // derived class's own implementation.
+  virtual void HandleRstOnValidNonexistentStream(
+      const QuicRstStreamFrame& frame);
+
  private:
   friend class test::QuicSessionPeer;
   friend class VisitorShim;
 
-  // Performs the work required to close |stream_id|.  If |locally_reset|
-  // then the stream has been reset by this endpoint, not by the peer.
-  void CloseStreamInner(QuicStreamId stream_id, bool locally_reset);
-
-  // When a stream is closed locally, it may not yet know how many bytes the
-  // peer sent on that stream.
-  // When this data arrives (via stream frame w. FIN, or RST) this method
-  // is called, and correctly updates the connection level flow controller.
-  void UpdateFlowControlOnFinalReceivedByteOffset(
-      QuicStreamId id,
-      QuicStreamOffset final_byte_offset);
-
   // Called in OnConfigNegotiated when we receive a new stream level flow
   // control window in a negotiated config. Closes the connection if invalid.
   void OnNewStreamFlowControlWindow(QuicStreamOffset new_window);
 
   // Called in OnConfigNegotiated when we receive a new connection level flow
   // control window in a negotiated config. Closes the connection if invalid.
   void OnNewSessionFlowControlWindow(QuicStreamOffset new_window);
 
   // Called in OnConfigNegotiated when auto-tuning is enabled for flow
   // control receive windows.
   void EnableAutoTuneReceiveWindow();
 
   // Called in OnConfigNegotiated for finch trials to measure performance of
   // starting with smaller flow control receive windows and auto-tuning.
   void AdjustInitialFlowControlWindows(size_t stream_window);
 
-  // Return true if given stream is peer initiated.
-  bool IsIncomingStream(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_;
 
   scoped_ptr<QuicConnection> connection_;
 
   // A shim to stand between the connection and the session, to handle stream
   // deletions.
   scoped_ptr<VisitorShim> visitor_shim_;
@@ skipping 44 matching lines @@
 
   // Used for connection-level flow control.
   QuicFlowController flow_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicSession);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_SESSION_H_