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

net/spdy/spdy_stream_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 "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_log_unittest.h"
 #include "net/spdy/buffered_spdy_framer.h"
@@ skipping 10 matching lines @@
 using namespace net::test_spdy3;
 
 // TODO(ukai): factor out common part with spdy_http_stream_unittest.cc
 //
 namespace net {
 
 namespace test {
 
 namespace {
 
-const SpdyHeaderInfo kSynStartHeader = {
-  SYN_STREAM,
-  1,
-  0,
-  ConvertRequestPriorityToSpdyPriority(LOWEST, 3),
-  0,
-  CONTROL_FLAG_NONE,
-  false,
-  RST_STREAM_INVALID,
-  NULL,
-  0,
-  DATA_FLAG_NONE
-};
-
-const char* const kGetHeaders[] = {
-  ":method",
-  "GET",
-  ":scheme",
-  "http",
-  ":host",
-  "www.google.com",
-  ":path",
-  "/",
-  ":version",
-  "HTTP/1.1",
-};
-
-// TODO(akalin): Factor out the two functions below (duplicated in
-// spdy_stream_spdy2_unittest.cc). The main sticking point is the
-// different definitions of the SpdyHeaderInfo struct in
-// spdy_test_util_spdy{2,3}.h.
-
-scoped_ptr<SpdyFrame> ConstructSpdyGetRequest() {
-  return scoped_ptr<SpdyFrame>(
-      ConstructSpdyPacket(
-          kSynStartHeader, NULL, 0, kGetHeaders, arraysize(kGetHeaders) / 2));
-}
-
-scoped_ptr<SpdyHeaderBlock> ConstructSpdyGetHeaderBlock() {
-  scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
-  for (size_t i = 0; i < arraysize(kGetHeaders) / 2; ++i) {
-    (*headers)[kGetHeaders[2*i]] = kGetHeaders[2*i+1];
-  }
-  return headers.Pass();
-}
-
-scoped_ptr<SpdyFrame> ConstructSpdyBodyFrame(const char* data, int length) {
-  BufferedSpdyFramer framer(kSpdyVersion3, false);
-  return scoped_ptr<SpdyFrame>(
-      framer.CreateDataFrame(1, data, length, DATA_FLAG_NONE));
-}
+const char kStreamUrl[] = "http://www.google.com/";
+const char kPostBody[] = "\0hello!\xff";
+const size_t kPostBodyLength = arraysize(kPostBody);
 
 class SpdyStreamSpdy3Test : public testing::Test {
  protected:
   SpdyStreamSpdy3Test() : host_port_pair_("www.google.com", 80) {
   }
 
   scoped_refptr<SpdySession> CreateSpdySession() {
     HostPortProxyPair pair(host_port_pair_, ProxyServer::Direct());
     scoped_refptr<SpdySession> session(
         session_->spdy_session_pool()->Get(pair, BoundNetLog()));
@@ skipping 18 matching lines @@
   virtual void TearDown() {
     MessageLoop::current()->RunUntilIdle();
   }
 
   HostPortPair host_port_pair_;
   SpdySessionDependencies session_deps_;
   scoped_refptr<HttpNetworkSession> session_;
 };
 
 TEST_F(SpdyStreamSpdy3Test, SendDataAfterOpen) {
+  GURL url(kStreamUrl);
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 
-  scoped_ptr<SpdyFrame> req = ConstructSpdyGetRequest();
-  scoped_ptr<SpdyFrame> msg = ConstructSpdyBodyFrame("\0hello!\xff", 8);
+  scoped_ptr<SpdyFrame> req(
+      ConstructSpdyPost(kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
+  scoped_ptr<SpdyFrame> msg(
+      ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*msg),
   };
   writes[0].sequence_number = 0;
   writes[1].sequence_number = 2;
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> echo = ConstructSpdyBodyFrame("\0hello!\xff", 8);
+  scoped_ptr<SpdyFrame> echo(
+      ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*echo),
     MockRead(ASYNC, 0, 0), // EOF
   };
   reads[0].sequence_number = 1;
   reads[1].sequence_number = 3;
   reads[2].sequence_number = 4;
 
   OrderedSocketData data(reads, arraysize(reads),
                          writes, arraysize(writes));
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   scoped_refptr<SpdySession> session(CreateSpdySession());
-  const char kStreamUrl[] = "http://www.google.com/";
-  GURL url(kStreamUrl);
 
   InitializeSpdySession(session, host_port_pair_);
 
   scoped_refptr<SpdyStream> stream =
       CreateStreamSynchronously(session, url, LOWEST, BoundNetLog());
   ASSERT_TRUE(stream.get() != NULL);
-  scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(8));
-  memcpy(buf->data(), "\0hello!\xff", 8);
+  scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(kPostBodyLength));
+  memcpy(buf->data(), kPostBody, kPostBodyLength);
 
   StreamDelegateSendImmediate delegate(
       stream.get(), scoped_ptr<SpdyHeaderBlock>(), buf.get());
   stream->SetDelegate(&delegate);
 
   EXPECT_FALSE(stream->HasUrl());
 
-  stream->set_spdy_headers(ConstructSpdyGetHeaderBlock());
+  stream->set_spdy_headers(
+      ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(true));
 
   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("\0hello!\xff", 8), delegate.received_data());
-  EXPECT_EQ(8, delegate.data_sent());
+  EXPECT_EQ(std::string(kPostBody, kPostBodyLength), delegate.received_data());
+  EXPECT_EQ(static_cast<int>(kPostBodyLength), delegate.data_sent());
 }
 
 TEST_F(SpdyStreamSpdy3Test, SendHeaderAndDataAfterOpen) {
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 
   scoped_ptr<SpdyFrame> expected_request(ConstructSpdyWebSocketSynStream(
       1,
       "/chat",
       "server.example.com",
       "http://example.com"));
   scoped_ptr<SpdyFrame> expected_headers(ConstructSpdyWebSocketHeadersFrame(
       1, "6", true));
-  scoped_ptr<SpdyFrame> expected_message = ConstructSpdyBodyFrame("hello!", 6);
+  scoped_ptr<SpdyFrame> expected_message(
+      ConstructSpdyBodyFrame(1, "hello!", 6, false));
   MockWrite writes[] = {
     CreateMockWrite(*expected_request),
     CreateMockWrite(*expected_headers),
     CreateMockWrite(*expected_message)
   };
   writes[0].sequence_number = 0;
   writes[1].sequence_number = 2;
   writes[1].sequence_number = 3;
 
   scoped_ptr<SpdyFrame> response(
       ConstructSpdyWebSocketSynReply(1));
   MockRead reads[] = {
     CreateMockRead(*response),
     MockRead(ASYNC, 0, 0), // EOF
   };
   reads[0].sequence_number = 1;
   reads[1].sequence_number = 4;
 
   OrderedSocketData data(reads, arraysize(reads),
                          writes, arraysize(writes));
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   scoped_refptr<SpdySession> session(CreateSpdySession());
-  const char kStreamUrl[] = "ws://server.example.com/chat";
-  GURL url(kStreamUrl);
+  GURL url("ws://server.example.com/chat");
 
   HostPortPair host_port_pair("server.example.com", 80);
   InitializeSpdySession(session, host_port_pair);
 
   scoped_refptr<SpdyStream> stream =
       CreateStreamSynchronously(session, url, HIGHEST, BoundNetLog());
   ASSERT_TRUE(stream.get() != NULL);
   scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(6));
   memcpy(buf->data(), "hello!", 6);
   TestCompletionCallback callback;
@@ skipping 22 matching lines @@
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 
   EXPECT_TRUE(delegate.send_headers_completed());
   EXPECT_EQ("101", delegate.GetResponseHeaderValue(":status"));
   EXPECT_EQ(1, delegate.headers_sent());
   EXPECT_EQ(std::string(), delegate.received_data());
   EXPECT_EQ(6, delegate.data_sent());
 }
 
 TEST_F(SpdyStreamSpdy3Test, PushedStream) {
-  const char kStreamUrl[] = "http://www.google.com/";
-
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
   scoped_refptr<SpdySession> spdy_session(CreateSpdySession());
 
   MockRead reads[] = {
     MockRead(ASYNC, 0, 0), // EOF
   };
 
   OrderedSocketData data(reads, arraysize(reads), NULL, 0);
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
@@ skipping 25 matching lines @@
   response[":version"] = "OK";
   stream->OnHeaders(headers);
 
   stream->set_response_received();
   EXPECT_TRUE(stream->response_received());
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 }
 
 TEST_F(SpdyStreamSpdy3Test, StreamError) {
+  GURL url(kStreamUrl);
+
   session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
 
-  scoped_ptr<SpdyFrame> req = ConstructSpdyGetRequest();
-  scoped_ptr<SpdyFrame> msg = ConstructSpdyBodyFrame("\0hello!\xff", 8);
+  scoped_ptr<SpdyFrame> req(
+      ConstructSpdyPost(kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
+  scoped_ptr<SpdyFrame> msg(
+      ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*msg),
   };
   writes[0].sequence_number = 0;
   writes[1].sequence_number = 2;
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> echo = ConstructSpdyBodyFrame("\0hello!\xff", 8);
+  scoped_ptr<SpdyFrame> echo(
+      ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
   MockRead reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*echo),
     MockRead(ASYNC, 0, 0),  // EOF
   };
   reads[0].sequence_number = 1;
   reads[1].sequence_number = 3;
   reads[2].sequence_number = 4;
 
   CapturingBoundNetLog log;
 
   OrderedSocketData data(reads, arraysize(reads),
                          writes, arraysize(writes));
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   scoped_refptr<SpdySession> session(CreateSpdySession());
-  const char kStreamUrl[] = "http://www.google.com/";
-  GURL url(kStreamUrl);
 
   InitializeSpdySession(session, host_port_pair_);
 
   scoped_refptr<SpdyStream> stream =
       CreateStreamSynchronously(session, url, LOWEST, log.bound());
   ASSERT_TRUE(stream.get() != NULL);
-  scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(8));
-  memcpy(buf->data(), "\0hello!\xff", 8);
+  scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(kPostBodyLength));
+  memcpy(buf->data(), kPostBody, kPostBodyLength);
 
   StreamDelegateSendImmediate delegate(
       stream.get(), scoped_ptr<SpdyHeaderBlock>(), buf.get());
   stream->SetDelegate(&delegate);
 
   EXPECT_FALSE(stream->HasUrl());
 
