Re-land: Defer SpdySession destruction to support closing writes

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 325 matching lines @@
 
   // Fills SSL Certificate Request info |cert_request_info| and returns
   // true when SSL is in use.
   bool GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info);
 
   // Send a WINDOW_UPDATE frame for a stream. Called by a stream
   // whenever receive window size is increased.
   void SendStreamWindowUpdate(SpdyStreamId stream_id,
                               uint32 delta_window_size);
 
-  // Whether the stream is closed, i.e. it has stopped processing data
-  // and is about to be destroyed.
-  //
-  // TODO(akalin): This is only used in tests. Remove this function
-  // and have tests test the WeakPtr instead.
-  bool IsClosed() const { return availability_state_ == STATE_CLOSED; }
+  // Accessors for the session's availability state.
+  bool IsAvailable() const { return availability_state_ == STATE_AVAILABLE; }
+  bool IsGoingAway() const { return availability_state_ == STATE_GOING_AWAY; }
+  bool IsDraining() const { return availability_state_ == STATE_DRAINING; }
 
   // Closes this session. This will close all active streams and mark
   // the session as permanently closed. Callers must assume that the
   // session is destroyed after this is called. (However, it may not
   // be destroyed right away, e.g. when a SpdySession function is
   // present in the call stack.)
   //
   // |err| should be < ERR_IO_PENDING; this function is intended to be
   // called on error.
   // |description| indicates the reason for the error.
@@ skipping 163 matching lines @@
 
   typedef std::set<SpdyStream*> CreatedStreamSet;
 
   enum AvailabilityState {
     // The session is available in its socket pool and can be used
     // freely.
     STATE_AVAILABLE,
     // The session can process data on existing streams but will
     // refuse to create new ones.
     STATE_GOING_AWAY,
-    // The session has been closed, is waiting to be deleted, and will
-    // refuse to process any more data.
-    STATE_CLOSED
+    // The session is draining its write queue in preparation of closing.
+    // Further writes will not be queued, and further reads will not be issued
+    // (though the remainder of a current read may be processed). The session
+    // will be destroyed by its write loop once the write queue is drained.
+    STATE_DRAINING,
   };
 
   enum ReadState {
     READ_STATE_DO_READ,
     READ_STATE_DO_READ_COMPLETE,
   };
 
   enum WriteState {
     // There is no in-flight write and the write queue is empty.
     WRITE_STATE_IDLE,
     WRITE_STATE_DO_WRITE,
     WRITE_STATE_DO_WRITE_COMPLETE,
   };
 
-  // The return value of DoCloseSession() describing what was done.
-  enum CloseSessionResult {
-    // The session was already closed so nothing was done.
-    SESSION_ALREADY_CLOSED,
-    // The session was moved into the closed state but was not removed
-    // from |pool_| (because we're in an IO loop).
-    SESSION_CLOSED_BUT_NOT_REMOVED,
-    // The session was moved into the closed state and removed from
-    // |pool_|.
-    SESSION_CLOSED_AND_REMOVED,
-  };
-
   // Checks whether a stream for the given |url| can be created or
   // retrieved from the set of unclaimed push streams. Returns OK if
   // so. Otherwise, the session is closed and an error <
   // ERR_IO_PENDING is returned.
   Error TryAccessStream(const GURL& url);
 
   // Called by SpdyStreamRequest to start a request to create a
   // stream. If OK is returned, then |stream| will be filled in with a
   // valid stream. If ERR_IO_PENDING is returned, then
   // |request->OnRequestComplete{Success,Failure}()| will be called
@@ skipping 37 matching lines @@
   // Send a RST_STREAM frame with the given parameters. There should
   // either be no active stream with the given ID, or that active
   // stream should be closed shortly after this function is called.
   //
   // TODO(akalin): Rename this to EnqueueResetStreamFrame().
   void EnqueueResetStreamFrame(SpdyStreamId stream_id,
                                RequestPriority priority,
                                SpdyRstStreamStatus status,
                                const std::string& description);
 
-  // Calls DoReadLoop and then if |availability_state_| is
-  // STATE_CLOSED, calls RemoveFromPool().
-  //
-  // Use this function instead of DoReadLoop when posting a task to
-  // pump the read loop.
+  // Calls DoReadLoop. Use this function instead of DoReadLoop when
+  // posting a task to pump the read loop.
   void PumpReadLoop(ReadState expected_read_state, int result);
 
   // Advance the ReadState state machine. |expected_read_state| is the
   // expected starting read state.
   //
   // This function must always be called via PumpReadLoop().
   int DoReadLoop(ReadState expected_read_state, int result);
   // The implementations of the states of the ReadState state machine.
   int DoRead();
   int DoReadComplete(int result);
 
