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 49 matching lines @@
   dict->SetInteger("flags", flags_);
   dict->Set("headers", headers_list);
   dict->SetInteger("stream_id", stream_id_);
   if (associated_stream_)
     dict->SetInteger("associated_stream", associated_stream_);
   return dict;
 }
 
 NetLogSpdySynParameter::~NetLogSpdySynParameter() {}
 
+NetLogSpdySynRenumberParameter::NetLogSpdySynRenumberParameter(
+    SpdyStreamId old_id,
+    SpdyStreamId new_id)
+    : old_id_(old_id),
+      new_id_(new_id) {
+}
+
+Value* NetLogSpdySynRenumberParameter::ToValue() const {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetInteger("old_id", old_id_);
+  dict->SetInteger("new_id", new_id_);
+  return dict;
+}
+
+NetLogSpdySynRenumberParameter::~NetLogSpdySynRenumberParameter() {}
+
+
 NetLogSpdyCredentialParameter::NetLogSpdyCredentialParameter(
     size_t slot,
     const std::string& origin)
     : slot_(slot),
       origin_(origin) {
 }
 
 Value* NetLogSpdyCredentialParameter::ToValue() const {
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger("slot", slot_);
@@ skipping 261 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 648 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_) {
+            SpdyStreamId old_id = 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);
+
+            if (net_log().IsLoggingAllEvents()) {
+              net_log().AddEvent(
+                  NetLog::TYPE_SPDY_SESSION_SYN_STREAM_RENUMBER,
+                  make_scoped_refptr(
+                      new NetLogSpdySynRenumberParameter(old_id, id)));
+            }
+          }
+          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 909 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