Fix out of order SYN_STEAM frames.

net/spdy/spdy_session_spdy3_unittest.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 "net/base/host_cache.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_log_unittest.h"
 #include "net/spdy/spdy_io_buffer.h"
@@ skipping 312 matching lines @@
   session->set_hung_interval(base::TimeDelta::FromSeconds(0));
 
   // Send a PING frame.
   session->WritePingFrame(1);
   EXPECT_LT(0, session->pings_in_flight());
   EXPECT_GE(session->next_ping_id(), static_cast<uint32>(1));
   EXPECT_TRUE(session->check_ping_status_pending());
 
   // Assert session is not closed.
   EXPECT_FALSE(session->IsClosed());
-  EXPECT_LT(0u, session->num_active_streams());
+  EXPECT_LT(0u, session->num_active_streams() + session->num_created_streams());
   EXPECT_TRUE(spdy_session_pool->HasSession(pair));
 
   // We set last time we have received any data in 1 sec less than now.
   // CheckPingStatus will trigger timeout because hung interval is zero.
   base::TimeTicks now = base::TimeTicks::Now();
   session->last_activity_time_ = now - base::TimeDelta::FromSeconds(1);
   session->CheckPingStatus(now);
 
   EXPECT_TRUE(session->IsClosed());
   EXPECT_EQ(0u, session->num_active_streams());
@@ skipping 99 matching lines @@
   spdy_session_pool->CloseIdleSessions();
   EXPECT_TRUE(session1->is_active());
   EXPECT_FALSE(session1->IsClosed());
   EXPECT_TRUE(session2->is_active());
   EXPECT_FALSE(session2->IsClosed());
   EXPECT_TRUE(session3->is_active());
   EXPECT_FALSE(session3->IsClosed());
 
   // Make sessions 1 and 3 inactive, but keep them open.
   // Session 2 still open and active
-  session1->CloseStream(spdy_stream1->stream_id(), OK);
-  session3->CloseStream(spdy_stream3->stream_id(), OK);
+  session1->CloseCreatedStream(spdy_stream1, OK);
+  session3->CloseCreatedStream(spdy_stream3, OK);
   EXPECT_FALSE(session1->is_active());
   EXPECT_FALSE(session1->IsClosed());
   EXPECT_TRUE(session2->is_active());
   EXPECT_FALSE(session2->IsClosed());
   EXPECT_FALSE(session3->is_active());
   EXPECT_FALSE(session3->IsClosed());
 
   // Should close session 1 and 3, 2 should be left open
   spdy_session_pool->CloseIdleSessions();
   EXPECT_FALSE(session1->is_active());
   EXPECT_TRUE(session1->IsClosed());
   EXPECT_TRUE(session2->is_active());
   EXPECT_FALSE(session2->IsClosed());
   EXPECT_FALSE(session3->is_active());
   EXPECT_TRUE(session3->IsClosed());
 
   // Should not do anything
   spdy_session_pool->CloseIdleSessions();
   EXPECT_TRUE(session2->is_active());
   EXPECT_FALSE(session2->IsClosed());
 
   // Make 2 not active
-  session2->CloseStream(spdy_stream2->stream_id(), OK);
+  session2->CloseCreatedStream(spdy_stream2, OK);
   EXPECT_FALSE(session2->is_active());
   EXPECT_FALSE(session2->IsClosed());
 
   // This should close session 2
   spdy_session_pool->CloseIdleSessions();
   EXPECT_FALSE(session2->is_active());
   EXPECT_TRUE(session2->IsClosed());
 }
 
 // Start with max concurrent streams set to 1.  Request two streams.  Receive a
@@ skipping 698 matching lines @@
   SettingsMap new_settings;
   int32 window_size = 1;
   new_settings[SETTINGS_INITIAL_WINDOW_SIZE] =
       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, window_size);
 
   // Set up the socket so we read a SETTINGS frame that sets
   // INITIAL_WINDOW_SIZE.
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<SpdyFrame> settings_frame(ConstructSpdySettings(new_settings));
   MockRead reads[] = {
-    CreateMockRead(*settings_frame),
-    MockRead(SYNCHRONOUS, 0, 0)  // EOF
+    CreateMockRead(*settings_frame, 0),
+    MockRead(ASYNC, 0, 2)  // EOF
   };
 
   SpdySessionDependencies session_deps;
+
   session_deps.host_resolver->set_synchronous_mode(true);
 
-  StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
-  data.set_connect_data(connect_data);
-  session_deps.socket_factory->AddSocketDataProvider(&data);
+  scoped_refptr<DeterministicSocketData> data =
+      new DeterministicSocketData(reads, arraysize(reads), NULL, 0);
+  data->set_connect_data(connect_data);
+  session_deps.deterministic_socket_factory->AddSocketDataProvider(data);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_refptr<HttpNetworkSession> http_session(
-      SpdySessionDependencies::SpdyCreateSession(&session_deps));
+      SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps));
 
   const std::string kTestHost("www.foo.com");
   const int kTestPort = 80;
   HostPortPair test_host_port_pair(kTestHost, kTestPort);
   HostPortProxyPair pair(test_host_port_pair, ProxyServer::Direct());
 
   SpdySessionPool* spdy_session_pool(http_session->spdy_session_pool());
 
   // Create a session.
   EXPECT_FALSE(spdy_session_pool->HasSession(pair));