-  // Calls DoWriteLoop and then if |availability_state_| is
-  // STATE_CLOSED, calls RemoveFromPool().
+  // Calls DoWriteLoop. If |availability_state_| is STATE_DRAINING and no
+  // writes remain, the session is removed from the session pool and
+  // destroyed.
   //
   // Use this function instead of DoWriteLoop when posting a task to
   // pump the write loop.
   void PumpWriteLoop(WriteState expected_write_state, int result);
 
+  // Iff the write loop is not currently active, posts a callback into
+  // PumpWriteLoop().
+  void MaybePostWriteLoop();
+
   // Advance the WriteState state machine. |expected_write_state| is
   // the expected starting write state.
   //
   // This function must always be called via PumpWriteLoop().
   int DoWriteLoop(WriteState expected_write_state, int result);
   // The implementations of the states of the WriteState state machine.
   int DoWrite();
   int DoWriteComplete(int result);
 
   // TODO(akalin): Rename the Send* and Write* functions below to
@@ skipping 82 matching lines @@
   void RecordPingRTTHistogram(base::TimeDelta duration);
   void RecordHistograms();
   void RecordProtocolErrorHistogram(SpdyProtocolErrorDetails details);
 
   // DCHECKs that |availability_state_| >= STATE_GOING_AWAY, that
   // there are no pending stream creation requests, and that there are
   // no created streams.
   void DcheckGoingAway() const;
 
   // Calls DcheckGoingAway(), then DCHECKs that |availability_state_|
-  // == STATE_CLOSED, |error_on_close_| has a valid value, that there
-  // are no active streams or unclaimed pushed streams, and that the
-  // write queue is empty.
-  void DcheckClosed() const;
+  // == STATE_DRAINING, |error_on_close_| has a valid value, and that there
+  // are no active streams or unclaimed pushed streams.
+  void DcheckDraining() const;
 
   // Closes all active streams with stream id's greater than
   // |last_good_stream_id|, as well as any created or pending
   // streams. Must be called only when |availability_state_| >=
   // STATE_GOING_AWAY. After this function, DcheckGoingAway() will
   // pass. May be called multiple times.
   void StartGoingAway(SpdyStreamId last_good_stream_id, Error status);
 
   // Must be called only when going away (i.e., DcheckGoingAway()
   // passes). If there are no more active streams and the session
   // isn't closed yet, close it.
   void MaybeFinishGoingAway();
 
-  // If the stream is already closed, does nothing. Otherwise, moves
-  // the session to a closed state. Then, if we're in an IO loop,
-  // returns (as the IO loop will do the pool removal itself when its
-  // done). Otherwise, also removes |this| from |pool_|. The returned
-  // result describes what was done.
-  CloseSessionResult DoCloseSession(Error err, const std::string& description);
-
-  // Remove this session from its pool, which must exist. Must be
-  // called only when the session is closed.
-  //
-  // Must be called only via Pump{Read,Write}Loop() or
-  // DoCloseSession().
-  void RemoveFromPool();
+  // If the session is already draining, does nothing. Otherwise, moves
+  // the session to the draining state.
+  void DoDrainSession(Error err, const std::string& description);
 
   // Called right before closing a (possibly-inactive) stream for a
   // reason other than being requested to by the stream.
   void LogAbandonedStream(SpdyStream* stream, Error status);
 
   // Called right before closing an active stream for a reason other
   // than being requested to by the stream.
   void LogAbandonedActiveStream(ActiveStreamMap::const_iterator it,
                                 Error status);
 
@@ skipping 224 matching lines @@
   int certificate_error_code_;
 
   // Spdy Frame state.
   scoped_ptr<BufferedSpdyFramer> buffered_spdy_framer_;
 
   // The state variables.
   AvailabilityState availability_state_;
   ReadState read_state_;
   WriteState write_state_;
 
-  // If the session was closed (i.e., |availability_state_| is
-  // STATE_CLOSED), then |error_on_close_| holds the error with which
-  // it was closed, which is < ERR_IO_PENDING. Otherwise, it is set to
-  // OK.
+  // If the session is closing (i.e., |availability_state_| is STATE_DRAINING),
+  // then |error_on_close_| holds the error with which it was closed, which
+  // may be OK (upon a polite GOAWAY) or an error < ERR_IO_PENDING otherwise.
+  // Initialized to OK.
   Error error_on_close_;
 
   // Limits
   size_t max_concurrent_streams_;  // 0 if no limit
   size_t max_concurrent_streams_limit_;
 
   // Some statistics counters for the session.
   int streams_initiated_count_;
   int streams_pushed_count_;
   int streams_pushed_and_claimed_count_;
@@ skipping 96 matching lines @@
   // This SPDY proxy is allowed to push resources from origins that are
   // different from those of their associated streams.
   HostPortPair trusted_spdy_proxy_;
 
   TimeFunc time_func_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_