Revert 273680 "Defer SpdySession destruction to support closing ..."

trunk/src/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 326 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);
 
-  // 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; }
+  // 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; }
 
   // 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 is draining its write queue in preparation of closing.
-    // Further writes will not be queued, and further reads will be
-    // neither issued nor processed. The session will be destroyed by its
-    // write loop once the write queue is drained.
-    STATE_DRAINING,
+    // The session has been closed, is waiting to be deleted, and will
+    // refuse to process any more data.
+    STATE_CLOSED
   };
 
   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. Use this function instead of DoReadLoop when
-  // posting a task to pump the read loop.
+  // 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.
   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. If |availability_state_| is STATE_DRAINING and no
-  // writes remain, the session is removed from the session pool and
-  // destroyed.
+  // Calls DoWriteLoop and then if |availability_state_| is
+  // STATE_CLOSED, calls RemoveFromPool().
   //
   // 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_DRAINING, |error_on_close_| has a valid value, and that there
-  // are no active streams or unclaimed pushed streams.
-  void DcheckDraining() const;
+  // == 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;
 
   // 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 session is already draining, does nothing. Otherwise, moves
-  // the session to the draining state.
-  void DoDrainSession(Error err, const std::string& description);
+  // 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();
 
   // 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 219 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 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.
+  // 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.
   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 102 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_