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

net/spdy/spdy_session.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_session.h"
 
 #include "base/basictypes.h"
 #include "base/linked_ptr.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 212 matching lines @@
     return net::OK;
 
   state_ = CONNECTING;
 
   static StatsCounter spdy_sessions("spdy.sessions");
   spdy_sessions.Increment();
 
   int rv = connection_->Init(group_name, destination, priority,
                              &connect_callback_, session_->tcp_socket_pool(),
                              net_log_);
-  DCHECK_LE(rv, 0);
+  DCHECK(rv <= 0);
 
   // If the connect is pending, we still return ok.  The APIs enqueue
   // work until after the connect completes asynchronously later.
   if (rv == net::ERR_IO_PENDING)
     return net::OK;
   OnTCPConnect(rv);
   return static_cast<net::Error>(rv);
 }
 
 int SpdySession::GetPushStream(
@@ skipping 117 matching lines @@
   LOG(INFO) << "Writing Stream Data for stream " << stream_id << " (" << len
             << " bytes)";
   const int kMss = 1430;  // This is somewhat arbitrary and not really fixed,
                           // but it will always work reasonably with ethernet.
   // Chop the world into 2-packet chunks.  This is somewhat arbitrary, but
   // is reasonably small and ensures that we elicit ACKs quickly from TCP
   // (because TCP tries to only ACK every other packet).
   const int kMaxSpdyFrameChunkSize = (2 * kMss) - spdy::SpdyFrame::size();
 
   // Find our stream
-  ActiveStreamMap::const_iterator it = active_streams_.find(stream_id);
-  if (it == active_streams_.end()) {
-    LOG(DFATAL) << "Attempting to write to stream " << stream_id
-                << ", which does not exist!";
+  DCHECK(IsStreamActive(stream_id));
+  scoped_refptr<SpdyStream> stream = active_streams_[stream_id];
+  CHECK_EQ(stream->stream_id(), stream_id);
+  if (!stream)
     return ERR_INVALID_SPDY_STREAM;
-  }
-
-  const scoped_refptr<SpdyStream>& stream = it->second;
-  if (!stream) {
-    LOG(DFATAL) << "Attempting to write to stream " << stream_id
-                << ", which does not exist!";
-    return ERR_INVALID_SPDY_STREAM;
-  }
-
-  CHECK_EQ(stream->stream_id(), stream_id);
 
   // TODO(mbelshe):  Setting of the FIN is assuming that the caller will pass
   //                 all data to write in a single chunk.  Is this always true?
 
   // Set the flags on the upload.
   spdy::SpdyDataFlags flags = spdy::DATA_FLAG_FIN;
   if (len > kMaxSpdyFrameChunkSize) {
     len = kMaxSpdyFrameChunkSize;
     flags = spdy::DATA_FLAG_NONE;
   }
 
   // TODO(mbelshe): reduce memory copies here.
   scoped_ptr<spdy::SpdyDataFrame> frame(
       spdy_framer_.CreateDataFrame(stream_id, data->data(), len, flags));
   QueueFrame(frame.get(), stream->priority(), stream);
   return ERR_IO_PENDING;
 }
 
