[SPDY] Add a SpdyStreamType enum and use it for SpdyStream

net/spdy/spdy_session_spdy2_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 "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
@@ skipping 147 matching lines @@
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
 
   CreateDeterministicNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   EXPECT_EQ(2, session->GetProtocolVersion());
 
   GURL url("http://www.google.com");
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, url, MEDIUM, BoundNetLog());
+      CreateStreamSynchronously(
+          SPDY_BIDIRECTIONAL_STREAM, session, url, MEDIUM, BoundNetLog());
 
   base::WeakPtr<SpdyStream> spdy_stream2 =
-      CreateStreamSynchronously(session, url, MEDIUM, BoundNetLog());
+      CreateStreamSynchronously(
+          SPDY_BIDIRECTIONAL_STREAM, session, url, MEDIUM, BoundNetLog());
 
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
   (*headers)["method"] = "GET";
   (*headers)["scheme"] = url.scheme();
   (*headers)["host"] = url.host();
   (*headers)["url"] = url.path();
   (*headers)["version"] = "HTTP/1.1";
   scoped_ptr<SpdyHeaderBlock> headers2(new SpdyHeaderBlock);
   *headers2 = *headers;
 
@@ skipping 50 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   CreateNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, test_url_, MEDIUM, BoundNetLog());
+      CreateStreamSynchronously(
+          SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
   test::StreamDelegateSendImmediate delegate(spdy_stream1, NULL);
   spdy_stream1->SetDelegate(&delegate);
 
   base::TimeTicks before_ping_time = base::TimeTicks::Now();
 
   session->set_connection_at_risk_of_loss_time(
       base::TimeDelta::FromSeconds(-1));
   session->set_hung_interval(base::TimeDelta::FromMilliseconds(50));
 
@@ skipping 33 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   CreateNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, test_url_, MEDIUM, BoundNetLog());
+      CreateStreamSynchronously(
+          SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
   test::StreamDelegateSendImmediate delegate(spdy_stream1, NULL);
   spdy_stream1->SetDelegate(&delegate);
 
   // Flush the SpdySession::OnReadComplete() task.
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_FALSE(spdy_session_pool_->HasSession(key_));
 
   // Delete the session.
@@ skipping 15 matching lines @@
   // Give the session a SPDY2 framer.
   session->buffered_spdy_framer_.reset(new BufferedSpdyFramer(SPDY2, false));
 
   // Create the associated stream and add to active streams.
   scoped_ptr<SpdyHeaderBlock> request_headers(new SpdyHeaderBlock);
   (*request_headers)["scheme"] = "http";
   (*request_headers)["host"] = "www.google.com";
   (*request_headers)["url"] = "/";
 
   scoped_ptr<SpdyStream> stream(
-      new SpdyStream(session, std::string(), DEFAULT_PRIORITY,
+      new SpdyStream(SPDY_REQUEST_RESPONSE_STREAM,
+                     session, std::string(), DEFAULT_PRIORITY,
                      kSpdyStreamInitialWindowSize,
                      kSpdyStreamInitialWindowSize,
-                     false, session->net_log_));
+                     session->net_log_));
   stream->SendRequestHeaders(request_headers.Pass(), NO_MORE_DATA_TO_SEND);
   SpdyStream* stream_ptr = stream.get();
   session->InsertCreatedStream(stream.Pass());
   stream = session->ActivateCreatedStream(stream_ptr);
   session->InsertActivatedStream(stream.Pass());
 
   SpdyHeaderBlock headers;
   headers["url"] = "http://www.google.com/a.dat";
   session->OnSynStream(2, 1, 0, 0, true, false, headers);
 
   // Verify that there is one unclaimed push stream.
   EXPECT_EQ(1u, session->num_unclaimed_pushed_streams());
