Landing Recent QUIC changes until Sat Apr 29 00:22:04 2017 +0000

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>
@@ skipping 232 matching lines @@
   // then a new stream is created and returned. In all other cases, nullptr is
   // returned.
   QuicStream* GetOrCreateStream(const QuicStreamId stream_id);
 
   // 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;
+  }
+
  protected:
   using StaticStreamMap = QuicSmallMap<QuicStreamId, QuicStream*, 2>;
 
   using DynamicStreamMap =
       QuicSmallMap<QuicStreamId, std::unique_ptr<QuicStream>, 10>;
 
   using ClosedStreams = std::vector<std::unique_ptr<QuicStream>>;
 
+  // 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.
   // Caller does not own the returned stream.
   // Returns nullptr and does error handling if the stream can not be created.
+  virtual QuicStream* MaybeCreateIncomingDynamicStream(QuicStreamId id);
+
+  // Create a new stream to handle a locally-initiated stream.
+  // Caller does not own the returned stream.
+  // Returns nullptr if max streams have already been opened.
+  virtual QuicStream* MaybeCreateOutgoingDynamicStream(SpdyPriority priority);
+
+  // TODO(ckrasic) - For all Create*DynamicStream below, remove when
+  // quic_reloadable_flag_quic_refactor_stream_creation is deprecated.
+
+  // Creates a new stream to handle a peer-initiated stream.
+  // Caller does not own the returned stream.
+  // Returns nullptr and does error handling if the stream can not be created.
   virtual QuicStream* CreateIncomingDynamicStream(QuicStreamId id) = 0;
 
   // Create a new stream to handle a locally-initiated stream.
   // Caller does not own the returned stream.
   // Returns nullptr if max streams have already been opened.
   virtual QuicStream* CreateOutgoingDynamicStream(SpdyPriority priority) = 0;
 
   // Return the reserved crypto stream.
   virtual QuicCryptoStream* GetMutableCryptoStream() = 0;
 
@@ skipping 22 matching lines @@
   // peer sent on that stream.
   // When this data arrives (via stream frame w. FIN, trailing headers, or RST)
   // this method is called, and correctly updates the connection level flow
   // controller.
   virtual void OnFinalByteOffsetReceived(QuicStreamId id,
                                          QuicStreamOffset final_byte_offset);
 
   // Return true if given stream is peer initiated.
   bool IsIncomingStream(QuicStreamId id) const;
 
+  // Unconditionally creates a stream.  Subclasses should use this to
+  // provide streams appropriately subclassed from |QuicStream|,
+  // e.g. |QuicSpdySession::CreateStream()| creates a |QuicSpdyStream|.
+  virtual std::unique_ptr<QuicStream> CreateStream(QuicStreamId id) = 0;
+
+  // Creates a stream and activates it, owned by the session.
+  QuicStream* CreateAndActivateStream(QuicStreamId id);
+
   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_; }
 
@@ skipping 36 matching lines @@
   bool MaybeIncreaseLargestPeerStreamId(const QuicStreamId stream_id);
 
   void InsertLocallyClosedStreamsHighestOffset(const QuicStreamId id,
                                                QuicStreamOffset offset);
   // 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);
 
+  bool respect_goaway() const { return respect_goaway_; }
+
  private:
   friend class test::QuicSessionPeer;
 
   // 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);
@@ skipping 65 matching lines @@
   // The latched error with which the connection was closed.
   QuicErrorCode error_;
 
   // Used for connection-level flow control.
   QuicFlowController flow_controller_;
 
   // 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_;
+
   DISALLOW_COPY_AND_ASSIGN(QuicSession);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_QUIC_SESSION_H_