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

net/spdy/spdy_stream.cc

 // 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.
 
 #include "net/spdy/spdy_stream.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/singleton.h"
 #include "net/spdy/spdy_session.h"
@@ skipping 10 matching lines @@
       session_(session),
       delegate_(NULL),
       request_time_(base::Time::Now()),
       response_(new spdy::SpdyHeaderBlock),
       response_complete_(false),
       io_state_(STATE_NONE),
       response_status_(OK),
       cancelled_(false),
       send_bytes_(0),
       recv_bytes_(0),
-      histograms_recorded_(false),
-      half_closed_client_side_(false),
-      half_closed_server_side_(false) {}
+      histograms_recorded_(false) {}
 
 SpdyStream::~SpdyStream() {
   DLOG(INFO) << "Deleting SpdyStream for stream " << stream_id_;
 
   // When the stream_id_ is 0, we expect that it is because
   // we've cancelled or closed the stream and set the stream_id to 0.
   if (!stream_id_)
     DCHECK(response_complete_);
 }
 
 void SpdyStream::SetDelegate(Delegate* delegate) {
   CHECK(delegate);
   delegate_ = delegate;
 
   if (!response_->empty()) {
     // The stream already got response.
     delegate_->OnResponseReceived(*response_, response_time_, OK);
   }
 
   std::vector<scoped_refptr<IOBufferWithSize> > buffers;
   buffers.swap(pending_buffers_);
   for (size_t i = 0; i < buffers.size(); ++i) {
     if (delegate_)
       delegate_->OnDataReceived(buffers[i]->data(), buffers[i]->size());
   }
 }
 
 void SpdyStream::DetachDelegate() {
   delegate_ = NULL;
-  if (!half_closed_client_side())
-    session_->CloseStream(stream_id_, ERR_ABORTED);
+  if (!cancelled())
+    Cancel();
 }
 
 const linked_ptr<spdy::SpdyHeaderBlock>& SpdyStream::spdy_headers() const {
   return request_;
 }
 
 void SpdyStream::set_spdy_headers(
     const linked_ptr<spdy::SpdyHeaderBlock>& headers) {
   request_ = headers;
 }
@@ skipping 49 matching lines @@
   LOG(INFO) << "SpdyStream: Data (" << length << " bytes) received for "
             << stream_id_;
 
   CHECK(!response_complete_);
 
   // If we don't have a response, then the SYN_REPLY did not come through.
   // We cannot pass data up to the caller unless the reply headers have been
   // received.
   if (response_->empty()) {
     session_->CloseStream(stream_id_, ERR_SYN_REPLY_NOT_RECEIVED);
-    //session_->CloseStreamAndSendRst(stream_id_, ERR_SYN_REPLY_NOT_RECEIVED);
-    // TODO(erikchen): We should close the session here.
     return;
   }
 
   // A zero-length read means that the stream is being closed.
   if (!length) {
     metrics_.StopStream();
     scoped_refptr<SpdyStream> self(this);
     session_->CloseStream(stream_id_, net::OK);
     UpdateHistograms();
     return;
@@ skipping 10 matching lines @@
     IOBufferWithSize* buf = new IOBufferWithSize(length);
     memcpy(buf->data(), data, length);
     pending_buffers_.push_back(buf);
     return;
   }
 
   delegate_->OnDataReceived(data, length);
 }
 
 void SpdyStream::OnWriteComplete(int status) {
-  // Behavior for status==0 is undefined, and should never happen. This should
-  // have already been checked prior to calling this function.
-  DCHECK_NE(status, 0);
+  // TODO(mbelshe): Check for cancellation here.  If we're cancelled, we
+  // should discontinue the DoLoop.
 
-  // It is possible that this stream was closed or cancelled while we had a
-  // write pending.
-  if (response_complete_ || cancelled_)
+  // It is possible that this stream was closed while we had a write pending.
+  if (response_complete_)
     return;
 
   if (status > 0)
     send_bytes_ += status;
 
   DoLoop(status);
 }
 
 void SpdyStream::OnClose(int status) {
   response_complete_ = true;
   response_status_ = status;
   stream_id_ = 0;
   Delegate* delegate = delegate_;
   delegate_ = NULL;
   if (delegate)
     delegate->OnClose(status);
 }
 
 void SpdyStream::Cancel() {
   cancelled_ = true;
-  if (!half_closed_client_side())
-    session_->CloseStreamAndSendRst(stream_id_, ERR_ABORTED);
+  session_->CloseStream(stream_id_, ERR_ABORTED);
 }
 
 int SpdyStream::DoSendRequest(bool has_upload_data) {
   CHECK(!cancelled_);
 
   if (!pushed_) {
     spdy::SpdyControlFlags flags = spdy::CONTROL_FLAG_NONE;
     if (!has_upload_data)
       flags = spdy::CONTROL_FLAG_FIN;
 
@@ skipping 201 matching lines @@
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamDownloadTime",
       recv_last_byte_time_ - recv_first_byte_time_);
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamTime",
       recv_last_byte_time_ - send_time_);
 
   UMA_HISTOGRAM_COUNTS("Net.SpdySendBytes", send_bytes_);
   UMA_HISTOGRAM_COUNTS("Net.SpdyRecvBytes", recv_bytes_);
 }
 
 }  // namespace net