-  SpdySession::PushedStreamMap::iterator  iter  =
+  SpdySession::PushedStreamMap::iterator iter =
       session->unclaimed_pushed_streams_.find("http://www.google.com/a.dat");
   EXPECT_TRUE(session->unclaimed_pushed_streams_.end() != iter);
 
   // Shift time.
   g_delta_seconds = 301;
 
   headers["url"] = "http://www.google.com/b.dat";
   session->OnSynStream(4, 1, 0, 0, true, false, headers);
 
   // Verify that the second pushed stream evicted the first pushed stream.
@@ skipping 24 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   CreateNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, test_url_, MEDIUM, BoundNetLog());
+      CreateStreamSynchronously(
+          SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
   test::StreamDelegateSendImmediate delegate(spdy_stream1, NULL);
   spdy_stream1->SetDelegate(&delegate);
 
   session->set_connection_at_risk_of_loss_time(base::TimeDelta::FromSeconds(0));
   session->set_hung_interval(base::TimeDelta::FromSeconds(0));
 
   // Send a PING frame.
   session->WritePingFrame(1);
   EXPECT_LT(0, session->pings_in_flight());
@@ skipping 38 matching lines @@
   HostPortPair test_host_port_pair1(kTestHost1, 80);
   SpdySessionKey key1(test_host_port_pair1, ProxyServer::Direct(),
                       kPrivacyModeDisabled);
   scoped_refptr<SpdySession> session1 = GetSession(key1);
   EXPECT_EQ(
       OK,
       InitializeSession(
           http_session_.get(), session1.get(), test_host_port_pair1));
   GURL url1(kTestHost1);
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session1, url1, MEDIUM, BoundNetLog());
+      CreateStreamSynchronously(
+          SPDY_BIDIRECTIONAL_STREAM, session1, url1, MEDIUM, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
 
   // Set up session 2
   session_deps_.socket_factory->AddSocketDataProvider(&data);
   const std::string kTestHost2("http://www.b.com");
   HostPortPair test_host_port_pair2(kTestHost2, 80);
   SpdySessionKey key2(test_host_port_pair2, ProxyServer::Direct(),
                       kPrivacyModeDisabled);
   scoped_refptr<SpdySession> session2 = GetSession(key2);
   EXPECT_EQ(
       OK,
       InitializeSession(
           http_session_.get(), session2.get(), test_host_port_pair2));
   GURL url2(kTestHost2);
   base::WeakPtr<SpdyStream> spdy_stream2 =
-      CreateStreamSynchronously(session2, url2, MEDIUM, BoundNetLog());
+      CreateStreamSynchronously(
+          SPDY_BIDIRECTIONAL_STREAM, session2, url2, MEDIUM, BoundNetLog());
   ASSERT_TRUE(spdy_stream2.get() != NULL);
 
   // Set up session 3
   session_deps_.socket_factory->AddSocketDataProvider(&data);
   const std::string kTestHost3("http://www.c.com");
   HostPortPair test_host_port_pair3(kTestHost3, 80);
   SpdySessionKey key3(test_host_port_pair3, ProxyServer::Direct(),
                       kPrivacyModeDisabled);
   scoped_refptr<SpdySession> session3 = GetSession(key3);
   EXPECT_EQ(
       OK,
       InitializeSession(
           http_session_.get(), session3.get(), test_host_port_pair3));
   GURL url3(kTestHost3);
   base::WeakPtr<SpdyStream> spdy_stream3 =
-      CreateStreamSynchronously(session3, url3, MEDIUM, BoundNetLog());
+      CreateStreamSynchronously(
+          SPDY_BIDIRECTIONAL_STREAM, session3, url3, MEDIUM, BoundNetLog());
   ASSERT_TRUE(spdy_stream3.get() != NULL);
 
   // All sessions are active and not closed
   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());
 
