Implement PUSH_PROMISE handling in spdy_session

net/spdy/spdy_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.
 
 #ifndef NET_SPDY_SPDY_SESSION_H_
 #define NET_SPDY_SPDY_SESSION_H_
 
 #include <deque>
 #include <map>
 #include <set>
@@ skipping 519 matching lines @@
   typedef std::deque<base::WeakPtr<SpdyStreamRequest> >
       PendingStreamRequestQueue;
 
   struct ActiveStreamInfo {
     ActiveStreamInfo();
     explicit ActiveStreamInfo(SpdyStream* stream);
     ~ActiveStreamInfo();
 
     SpdyStream* stream;
     bool waiting_for_syn_reply;
+    bool reserved_remote;

[Johnny, 2014/06/17 04:01:33]

Rather than having |reserved_remote| here, add an "IsReservedRemote()" accessor
which queries stream's |io_state_|.

[baranovich, 2014/06/17 21:33:43]

Done.

   };
   typedef std::map<SpdyStreamId, ActiveStreamInfo> ActiveStreamMap;
 
   struct PushedStreamInfo {
     PushedStreamInfo();
     PushedStreamInfo(SpdyStreamId stream_id, base::TimeTicks creation_time);
     ~PushedStreamInfo();
 
     SpdyStreamId stream_id;
     base::TimeTicks creation_time;
@@ skipping 54 matching lines @@
 
   // Returns the next pending stream request to process, or NULL if
   // there is none.
   base::WeakPtr<SpdyStreamRequest> GetNextPendingStreamRequest();
 
   // Called when there is room to create more streams (e.g., a stream
   // was closed). Processes as many pending stream requests as
   // possible.
   void ProcessPendingStreamRequests();
 
+  bool TryCreatePushStream(SpdyStreamId stream_id,
+                           SpdyStreamId associated_stream_id,
+                           SpdyPriority priority,
+                           const SpdyHeaderBlock& headers);
+  void ActivateReservedStreamIterator(ActiveStreamMap::iterator it);
+
   // Close the stream pointed to by the given iterator. Note that that
   // stream may hold the last reference to the session.
   void CloseActiveStreamIterator(ActiveStreamMap::iterator it, int status);
 
   // Close the stream pointed to by the given iterator. Note that that
   // stream may hold the last reference to the session.
   void CloseCreatedStreamIterator(CreatedStreamSet::iterator it, int status);
 
   // Calls EnqueueResetStreamFrame() and then
   // CloseActiveStreamIterator().
@@ skipping 337 matching lines @@
   // 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).
   //
   // |active_streams_| owns all its SpdyStream objects.
   //
   // TODO(willchan): Perhaps we should separate out cancelled streams and move
   // them into a separate ActiveStreamMap, and not deliver network events to
   // them?
   ActiveStreamMap active_streams_;
+  size_t reserved_remote_stream_num_;

[Johnny, 2014/06/17 04:01:33]

How about |num_reserved_remote_streams_| to match
num_active_streams()/num_created_streams()/etc convention used elsewhere. Needs
a good comment about what this is and why it's tracked.

[baranovich, 2014/06/17 21:33:43]

Done. Deleted.

 
   // (Bijective) map from the URL to the ID of the streams that have
   // already started to be pushed by the server, but do not have
   // consumers yet. Contains a subset of |active_streams_|.
   PushedStreamMap unclaimed_pushed_streams_;
 
   // Set of all created streams but that have not yet sent any frames.
   //
   // |created_streams_| owns all its SpdyStream objects.
   CreatedStreamSet created_streams_;
@@ skipping 146 matching lines @@
   // Used for posting asynchronous IO tasks.  We use this even though
   // SpdySession is refcounted because we don't need to keep the SpdySession
   // alive if the last reference is within a RunnableMethod.  Just revoke the
   // method.
   base::WeakPtrFactory<SpdySession> weak_factory_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_