[SPDY] Refactor tests in preparation for a fix for a session flow control bug

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 "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/pending_task.h"
@@ skipping 23 matching lines @@
 
 static const char kTestUrl[] = "http://www.example.org/";
 static const char kTestHost[] = "www.example.org";
 static const int kTestPort = 80;
 
 static int g_delta_seconds = 0;
 base::TimeTicks TheNearFuture() {
   return base::TimeTicks::Now() + base::TimeDelta::FromSeconds(g_delta_seconds);
 }
 
+// TODO(akalin): Merge with ConstructSpdyGet(). (The sticking point is
+// CONTROL_FLAG_NONE vs. CONTROL_FLAG_FIN.)

[Ryan Hamilton, 2013/03/14 15:29:45]

Curious...  Isn't it illegal for a SYN_STREAM which encodes a GET to have the
fin bit unset?  (Since a GET can't have a body?)  From the SPDY/3 Spec:

For requests which do not contain a body, the SYN_STREAM frame MUST set the
FLAG_FIN, indicating that the client intends to send no further data on this
stream. 

I gather it is important that this request not have the fin bit set.  Should it
be a POST instead?  (I think we might have a helper method for that)

[akalin, 2013/03/15 17:28:56]

Okay, converted these tests to use posts and added the necessary util functions.
Also removed these ad-hoc util functions.

+scoped_ptr<SpdyFrame> ConstructSpdyGetRequest(const char* url,
+                                              SpdyStreamId id,
+                                              RequestPriority priority) {
+  const SpdyHeaderInfo kSynStartHeader = {
+    SYN_STREAM,
+    id,
+    0,
+    ConvertRequestPriorityToSpdyPriority(priority, 3),
+    0,
+    CONTROL_FLAG_NONE,
+    false,
+    RST_STREAM_INVALID,
+    NULL,
+    0,
+    DATA_FLAG_NONE
+  };
+
+  return scoped_ptr<SpdyFrame>(
+      ConstructSpdyPacket(kSynStartHeader, ConstructHeaderBlock(url)));
+}
+
 }  // namespace
 
 class SpdySessionSpdy3Test : public PlatformTest {
  protected:
   SpdySessionSpdy3Test()
       : spdy_session_pool_(NULL),
         test_url_(kTestUrl),
         test_host_port_pair_(kTestHost, kTestPort),
         pair_(test_host_port_pair_, ProxyServer::Direct()) {
   }
@@ skipping 887 matching lines @@
   scoped_refptr<SpdyStream> spdy_stream1 =
       CreateStreamSynchronously(session, url, LOWEST, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
   EXPECT_EQ(0u, spdy_stream1->stream_id());
 
   scoped_refptr<SpdyStream> spdy_stream2 =
       CreateStreamSynchronously(session, url, HIGHEST, 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"] = url.scheme();
-  (*headers)[":host"] = url.host();
-  (*headers)[":path"] = url.path();
-  (*headers)[":version"] = "HTTP/1.1";
-  scoped_ptr<SpdyHeaderBlock> headers2(new SpdyHeaderBlock);
-  *headers2 = *headers;
-
-  spdy_stream1->set_spdy_headers(headers.Pass());
+  spdy_stream1->set_spdy_headers(ConstructHeaderBlock(url.spec()));
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
-  spdy_stream2->set_spdy_headers(headers2.Pass());
+  spdy_stream2->set_spdy_headers(ConstructHeaderBlock(url.spec()));
   EXPECT_TRUE(spdy_stream2->HasUrl());
 
   spdy_stream1->SendRequest(false);
   spdy_stream2->SendRequest(false);
   MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(3u, spdy_stream1->stream_id());
   EXPECT_EQ(1u, spdy_stream2->stream_id());
 
   spdy_stream1->Cancel();
@@ skipping 39 matching lines @@
       CreateStreamSynchronously(session, url1, HIGHEST, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
   EXPECT_EQ(0u, spdy_stream1->stream_id());
 
   GURL url2("http://www.google.com");
   scoped_refptr<SpdyStream> spdy_stream2 =
       CreateStreamSynchronously(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)[":path"] = url1.path();
-  (*headers)[":version"] = "HTTP/1.1";
-  scoped_ptr<SpdyHeaderBlock> headers2(new SpdyHeaderBlock);
-  *headers2 = *headers;
-
-  spdy_stream1->set_spdy_headers(headers.Pass());
+  spdy_stream1->set_spdy_headers(ConstructHeaderBlock(url1.spec()));
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
-  spdy_stream2->set_spdy_headers(headers2.Pass());
+  spdy_stream2->set_spdy_headers(ConstructHeaderBlock(url2.spec()));
   EXPECT_TRUE(spdy_stream2->HasUrl());
 
   spdy_stream1->SendRequest(false);
   spdy_stream2->SendRequest(false);
 
   EXPECT_EQ(0u, spdy_stream1->stream_id());
 
   spdy_stream1->Cancel();
 
   EXPECT_EQ(0u, spdy_stream1->stream_id());
@@ skipping 40 matching lines @@
       CreateStreamSynchronously(session, url1, HIGHEST, BoundNetLog());
   ASSERT_TRUE(spdy_stream1.get() != NULL);
   EXPECT_EQ(0u, spdy_stream1->stream_id());
 
   GURL url2("http://www.google.com");
   scoped_refptr<SpdyStream> spdy_stream2 =
       CreateStreamSynchronously(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);
-  *headers2 = *headers;
-
-  spdy_stream1->set_spdy_headers(headers.Pass());
+  spdy_stream1->set_spdy_headers(ConstructHeaderBlock(url1.spec()));
   EXPECT_TRUE(spdy_stream1->HasUrl());
   test::ClosingDelegate delegate1(spdy_stream1.get());
   spdy_stream1->SetDelegate(&delegate1);
 
-  spdy_stream2->set_spdy_headers(headers2.Pass());
+  spdy_stream2->set_spdy_headers(ConstructHeaderBlock(url2.spec()));
   EXPECT_TRUE(spdy_stream2->HasUrl());
   test::ClosingDelegate delegate2(spdy_stream2.get());
   spdy_stream2->SetDelegate(&delegate2);
 
   spdy_stream1->SendRequest(false);
   spdy_stream2->SendRequest(false);
 
   // Ensure that the streams have not yet been activated and assigned an id.
   EXPECT_EQ(0u, spdy_stream1->stream_id());
   EXPECT_EQ(0u, spdy_stream2->stream_id());
@@ skipping 222 matching lines @@
   GURL url3("http://www.google.com");
   SpdyStreamRequest request3;
   ASSERT_EQ(ERR_IO_PENDING,
             request3.StartRequest(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)[":path"] = url1.path();
-  (*headers)[":version"] = "HTTP/1.1";
-  scoped_ptr<SpdyHeaderBlock> headers2(new SpdyHeaderBlock);
-  *headers2 = *headers;
-  scoped_ptr<SpdyHeaderBlock> headers3(new SpdyHeaderBlock);
-  *headers3 = *headers;
-
-  spdy_stream1->set_spdy_headers(headers.Pass());
+  spdy_stream1->set_spdy_headers(ConstructHeaderBlock(url1.spec()));
   EXPECT_TRUE(spdy_stream1->HasUrl());
   spdy_stream1->SendRequest(false);
 
   // Run until 1st stream is closed and 2nd one is opened.
   EXPECT_EQ(0u, spdy_stream1->stream_id());
   data.RunFor(3);
   EXPECT_EQ(1u, spdy_stream1->stream_id());
   EXPECT_EQ(2u, session->num_active_streams() + session->num_created_streams());
   EXPECT_EQ(0u, session->pending_create_stream_queues(LOWEST));
 
   scoped_refptr<SpdyStream> stream2 = request2.ReleaseStream();
-  stream2->set_spdy_headers(headers2.Pass());
+  stream2->set_spdy_headers(ConstructHeaderBlock(url2.spec()));
   EXPECT_TRUE(stream2->HasUrl());
   stream2->SendRequest(false);
 
   // Run until 2nd stream is closed.
   EXPECT_EQ(0u, stream2->stream_id());
   data.RunFor(3);
   EXPECT_EQ(3u, stream2->stream_id());
   EXPECT_EQ(1u, session->num_active_streams() + session->num_created_streams());
   EXPECT_EQ(0u, session->pending_create_stream_queues(LOWEST));
 
   scoped_refptr<SpdyStream> stream3 = request3.ReleaseStream();
-  stream3->set_spdy_headers(headers3.Pass());
+  stream3->set_spdy_headers(ConstructHeaderBlock(url3.spec()));
   EXPECT_TRUE(stream3->HasUrl());
   stream3->SendRequest(false);
 
   EXPECT_EQ(0u, stream3->stream_id());
   data.RunFor(4);
   EXPECT_EQ(5u, stream3->stream_id());
   EXPECT_EQ(0u, session->num_active_streams() + session->num_created_streams());
   EXPECT_EQ(0u, session->pending_create_stream_queues(LOWEST));
 }
 
@@ skipping 296 matching lines @@
   CreateDeterministicNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   GURL url1("http://www.google.com");
   scoped_refptr<SpdyStream> spdy_stream1 =
       CreateStreamSynchronously(session, url1, MEDIUM, BoundNetLog());
   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)[":path"] = url1.path();
-  (*headers)[":version"] = "HTTP/1.1";
-
-  spdy_stream1->set_spdy_headers(headers.Pass());
+  spdy_stream1->set_spdy_headers(ConstructHeaderBlock(url1.spec()));
   EXPECT_TRUE(spdy_stream1->HasUrl());
   spdy_stream1->SendRequest(false);
 
   // Set up the TaskObserver to verify SpdySession::DoRead doesn't post a task.
   SpdySessionTestTaskObserver observer("spdy_session.cc", "DoRead");
 
   // Run until 1st read.
   EXPECT_EQ(0u, spdy_stream1->stream_id());
   data.RunFor(2);
   EXPECT_EQ(1u, spdy_stream1->stream_id());
@@ skipping 62 matching lines @@
   CreateDeterministicNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   GURL url1("http://www.google.com");
   scoped_refptr<SpdyStream> spdy_stream1 =
       CreateStreamSynchronously(session, url1, MEDIUM, BoundNetLog());
   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)[":path"] = url1.path();
-  (*headers)[":version"] = "HTTP/1.1";
-
-  spdy_stream1->set_spdy_headers(headers.Pass());
+  spdy_stream1->set_spdy_headers(ConstructHeaderBlock(url1.spec()));
   EXPECT_TRUE(spdy_stream1->HasUrl());
   spdy_stream1->SendRequest(false);
 
   // Set up the TaskObserver to verify SpdySession::DoRead posts a task.
   SpdySessionTestTaskObserver observer("spdy_session.cc", "DoRead");
 
   // Run until 1st read.
   EXPECT_EQ(0u, spdy_stream1->stream_id());
   data.RunFor(2);
   EXPECT_EQ(1u, spdy_stream1->stream_id());
@@ skipping 85 matching lines @@
   CreateDeterministicNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   GURL url1("http://www.google.com");
   scoped_refptr<SpdyStream> spdy_stream1 =
       CreateStreamSynchronously(session, url1, MEDIUM, BoundNetLog());
   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)[":path"] = url1.path();
-  (*headers)[":version"] = "HTTP/1.1";
-
-  spdy_stream1->set_spdy_headers(headers.Pass());
+  spdy_stream1->set_spdy_headers(ConstructHeaderBlock(url1.spec()));
   EXPECT_TRUE(spdy_stream1->HasUrl());
   spdy_stream1->SendRequest(false);
 
   // Set up the TaskObserver to monitor SpdySession::DoRead posting of tasks.
   SpdySessionTestTaskObserver observer("spdy_session.cc", "DoRead");
 
   // Run until 1st read.
   EXPECT_EQ(0u, spdy_stream1->stream_id());
   data.RunFor(2);
   EXPECT_EQ(1u, spdy_stream1->stream_id());
@@ skipping 47 matching lines @@
   CreateDeterministicNetworkSession();
 
   scoped_refptr<SpdySession> session = CreateInitializedSession();
 
   GURL url1("http://www.google.com");
   scoped_refptr<SpdyStream> spdy_stream1 =
       CreateStreamSynchronously(session, url1, MEDIUM, BoundNetLog());
   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)[":path"] = url1.path();