@@ skipping 82 matching lines @@
   spdy_session_pool_->http_server_properties()->SetSpdySetting(
       test_host_port_pair_,
       kSpdySettingsIds1,
       SETTINGS_FLAG_PLEASE_PERSIST,
       1);
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   // Create 2 streams.  First will succeed.  Second will be pending.
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, test_url_, MEDIUM, BoundNetLog());
+      CreateStreamSynchronously(
+          SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
 
   StreamReleaserCallback stream_releaser;
   SpdyStreamRequest request;
   ASSERT_EQ(ERR_IO_PENDING,
-            request.StartRequest(session, test_url_, MEDIUM,
-                                 BoundNetLog(),
-                                 stream_releaser.MakeCallback(&request)));
+            request.StartRequest(
+                SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM,
+                BoundNetLog(),
+                stream_releaser.MakeCallback(&request)));
 
   EXPECT_EQ(OK, stream_releaser.WaitForResult());
 }
 
 // Start with max concurrent streams set to 1 (that is persisted). Receive a
 // settings frame setting max concurrent streams to 2 and which also clears the
 // persisted data. Verify that persisted data is correct.
 TEST_F(SpdySessionSpdy2Test, ClearSettings) {
   session_deps_.host_resolver->set_synchronous_mode(true);
 
@@ skipping 31 matching lines @@
       SETTINGS_FLAG_PLEASE_PERSIST,
       1);
 
   EXPECT_EQ(1u, spdy_session_pool_->http_server_properties()->GetSpdySettings(
       test_host_port_pair_).size());
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   // Create 2 streams.  First will succeed.  Second will be pending.
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, test_url_, MEDIUM, BoundNetLog());
+      CreateStreamSynchronously(
+          SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
 
   StreamReleaserCallback stream_releaser;
   SpdyStreamRequest request;
   ASSERT_EQ(ERR_IO_PENDING,
-            request.StartRequest(session, test_url_, MEDIUM,
-                                 BoundNetLog(),
-                                 stream_releaser.MakeCallback(&request)));
+            request.StartRequest(
+                SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM,
+                BoundNetLog(),
+                stream_releaser.MakeCallback(&request)));
 
   EXPECT_EQ(OK, stream_releaser.WaitForResult());
 
   // Make sure that persisted data is cleared.
   EXPECT_EQ(0u, spdy_session_pool_->http_server_properties()->GetSpdySettings(
       test_host_port_pair_).size());
 
   // Make sure session's max_concurrent_streams is 2.
   EXPECT_EQ(2u, session->max_concurrent_streams());
 
@@ skipping 26 matching lines @@
   spdy_session_pool_->http_server_properties()->SetSpdySetting(
       test_host_port_pair_,
       SETTINGS_MAX_CONCURRENT_STREAMS,
       SETTINGS_FLAG_PLEASE_PERSIST,
       1);
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   // Create 2 streams.  First will succeed.  Second will be pending.
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, test_url_, MEDIUM, BoundNetLog());
+      CreateStreamSynchronously(
+          SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
 
   // Use scoped_ptr to let us invalidate the memory when we want to, to trigger
   // a valgrind error if the callback is invoked when it's not supposed to be.
   scoped_ptr<TestCompletionCallback> callback(new TestCompletionCallback);
 
   SpdyStreamRequest request;
   ASSERT_EQ(ERR_IO_PENDING,
-            request.StartRequest(session, test_url_, MEDIUM,
-                                 BoundNetLog(),
-                                 callback->callback()));
+            request.StartRequest(
+                SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM,
+                BoundNetLog(),
+                callback->callback()));
 
   // Release the first one, this will allow the second to be created.
   spdy_stream1->Cancel();
   EXPECT_EQ(NULL, spdy_stream1.get());
 
   request.CancelRequest();
   callback.reset();
 
   // Should not crash when running the pending callback.
   base::MessageLoop::current()->RunUntilIdle();
@@ skipping 253 matching lines @@
       session = NULL;
       spdy_session_pool->Remove(session2);
       session2 = NULL;
       break;
     case SPDY_POOL_CLOSE_CURRENT_SESSIONS:
       spdy_session_pool->CloseCurrentSessions(net::ERR_ABORTED);
       break;
     case SPDY_POOL_CLOSE_IDLE_SESSIONS:
       GURL url(test_hosts[0].url);
       base::WeakPtr<SpdyStream> spdy_stream =