-void SpdySession::CloseStreamAndSendRst(spdy::SpdyStreamId stream_id,
-                                        int status) {
-  LOG(INFO) << "Closing stream " << stream_id << " with status " << status
-            << " and sending RST_STREAM frame.";
+void SpdySession::CloseStream(spdy::SpdyStreamId stream_id, int status) {
+  LOG(INFO) << "Closing stream " << stream_id << " with status " << status;
+  // TODO(mbelshe): We should send a RST_STREAM control frame here
+  //                so that the server can cancel a large send.
 
-  DCHECK(IsStreamActive(stream_id));
-  const scoped_refptr<SpdyStream>& stream = active_streams_[stream_id];
-  // We send a RST_STREAM control frame here so that the server can cancel a
-  // large send.
-  scoped_ptr<spdy::SpdyRstStreamControlFrame> rst_frame(
-      spdy_framer_.CreateRstStream(stream_id, spdy::CANCEL));
-  QueueFrame(rst_frame.get(), stream->priority(), stream);
-
-  CloseStream(stream_id, status);
+  DeleteStream(stream_id, status);
 }
 
 bool SpdySession::IsStreamActive(spdy::SpdyStreamId stream_id) const {
   return ContainsKey(active_streams_, stream_id);
 }
 
 LoadState SpdySession::GetLoadState() const {
   // NOTE: The application only queries the LoadState via the
   //       SpdyNetworkTransaction, and details are only needed when
   //       we're in the process of connecting.
@@ skipping 106 matching lines @@
       spdy_framer_.Reset();
   }
 
   if (state_ != CLOSED)
     ReadSocket();
 }
 
 void SpdySession::OnWriteComplete(int result) {
   DCHECK(write_pending_);
   DCHECK(in_flight_write_.size());
+  DCHECK_NE(result, 0);  // This shouldn't happen for write.
 
   write_pending_ = false;
 
   scoped_refptr<SpdyStream> stream = in_flight_write_.stream();
 
   LOG(INFO) << "Spdy write complete (result=" << result << ")"
             << (stream ? std::string(" for stream ") +
                 IntToString(stream->stream_id()) : "");
 
   if (result >= 0) {
     // It should not be possible to have written more bytes than our
     // in_flight_write_.
     DCHECK_LE(result, in_flight_write_.buffer()->BytesRemaining());
 
     in_flight_write_.buffer()->DidConsume(result);
 
     // We only notify the stream when we've fully written the pending frame.
     if (!in_flight_write_.buffer()->BytesRemaining()) {
       if (stream) {
-        // If we finished writing all the data from the buffer, it should not be
-        // the case that we wrote nothing.
-        DCHECK_NE(result, 0);
-
         // Report the number of bytes written to the caller, but exclude the
         // frame size overhead.  NOTE: if this frame was compressed the
         // reported bytes written is the compressed size, not the original
         // size.
-        result = in_flight_write_.buffer()->size();
-        DCHECK_GT(result, static_cast<int>(spdy::SpdyFrame::size()));
-        result -= static_cast<int>(spdy::SpdyFrame::size());
+        if (result > 0) {
+          result = in_flight_write_.buffer()->size();
+          DCHECK_GT(result, static_cast<int>(spdy::SpdyFrame::size()));
+          result -= static_cast<int>(spdy::SpdyFrame::size());
+        }
 
         // It is possible that the stream was cancelled while we were writing
         // to the socket.
         if (!stream->cancelled())
           stream->OnWriteComplete(result);
       }
 
       // Cleanup the write which just completed.
       in_flight_write_.release();
     }
@@ skipping 138 matching lines @@
     streams_abandoned_count_ += pushed_streams_.size();
     abandoned_push_streams.Add(pushed_streams_.size());
   }
 
   while (!active_streams_.empty()) {
     ActiveStreamMap::iterator it = active_streams_.begin();
     const scoped_refptr<SpdyStream>& stream = it->second;
     DCHECK(stream);
     LOG(ERROR) << "ABANDONED (stream_id=" << stream->stream_id()
       << "): " << stream->path();
-    CloseStream(stream->stream_id(), status);
+    DeleteStream(stream->stream_id(), status);
   }
 
   // TODO(erikchen): ideally stream->OnClose() is only ever called by
-  // CloseStream, but pending streams fall into their own category for now.
+  // DeleteStream, but pending streams fall into their own category for now.
   PendingStreamMap::iterator it;
   for (it = pending_streams_.begin(); it != pending_streams_.end(); ++it)
   {
     const scoped_refptr<SpdyStream>& stream = it->second;
     if (stream)
       stream->OnClose(ERR_ABORTED);
   }
   pending_streams_.clear();
 
   // We also need to drain the queue.
@@ skipping 40 matching lines @@
   }
 }
 
 void SpdySession::ActivateStream(SpdyStream* stream) {
   const spdy::SpdyStreamId id = stream->stream_id();
   DCHECK(!IsStreamActive(id));
 
   active_streams_[id] = stream;
 }
 