-  (*headers)[":version"] = "HTTP/1.1";
-
-  spdy_stream1->set_spdy_headers(headers.Pass());
+  spdy_stream1->set_spdy_headers(ConstructHeaderBlock(url1.spec()));
   EXPECT_TRUE(spdy_stream1->HasUrl());
   spdy_stream1->SendRequest(false);
 
   // Run until 1st read.
   EXPECT_EQ(0u, spdy_stream1->stream_id());
   data.RunFor(1);
   EXPECT_EQ(1u, spdy_stream1->stream_id());
 
   // Drop the reference to the session.
   session = NULL;
@@ skipping 333 matching lines @@
       CreateStreamSynchronously(session, url1, MEDIUM, BoundNetLog());
   ASSERT_TRUE(stream.get() != NULL);
   EXPECT_EQ(0u, stream->stream_id());
 
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(msg_data_size));
   memcpy(buf->data(), msg_data.data(), msg_data_size);
   test::StreamDelegateSendImmediate delegate(
       stream.get(), scoped_ptr<SpdyHeaderBlock>(), buf.get());
   stream->SetDelegate(&delegate);
 
-  scoped_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";
-
-  stream->set_spdy_headers(headers.Pass());
+  stream->set_spdy_headers(ConstructHeaderBlock(url1.spec()));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(true));
 
   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
   EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
   EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
 
   data.RunFor(2);
 
   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