-          CreateStreamSynchronously(session, url, MEDIUM, BoundNetLog());
+          CreateStreamSynchronously(
+              SPDY_BIDIRECTIONAL_STREAM, session, url, MEDIUM, BoundNetLog());
       GURL url1(test_hosts[1].url);
       base::WeakPtr<SpdyStream> spdy_stream1 =
-          CreateStreamSynchronously(session1, url1, MEDIUM, BoundNetLog());
+          CreateStreamSynchronously(
+              SPDY_BIDIRECTIONAL_STREAM, session1, url1, MEDIUM, BoundNetLog());
       GURL url2(test_hosts[2].url);
       base::WeakPtr<SpdyStream> spdy_stream2 =
-          CreateStreamSynchronously(session2, url2, MEDIUM, BoundNetLog());
+          CreateStreamSynchronously(
+              SPDY_BIDIRECTIONAL_STREAM, session2, url2, MEDIUM, BoundNetLog());
 
       // Close streams to make spdy_session and spdy_session1 inactive.
       session->CloseCreatedStream(spdy_stream, OK);
       EXPECT_EQ(NULL, spdy_stream.get());
       session1->CloseCreatedStream(spdy_stream1, OK);
       EXPECT_EQ(NULL, spdy_stream1.get());
 
       // Check spdy_session and spdy_session1 are not closed.
       EXPECT_FALSE(session->is_active());
       EXPECT_FALSE(session->IsClosed());
@@ skipping 141 matching lines @@
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   CreateNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   GURL url("http://www.google.com");
 
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, url, LOWEST, BoundNetLog());
+      CreateStreamSynchronously(
+          SPDY_BIDIRECTIONAL_STREAM, session, url, LOWEST, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
   EXPECT_EQ(0u, spdy_stream1->stream_id());
   test::StreamDelegateDoNothing delegate1(spdy_stream1);
   spdy_stream1->SetDelegate(&delegate1);
 
   base::WeakPtr<SpdyStream> spdy_stream2 =
-      CreateStreamSynchronously(session, url, HIGHEST, BoundNetLog());
+      CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
+                                session, url, HIGHEST, BoundNetLog());
   ASSERT_TRUE(spdy_stream2.get() != NULL);
   EXPECT_EQ(0u, spdy_stream2->stream_id());
   test::StreamDelegateDoNothing delegate2(spdy_stream2);
   spdy_stream2->SetDelegate(&delegate2);
 
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
   (*headers)["method"] = "GET";
   (*headers)["scheme"] = url.scheme();
   (*headers)["host"] = url.host();
   (*headers)["url"] = url.path();
@@ skipping 41 matching lines @@
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
 
   CreateDeterministicNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   GURL url1("http://www.google.com");
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, url1, HIGHEST, BoundNetLog());
+      CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
+                                session, url1, HIGHEST, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
   EXPECT_EQ(0u, spdy_stream1->stream_id());
   test::StreamDelegateDoNothing delegate1(spdy_stream1);
   spdy_stream1->SetDelegate(&delegate1);
 
   GURL url2("http://www.google.com");
   base::WeakPtr<SpdyStream> spdy_stream2 =
-      CreateStreamSynchronously(session, url2, LOWEST, BoundNetLog());
+      CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
+                                session, url2, LOWEST, BoundNetLog());
   ASSERT_TRUE(spdy_stream2.get() != NULL);
   EXPECT_EQ(0u, spdy_stream2->stream_id());
   test::StreamDelegateDoNothing delegate2(spdy_stream2);
   spdy_stream2->SetDelegate(&delegate2);
 
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
   (*headers)["method"] = "GET";
   (*headers)["scheme"] = url1.scheme();
   (*headers)["host"] = url1.host();
   (*headers)["url"] = url1.path();