-void SpdySession::CloseStream(spdy::SpdyStreamId id, int status) {
+void SpdySession::DeleteStream(spdy::SpdyStreamId id, int status) {
   // Remove the stream from pushed_streams_ and active_streams_.
   ActivePushedStreamList::iterator it;
   for (it = pushed_streams_.begin(); it != pushed_streams_.end(); ++it) {
     scoped_refptr<SpdyStream> curr = *it;
     if (id == curr->stream_id()) {
       pushed_streams_.erase(it);
       break;
     }
   }
 
   // The stream might have been deleted.
   ActiveStreamMap::iterator it2 = active_streams_.find(id);
   if (it2 == active_streams_.end())
     return;
 
   // If this is an active stream, call the callback.
   const scoped_refptr<SpdyStream> stream(it2->second);
   active_streams_.erase(it2);
-  if (stream) {
-    // This is the only place that should set the half_closed flag on the
-    // stream, and it should only be done once.
-    DCHECK(!stream->half_closed_client_side());
-    stream->HalfCloseClientSide();
+  if (stream)
     stream->OnClose(status);
-  }
 }
 
 void SpdySession::RemoveFromPool() {
   if (in_session_pool_) {
     session_->spdy_session_pool()->Remove(this);
     in_session_pool_ = false;
   }
 }
 
 scoped_refptr<SpdyStream> SpdySession::GetActivePushStream(
@@ skipping 52 matching lines @@
 }
 
 bool SpdySession::Respond(const spdy::SpdyHeaderBlock& headers,
                           const scoped_refptr<SpdyStream> stream) {
   int rv = OK;
 
   rv = stream->OnResponseReceived(headers);
   if (rv < 0) {
     DCHECK_NE(rv, ERR_IO_PENDING);
     const spdy::SpdyStreamId stream_id = stream->stream_id();
-    CloseStream(stream_id, rv);
+    DeleteStream(stream_id, rv);
     return false;
   }
   return true;
 }
 
 void SpdySession::OnSyn(const spdy::SpdySynStreamControlFrame& frame,
                         const linked_ptr<spdy::SpdyHeaderBlock>& headers) {
   spdy::SpdyStreamId stream_id = frame.stream_id();
 
   LOG(INFO) << "Spdy SynStream for stream " << stream_id;
@@ skipping 158 matching lines @@
 
   switch (type) {
     case spdy::GOAWAY:
       OnGoAway(*reinterpret_cast<const spdy::SpdyGoAwayControlFrame*>(frame));
       break;
     case spdy::SETTINGS:
       OnSettings(
           *reinterpret_cast<const spdy::SpdySettingsControlFrame*>(frame));
       break;
     case spdy::RST_STREAM:
-      OnRst(*reinterpret_cast<const spdy::SpdyRstStreamControlFrame*>(frame));
+      OnFin(*reinterpret_cast<const spdy::SpdyRstStreamControlFrame*>(frame));
       break;
     case spdy::SYN_STREAM:
       OnSyn(*reinterpret_cast<const spdy::SpdySynStreamControlFrame*>(frame),
             headers);
       break;
     case spdy::SYN_REPLY:
       OnSynReply(
           *reinterpret_cast<const spdy::SpdySynReplyControlFrame*>(frame),
           headers);
       break;
     default:
       DCHECK(false);  // Error!
   }
 }
 
-void SpdySession::OnRst(const spdy::SpdyRstStreamControlFrame& frame) {
+void SpdySession::OnFin(const spdy::SpdyRstStreamControlFrame& frame) {
   spdy::SpdyStreamId stream_id = frame.stream_id();
   LOG(INFO) << "Spdy Fin for stream " << stream_id;
 
   bool valid_stream = IsStreamActive(stream_id);
   if (!valid_stream) {
     // NOTE:  it may just be that the stream was cancelled.
     LOG(WARNING) << "Received FIN for invalid stream" << stream_id;
     return;
   }
   scoped_refptr<SpdyStream> stream = active_streams_[stream_id];
   CHECK_EQ(stream->stream_id(), stream_id);
   CHECK(!stream->cancelled());
 
   const BoundNetLog& log = stream->net_log();
   log.AddEvent(
       NetLog::TYPE_SPDY_STREAM_RST_STREAM,
       new NetLogIntegerParameter("status", frame.status()));
 
   if (frame.status() == 0) {
     stream->OnDataReceived(NULL, 0);
   } else {
     LOG(ERROR) << "Spdy stream closed: " << frame.status();
     // TODO(mbelshe): Map from Spdy-protocol errors to something sensical.
     //                For now, it doesn't matter much - it is a protocol error.
-    CloseStream(stream_id, ERR_SPDY_PROTOCOL_ERROR);
+    DeleteStream(stream_id, ERR_SPDY_PROTOCOL_ERROR);
   }
 }
 
 void SpdySession::OnGoAway(const spdy::SpdyGoAwayControlFrame& frame) {
   LOG(INFO) << "Spdy GOAWAY for session[" << this << "] for " <<
       host_port_pair().ToString();
 
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_GOAWAY,
       new NetLogIntegerParameter(
@@ skipping 86 matching lines @@
           UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SpdySettingsRetransRate",
                                       setting.second,
                                       1, 100, 50);
           break;
       }
     }
   }
 }
 
 }  // namespace net