@@ skipping 36 matching lines @@
   session->IncreaseRecvWindowSize(msg_data_size);
 
   EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
   EXPECT_EQ(msg_data_size, session->session_unacked_recv_window_bytes_);
 
   stream->Close();
 
   EXPECT_EQ(OK, delegate.WaitForClose());
 }
 
+// TODO(akalin): Re-enable the tests below when we fix the unstall bug
+// mentioned in crbug.com/178943.
+
+// Cause a stall by reducing the flow control send window to 0. The
+// stream should resume when that window is then increased.
+TEST_F(SpdySessionSpdy3Test, DISABLED_ResumeAfterSendWindowSizeIncrease31) {
+  const char kStreamUrl[] = "http://www.google.com/";
+  GURL url(kStreamUrl);
+
+  session_deps_.enable_spdy_31 = true;
+  session_deps_.host_resolver->set_synchronous_mode(true);
+
+  scoped_ptr<SpdyFrame> initial_window_update(
+      ConstructSpdyWindowUpdate(
+          kSessionFlowControlStreamId,
+          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
+  const char kBodyData[] = "Body data";
+  const size_t kBodyDataSize = arraysize(kBodyData);
+  scoped_ptr<SpdyFrame> req = ConstructSpdyGetRequest(kStreamUrl, 1, LOWEST);
+  scoped_ptr<SpdyFrame> msg(
+      ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, DATA_FLAG_NONE));
+  MockWrite writes[] = {
+    CreateMockWrite(*initial_window_update, 0),
+    CreateMockWrite(*req, 1),
+    CreateMockWrite(*msg, 3),
+  };
+
+  scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> echo(
+      ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, DATA_FLAG_NONE));
+  MockRead reads[] = {
+    CreateMockRead(*resp, 2),
+    CreateMockRead(*echo, 4),
+    MockRead(ASYNC, 0, 0, 5), // EOF
+  };
+
+  DeterministicSocketData data(reads, arraysize(reads),
+                               writes, arraysize(writes));
+  MockConnect connect_data(SYNCHRONOUS, OK);
+  data.set_connect_data(connect_data);
+
+  session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+
+  CreateDeterministicNetworkSession();
+  scoped_refptr<SpdySession> session = GetSession(pair_);
+  InitializeSession(
+      http_session_.get(), session.get(), test_host_port_pair_);
+  EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
+            session->flow_control_state());
+
+  scoped_refptr<SpdyStream> stream =
+      CreateStreamSynchronously(session, url, LOWEST, BoundNetLog());
+  ASSERT_TRUE(stream.get() != NULL);
+  scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(kBodyDataSize));
+  memcpy(buf->data(), kBodyData, kBodyDataSize);
+
+  test::StreamDelegateWithBody delegate(stream.get(), buf);
+  stream->SetDelegate(&delegate);
+
+  EXPECT_FALSE(stream->HasUrl());
+
+  stream->set_spdy_headers(ConstructHeaderBlock(kStreamUrl));
+  EXPECT_TRUE(stream->HasUrl());
+  EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
+
+  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(true));
+
+  data.RunFor(3);
+
+  EXPECT_FALSE(stream->stalled_by_flow_control());
+
+  // Reduce the send window size to 0 to stall.
+  while (session->session_send_window_size_ > 0) {
+    session->DecreaseSendWindowSize(
+        std::min(kMaxSpdyFrameChunkSize, session->session_send_window_size_));
+  }
+
+  stream->QueueStreamData(buf.get(), buf->size(), DATA_FLAG_NONE);
+
+  EXPECT_TRUE(stream->stalled_by_flow_control());
+
+  session->IncreaseSendWindowSize(kBodyDataSize);
+
+  EXPECT_FALSE(stream->stalled_by_flow_control());
+
+  data.RunFor(3);
+
+  EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
+
+  EXPECT_TRUE(delegate.send_headers_completed());
+  EXPECT_EQ("200", delegate.GetResponseHeaderValue(":status"));
+  EXPECT_EQ("HTTP/1.1", delegate.GetResponseHeaderValue(":version"));
+  EXPECT_EQ(std::string(kBodyData, kBodyDataSize), delegate.received_data());
+  EXPECT_EQ(static_cast<int>(kBodyDataSize), delegate.body_data_sent());
+}
+
+// Cause a stall by reducing the flow control recv window to 0. The
+// stream should resume when that window is then increased.
+TEST_F(SpdySessionSpdy3Test,
+       DISABLED_ResumeByPriorityAfterSendWindowSizeIncrease31) {
+  const char kStreamUrl[] = "http://www.google.com/";
+  GURL url(kStreamUrl);
+
+  session_deps_.enable_spdy_31 = true;
+  session_deps_.host_resolver->set_synchronous_mode(true);
+
+  const char kBodyData[] = "Body data";
+  const size_t kBodyDataSize = arraysize(kBodyData);
+  scoped_ptr<SpdyFrame> initial_window_update(
+      ConstructSpdyWindowUpdate(
+          kSessionFlowControlStreamId,
+          kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
+  scoped_ptr<SpdyFrame> req1 = ConstructSpdyGetRequest(kStreamUrl, 1, LOWEST);
+  scoped_ptr<SpdyFrame> req2 = ConstructSpdyGetRequest(kStreamUrl, 3, MEDIUM);
+  scoped_ptr<SpdyFrame> msg1(
+      ConstructSpdyBodyFrame(3, kBodyData, kBodyDataSize, DATA_FLAG_NONE));
+  scoped_ptr<SpdyFrame> msg2(
+      ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, DATA_FLAG_NONE));
+  MockWrite writes[] = {
+    CreateMockWrite(*initial_window_update, 0),
+    CreateMockWrite(*req1, 1),
+    CreateMockWrite(*req2, 3),
+    CreateMockWrite(*msg1, 5),
+    CreateMockWrite(*msg2, 7),
+  };
+
+  scoped_ptr<SpdyFrame> resp1(ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 3));
+  scoped_ptr<SpdyFrame> echo1(
+      ConstructSpdyBodyFrame(3, kBodyData, kBodyDataSize, DATA_FLAG_NONE));
+  scoped_ptr<SpdyFrame> echo2(
+      ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, DATA_FLAG_NONE));
+  MockRead reads[] = {
+    CreateMockRead(*resp1, 2),
+    CreateMockRead(*resp2, 4),
+    CreateMockRead(*echo1, 6),
+    CreateMockRead(*echo2, 8),
+    MockRead(ASYNC, 0, 0, 9), // EOF
+  };
+
+  DeterministicSocketData data(reads, arraysize(reads),
+                               writes, arraysize(writes));
+  MockConnect connect_data(SYNCHRONOUS, OK);
+  data.set_connect_data(connect_data);
+
+  session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+
+  CreateDeterministicNetworkSession();
+  scoped_refptr<SpdySession> session = GetSession(pair_);
+  InitializeSession(
+      http_session_.get(), session.get(), test_host_port_pair_);
+  EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
+            session->flow_control_state());
+
+  scoped_refptr<SpdyStream> stream1 =
+      CreateStreamSynchronously(session, url, LOWEST, BoundNetLog());
+  ASSERT_TRUE(stream1.get() != NULL);
+  scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(kBodyDataSize));
+  memcpy(buf->data(), kBodyData, kBodyDataSize);
+
+  test::StreamDelegateWithBody delegate1(stream1.get(), buf);
+  stream1->SetDelegate(&delegate1);
+
+  EXPECT_FALSE(stream1->HasUrl());
+
+  stream1->set_spdy_headers(ConstructHeaderBlock(kStreamUrl));
+  EXPECT_TRUE(stream1->HasUrl());
+  EXPECT_EQ(kStreamUrl, stream1->GetUrl().spec());
+
+  EXPECT_EQ(ERR_IO_PENDING, stream1->SendRequest(true));
+
+  data.RunFor(3);
+  EXPECT_EQ(1u, stream1->stream_id());
+
+  scoped_refptr<SpdyStream> stream2 =
+      CreateStreamSynchronously(session, url, MEDIUM, BoundNetLog());
+  ASSERT_TRUE(stream2.get() != NULL);
+  scoped_refptr<IOBufferWithSize> buf2(new IOBufferWithSize(kBodyDataSize));
+  memcpy(buf2->data(), kBodyData, kBodyDataSize);
+
+  test::StreamDelegateWithBody delegate2(stream2.get(), buf2);
+  stream2->SetDelegate(&delegate2);
+
+  EXPECT_FALSE(stream2->HasUrl());
+
+  stream2->set_spdy_headers(ConstructHeaderBlock(kStreamUrl));
+  EXPECT_TRUE(stream2->HasUrl());
+  EXPECT_EQ(kStreamUrl, stream2->GetUrl().spec());
+
+  EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequest(true));
+
+  data.RunFor(2);
+  EXPECT_EQ(3u, stream2->stream_id());
+
+  EXPECT_FALSE(stream1->stalled_by_flow_control());
+  EXPECT_FALSE(stream2->stalled_by_flow_control());
+
+  // Reduce the send window size to 0 to stall.
+  while (session->session_send_window_size_ > 0) {
+    session->DecreaseSendWindowSize(
+        std::min(kMaxSpdyFrameChunkSize, session->session_send_window_size_));
+  }
+
+  stream1->QueueStreamData(buf.get(), buf->size(), DATA_FLAG_NONE);
+  stream2->QueueStreamData(buf.get(), buf->size(), DATA_FLAG_NONE);
+
+  EXPECT_TRUE(stream1->stalled_by_flow_control());
+  EXPECT_TRUE(stream2->stalled_by_flow_control());
+
+  // This should unstall only stream2.
+  session->IncreaseSendWindowSize(kBodyDataSize);
+
+  EXPECT_TRUE(stream1->stalled_by_flow_control());
+  EXPECT_FALSE(stream2->stalled_by_flow_control());
+
+  data.RunFor(2);
+
+  EXPECT_TRUE(stream1->stalled_by_flow_control());
+  EXPECT_FALSE(stream2->stalled_by_flow_control());
+
+  // This should then unstall stream1.
+  session->IncreaseSendWindowSize(kBodyDataSize);
+
+  EXPECT_FALSE(stream1->stalled_by_flow_control());
+  EXPECT_FALSE(stream2->stalled_by_flow_control());
+
+  data.RunFor(3);
+
+  EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate1.WaitForClose());
+  EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate2.WaitForClose());
+
+  EXPECT_TRUE(delegate1.send_headers_completed());
+  EXPECT_EQ("200", delegate1.GetResponseHeaderValue(":status"));
+  EXPECT_EQ("HTTP/1.1", delegate1.GetResponseHeaderValue(":version"));
+  EXPECT_EQ(std::string(kBodyData, kBodyDataSize), delegate1.received_data());
+  EXPECT_EQ(static_cast<int>(kBodyDataSize), delegate1.body_data_sent());
+
+  EXPECT_TRUE(delegate2.send_headers_completed());
+  EXPECT_EQ("200", delegate2.GetResponseHeaderValue(":status"));
+  EXPECT_EQ("HTTP/1.1", delegate2.GetResponseHeaderValue(":version"));
+  EXPECT_EQ(std::string(kBodyData, kBodyDataSize), delegate2.received_data());
+  EXPECT_EQ(static_cast<int>(kBodyDataSize), delegate2.body_data_sent());
+}
+
 }  // namespace net