@@ skipping 19 matching lines @@
   TestCompletionCallback callback1;
   GURL url("http://www.google.com");
   EXPECT_EQ(OK,
             session->CreateStream(url,
                                   MEDIUM,  /* priority, not important */
                                   &spdy_stream1,
                                   BoundNetLog(),
                                   callback1.callback()));
   EXPECT_NE(spdy_stream1->send_window_size(), window_size);
 
+  data->RunFor(1);  // Process the SETTINGS frame, but not the EOF
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(session->initial_send_window_size(), window_size);
   EXPECT_EQ(spdy_stream1->send_window_size(), window_size);
 
   // Release the first one, this will allow the second to be created.
   spdy_stream1->Cancel();
   spdy_stream1 = NULL;
 
   scoped_refptr<SpdyStream> spdy_stream2;
   EXPECT_EQ(OK,
             session->CreateStream(url,
                                   MEDIUM,  /* priority, not important */
                                   &spdy_stream2,
                                   BoundNetLog(),
                                   callback1.callback()));
 
   EXPECT_EQ(spdy_stream2->send_window_size(), window_size);
   spdy_stream2->Cancel();
   spdy_stream2 = NULL;
 }
 
 TEST_F(SpdySessionSpdy3Test, OutOfOrderSynStreams) {
   // Construct the request.
   MockConnect connect_data(SYNCHRONOUS, OK);
-  scoped_ptr<SpdyFrame> req1(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
-  scoped_ptr<SpdyFrame> req2(ConstructSpdyGet(NULL, 0, false, 3, HIGHEST));
+  scoped_ptr<SpdyFrame> req1(ConstructSpdyGet(NULL, 0, false, 1, HIGHEST));
+  scoped_ptr<SpdyFrame> req2(ConstructSpdyGet(NULL, 0, false, 3, LOWEST));
   MockWrite writes[] = {
     CreateMockWrite(*req1, 2),
     CreateMockWrite(*req2, 1),
   };
 
   scoped_ptr<SpdyFrame> resp1(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<SpdyFrame> body1(ConstructSpdyBodyFrame(3, true));
   scoped_ptr<SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 5));
   scoped_ptr<SpdyFrame> body2(ConstructSpdyBodyFrame(5, true));
   MockRead reads[] = {
@@ skipping 43 matching lines @@
                                  http_session->GetTransportSocketPool(
                                      HttpNetworkSession::NORMAL_SOCKET_POOL),
                                  BoundNetLog()));
   EXPECT_EQ(OK, session->InitializeWithSocket(connection.release(), false, OK));
 
   scoped_refptr<SpdyStream> spdy_stream1;
   TestCompletionCallback callback1;
   GURL url1("http://www.google.com");
   EXPECT_EQ(OK, session->CreateStream(url1, LOWEST, &spdy_stream1,
                                       BoundNetLog(), callback1.callback()));
-  EXPECT_EQ(1u, spdy_stream1->stream_id());
+  EXPECT_EQ(0u, spdy_stream1->stream_id());
 
   scoped_refptr<SpdyStream> spdy_stream2;
   TestCompletionCallback callback2;
   GURL url2("http://www.google.com");
   EXPECT_EQ(OK, session->CreateStream(url2, HIGHEST, &spdy_stream2,
                                       BoundNetLog(), callback2.callback()));
-  EXPECT_EQ(3u, spdy_stream2->stream_id());
+  EXPECT_EQ(0u, spdy_stream2->stream_id());
 
   linked_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
   (*headers)[":method"] = "GET";
   (*headers)[":scheme"] = url1.scheme();
   (*headers)[":host"] = url1.host();
   (*headers)[":path"] = url1.path();
   (*headers)[":version"] = "HTTP/1.1";
   spdy_stream1->set_spdy_headers(headers);
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
   spdy_stream2->set_spdy_headers(headers);
   EXPECT_TRUE(spdy_stream2->HasUrl());
 
   spdy_stream1->SendRequest(false);
   spdy_stream2->SendRequest(false);
   MessageLoop::current()->RunAllPending();
 
-  EXPECT_EQ(1u, spdy_stream1->stream_id());
-  EXPECT_EQ(3u, spdy_stream2->stream_id());
+  EXPECT_EQ(3u, spdy_stream1->stream_id());
+  EXPECT_EQ(1u, spdy_stream2->stream_id());
 
   spdy_stream1->Cancel();
   spdy_stream1 = NULL;
 
   spdy_stream2->Cancel();
   spdy_stream2 = NULL;
 }
 
 }  // namespace net