@@ skipping 44 matching lines @@
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
 
   CreateDeterministicNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   GURL url1("http://www.google.com");
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, url1, HIGHEST, BoundNetLog());
+      CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
+                                session, url1, HIGHEST, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
   EXPECT_EQ(0u, spdy_stream1->stream_id());
 
   GURL url2("http://www.google.com");
   base::WeakPtr<SpdyStream> spdy_stream2 =
-      CreateStreamSynchronously(session, url2, LOWEST, BoundNetLog());
+      CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
+                                session, url2, LOWEST, BoundNetLog());
   ASSERT_TRUE(spdy_stream2.get() != NULL);
   EXPECT_EQ(0u, spdy_stream2->stream_id());
 
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
   (*headers)["method"] = "GET";
   (*headers)["scheme"] = url1.scheme();
   (*headers)["host"] = url1.host();
   (*headers)["url"] = url1.path();
   (*headers)["version"] = "HTTP/1.1";
   scoped_ptr<SpdyHeaderBlock> headers2(new SpdyHeaderBlock);
@@ skipping 219 matching lines @@
 
   CreateDeterministicNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   // Read the settings frame.
   data.RunFor(1);
 
   GURL url1("http://www.google.com");
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, url1, LOWEST, BoundNetLog());
+      CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
+                                session, url1, LOWEST, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
   EXPECT_EQ(0u, spdy_stream1->stream_id());
   test::StreamDelegateDoNothing delegate1(spdy_stream1);
   spdy_stream1->SetDelegate(&delegate1);
 
   TestCompletionCallback callback2;
   GURL url2("http://www.google.com");
   SpdyStreamRequest request2;
   ASSERT_EQ(ERR_IO_PENDING,
-            request2.StartRequest(session, url2, LOWEST,
-                                  BoundNetLog(),
+            request2.StartRequest(SPDY_REQUEST_RESPONSE_STREAM,
+                                  session, url2, LOWEST, BoundNetLog(),
                                   callback2.callback()));
 
   TestCompletionCallback callback3;
   GURL url3("http://www.google.com");
   SpdyStreamRequest request3;
   ASSERT_EQ(ERR_IO_PENDING,
-            request3.StartRequest(session, url3, LOWEST,
-                                  BoundNetLog(),
+            request3.StartRequest(SPDY_REQUEST_RESPONSE_STREAM,
+                                  session, url3, LOWEST, BoundNetLog(),
                                   callback3.callback()));
 
   EXPECT_EQ(1u, session->num_active_streams() + session->num_created_streams());
   EXPECT_EQ(2u, session->pending_create_stream_queues(LOWEST));
 
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
   (*headers)["method"] = "GET";
   (*headers)["scheme"] = url1.scheme();
   (*headers)["host"] = url1.host();
   (*headers)["url"] = url1.path();
@@ skipping 67 matching lines @@
   spdy_session_pool_->http_server_properties()->SetSpdySetting(
       test_host_port_pair_,
       SETTINGS_MAX_CONCURRENT_STREAMS,
       SETTINGS_FLAG_PLEASE_PERSIST,
       1);
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   GURL url1("http://www.google.com");
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, url1, LOWEST, BoundNetLog());
+      CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
+                                session, url1, LOWEST, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
   EXPECT_EQ(0u, spdy_stream1->stream_id());
 
   TestCompletionCallback callback2;
   GURL url2("http://www.google.com");
   SpdyStreamRequest request2;
   ASSERT_EQ(ERR_IO_PENDING,
-            request2.StartRequest(session, url2, LOWEST,
+            request2.StartRequest(SPDY_BIDIRECTIONAL_STREAM,
+                                  session, url2, LOWEST,
                                   BoundNetLog(),
                                   callback2.callback()));
 
   TestCompletionCallback callback3;
   GURL url3("http://www.google.com");
   SpdyStreamRequest request3;
   ASSERT_EQ(ERR_IO_PENDING,
-            request3.StartRequest(session, url3, LOWEST,
+            request3.StartRequest(SPDY_BIDIRECTIONAL_STREAM,
+                                  session, url3, LOWEST,
                                   BoundNetLog(),
                                   callback3.callback()));
 
   EXPECT_EQ(1u, session->num_active_streams() + session->num_created_streams());
   EXPECT_EQ(2u, session->pending_create_stream_queues(LOWEST));
 
   // Cancel the first stream, this will allow the second stream to be created.
   EXPECT_TRUE(spdy_stream1.get() != NULL);
   spdy_stream1->Cancel();
   EXPECT_EQ(NULL, spdy_stream1.get());
@@ skipping 126 matching lines @@
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
 
   CreateDeterministicNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   GURL url1("http://www.google.com");
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, url1, MEDIUM, BoundNetLog());
+      CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
+                                session, url1, MEDIUM, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
   EXPECT_EQ(0u, spdy_stream1->stream_id());
   test::StreamDelegateDoNothing delegate1(spdy_stream1);
   spdy_stream1->SetDelegate(&delegate1);
 
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
   (*headers)["method"] = "GET";
   (*headers)["scheme"] = url1.scheme();
   (*headers)["host"] = url1.host();
   (*headers)["url"] = url1.path();
@@ skipping 72 matching lines @@
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
 
   CreateDeterministicNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   GURL url1("http://www.google.com");
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, url1, MEDIUM, BoundNetLog());
+      CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
+                                session, url1, MEDIUM, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
   EXPECT_EQ(0u, spdy_stream1->stream_id());
   test::StreamDelegateDoNothing delegate1(spdy_stream1);
   spdy_stream1->SetDelegate(&delegate1);
 
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
   (*headers)["method"] = "GET";
   (*headers)["scheme"] = url1.scheme();
   (*headers)["host"] = url1.host();
   (*headers)["url"] = url1.path();
@@ skipping 95 matching lines @@
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
 
   CreateDeterministicNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   GURL url1("http://www.google.com");
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, url1, MEDIUM, BoundNetLog());
+      CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
+                                session, url1, MEDIUM, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
   EXPECT_EQ(0u, spdy_stream1->stream_id());
   test::StreamDelegateDoNothing delegate1(spdy_stream1);
   spdy_stream1->SetDelegate(&delegate1);
 
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
   (*headers)["method"] = "GET";
   (*headers)["scheme"] = url1.scheme();
   (*headers)["host"] = url1.host();
   (*headers)["url"] = url1.path();
