Implement MAX_CONCURRENT_STREAMS SETTINGS header

net/spdy/spdy_session.h

 // Copyright (c) 2009 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_SPDY_SPDY_SESSION_H_
 #define NET_SPDY_SPDY_SESSION_H_
 
 #include <deque>
 #include <list>
 #include <map>
@@ skipping 13 matching lines @@
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/tcp_client_socket_pool.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_io_buffer.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"  // For FRIEND_TEST
 
 namespace net {
 
+class SpdyHttpStream;
 class SpdyStream;
 class HttpNetworkSession;
 class BoundNetLog;
 class SSLInfo;
 
 class SpdySession : public base::RefCounted<SpdySession>,
                     public spdy::SpdyFramerVisitorInterface {
  public:
   // Create a new SpdySession.
   // |host_port_pair| is the host/port that this session connects to.
@@ skipping 16 matching lines @@
   // If the server initiates a stream, it might already exist for a given path.
   // The server might also not have initiated the stream yet, but indicated it
   // will via X-Associated-Content.  Writes the stream out to |spdy_stream|.
   // Returns a net error code.
   int GetPushStream(
       const GURL& url,
       scoped_refptr<SpdyStream>* spdy_stream,
       const BoundNetLog& stream_net_log);
 
   // Create a new stream for a given |url|.  Writes it out to |spdy_stream|.
-  // Returns a net error code.
+  // Returns a net error code, possibly ERR_IO_PENDING.
   int CreateStream(
       const GURL& url,
       RequestPriority priority,
       scoped_refptr<SpdyStream>* spdy_stream,
-      const BoundNetLog& stream_net_log);
+      const BoundNetLog& stream_net_log,
+      CompletionCallback* callback,
+      const SpdyHttpStream* spdy_http_stream);
+
+  // Remove PendingCreateStream objects on transaction deletion
+  void CancelPendingCreateStreams(const SpdyHttpStream* trans);
 
   // Used by SpdySessionPool to initialize with a pre-existing SSL socket.
   // Returns OK on success, or an error on failure.
   net::Error InitializeWithSSLSocket(ClientSocketHandle* connection,
                                      int certificate_error_code);
 
   // Send the SYN frame for |stream_id|.
   int WriteSynStream(
       spdy::SpdyStreamId stream_id,
       RequestPriority priority,
@@ skipping 35 matching lines @@
   friend class base::RefCounted<SpdySession>;
   FRIEND_TEST(SpdySessionTest, GetActivePushStream);
 
   enum State {
     IDLE,
     CONNECTING,
     CONNECTED,
     CLOSED
   };
 
+  enum { kDefaultMaxConcurrentStreams = 100 };  // TODO(mbelshe) remove this
+
+  struct PendingCreateStream {
+    const GURL* url;
+    RequestPriority priority;
+    scoped_refptr<SpdyStream>* spdy_stream;
+    const BoundNetLog* stream_net_log;
+    CompletionCallback* callback;
+
+    const SpdyHttpStream* spdy_http_stream;
+
+    PendingCreateStream(const GURL& url, RequestPriority priority,
+                        scoped_refptr<SpdyStream>* spdy_stream,
+                        const BoundNetLog& stream_net_log,
+                        CompletionCallback* callback,
+                        const SpdyHttpStream* spdy_http_stream)
+        : url(&url), priority(priority), spdy_stream(spdy_stream),
+          stream_net_log(&stream_net_log), callback(callback),
+          spdy_http_stream(spdy_http_stream) { }
+  };
+  typedef std::queue<PendingCreateStream, std::list< PendingCreateStream> >
+      PendingCreateStreamQueue;
   typedef std::map<int, scoped_refptr<SpdyStream> > ActiveStreamMap;
   // Only HTTP push a stream.
   typedef std::list<scoped_refptr<SpdyStream> > ActivePushedStreamList;
   typedef std::map<std::string, scoped_refptr<SpdyStream> > PendingStreamMap;
   typedef std::priority_queue<SpdyIOBuffer> OutputQueue;
 
   virtual ~SpdySession();
 
+  void ProcessPendingCreateStreams();
+  int CreateStreamImpl(
+      const GURL& url,
+      RequestPriority priority,
+      scoped_refptr<SpdyStream>* spdy_stream,
+      const BoundNetLog& stream_net_log);
+
   // SpdyFramerVisitorInterface
   virtual void OnError(spdy::SpdyFramer*);
   virtual void OnStreamFrameData(spdy::SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len);
   virtual void OnControl(const spdy::SpdyControlFrame* frame);
 
   // Control frame handlers.
   void OnSyn(const spdy::SpdySynStreamControlFrame& frame,
              const linked_ptr<spdy::SpdyHeaderBlock>& headers);
   void OnSynReply(const spdy::SpdySynReplyControlFrame& frame,
                   const linked_ptr<spdy::SpdyHeaderBlock>& headers);
   void OnFin(const spdy::SpdyRstStreamControlFrame& frame);
   void OnGoAway(const spdy::SpdyGoAwayControlFrame& frame);
   void OnSettings(const spdy::SpdySettingsControlFrame& frame);
 
   // IO Callbacks
   void OnTCPConnect(int result);
   void OnSSLConnect(int result);
   void OnReadComplete(int result);
   void OnWriteComplete(int result);
 
   // Send relevant SETTINGS.  This is generally called on connection setup.
   void SendSettings();
 
+  // Handle SETTINGS.  Either when we send settings, or when we receive a
+  // SETTINGS ontrol frame, update our SpdySession accordingly.
+  void HandleSettings(const spdy::SpdySettings& settings);
+
   // Start reading from the socket.
   // Returns OK on success, or an error on failure.
   net::Error ReadSocket();
 
   // Write current data to the socket.
   void WriteSocketLater();
   void WriteSocket();
 
   // Get a new stream id.
   int GetNewStreamId();
@@ skipping 42 matching lines @@
 
   // The socket handle for this session.
   scoped_ptr<ClientSocketHandle> connection_;
 
   // The read buffer used to read data from the socket.
   scoped_refptr<IOBuffer> read_buffer_;
   bool read_pending_;
 
   int stream_hi_water_mark_;  // The next stream id to use.
 
+  // Queue, for each priority, of pending Create Streams that have not
+  // yet been satisfied
+  PendingCreateStreamQueue create_stream_queues_[NUM_PRIORITIES];
+
   // TODO(mbelshe): We need to track these stream lists better.
   //                I suspect it is possible to remove a stream from
   //                one list, but not the other.
 
   // Map from stream id to all active streams.  Streams are active in the sense
   // that they have a consumer (typically SpdyNetworkTransaction and regardless
   // of whether or not there is currently any ongoing IO [might be waiting for
   // the server to start pushing the stream]) or there are still network events
   // incoming even though the consumer has already gone away (cancellation).
   // TODO(willchan): Perhaps we should separate out cancelled streams and move
@@ skipping 26 matching lines @@
 
   // Spdy Frame state.
   spdy::SpdyFramer spdy_framer_;
 
   // If an error has occurred on the session, the session is effectively
   // dead.  Record this error here.  When no error has occurred, |error_| will
   // be OK.
   net::Error error_;
   State state_;
 
+  // Limits
+  size_t max_concurrent_streams_;  // 0 if no limit
+
   // Some statistics counters for the session.
   int streams_initiated_count_;
   int streams_pushed_count_;
   int streams_pushed_and_claimed_count_;
   int streams_abandoned_count_;
   bool sent_settings_;      // Did this session send settings when it started.
   bool received_settings_;  // Did this session receive at least one settings
                             // frame.
 
   bool in_session_pool_;  // True if the session is currently in the pool.
 
   BoundNetLog net_log_;
 
   static bool use_ssl_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_