Correct SpdySession StreamID exhaustion behavior

net/spdy/spdy_session.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_session.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/basictypes.h"
@@ skipping 31 matching lines @@
 #include "net/ssl/server_bound_cert_service.h"
 
 namespace net {
 
 namespace {
 
 const int kReadBufferSize = 8 * 1024;
 const int kDefaultConnectionAtRiskOfLossSeconds = 10;
 const int kHungIntervalSeconds = 10;
 
-// Always start at 1 for the first stream id.
+// As we always act as the client, start at 1 for the first stream id.
 const SpdyStreamId kFirstStreamId = 1;
+const SpdyStreamId kLastStreamId = 0x7fffffff;
 
 // Minimum seconds that unclaimed pushed streams will be kept in memory.
 const int kMinPushedStreamLifetimeSeconds = 300;
 
 scoped_ptr<base::ListValue> SpdyHeaderBlockToListValue(
     const SpdyHeaderBlock& headers,
     net::NetLog::LogLevel log_level) {
   scoped_ptr<base::ListValue> headers_list(new base::ListValue());
   for (SpdyHeaderBlock::const_iterator it = headers.begin();
        it != headers.end(); ++it) {
@@ skipping 1313 matching lines @@
       CHECK(!stream->IsClosed());
 
     // Activate the stream only when sending the SYN_STREAM frame to
     // guarantee monotonically-increasing stream IDs.
     if (frame_type == SYN_STREAM) {
       CHECK(stream.get());
       CHECK_EQ(stream->stream_id(), 0u);
       scoped_ptr<SpdyStream> owned_stream =
           ActivateCreatedStream(stream.get());
       InsertActivatedStream(owned_stream.Pass());
+
+      if (stream_hi_water_mark_ > kLastStreamId) {
+        CHECK_EQ(stream->stream_id(), kLastStreamId);
+        // We've exhausted the stream ID space, and no new streams may be
+        // created after this one.
+        MakeUnavailable();
+        StartGoingAway(kLastStreamId, ERR_ABORTED);
+      }
     }
 
     in_flight_write_ = producer->ProduceBuffer();
     if (!in_flight_write_) {
       NOTREACHED();
       return ERR_UNEXPECTED;
     }
     in_flight_write_frame_type_ = frame_type;
     in_flight_write_frame_size_ = in_flight_write_->GetRemainingSize();
     DCHECK_GE(in_flight_write_frame_size_,
@@ skipping 206 matching lines @@
   base::StatsCounter abandoned_streams("spdy.abandoned_streams");
   abandoned_streams.Increment();
   if (it->second.stream->type() == SPDY_PUSH_STREAM &&
       unclaimed_pushed_streams_.find(it->second.stream->url()) !=
       unclaimed_pushed_streams_.end()) {
     base::StatsCounter abandoned_push_streams("spdy.abandoned_push_streams");
     abandoned_push_streams.Increment();
   }
 }
 
-int SpdySession::GetNewStreamId() {
-  int id = stream_hi_water_mark_;
+SpdyStreamId SpdySession::GetNewStreamId() {
+  CHECK_LE(stream_hi_water_mark_, kLastStreamId);
+  SpdyStreamId id = stream_hi_water_mark_;
   stream_hi_water_mark_ += 2;
-  if (stream_hi_water_mark_ > 0x7fff)
-    stream_hi_water_mark_ = 1;
   return id;
 }
 
 void SpdySession::CloseSessionOnError(Error err,
                                       const std::string& description) {
   // We may be called from anywhere, so we can't expect a particular
   // return value.
   ignore_result(DoCloseSession(err, description));
 }
 
@@ skipping 1422 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net