@@ skipping 57 matching lines @@
 
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
 
   CreateDeterministicNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   GURL url1("http://www.google.com");
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session, url1, MEDIUM, BoundNetLog());
+      CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
+                                session, url1, MEDIUM, BoundNetLog());
   session = NULL;
   ASSERT_TRUE(spdy_stream1.get() != NULL);
   EXPECT_EQ(0u, spdy_stream1->stream_id());
 
   scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
   (*headers)["method"] = "GET";
   (*headers)["scheme"] = url1.scheme();
   (*headers)["host"] = url1.host();
   (*headers)["url"] = url1.path();
   (*headers)["version"] = "HTTP/1.1";
@@ skipping 201 matching lines @@
   EXPECT_EQ(
       OK,
       InitializeSession(http_session_.get(), session1.get(),
                         key1.host_port_pair()));
   EXPECT_FALSE(pool->IsStalled());
 
   // Create a stream using the session, and send a request.
 
   TestCompletionCallback callback1;
   base::WeakPtr<SpdyStream> spdy_stream1 =
-      CreateStreamSynchronously(session1, url1, DEFAULT_PRIORITY,
+      CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
+                                session1, url1, DEFAULT_PRIORITY,
                                 BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get());
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
   spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
   base::MessageLoop::current()->RunUntilIdle();
 
   // Release the session, so holding onto a pointer here does not affect
@@ skipping 23 matching lines @@
   // Cancelling the request should still not release the session's socket,
   // since the session is still kept alive by the SpdySessionPool.
   ASSERT_TRUE(spdy_stream1.get());
   spdy_stream1->Cancel();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(pool->IsStalled());
   EXPECT_FALSE(callback2.have_result());
 }
 
 }  // namespace net