Revert "Streams send a Rst frame upon being closed by client. Some minor editorial fixes."

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 73 matching lines @@
       spdy::SpdyStreamId stream_id,
       RequestPriority priority,
       spdy::SpdyControlFlags flags,
       const linked_ptr<spdy::SpdyHeaderBlock>& headers);
 
   // Write a data frame to the stream.
   // Used to create and queue a data frame for the given stream.
   int WriteStreamData(spdy::SpdyStreamId stream_id, net::IOBuffer* data,
                       int len);
 
-  // This marks the stream as half closed from the client side, and removes it
-  // from the active_streams_ map.
-  void CloseStream(spdy::SpdyStreamId id, int status);
-  // This is identical to CloseStream, except it also sends a Rst stream frame.
-  void CloseStreamAndSendRst(spdy::SpdyStreamId stream_id, int status);
-
-  // Half close a stream.
-  void HalfCloseStreamClientSide(spdy::SpdyStreamId stream_id, int status);
-  void HalfCloseStreamServerSide(spdy::SpdyStreamId stream_id, int status);
-
+  // Close a stream.
+  void CloseStream(spdy::SpdyStreamId stream_id, int status);
 
   // Check if a stream is active.
   bool IsStreamActive(spdy::SpdyStreamId stream_id) const;
 
   // The LoadState is used for informing the user of the current network
   // status, such as "resolving host", "connecting", etc.
   LoadState GetLoadState() const;
 
   // Closes all streams.  Used as part of shutdown.
   void CloseAllStreams(net::Error status);
@@ skipping 29 matching lines @@
   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 OnRst(const spdy::SpdyRstStreamControlFrame& frame);
+  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.
@@ skipping 18 matching lines @@
                   SpdyStream* stream);
 
   // Closes this session.  This will close all active streams and mark
   // the session as permanently closed.
   // |err| should not be OK; this function is intended to be called on
   // error.
   void CloseSessionOnError(net::Error err);
 
   // Track active streams in the active stream list.
   void ActivateStream(SpdyStream* stream);
+  void DeleteStream(spdy::SpdyStreamId id, int status);
 
   // Removes this session from the session pool.
   void RemoveFromPool();
 
   // Check if we have a pending pushed-stream for this url
   // Returns the stream if found (and returns it from the pending
   // list), returns NULL otherwise.
   scoped_refptr<SpdyStream> GetActivePushStream(const std::string& url);
 
   // Calls OnResponseReceived().
@@ skipping 68 matching lines @@
   // 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_;
 
   // Some statistics counters for the session.
   int streams_initiated_count_;
   int streams_pushed_count_;
   int streams_pushed_and_claimed_count_;
-  int streams_abandoned_count_;  // # of streams that were pushed & abandoned.
+  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_