Change the stream_id for streams which are serialized out of order.

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 <map>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 331 matching lines @@
                          const HostPortPair& trusted_spdy_proxy,
                          NetLog* net_log)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       host_port_proxy_pair_(host_port_proxy_pair),
       spdy_session_pool_(spdy_session_pool),
       http_server_properties_(http_server_properties),
       connection_(new ClientSocketHandle),
       read_buffer_(new IOBuffer(kReadBufferSize)),
       read_pending_(false),
       stream_hi_water_mark_(1),  // Always start at 1 for the first stream id.
+      last_syn_stream_id_(0),
       write_pending_(false),
       delayed_write_pending_(false),
       is_secure_(false),
       certificate_error_code_(OK),
       error_(OK),
       state_(IDLE),
       max_concurrent_streams_(g_init_max_concurrent_streams),
       streams_initiated_count_(0),
       streams_pushed_count_(0),
       streams_pushed_and_claimed_count_(0),
@@ skipping 306 matching lines @@
           ConvertRequestPriorityToSpdyPriority(priority, GetProtocolVersion()),
           credential_slot, flags, false, headers.get()));
   QueueFrame(syn_frame.get(), priority, stream);
 
   base::StatsCounter spdy_requests("spdy.requests");
   spdy_requests.Increment();
   streams_initiated_count_++;
 
   if (net_log().IsLoggingAllEvents()) {
     net_log().AddEvent(
         NetLog::TYPE_SPDY_SESSION_SYN_STREAM,

[willchan no longer on Chromium, 2012/05/15 13:54:15]

This is going to be off now...right? Maybe we just need to temporarily know this
is wrong? Long-term, we'll fix this to be right...perhaps what we should do
temporarily is add a new event that says we're rewriting the stream id at the
last second and indicate the old and new stream ids?

[Ryan Hamilton, 2012/05/15 16:41:11]

Oh, right.  I had though about this, but apparently neglected to implement. 
I've added a new event type for renumbering a SPDY stream, and have tweaked this
CL accordingly.

         make_scoped_refptr(
             new NetLogSpdySynParameter(headers, flags, stream_id, 0)));
   }
 
   // Some servers don't like too many pings, so we limit our current sending to
   // no more than two pings for any syn frame or data frame sent.  To do this,
   // we avoid ever setting this to true unless we send a syn (which we have just
   // done) or data frame. This approach may change over time as servers change
   // their responses to pings.
   need_to_send_ping_ = true;
@@ skipping 339 matching lines @@
   while (in_flight_write_.buffer() || !queue_.empty()) {
     if (!in_flight_write_.buffer()) {
       // Grab the next SpdyFrame to send.
       SpdyIOBuffer next_buffer = queue_.top();
       queue_.pop();
 
       // We've deferred compression until just before we write it to the socket,
       // which is now.  At this time, we don't compress our data frames.
       SpdyFrame uncompressed_frame(next_buffer.buffer()->data(), false);
       size_t size;
+      if (uncompressed_frame.is_control_frame()) {
+        SpdyControlFrame control_frame(next_buffer.buffer()->data(), false);
+        if (control_frame.type() == SYN_STREAM) {
+          SpdySynStreamControlFrame syn_stream(next_buffer.buffer()->data(),
+                                               false);
+          SpdyStreamId id = syn_stream.stream_id();
+          DCHECK(IsStreamActive(id));
+          if (id < last_syn_stream_id_) {
+            // need to play some games to change the stream_id
+            scoped_refptr<SpdyStream> stream = active_streams_[id];
+            active_streams_.erase(id);
+            id = GetNewStreamId();
+            syn_stream.set_stream_id(id);
+            stream->set_stream_id(id);
+            ActivateStream(stream);
+          }
+          last_syn_stream_id_ = id;
+        }
+      }
       if (buffered_spdy_framer_->IsCompressible(uncompressed_frame)) {
         DCHECK(uncompressed_frame.is_control_frame());
         scoped_ptr<SpdyFrame> compressed_frame(
             buffered_spdy_framer_->CompressControlFrame(
                 reinterpret_cast<const SpdyControlFrame&>(uncompressed_frame)));
         if (!compressed_frame.get()) {
           RecordProtocolErrorHistogram(
               PROTOCOL_ERROR_SPDY_COMPRESSION_FAILURE);
           CloseSessionOnError(
               net::ERR_SPDY_PROTOCOL_ERROR, true, "SPDY Compression failure.");
@@ skipping 934 matching lines @@
 SSLClientSocket* SpdySession::GetSSLClientSocket() const {
   if (!is_secure_)
     return NULL;
   SSLClientSocket* ssl_socket =
       reinterpret_cast<SSLClientSocket*>(connection_->socket());
   DCHECK(ssl_socket);
   return ssl_socket;
 }
 
 }  // namespace net