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

net/spdy/spdy_stream.h

 // Copyright (c) 2010 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_STREAM_H_
 #define NET_SPDY_SPDY_STREAM_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 91 matching lines @@
 
   const BoundNetLog& net_log() const { return net_log_; }
   void set_net_log(const BoundNetLog& log) { net_log_ = log; }
 
   const linked_ptr<spdy::SpdyHeaderBlock>& spdy_headers() const;
   void set_spdy_headers(const linked_ptr<spdy::SpdyHeaderBlock>& headers);
   base::Time GetRequestTime() const;
   void SetRequestTime(base::Time t);
 
   // Called by the SpdySession when a response (e.g. a SYN_REPLY) has been
-  // received for this stream.
+  // received for this stream.  |path| is the path of the URL for a server
+  // initiated stream, otherwise is empty.
   // Returns a status code.
   int OnResponseReceived(const spdy::SpdyHeaderBlock& response);
 
   // Called by the SpdySession when response data has been received for this
   // stream.  This callback may be called multiple times as data arrives
   // from the network, and will never be called prior to OnResponseReceived.
   // |buffer| contains the data received.  The stream must copy any data
   //          from this buffer before returning from this callback.
   // |length| is the number of bytes received or an error.
-  //          A length of zero indicates end-of-stream.
+  //         A zero-length count does not indicate end-of-stream.
   void OnDataReceived(const char* buffer, int bytes);
 
   // Called by the SpdySession when a write has completed.  This callback
   // will be called multiple times for each write which completes.  Writes
   // include the SYN_STREAM write and also DATA frame writes.
   // |result| is the number of bytes written or a net error code.
   void OnWriteComplete(int status);
 
   // Called by the SpdySession when the request is finished.  This callback
   // will always be called at the end of the request and signals to the
@@ skipping 19 matching lines @@
 
   // Sends DATA frame.
   int WriteStreamData(IOBuffer* data, int length);
 
   bool GetSSLInfo(SSLInfo* ssl_info, bool* was_npn_negotiated);
 
   bool is_idle() const { return io_state_ == STATE_NONE; }
   bool response_complete() const { return response_complete_; }
   int response_status() const { return response_status_; }
 
-  // If this function returns true, then the spdy_session is guaranteeing that
-  // this spdy_stream has been removed from active_streams.
-  bool half_closed_client_side() const { return half_closed_client_side_; }
-
-  bool half_closed_server_side() const { return half_closed_server_side_; }
-  bool half_closed_both_sides() const {
-    return half_closed_client_side_ && half_closed_server_side_;
-  }
-
-  // These two functions should only ever be called by spdy_session, and should
-  // only be called once.
-  void HalfCloseClientSide() { half_closed_client_side_ = true; }
-  void HalfCloseServerSide() { half_closed_server_side_ = true; }
-
  private:
   enum State {
     STATE_NONE,
     STATE_SEND_HEADERS,
     STATE_SEND_HEADERS_COMPLETE,
     STATE_SEND_BODY,
     STATE_SEND_BODY_COMPLETE,
     STATE_READ_HEADERS,
     STATE_READ_HEADERS_COMPLETE,
     STATE_READ_BODY,
@@ skipping 55 matching lines @@
   BoundNetLog net_log_;
 
   base::TimeTicks send_time_;
   base::TimeTicks recv_first_byte_time_;
   base::TimeTicks recv_last_byte_time_;
   int send_bytes_;
   int recv_bytes_;
   bool histograms_recorded_;
   // Data received before delegate is attached.
   std::vector<scoped_refptr<IOBufferWithSize> > pending_buffers_;
-  bool half_closed_client_side_;
-  bool half_closed_server_side_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyStream);
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_STREAM_H_