-  stream->set_spdy_headers(ConstructSpdyGetHeaderBlock());
+  stream->set_spdy_headers(
+      ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(true));
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 
   const SpdyStreamId stream_id = stream->stream_id();
 
   EXPECT_TRUE(delegate.send_headers_completed());
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(":status"));
   EXPECT_EQ("HTTP/1.1", delegate.GetResponseHeaderValue(":version"));
-  EXPECT_EQ(std::string("\0hello!\xff", 8), delegate.received_data());
-  EXPECT_EQ(8, delegate.data_sent());
+  EXPECT_EQ(std::string(kPostBody, kPostBodyLength), delegate.received_data());
+  EXPECT_EQ(static_cast<int>(kPostBodyLength), delegate.data_sent());
 
   // Check that the NetLog was filled reasonably.
   net::CapturingNetLog::CapturedEntryList entries;
   log.GetEntries(&entries);
   EXPECT_LT(0u, entries.size());
 
   // Check that we logged SPDY_STREAM_ERROR correctly.
   int pos = net::ExpectLogContainsSomewhere(
       entries, 0,
       net::NetLog::TYPE_SPDY_STREAM_ERROR,
@@ skipping 25 matching lines @@
 
   CapturingBoundNetLog log;
 
   OrderedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   scoped_refptr<SpdySession> session(CreateSpdySession());
-  const char kStreamUrl[] = "http://www.google.com/";
   GURL url(kStreamUrl);
 
   InitializeSpdySession(session, host_port_pair_);
 
   scoped_refptr<SpdyStream> stream =
       CreateStreamSynchronously(session, url, LOWEST, log.bound());
   ASSERT_TRUE(stream.get() != NULL);
 
   scoped_ptr<StreamDelegateSendImmediate> delegate(
       new StreamDelegateSendImmediate(
           stream.get(), scoped_ptr<SpdyHeaderBlock>(),
-          new IOBufferWithSize(8)));
+          new IOBufferWithSize(kPostBodyLength)));
   stream->SetDelegate(delegate.get());
 
   EXPECT_FALSE(stream->HasUrl());
   EXPECT_EQ(0u, stream->stream_id());
   EXPECT_FALSE(stream->closed());
 
   int32 old_send_window_size = stream->send_window_size();
   ASSERT_GT(old_send_window_size, 0);
   int32 delta_window_size = kint32max - old_send_window_size + 1;
   stream->IncreaseSendWindowSize(delta_window_size);
   EXPECT_EQ(old_send_window_size, stream->send_window_size());
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate->WaitForClose());
 }
 
