[SPDY] Close SPDY sessions on session flow control errors

net/spdy/spdy_stream.cc

 // 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.
 
 #include "net/spdy/spdy_stream.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "net/spdy/spdy_buffer_producer.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
 namespace {
 
 Value* NetLogSpdyStreamErrorCallback(SpdyStreamId stream_id,
@@ skipping 157 matching lines @@
   pending_buffers_.release(&buffers);
   for (size_t i = 0; i < buffers.size(); ++i) {
     // It is always possible that a callback to the delegate results in
     // the delegate no longer being available.
     if (!delegate_)
       break;
     if (buffers[i]) {
       delegate_->OnDataReceived(scoped_ptr<SpdyBuffer>(buffers[i]));
     } else {
       delegate_->OnDataReceived(scoped_ptr<SpdyBuffer>());
-      session_->CloseStream(stream_id_, net::OK);
+      session_->CloseStream(stream_id_, OK);
       // Note: |this| may be deleted after calling CloseStream.
       DCHECK_EQ(buffers.size() - 1, i);
     }
   }
 }
 
 scoped_ptr<SpdyFrame> SpdyStream::ProduceSynStreamFrame() {
   CHECK_EQ(io_state_, STATE_SEND_HEADERS_COMPLETE);
   CHECK(request_.get());
   CHECK_GT(stream_id_, 0u);
@@ skipping 162 matching lines @@
         stream_id_, static_cast<uint32>(unacked_recv_window_bytes_));
     unacked_recv_window_bytes_ = 0;
   }
 }
 
 void SpdyStream::DecreaseRecvWindowSize(int32 delta_window_size) {
   DCHECK(session_->IsStreamActive(stream_id_));
   DCHECK_GE(session_->flow_control_state(), SpdySession::FLOW_CONTROL_STREAM);
   DCHECK_GE(delta_window_size, 1);
 
-  // Since we never decrease the initial window size,
+  // Since we never decrease the initial receive window size,
   // |delta_window_size| should never cause |recv_window_size_| to go
-  // negative. If we do, it's a client-side bug, so we use
-  // PROTOCOL_ERROR for lack of a better error code.
+  // negative. If we do, the receive window isn't being respected.
   if (delta_window_size > recv_window_size_) {
     session_->ResetStream(
         stream_id_, RST_STREAM_PROTOCOL_ERROR,
-        "Invalid delta_window_size for DecreaseRecvWindowSize");
-    NOTREACHED();
+        "delta_window_size is " + base::IntToString(delta_window_size) +
+        " in DecreaseRecvWindowSize, which is larger than the receive " +
+        "window size of " + base::IntToString(recv_window_size_));
     return;
   }
 
   recv_window_size_ -= delta_window_size;
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_STREAM_UPDATE_RECV_WINDOW,
       base::Bind(&NetLogSpdyStreamWindowUpdateCallback,
                  stream_id_, -delta_window_size, recv_window_size_));
 }
 
@@ skipping 125 matching lines @@
       // Note: we leave the stream open in the session until the stream
       //       is claimed.
     }
     return;
   }
 
   CHECK(!closed());
 
   if (!buffer) {
     metrics_.StopStream();
-    session_->CloseStream(stream_id_, net::OK);
+    session_->CloseStream(stream_id_, OK);
     // Note: |this| may be deleted after calling CloseStream.
     return;
   }
 
   size_t length = buffer->GetRemainingSize();
   DCHECK_LE(length, session_->GetDataFrameMaximumPayload());
   if (session_->flow_control_state() >= SpdySession::FLOW_CONTROL_STREAM) {
     DecreaseRecvWindowSize(static_cast<int32>(length));
     buffer->AddConsumeCallback(
         base::Bind(&SpdyStream::OnReadBufferConsumed,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // Track our bandwidth.
   metrics_.RecordBytes(length);
   recv_bytes_ += length;
   recv_last_byte_time_ = base::TimeTicks::Now();
 
-  if (delegate_->OnDataReceived(buffer.Pass()) != net::OK) {
+  if (delegate_->OnDataReceived(buffer.Pass()) != OK) {
     // |delegate_| rejected the data.
     LogStreamError(ERR_SPDY_PROTOCOL_ERROR, "Delegate rejected the data");
     session_->CloseStream(stream_id_, ERR_SPDY_PROTOCOL_ERROR);
     return;
   }
 }
 
 void SpdyStream::OnFrameWriteComplete(SpdyFrameType frame_type,
                                       size_t frame_size) {
   if (frame_size < session_->GetFrameMinimumSize() ||
@@ skipping 33 matching lines @@
 
   cancelled_ = true;
   if (session_->IsStreamActive(stream_id_))
     session_->ResetStream(stream_id_, RST_STREAM_CANCEL, std::string());
   else if (stream_id_ == 0)
     session_->CloseCreatedStream(this, RST_STREAM_CANCEL);
 }
 
 void SpdyStream::Close() {
   if (stream_id_ != 0)
-    session_->CloseStream(stream_id_, net::OK);
+    session_->CloseStream(stream_id_, OK);
   else
     session_->CloseCreatedStream(this, OK);
 }
 
 int SpdyStream::SendRequest(bool has_upload_data) {
   // Pushed streams do not send any data, and should always be
   // idle. However, we still want to return IO_PENDING to mimic
   // non-push behavior.
   has_upload_data_ = has_upload_data;
   if (pushed_) {
@@ skipping 366 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