-// Cause a stall by reducing the flow control recv window to 0. The
+// Cause a stall by reducing the flow control send window to 0. The
 // stream should resume when that window is then increased.
-TEST_F(SpdyStreamSpdy3Test, ResumeAfterRecvWindowSizeIncrease) {
+TEST_F(SpdyStreamSpdy3Test, ResumeAfterSendWindowSizeIncrease) {
+  GURL url(kStreamUrl);
+
   session_ =
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 
-  const char kBodyData[] = "Body data";
-  const size_t kBodyDataSize = arraysize(kBodyData);
-  scoped_ptr<SpdyFrame> req = ConstructSpdyGetRequest();
-  scoped_ptr<SpdyFrame> msg = ConstructSpdyBodyFrame(kBodyData, kBodyDataSize);
+  scoped_ptr<SpdyFrame> req(
+      ConstructSpdyPost(kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
+  scoped_ptr<SpdyFrame> msg(
+      ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
   MockWrite writes[] = {
     CreateMockWrite(*req, 0),
     CreateMockWrite(*msg, 2),
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> echo = ConstructSpdyBodyFrame(kBodyData, kBodyDataSize);
+  scoped_ptr<SpdyFrame> echo(
+      ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
   MockRead reads[] = {
     CreateMockRead(*resp, 1),
     CreateMockRead(*echo, 3),
     MockRead(ASYNC, 0, 0, 4), // 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);
 
   scoped_refptr<SpdySession> session(CreateSpdySession());
-  const char kStreamUrl[] = "http://www.google.com/";
-  GURL url(kStreamUrl);
 
   InitializeSpdySession(session, host_port_pair_);
 
   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);
+  scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(kPostBodyLength));
+  memcpy(buf->data(), kPostBody, kPostBodyLength);
 
   StreamDelegateWithBody delegate(stream.get(), buf);
   stream->SetDelegate(&delegate);
 
   EXPECT_FALSE(stream->HasUrl());
 
-  stream->set_spdy_headers(ConstructSpdyGetHeaderBlock());
+  stream->set_spdy_headers(
+      ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(true));
 
   data.RunFor(2);
 
   EXPECT_FALSE(stream->stalled_by_flow_control());
 
   // Reduce the send window size to 0 to stall.
   while (stream->send_window_size() > 0) {
     stream->DecreaseSendWindowSize(
         std::min(kMaxSpdyFrameChunkSize, stream->send_window_size()));
   }
 
   stream->QueueStreamData(buf.get(), buf->size(), DATA_FLAG_NONE);
 
   EXPECT_TRUE(stream->stalled_by_flow_control());
 
-  stream->IncreaseSendWindowSize(kBodyDataSize);
+  stream->IncreaseSendWindowSize(kPostBodyLength);
 
   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());
+  EXPECT_EQ(std::string(kPostBody, kPostBodyLength), delegate.received_data());
+  EXPECT_EQ(static_cast<int>(kPostBodyLength), delegate.body_data_sent());
 }
 
-// Cause a stall by reducing the flow control recv window to 0. The
+// Cause a stall by reducing the flow control send window to 0. The
 // stream should resume when that window is then adjusted positively.
-TEST_F(SpdyStreamSpdy3Test, ResumeAfterRecvWindowSizeAdjust) {
+TEST_F(SpdyStreamSpdy3Test, ResumeAfterSendWindowSizeAdjust) {
+  GURL url(kStreamUrl);
+
   session_ =
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
 
-  const char kBodyData[] = "Body data";
-  const size_t kBodyDataSize = arraysize(kBodyData);
-  scoped_ptr<SpdyFrame> req = ConstructSpdyGetRequest();
+  scoped_ptr<SpdyFrame> req(
+      ConstructSpdyPost(kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> msg(
-      ConstructSpdyBodyFrame(kBodyData, kBodyDataSize));
+      ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
   MockWrite writes[] = {
     CreateMockWrite(*req, 0),
     CreateMockWrite(*msg, 2),
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> echo(
-      ConstructSpdyBodyFrame(kBodyData, kBodyDataSize));
+      ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
   MockRead reads[] = {
     CreateMockRead(*resp, 1),
     CreateMockRead(*echo, 3),
     MockRead(ASYNC, 0, 0, 4), // 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);
 
   scoped_refptr<SpdySession> session(CreateSpdySession());
-  const char kStreamUrl[] = "http://www.google.com/";
-  GURL url(kStreamUrl);
 
   InitializeSpdySession(session, host_port_pair_);
 
   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);
+  scoped_refptr<IOBufferWithSize> buf(new IOBufferWithSize(kPostBodyLength));
+  memcpy(buf->data(), kPostBody, kPostBodyLength);
 
   StreamDelegateWithBody delegate(stream.get(), buf);
   stream->SetDelegate(&delegate);
 
   EXPECT_FALSE(stream->HasUrl());
 
-  stream->set_spdy_headers(ConstructSpdyGetHeaderBlock());
+  stream->set_spdy_headers(
+      ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(true));
 
   data.RunFor(2);
 
   EXPECT_FALSE(stream->stalled_by_flow_control());
 
   // Reduce the send window size to 0 to stall.
   while (stream->send_window_size() > 0) {
     stream->DecreaseSendWindowSize(
         std::min(kMaxSpdyFrameChunkSize, stream->send_window_size()));
   }
 
   stream->QueueStreamData(buf.get(), buf->size(), DATA_FLAG_NONE);
 
   EXPECT_TRUE(stream->stalled_by_flow_control());
 
-  stream->AdjustSendWindowSize(-static_cast<int>(kBodyDataSize));
+  stream->AdjustSendWindowSize(-static_cast<int>(kPostBodyLength));
 
   EXPECT_TRUE(stream->stalled_by_flow_control());
 
-  stream->AdjustSendWindowSize(kBodyDataSize);
+  stream->AdjustSendWindowSize(kPostBodyLength);
 
   EXPECT_TRUE(stream->stalled_by_flow_control());
 
-  stream->AdjustSendWindowSize(kBodyDataSize);
+  stream->AdjustSendWindowSize(kPostBodyLength);
 
   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());
+  EXPECT_EQ(std::string(kPostBody, kPostBodyLength), delegate.received_data());
+  EXPECT_EQ(static_cast<int>(kPostBodyLength), delegate.body_data_sent());
 }
 
 }  // namespace
 
 }  // namespace test
 
 }  // namespace net