[SPDY] Keep track of whether we have no more data to send in SpdyStream

Replace pending_send_flags_ and has_upload_data_ with send_status_, and
update/check its value as necessary.

Make SpdyStream::Send{Request,StreamData}() take a SpdySendStatus
parameter.

Remove OnSendBodyComplete()'s return value, since it's now redundant.

Rename SendRequest() and related functions to SendRequestHeaders().

Change references to "send headers" to "send request".

Fix some discovered erroneous data in tests.

BUG=243643
R=rch@chromium.org

Review URL: https://codereview.chromium.org/15983003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@202252 0039d316-1c4b-4281-b951-d872f2087c98

14 files changed, 202 insertions, 168 deletions

diff --git a/net/spdy/spdy_http_stream.cc b/net/spdy/spdy_http_stream.cc
index dd98417..a9fe271 100644
--- a/net/spdy/spdy_http_stream.cc
+++ b/net/spdy/spdy_http_stream.cc
@@ -263,7 +263,10 @@ int SpdyHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
   stream_->net_log().AddEvent(
       NetLog::TYPE_HTTP_TRANSACTION_SPDY_SEND_REQUEST_HEADERS,
       base::Bind(&SpdyHeaderBlockNetLogCallback, headers.get()));
-  result = stream_->SendRequest(headers.Pass(), has_upload_data_);
+  result =
+      stream_->SendRequestHeaders(
+          headers.Pass(),
+          has_upload_data_ ? MORE_DATA_TO_SEND : NO_MORE_DATA_TO_SEND);
   if (result == ERR_IO_PENDING) {
     CHECK(callback_.is_null());
     callback_ = callback;
@@ -279,7 +282,7 @@ void SpdyHttpStream::Cancel() {
   }
 }
 
-SpdySendStatus SpdyHttpStream::OnSendHeadersComplete() {
+SpdySendStatus SpdyHttpStream::OnSendRequestHeadersComplete() {
   if (!callback_.is_null())
     DoCallback(OK);
   return has_upload_data_ ? MORE_DATA_TO_SEND : NO_MORE_DATA_TO_SEND;
@@ -296,14 +299,10 @@ void SpdyHttpStream::OnSendBody() {
   }
 }
 
-SpdySendStatus SpdyHttpStream::OnSendBodyComplete() {
+void SpdyHttpStream::OnSendBodyComplete() {
   // |status| is the number of bytes written to the SPDY stream.
   CHECK(request_info_ && request_info_->upload_data_stream);
   raw_request_body_buf_size_ = 0;
-
-  // Check for more data to send.
-  return request_info_->upload_data_stream->IsEOF() ?
-      NO_MORE_DATA_TO_SEND : MORE_DATA_TO_SEND;
 }
 
 int SpdyHttpStream::OnResponseReceived(const SpdyHeaderBlock& response,
@@ -456,7 +455,7 @@ void SpdyHttpStream::SendRequestBodyData() {
   }
   stream_->SendStreamData(raw_request_body_buf_,
                           raw_request_body_buf_size_,
-                          eof ? DATA_FLAG_FIN : DATA_FLAG_NONE);
+                          eof ? NO_MORE_DATA_TO_SEND : MORE_DATA_TO_SEND);
 }
 
 void SpdyHttpStream::ScheduleBufferedReadCallback() {
diff --git a/net/spdy/spdy_http_stream.h b/net/spdy/spdy_http_stream.h
index c02ec44..8f09ef8 100644
--- a/net/spdy/spdy_http_stream.h
+++ b/net/spdy/spdy_http_stream.h
@@ -84,9 +84,9 @@ class NET_EXPORT_PRIVATE SpdyHttpStream : public SpdyStream::Delegate,
   virtual void Drain(HttpNetworkSession* session) OVERRIDE;
 
   // SpdyStream::Delegate implementation.
-  virtual SpdySendStatus OnSendHeadersComplete() OVERRIDE;
+  virtual SpdySendStatus OnSendRequestHeadersComplete() OVERRIDE;
   virtual void OnSendBody() OVERRIDE;
-  virtual SpdySendStatus OnSendBodyComplete() OVERRIDE;
+  virtual void OnSendBodyComplete() OVERRIDE;
   virtual int OnResponseReceived(const SpdyHeaderBlock& response,
                                  base::Time response_time,
                                  int status) OVERRIDE;
diff --git a/net/spdy/spdy_proxy_client_socket.cc b/net/spdy/spdy_proxy_client_socket.cc
index f009ba4..14d9721 100644
--- a/net/spdy/spdy_proxy_client_socket.cc
+++ b/net/spdy/spdy_proxy_client_socket.cc
@@ -226,7 +226,7 @@ int SpdyProxyClientSocket::Write(IOBuffer* buf, int buf_len,
     return ERR_SOCKET_NOT_CONNECTED;
 
   DCHECK(spdy_stream_);
-  spdy_stream_->SendStreamData(buf, buf_len, DATA_FLAG_NONE);
+  spdy_stream_->SendStreamData(buf, buf_len, MORE_DATA_TO_SEND);
   net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT,
                                 buf_len, buf->data());
   write_callback_ = callback;
@@ -369,7 +369,7 @@ int SpdyProxyClientSocket::DoSendRequest() {
     headers->erase("scheme");
   }
 
-  return spdy_stream_->SendRequest(headers.Pass(), true);
+  return spdy_stream_->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND);
 }
 
 int SpdyProxyClientSocket::DoSendRequestComplete(int result) {
@@ -435,7 +435,7 @@ int SpdyProxyClientSocket::DoReadReplyComplete(int result) {
 // SpdyStream::Delegate methods:
 // Called when SYN frame has been sent.
 // Returns true if no more data to be sent after SYN frame.
-SpdySendStatus SpdyProxyClientSocket::OnSendHeadersComplete() {
+SpdySendStatus SpdyProxyClientSocket::OnSendRequestHeadersComplete() {
   DCHECK_EQ(next_state_, STATE_SEND_REQUEST_COMPLETE);
 
   OnIOComplete(OK);
@@ -451,11 +451,10 @@ void SpdyProxyClientSocket::OnSendBody() {
   CHECK(false);
 }
 
-SpdySendStatus SpdyProxyClientSocket::OnSendBodyComplete() {
+void SpdyProxyClientSocket::OnSendBodyComplete() {
   // Because we use |spdy_stream_| via STATE_OPEN (ala WebSockets)
   // OnSendBodyComplete() must never be called.
   CHECK(false);
-  return NO_MORE_DATA_TO_SEND;
 }
 
 int SpdyProxyClientSocket::OnResponseReceived(
diff --git a/net/spdy/spdy_proxy_client_socket.h b/net/spdy/spdy_proxy_client_socket.h
index fb26c272..57143d9 100644
--- a/net/spdy/spdy_proxy_client_socket.h
+++ b/net/spdy/spdy_proxy_client_socket.h
@@ -91,9 +91,9 @@ class NET_EXPORT_PRIVATE SpdyProxyClientSocket : public ProxyClientSocket,
   virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
 
   // SpdyStream::Delegate implementation.
-  virtual SpdySendStatus OnSendHeadersComplete() OVERRIDE;
+  virtual SpdySendStatus OnSendRequestHeadersComplete() OVERRIDE;
   virtual void OnSendBody() OVERRIDE;
-  virtual SpdySendStatus OnSendBodyComplete() OVERRIDE;
+  virtual void OnSendBodyComplete() OVERRIDE;
   virtual int OnResponseReceived(const SpdyHeaderBlock& response,
                                  base::Time response_time,
                                  int status) OVERRIDE;
diff --git a/net/spdy/spdy_session_spdy2_unittest.cc b/net/spdy/spdy_session_spdy2_unittest.cc
index 2db8b34..fef9294 100644
--- a/net/spdy/spdy_session_spdy2_unittest.cc
+++ b/net/spdy/spdy_session_spdy2_unittest.cc
@@ -179,9 +179,9 @@ TEST_F(SpdySessionSpdy2Test, GoAway) {
   scoped_ptr<SpdyHeaderBlock> headers2(new SpdyHeaderBlock);
   *headers2 = *headers;
 
-  spdy_stream1->SendRequest(headers.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
-  spdy_stream2->SendRequest(headers2.Pass(), false);
+  spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream2->HasUrl());
   data.RunFor(2);
 
@@ -333,7 +333,7 @@ TEST_F(SpdySessionSpdy2Test, DeleteExpiredPushStreams) {
                      kSpdyStreamInitialWindowSize,
                      kSpdyStreamInitialWindowSize,
                      false, session->net_log_));
-  stream->SendRequest(request_headers.Pass(), false);
+  stream->SendRequestHeaders(request_headers.Pass(), NO_MORE_DATA_TO_SEND);
   SpdyStream* stream_ptr = stream.get();
   session->InsertCreatedStream(stream.Pass());
   stream = session->ActivateCreatedStream(stream_ptr);
@@ -1174,9 +1174,9 @@ TEST_F(SpdySessionSpdy2Test, OutOfOrderSynStreams) {
   scoped_ptr<SpdyHeaderBlock> headers2(new SpdyHeaderBlock);
   *headers2 = *headers;
 
-  spdy_stream1->SendRequest(headers.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
-  spdy_stream2->SendRequest(headers2.Pass(), false);
+  spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream2->HasUrl());
 
   base::MessageLoop::current()->RunUntilIdle();
@@ -1244,9 +1244,9 @@ TEST_F(SpdySessionSpdy2Test, CancelStream) {
   scoped_ptr<SpdyHeaderBlock> headers2(new SpdyHeaderBlock);
   *headers2 = *headers;
 
-  spdy_stream1->SendRequest(headers.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
-  spdy_stream2->SendRequest(headers2.Pass(), false);
+  spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream2->HasUrl());
 
   EXPECT_EQ(0u, spdy_stream1->stream_id());
@@ -1319,9 +1319,9 @@ TEST_F(SpdySessionSpdy2Test, CloseSessionWithTwoCreatedStreams) {
   test::StreamDelegateDoNothing delegate2(spdy_stream2);
   spdy_stream2->SetDelegate(&delegate2);
 
-  spdy_stream1->SendRequest(headers.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
-  spdy_stream2->SendRequest(headers2.Pass(), false);
+  spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream2->HasUrl());
 
   // Ensure that the streams have not yet been activated and assigned an id.
@@ -1576,7 +1576,7 @@ TEST_F(SpdySessionSpdy2Test, CloseTwoStalledCreateStream) {
   scoped_ptr<SpdyHeaderBlock> headers3(new SpdyHeaderBlock);
   *headers3 = *headers;
 
-  spdy_stream1->SendRequest(headers.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
   // Run until 1st stream is closed and 2nd one is opened.
@@ -1592,7 +1592,7 @@ TEST_F(SpdySessionSpdy2Test, CloseTwoStalledCreateStream) {
   base::WeakPtr<SpdyStream> stream2 = request2.ReleaseStream();
   test::StreamDelegateDoNothing delegate2(stream2);
   stream2->SetDelegate(&delegate2);
-  stream2->SendRequest(headers2.Pass(), false);
+  stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(stream2->HasUrl());
 
   // Run until 2nd stream is closed.
@@ -1607,7 +1607,7 @@ TEST_F(SpdySessionSpdy2Test, CloseTwoStalledCreateStream) {
   ASSERT_TRUE(stream3.get() != NULL);
   test::StreamDelegateDoNothing delegate3(stream3);
   stream3->SetDelegate(&delegate3);
-  stream3->SendRequest(headers3.Pass(), false);
+  stream3->SendRequestHeaders(headers3.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(stream3->HasUrl());
 
   EXPECT_EQ(0u, delegate3.stream_id());
@@ -1823,7 +1823,7 @@ TEST_F(SpdySessionSpdy2Test, ReadDataWithoutYielding) {
   (*headers)["url"] = url1.path();
   (*headers)["version"] = "HTTP/1.1";
 
-  spdy_stream1->SendRequest(headers.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
   // Set up the TaskObserver to verify SpdySession::DoRead doesn't post a task.
@@ -1916,7 +1916,7 @@ TEST_F(SpdySessionSpdy2Test, TestYieldingDuringReadData) {
   (*headers)["url"] = url1.path();
   (*headers)["version"] = "HTTP/1.1";
 
-  spdy_stream1->SendRequest(headers.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
   // Set up the TaskObserver to verify SpdySession::DoRead posts a task.
@@ -2032,7 +2032,7 @@ TEST_F(SpdySessionSpdy2Test, TestYieldingDuringAsyncReadData) {
   (*headers)["url"] = url1.path();
   (*headers)["version"] = "HTTP/1.1";
 
-  spdy_stream1->SendRequest(headers.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
   // Set up the TaskObserver to monitor SpdySession::DoRead posting of tasks.
@@ -2109,7 +2109,7 @@ TEST_F(SpdySessionSpdy2Test, GoAwayWhileInDoLoop) {
   (*headers)["url"] = url1.path();
   (*headers)["version"] = "HTTP/1.1";
 
-  spdy_stream1->SendRequest(headers.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
   // Run until 1st read.
@@ -2325,7 +2325,7 @@ TEST_F(SpdySessionSpdy2Test, CloseOneIdleConnectionFailsWhenSessionInUse) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
-  spdy_stream1->SendRequest(headers.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
   base::MessageLoop::current()->RunUntilIdle();
 
diff --git a/net/spdy/spdy_session_spdy3_unittest.cc b/net/spdy/spdy_session_spdy3_unittest.cc
index 980ab91..de539d3 100644
--- a/net/spdy/spdy_session_spdy3_unittest.cc
+++ b/net/spdy/spdy_session_spdy3_unittest.cc
@@ -262,9 +262,9 @@ TEST_F(SpdySessionSpdy3Test, GoAway) {
   scoped_ptr<SpdyHeaderBlock> headers2(new SpdyHeaderBlock);
   *headers2 = *headers;
 
-  spdy_stream1->SendRequest(headers.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
-  spdy_stream2->SendRequest(headers2.Pass(), false);
+  spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream2->HasUrl());
 
   data.RunFor(2);
@@ -417,7 +417,7 @@ TEST_F(SpdySessionSpdy3Test, DeleteExpiredPushStreams) {
                      kSpdyStreamInitialWindowSize,
                      kSpdyStreamInitialWindowSize,
                      false, session->net_log_));
-  stream->SendRequest(request_headers.Pass(), false);
+  stream->SendRequestHeaders(request_headers.Pass(), NO_MORE_DATA_TO_SEND);
   SpdyStream* stream_ptr = stream.get();
   session->InsertCreatedStream(stream.Pass());
   stream = session->ActivateCreatedStream(stream_ptr);
@@ -1313,12 +1313,12 @@ TEST_F(SpdySessionSpdy3Test, OutOfOrderSynStreams) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructGetHeaderBlock(url.spec()));
-  spdy_stream1->SendRequest(headers.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
   scoped_ptr<SpdyHeaderBlock> headers2(
       spdy_util_.ConstructGetHeaderBlock(url.spec()));
-  spdy_stream2->SendRequest(headers2.Pass(), false);
+  spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream2->HasUrl());
 
   base::MessageLoop::current()->RunUntilIdle();
@@ -1379,12 +1379,12 @@ TEST_F(SpdySessionSpdy3Test, CancelStream) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
-  spdy_stream1->SendRequest(headers.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
   scoped_ptr<SpdyHeaderBlock> headers2(
       spdy_util_.ConstructGetHeaderBlock(url2.spec()));
-  spdy_stream2->SendRequest(headers2.Pass(), false);
+  spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream2->HasUrl());
 
   EXPECT_EQ(0u, spdy_stream1->stream_id());
@@ -1450,12 +1450,12 @@ TEST_F(SpdySessionSpdy3Test, CloseSessionWithTwoCreatedStreams) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
-  spdy_stream1->SendRequest(headers.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
   scoped_ptr<SpdyHeaderBlock> headers2(
       spdy_util_.ConstructGetHeaderBlock(url2.spec()));
-  spdy_stream2->SendRequest(headers2.Pass(), false);
+  spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream2->HasUrl());
 
   // Ensure that the streams have not yet been activated and assigned an id.
@@ -1703,7 +1703,7 @@ TEST_F(SpdySessionSpdy3Test, CloseTwoStalledCreateStream) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
-  spdy_stream1->SendRequest(headers.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
   // Run until 1st stream is closed and 2nd one is opened.
@@ -1721,7 +1721,7 @@ TEST_F(SpdySessionSpdy3Test, CloseTwoStalledCreateStream) {
   stream2->SetDelegate(&delegate2);
   scoped_ptr<SpdyHeaderBlock> headers2(
       spdy_util_.ConstructGetHeaderBlock(url2.spec()));
-  stream2->SendRequest(headers2.Pass(), false);
+  stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(stream2->HasUrl());
 
   // Run until 2nd stream is closed.
@@ -1737,7 +1737,7 @@ TEST_F(SpdySessionSpdy3Test, CloseTwoStalledCreateStream) {
   stream3->SetDelegate(&delegate3);
   scoped_ptr<SpdyHeaderBlock> headers3(
       spdy_util_.ConstructGetHeaderBlock(url3.spec()));
-  stream3->SendRequest(headers3.Pass(), false);
+  stream3->SendRequestHeaders(headers3.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(stream3->HasUrl());
 
   EXPECT_EQ(0u, delegate3.stream_id());
@@ -2067,7 +2067,7 @@ TEST_F(SpdySessionSpdy3Test, ReadDataWithoutYielding) {
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
-  spdy_stream1->SendRequest(headers1.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers1.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
   // Set up the TaskObserver to verify SpdySession::DoRead doesn't post a task.
@@ -2155,7 +2155,7 @@ TEST_F(SpdySessionSpdy3Test, TestYieldingDuringReadData) {
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
-  spdy_stream1->SendRequest(headers1.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers1.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
   // Set up the TaskObserver to verify SpdySession::DoRead posts a task.
@@ -2266,7 +2266,7 @@ TEST_F(SpdySessionSpdy3Test, TestYieldingDuringAsyncReadData) {
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
-  spdy_stream1->SendRequest(headers1.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers1.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
   // Set up the TaskObserver to monitor SpdySession::DoRead posting of tasks.
@@ -2338,7 +2338,7 @@ TEST_F(SpdySessionSpdy3Test, GoAwayWhileInDoLoop) {
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
-  spdy_stream1->SendRequest(headers1.Pass(), false);
+  spdy_stream1->SendRequestHeaders(headers1.Pass(), NO_MORE_DATA_TO_SEND);
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
   // Run until 1st read.
@@ -2684,7 +2684,8 @@ TEST_F(SpdySessionSpdy3Test, SessionFlowControlNoReceiveLeaks31) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(url.spec(), msg_data_size));
-  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
 
   EXPECT_EQ(kDefaultInitialRecvWindowSize, session->session_recv_window_size_);
@@ -2762,7 +2763,8 @@ TEST_F(SpdySessionSpdy3Test, SessionFlowControlNoSendLeaks31) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(url.spec(), msg_data_size));
-  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
 
   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
@@ -2852,7 +2854,8 @@ TEST_F(SpdySessionSpdy3Test, SessionFlowControlEndToEnd31) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(url.spec(), msg_data_size));
-  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
 
   EXPECT_EQ(kSpdySessionInitialWindowSize, session->session_send_window_size_);
@@ -2934,7 +2937,7 @@ void SpdySessionSpdy3Test::RunResumeAfterUnstallTest31(
   scoped_ptr<SpdyFrame> req(
       ConstructSpdyPost(kStreamUrl, 1, kBodyDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body(
-      ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, false));
+      ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, true));
   MockWrite writes[] = {
     CreateMockWrite(*initial_window_update, 0),
     CreateMockWrite(*req, 1),
@@ -2975,7 +2978,8 @@ void SpdySessionSpdy3Test::RunResumeAfterUnstallTest31(
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
-  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
@@ -3076,9 +3080,9 @@ TEST_F(SpdySessionSpdy3Test, ResumeByPriorityAfterSendWindowSizeIncrease31) {
   scoped_ptr<SpdyFrame> req2(
       ConstructSpdyPost(kStreamUrl, 3, kBodyDataSize, MEDIUM, NULL, 0));
   scoped_ptr<SpdyFrame> body1(
-      ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, false));
+      ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, true));
   scoped_ptr<SpdyFrame> body2(
-      ConstructSpdyBodyFrame(3, kBodyData, kBodyDataSize, false));
+      ConstructSpdyBodyFrame(3, kBodyData, kBodyDataSize, true));
   MockWrite writes[] = {
     CreateMockWrite(*initial_window_update, 0),
     CreateMockWrite(*req1, 1),
@@ -3134,7 +3138,8 @@ TEST_F(SpdySessionSpdy3Test, ResumeByPriorityAfterSendWindowSizeIncrease31) {
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
-  EXPECT_EQ(ERR_IO_PENDING, stream1->SendRequest(headers1.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream1->SendRequestHeaders(headers1.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream1->HasUrl());
   EXPECT_EQ(kStreamUrl, stream1->GetUrl().spec());
 
@@ -3144,7 +3149,8 @@ TEST_F(SpdySessionSpdy3Test, ResumeByPriorityAfterSendWindowSizeIncrease31) {
 
   scoped_ptr<SpdyHeaderBlock> headers2(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
-  EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequest(headers2.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream2->SendRequestHeaders(headers2.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream2->HasUrl());
   EXPECT_EQ(kStreamUrl, stream2->GetUrl().spec());
 
@@ -3200,13 +3206,12 @@ class StreamClosingDelegate : public test::StreamDelegateWithBody {
     stream_to_close_ = stream_to_close;
   }
 
-  virtual SpdySendStatus OnSendBodyComplete() OVERRIDE {
-    SpdySendStatus status = test::StreamDelegateWithBody::OnSendBodyComplete();
+  virtual void OnSendBodyComplete() OVERRIDE {
+    test::StreamDelegateWithBody::OnSendBodyComplete();
     if (stream_to_close_) {
       stream_to_close_->Close();
       EXPECT_EQ(NULL, stream_to_close_.get());
     }
-    return status;
   }
 
  private:
@@ -3233,7 +3238,7 @@ TEST_F(SpdySessionSpdy3Test, SendWindowSizeIncreaseWithDeletedStreams31) {
   scoped_ptr<SpdyFrame> req3(
       ConstructSpdyPost(kStreamUrl, 5, kBodyDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body2(
-      ConstructSpdyBodyFrame(3, kBodyData, kBodyDataSize, false));
+      ConstructSpdyBodyFrame(3, kBodyData, kBodyDataSize, true));
   MockWrite writes[] = {
     CreateMockWrite(*initial_window_update, 0),
     CreateMockWrite(*req1, 1),
@@ -3297,7 +3302,8 @@ TEST_F(SpdySessionSpdy3Test, SendWindowSizeIncreaseWithDeletedStreams31) {
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
-  EXPECT_EQ(ERR_IO_PENDING, stream1->SendRequest(headers1.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream1->SendRequestHeaders(headers1.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream1->HasUrl());
   EXPECT_EQ(kStreamUrl, stream1->GetUrl().spec());
 
@@ -3307,7 +3313,8 @@ TEST_F(SpdySessionSpdy3Test, SendWindowSizeIncreaseWithDeletedStreams31) {
 
   scoped_ptr<SpdyHeaderBlock> headers2(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
-  EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequest(headers2.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream2->SendRequestHeaders(headers2.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream2->HasUrl());
   EXPECT_EQ(kStreamUrl, stream2->GetUrl().spec());
 
@@ -3317,7 +3324,8 @@ TEST_F(SpdySessionSpdy3Test, SendWindowSizeIncreaseWithDeletedStreams31) {
 
   scoped_ptr<SpdyHeaderBlock> headers3(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
-  EXPECT_EQ(ERR_IO_PENDING, stream3->SendRequest(headers3.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream3->SendRequestHeaders(headers3.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream3->HasUrl());
   EXPECT_EQ(kStreamUrl, stream3->GetUrl().spec());
 
@@ -3439,7 +3447,8 @@ TEST_F(SpdySessionSpdy3Test, SendWindowSizeIncreaseWithDeletedSession31) {
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
-  EXPECT_EQ(ERR_IO_PENDING, stream1->SendRequest(headers1.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream1->SendRequestHeaders(headers1.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream1->HasUrl());
   EXPECT_EQ(kStreamUrl, stream1->GetUrl().spec());
 
@@ -3449,7 +3458,8 @@ TEST_F(SpdySessionSpdy3Test, SendWindowSizeIncreaseWithDeletedSession31) {
 
   scoped_ptr<SpdyHeaderBlock> headers2(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
-  EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequest(headers2.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream2->SendRequestHeaders(headers2.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream2->HasUrl());
   EXPECT_EQ(kStreamUrl, stream2->GetUrl().spec());
 
@@ -3646,7 +3656,9 @@ TEST_F(SpdySessionSpdy3Test, CloseOneIdleConnectionFailsWhenSessionInUse) {
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructGetHeaderBlock(url1.spec()));
-  EXPECT_EQ(ERR_IO_PENDING, spdy_stream1->SendRequest(headers1.Pass(), false));
+  EXPECT_EQ(ERR_IO_PENDING,
+            spdy_stream1->SendRequestHeaders(
+                headers1.Pass(), NO_MORE_DATA_TO_SEND));
   EXPECT_TRUE(spdy_stream1->HasUrl());
 
   base::MessageLoop::current()->RunUntilIdle();
diff --git a/net/spdy/spdy_stream.cc b/net/spdy/spdy_stream.cc
index 20f43f8..8a45ad8 100644
--- a/net/spdy/spdy_stream.cc
+++ b/net/spdy/spdy_stream.cc
@@ -100,12 +100,11 @@ SpdyStream::SpdyStream(SpdySession* session,
       response_received_(false),
       session_(session),
       delegate_(NULL),
-      pending_send_flags_(DATA_FLAG_NONE),
+      send_status_(MORE_DATA_TO_SEND),
       request_time_(base::Time::Now()),
       response_(new SpdyHeaderBlock),
       io_state_(STATE_NONE),
       response_status_(OK),
-      has_upload_data_(false),
       net_log_(net_log),
       send_bytes_(0),
       recv_bytes_(0),
@@ -175,12 +174,13 @@ void SpdyStream::PushedStreamReplayData() {
 }
 
 scoped_ptr<SpdyFrame> SpdyStream::ProduceSynStreamFrame() {
-  CHECK_EQ(io_state_, STATE_SEND_HEADERS_COMPLETE);
+  CHECK_EQ(io_state_, STATE_SEND_REQUEST_HEADERS_COMPLETE);
   CHECK(request_.get());
   CHECK_GT(stream_id_, 0u);
 
   SpdyControlFlags flags =
-      has_upload_data_ ? CONTROL_FLAG_NONE : CONTROL_FLAG_FIN;
+      (send_status_ == NO_MORE_DATA_TO_SEND) ?
+      CONTROL_FLAG_FIN : CONTROL_FLAG_NONE;
   scoped_ptr<SpdyFrame> frame(session_->CreateSynStream(
       stream_id_, priority_, slot_, flags, *request_));
   send_time_ = base::TimeTicks::Now();
@@ -561,18 +561,18 @@ void SpdyStream::Close() {
   }
 }
 
-int SpdyStream::SendRequest(scoped_ptr<SpdyHeaderBlock> headers,
-                            bool has_upload_data) {
-  DCHECK(!request_);
+int SpdyStream::SendRequestHeaders(scoped_ptr<SpdyHeaderBlock> headers,
+                                   SpdySendStatus send_status) {
+  CHECK_EQ(send_status_, MORE_DATA_TO_SEND);
+  CHECK(!request_);
   request_ = headers.Pass();
-
   // Pushed streams do not send any data, and should always be
   // idle. However, we still want to return IO_PENDING to mimic
   // non-push behavior.
-  has_upload_data_ = has_upload_data;
+  send_status_ = send_status;
   if (pushed_) {
     DCHECK(is_idle());
-    DCHECK(!has_upload_data_);
+    DCHECK_EQ(send_status_, NO_MORE_DATA_TO_SEND);
     DCHECK(response_received());
     send_time_ = base::TimeTicks::Now();
     return ERR_IO_PENDING;
@@ -584,10 +584,11 @@ int SpdyStream::SendRequest(scoped_ptr<SpdyHeaderBlock> headers,
 
 void SpdyStream::SendStreamData(IOBuffer* data,
                                 int length,
-                                SpdyDataFlags flags) {
+                                SpdySendStatus send_status) {
+  CHECK_EQ(send_status_, MORE_DATA_TO_SEND);
   CHECK(!pending_send_data_);
   pending_send_data_ = new DrainableIOBuffer(data, length);
-  pending_send_flags_ = flags;
+  send_status_ = send_status;
   QueueNextDataFrame();
 }
 
@@ -660,13 +661,13 @@ int SpdyStream::DoLoop(int result) {
       case STATE_SEND_DOMAIN_BOUND_CERT_COMPLETE:
         result = DoSendDomainBoundCertComplete(result);
         break;
-      case STATE_SEND_HEADERS:
+      case STATE_SEND_REQUEST_HEADERS:
         CHECK_EQ(result, OK);
-        result = DoSendHeaders();
+        result = DoSendRequestHeaders();
         break;
-      case STATE_SEND_HEADERS_COMPLETE:
+      case STATE_SEND_REQUEST_HEADERS_COMPLETE:
         CHECK_EQ(result, OK);
-        result = DoSendHeadersComplete();
+        result = DoSendRequestHeadersComplete();
         break;
       case STATE_SEND_BODY:
         CHECK_EQ(result, OK);
@@ -720,15 +721,15 @@ int SpdyStream::DoGetDomainBoundCert() {
   CHECK(request_.get());
   GURL url = GetUrl();
   if (!session_->NeedsCredentials() || pushed_ || !url.SchemeIs("https")) {
-    // Proceed directly to sending headers
-    io_state_ = STATE_SEND_HEADERS;
+    // Proceed directly to sending the request headers
+    io_state_ = STATE_SEND_REQUEST_HEADERS;
     return OK;
   }
 
   slot_ = session_->credential_state()->FindCredentialSlot(GetUrl());
   if (slot_ != SpdyCredentialState::kNoEntry) {
-    // Proceed directly to sending headers
-    io_state_ = STATE_SEND_HEADERS;
+    // Proceed directly to sending the request headers
+    io_state_ = STATE_SEND_REQUEST_HEADERS;
     return OK;
   }
 
@@ -791,12 +792,12 @@ int SpdyStream::DoSendDomainBoundCertComplete(int result) {
     return result;
 
   DCHECK_EQ(just_completed_frame_type_, CREDENTIAL);
-  io_state_ = STATE_SEND_HEADERS;
+  io_state_ = STATE_SEND_REQUEST_HEADERS;
   return OK;
 }
 
-int SpdyStream::DoSendHeaders() {
-  io_state_ = STATE_SEND_HEADERS_COMPLETE;
+int SpdyStream::DoSendRequestHeaders() {
+  io_state_ = STATE_SEND_REQUEST_HEADERS_COMPLETE;
 
   session_->EnqueueStreamWrite(
       GetWeakPtr(), SYN_STREAM,
@@ -805,14 +806,18 @@ int SpdyStream::DoSendHeaders() {
   return ERR_IO_PENDING;
 }
 
-int SpdyStream::DoSendHeadersComplete() {
+int SpdyStream::DoSendRequestHeadersComplete() {
   DCHECK_EQ(just_completed_frame_type_, SYN_STREAM);
   DCHECK_NE(stream_id_, 0u);
   if (!delegate_)
     return ERR_UNEXPECTED;
 
+  // We don't store the return value in |send_status_|; see comments
+  // in spdy_stream.h for OnSendRequestHeadersComplete().
+  SpdySendStatus send_status = delegate_->OnSendRequestHeadersComplete();
+
   io_state_ =
-      (delegate_->OnSendHeadersComplete() == MORE_DATA_TO_SEND) ?
+      (send_status == MORE_DATA_TO_SEND) ?
       STATE_SEND_BODY : STATE_WAITING_FOR_RESPONSE;
 
   return OK;
@@ -833,10 +838,10 @@ int SpdyStream::DoSendBodyComplete(int result) {
   if (result != OK)
     return result;
 
-  SpdySendStatus send_status = delegate_->OnSendBodyComplete();
+  delegate_->OnSendBodyComplete();
 
   io_state_ =
-      (send_status == MORE_DATA_TO_SEND) ?
+      (send_status_ == MORE_DATA_TO_SEND) ?
       STATE_SEND_BODY : STATE_WAITING_FOR_RESPONSE;
 
   return OK;
@@ -887,7 +892,6 @@ int SpdyStream::ProcessJustCompletedFrame(int result, State io_pending_state) {
   }
 
   pending_send_data_ = NULL;
-  pending_send_flags_ = DATA_FLAG_NONE;
 
   if (!delegate_) {
     NOTREACHED();
@@ -915,17 +919,20 @@ void SpdyStream::UpdateHistograms() {
 }
 
 void SpdyStream::QueueNextDataFrame() {
-  // Until the headers have been completely sent, we can not be sure
+  // Until the request has been completely sent, we cannot be sure
   // that our stream_id is correct.
-  DCHECK_GT(io_state_, STATE_SEND_HEADERS_COMPLETE);
+  DCHECK_GT(io_state_, STATE_SEND_REQUEST_HEADERS_COMPLETE);
   CHECK_GT(stream_id_, 0u);
   CHECK(pending_send_data_);
   CHECK_GT(pending_send_data_->BytesRemaining(), 0);
 
+  SpdyDataFlags flags =
+      (send_status_ == NO_MORE_DATA_TO_SEND) ?
+      DATA_FLAG_FIN : DATA_FLAG_NONE;
   scoped_ptr<SpdyBuffer> data_buffer(session_->CreateDataBuffer(
       stream_id_,
       pending_send_data_, pending_send_data_->BytesRemaining(),
-      pending_send_flags_));
+      flags));
   // We'll get called again by PossiblyResumeIfSendStalled().
   if (!data_buffer)
     return;
diff --git a/net/spdy/spdy_stream.h b/net/spdy/spdy_stream.h
index cf14def..883e7a3 100644
--- a/net/spdy/spdy_stream.h
+++ b/net/spdy/spdy_stream.h
@@ -56,22 +56,33 @@ class NET_EXPORT_PRIVATE SpdyStream {
    public:
     Delegate() {}
 
-    // Called when SYN frame has been sent.  Must return whether
-    // there's body data to send.
-    virtual SpdySendStatus OnSendHeadersComplete() = 0;
+    // Called when the request headers have been sent.  Must return
+    // whether there's body data to send.
+    //
+    // There's some redundancy in SendRequestHeaders() taking a
+    // SpdySendStatus and this function returning one, but it's
+    // necessary. Bidirectional streams always pass in
+    // MORE_DATA_TO_SEND to SendRequestHeaders() but must return
+    // NO_MORE_DATA_TO_SEND from OnSendRequestHeadersComplete(), while
+    // request/response streams always return the same value from
+    // OnSendRequestHeadersComplete() as the one they pass into
+    // SendRequestHeaders().
+    //
+    // TODO(akalin): Have a less subtle way of differentiating
+    // request/response streams from bidirectional ones.
+    virtual SpdySendStatus OnSendRequestHeadersComplete() = 0;
 
     // Called when the stream is ready to send body data.  The
     // delegate must call SendStreamData() on the stream, either
     // immediately or asynchronously (e.g., if the data to be send has
     // to be read asynchronously).
     //
-    // Called only when OnSendHeadersComplete() or
+    // Called only when OnSendRequestHeadersComplete() or
     // OnSendBodyComplete() returns MORE_DATA_TO_SEND.
     virtual void OnSendBody() = 0;
 
-    // Called when body data has been sent. Must return whether
-    // there's more body data to send.
-    virtual SpdySendStatus OnSendBodyComplete() = 0;
+    // Called when body data has been sent.
+    virtual void OnSendBodyComplete() = 0;
 
     // Called when the SYN_STREAM, SYN_REPLY, or HEADERS frames are received.
     // Normal streams will receive a SYN_REPLY and optional HEADERS frames.
@@ -287,19 +298,16 @@ class NET_EXPORT_PRIVATE SpdyStream {
   // TODO(akalin): Mandate that only one send can be in flight at one
   // time.
 
-  // Sends the request.
+  // Sends the request headers.
   // For non push stream, it will send SYN_STREAM frame.
-  int SendRequest(scoped_ptr<SpdyHeaderBlock> headers, bool has_upload_data);
+  int SendRequestHeaders(scoped_ptr<SpdyHeaderBlock> headers,
+                         SpdySendStatus send_status);
 
   // Sends a DATA frame. The delegate will be notified via
   // OnSendBodyComplete() (if the response hasn't been received yet)
   // or OnDataSent() (if the response has been received) when the send
   // is complete. Only one data send can be in flight at one time.
-  //
-  // |flags| must be DATA_FLAG_NONE except for the last piece of data
-  // for a request in a request/response stream, where it should be
-  // DATA_FLAG_FIN.
-  void SendStreamData(IOBuffer* data, int length, SpdyDataFlags flags);
+  void SendStreamData(IOBuffer* data, int length, SpdySendStatus send_status);
 
   // Fills SSL info in |ssl_info| and returns true when SSL is in use.
   bool GetSSLInfo(SSLInfo* ssl_info,
@@ -345,8 +353,8 @@ class NET_EXPORT_PRIVATE SpdyStream {
     STATE_GET_DOMAIN_BOUND_CERT_COMPLETE,
     STATE_SEND_DOMAIN_BOUND_CERT,
     STATE_SEND_DOMAIN_BOUND_CERT_COMPLETE,
-    STATE_SEND_HEADERS,
-    STATE_SEND_HEADERS_COMPLETE,
+    STATE_SEND_REQUEST_HEADERS,
+    STATE_SEND_REQUEST_HEADERS_COMPLETE,
     STATE_SEND_BODY,
     STATE_SEND_BODY_COMPLETE,
     STATE_WAITING_FOR_RESPONSE,
@@ -364,8 +372,8 @@ class NET_EXPORT_PRIVATE SpdyStream {
   int DoGetDomainBoundCertComplete(int result);
   int DoSendDomainBoundCert();
   int DoSendDomainBoundCertComplete(int result);
-  int DoSendHeaders();
-  int DoSendHeadersComplete();
+  int DoSendRequestHeaders();
+  int DoSendRequestHeadersComplete();
   int DoSendBody();
   int DoSendBodyComplete(int result);
   int DoReadHeaders();
@@ -432,12 +440,14 @@ class NET_EXPORT_PRIVATE SpdyStream {
   // The transaction should own the delegate.
   SpdyStream::Delegate* delegate_;
 
-  // The request to send.
+  // Whether or not we have more data to send on this stream.
+  SpdySendStatus send_status_;
+
+  // The headers for the request to send.
   scoped_ptr<SpdyHeaderBlock> request_;
 
   // The data waiting to be sent.
   scoped_refptr<DrainableIOBuffer> pending_send_data_;
-  SpdyDataFlags pending_send_flags_;
 
   // The time at which the request was made that resulted in this response.
   // For cached responses, this time could be "far" in the past.
@@ -452,8 +462,6 @@ class NET_EXPORT_PRIVATE SpdyStream {
   // Not valid until the stream is closed.
   int response_status_;
 
-  bool has_upload_data_;
-
   BoundNetLog net_log_;
 
   base::TimeTicks send_time_;
diff --git a/net/spdy/spdy_stream_spdy2_unittest.cc b/net/spdy/spdy_stream_spdy2_unittest.cc
index ff67798..953d8ee 100644
--- a/net/spdy/spdy_stream_spdy2_unittest.cc
+++ b/net/spdy/spdy_stream_spdy2_unittest.cc
@@ -128,7 +128,8 @@ TEST_F(SpdyStreamSpdy2Test, SendDataAfterOpen) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
-  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
@@ -240,7 +241,8 @@ TEST_F(SpdyStreamSpdy2Test, StreamError) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
-  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
@@ -285,11 +287,14 @@ TEST_F(SpdyStreamSpdy2Test, SendLargeDataAfterOpenRequestResponse) {
   scoped_ptr<SpdyFrame> chunk(
       ConstructSpdyBodyFrame(
           1, chunk_data.data(), chunk_data.length(), false));
+  scoped_ptr<SpdyFrame> last_chunk(
+      ConstructSpdyBodyFrame(
+          1, chunk_data.data(), chunk_data.length(), true));
   MockWrite writes[] = {
     CreateMockWrite(*req, 0),
     CreateMockWrite(*chunk, 1),
     CreateMockWrite(*chunk, 2),
-    CreateMockWrite(*chunk, 3),
+    CreateMockWrite(*last_chunk, 3),
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
@@ -320,7 +325,8 @@ TEST_F(SpdyStreamSpdy2Test, SendLargeDataAfterOpenRequestResponse) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
-  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
@@ -382,7 +388,8 @@ TEST_F(SpdyStreamSpdy2Test, SendLargeDataAfterOpenBidirectional) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
-  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
diff --git a/net/spdy/spdy_stream_spdy3_unittest.cc b/net/spdy/spdy_stream_spdy3_unittest.cc
index 2c26942..98c7735 100644
--- a/net/spdy/spdy_stream_spdy3_unittest.cc
+++ b/net/spdy/spdy_stream_spdy3_unittest.cc
@@ -137,7 +137,8 @@ TEST_F(SpdyStreamSpdy3Test, SendDataAfterOpen) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
-  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
@@ -252,7 +253,8 @@ TEST_F(SpdyStreamSpdy3Test, StreamError) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
-  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
@@ -297,11 +299,14 @@ TEST_F(SpdyStreamSpdy3Test, SendLargeDataAfterOpenRequestResponse) {
   scoped_ptr<SpdyFrame> chunk(
       ConstructSpdyBodyFrame(
           1, chunk_data.data(), chunk_data.length(), false));
+  scoped_ptr<SpdyFrame> last_chunk(
+      ConstructSpdyBodyFrame(
+          1, chunk_data.data(), chunk_data.length(), true));
   MockWrite writes[] = {
     CreateMockWrite(*req, 0),
     CreateMockWrite(*chunk, 1),
     CreateMockWrite(*chunk, 2),
-    CreateMockWrite(*chunk, 3),
+    CreateMockWrite(*last_chunk, 3),
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructSpdyPostSynReply(NULL, 0));
@@ -332,7 +337,8 @@ TEST_F(SpdyStreamSpdy3Test, SendLargeDataAfterOpenRequestResponse) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
-  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
@@ -394,7 +400,8 @@ TEST_F(SpdyStreamSpdy3Test, SendLargeDataAfterOpenBidirectional) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
-  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
@@ -451,7 +458,8 @@ TEST_F(SpdyStreamSpdy3Test, IncreaseSendWindowSizeOverflow) {
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
-  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
@@ -511,7 +519,7 @@ void SpdyStreamSpdy3Test::RunResumeAfterUnstallRequestResponseTest(
   scoped_ptr<SpdyFrame> req(
       ConstructSpdyPost(kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body(
-      ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
+      ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, true));
   MockWrite writes[] = {
     CreateMockWrite(*req, 0),
     CreateMockWrite(*body, 1),
@@ -546,7 +554,8 @@ void SpdyStreamSpdy3Test::RunResumeAfterUnstallRequestResponseTest(
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
-  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
@@ -631,7 +640,8 @@ void SpdyStreamSpdy3Test::RunResumeAfterUnstallBidirectionalTest(
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength));
-  EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(headers.Pass(), true));
+  EXPECT_EQ(ERR_IO_PENDING,
+            stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
diff --git a/net/spdy/spdy_stream_test_util.cc b/net/spdy/spdy_stream_test_util.cc
index ee23b58..fd1f148 100644
--- a/net/spdy/spdy_stream_test_util.cc
+++ b/net/spdy/spdy_stream_test_util.cc
@@ -20,7 +20,7 @@ ClosingDelegate::ClosingDelegate(
 
 ClosingDelegate::~ClosingDelegate() {}
 
-SpdySendStatus ClosingDelegate::OnSendHeadersComplete() {
+SpdySendStatus ClosingDelegate::OnSendRequestHeadersComplete() {
   return NO_MORE_DATA_TO_SEND;
 }
 
@@ -28,9 +28,7 @@ void ClosingDelegate::OnSendBody() {
   ADD_FAILURE() << "OnSendBody should not be called";
 }
 
-SpdySendStatus ClosingDelegate::OnSendBodyComplete() {
-  return NO_MORE_DATA_TO_SEND;
-}
+void ClosingDelegate::OnSendBodyComplete() {}
 
 int ClosingDelegate::OnResponseReceived(const SpdyHeaderBlock& response,
                                         base::Time response_time,
@@ -60,7 +58,7 @@ StreamDelegateBase::StreamDelegateBase(
 StreamDelegateBase::~StreamDelegateBase() {
 }
 
-SpdySendStatus StreamDelegateBase::OnSendHeadersComplete() {
+SpdySendStatus StreamDelegateBase::OnSendRequestHeadersComplete() {
   stream_id_ = stream_->stream_id();
   EXPECT_NE(stream_id_, 0u);
   send_headers_completed_ = true;
@@ -125,9 +123,7 @@ void StreamDelegateDoNothing::OnSendBody() {
   ADD_FAILURE() << "OnSendBody should not be called";
 }
 
-SpdySendStatus StreamDelegateDoNothing::OnSendBodyComplete() {
-  return NO_MORE_DATA_TO_SEND;
-}
+void StreamDelegateDoNothing::OnSendBodyComplete() {}
 
 StreamDelegateSendImmediate::StreamDelegateSendImmediate(
     const base::WeakPtr<SpdyStream>& stream,
@@ -142,9 +138,8 @@ void StreamDelegateSendImmediate::OnSendBody() {
   ADD_FAILURE() << "OnSendBody should not be called";
 }
 
-SpdySendStatus StreamDelegateSendImmediate::OnSendBodyComplete() {
+void StreamDelegateSendImmediate::OnSendBodyComplete() {
   ADD_FAILURE() << "OnSendBodyComplete should not be called";
-  return NO_MORE_DATA_TO_SEND;
 }
 
 int StreamDelegateSendImmediate::OnResponseReceived(
@@ -155,7 +150,7 @@ int StreamDelegateSendImmediate::OnResponseReceived(
       StreamDelegateBase::OnResponseReceived(response, response_time, status);
   if (data_.data()) {
     scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(data_.as_string()));
-    stream()->SendStreamData(buf, buf->size(), DATA_FLAG_NONE);
+    stream()->SendStreamData(buf, buf->size(), MORE_DATA_TO_SEND);
   }
   return status;
 }
@@ -169,18 +164,16 @@ StreamDelegateWithBody::StreamDelegateWithBody(
 StreamDelegateWithBody::~StreamDelegateWithBody() {
 }
 
-SpdySendStatus StreamDelegateWithBody::OnSendHeadersComplete() {
-  StreamDelegateBase::OnSendHeadersComplete();
+SpdySendStatus StreamDelegateWithBody::OnSendRequestHeadersComplete() {
+  StreamDelegateBase::OnSendRequestHeadersComplete();
   return MORE_DATA_TO_SEND;
 }
 
 void StreamDelegateWithBody::OnSendBody() {
-  stream()->SendStreamData(buf_.get(), buf_->size(), DATA_FLAG_NONE);
+  stream()->SendStreamData(buf_.get(), buf_->size(), NO_MORE_DATA_TO_SEND);
 }
 
-SpdySendStatus StreamDelegateWithBody::OnSendBodyComplete() {
-  return NO_MORE_DATA_TO_SEND;
-}
+void StreamDelegateWithBody::OnSendBodyComplete() {}
 
 } // namespace test
 
diff --git a/net/spdy/spdy_stream_test_util.h b/net/spdy/spdy_stream_test_util.h
index 827f476..bcf5da8 100644
--- a/net/spdy/spdy_stream_test_util.h
+++ b/net/spdy/spdy_stream_test_util.h
@@ -26,9 +26,9 @@ class ClosingDelegate : public SpdyStream::Delegate {
   virtual ~ClosingDelegate();
 
   // SpdyStream::Delegate implementation.
-  virtual SpdySendStatus OnSendHeadersComplete() OVERRIDE;
+  virtual SpdySendStatus OnSendRequestHeadersComplete() OVERRIDE;
   virtual void OnSendBody() OVERRIDE;
-  virtual SpdySendStatus OnSendBodyComplete() OVERRIDE;
+  virtual void OnSendBodyComplete() OVERRIDE;
   virtual int OnResponseReceived(const SpdyHeaderBlock& response,
                                  base::Time response_time,
                                  int status) OVERRIDE;
@@ -50,9 +50,9 @@ class StreamDelegateBase : public SpdyStream::Delegate {
   explicit StreamDelegateBase(const base::WeakPtr<SpdyStream>& stream);
   virtual ~StreamDelegateBase();
 
-  virtual SpdySendStatus OnSendHeadersComplete() OVERRIDE;
+  virtual SpdySendStatus OnSendRequestHeadersComplete() OVERRIDE;
   virtual void OnSendBody() = 0;
-  virtual SpdySendStatus OnSendBodyComplete() = 0;
+  virtual void OnSendBodyComplete() = 0;
   virtual int OnResponseReceived(const SpdyHeaderBlock& response,
                                  base::Time response_time,
                                  int status) OVERRIDE;
@@ -98,7 +98,7 @@ class StreamDelegateDoNothing : public StreamDelegateBase {
   virtual ~StreamDelegateDoNothing();
 
   virtual void OnSendBody() OVERRIDE;
-  virtual SpdySendStatus OnSendBodyComplete() OVERRIDE;
+  virtual void OnSendBodyComplete() OVERRIDE;
 };
 
 // Test delegate that sends data immediately in OnResponseReceived().
@@ -110,7 +110,7 @@ class StreamDelegateSendImmediate : public StreamDelegateBase {
   virtual ~StreamDelegateSendImmediate();
 
   virtual void OnSendBody() OVERRIDE;
-  virtual SpdySendStatus OnSendBodyComplete() OVERRIDE;
+  virtual void OnSendBodyComplete() OVERRIDE;
   virtual int OnResponseReceived(const SpdyHeaderBlock& response,
                                  base::Time response_time,
                                  int status) OVERRIDE;
@@ -126,9 +126,9 @@ class StreamDelegateWithBody : public StreamDelegateBase {
                          base::StringPiece data);
   virtual ~StreamDelegateWithBody();
 
-  virtual SpdySendStatus OnSendHeadersComplete() OVERRIDE;
+  virtual SpdySendStatus OnSendRequestHeadersComplete() OVERRIDE;
   virtual void OnSendBody() OVERRIDE;
-  virtual SpdySendStatus OnSendBodyComplete() OVERRIDE;
+  virtual void OnSendBodyComplete() OVERRIDE;
 
  private:
   scoped_refptr<StringIOBuffer> buf_;
diff --git a/net/spdy/spdy_websocket_stream.cc b/net/spdy/spdy_websocket_stream.cc
index df8f417..0ec5291 100644
--- a/net/spdy/spdy_websocket_stream.cc
+++ b/net/spdy/spdy_websocket_stream.cc
@@ -56,7 +56,7 @@ int SpdyWebSocketStream::SendRequest(scoped_ptr<SpdyHeaderBlock> headers) {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
-  int result = stream_->SendRequest(headers.Pass(), true);
+  int result = stream_->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND);
   if (result < OK && result != ERR_IO_PENDING)
     Close();
   return result;
@@ -71,7 +71,7 @@ int SpdyWebSocketStream::SendData(const char* data, int length) {
   pending_send_data_length_ = static_cast<size_t>(length);
   scoped_refptr<IOBuffer> buf(new IOBuffer(length));
   memcpy(buf->data(), data, length);
-  stream_->SendStreamData(buf.get(), length, DATA_FLAG_NONE);
+  stream_->SendStreamData(buf.get(), length, MORE_DATA_TO_SEND);
   return ERR_IO_PENDING;
 }
 
@@ -82,7 +82,7 @@ void SpdyWebSocketStream::Close() {
   }
 }
 
-SpdySendStatus SpdyWebSocketStream::OnSendHeadersComplete() {
+SpdySendStatus SpdyWebSocketStream::OnSendRequestHeadersComplete() {
   DCHECK(delegate_);
   delegate_->OnSentSpdyHeaders();
   return NO_MORE_DATA_TO_SEND;
@@ -92,9 +92,8 @@ void SpdyWebSocketStream::OnSendBody() {
   CHECK(false);
 }
 
-SpdySendStatus SpdyWebSocketStream::OnSendBodyComplete() {
+void SpdyWebSocketStream::OnSendBodyComplete() {
   CHECK(false);
-  return NO_MORE_DATA_TO_SEND;
 }
 
 int SpdyWebSocketStream::OnResponseReceived(
diff --git a/net/spdy/spdy_websocket_stream.h b/net/spdy/spdy_websocket_stream.h
index e497944..63128fd 100644
--- a/net/spdy/spdy_websocket_stream.h
+++ b/net/spdy/spdy_websocket_stream.h
@@ -74,9 +74,9 @@ class NET_EXPORT_PRIVATE SpdyWebSocketStream
   void Close();
 
   // SpdyStream::Delegate
-  virtual SpdySendStatus OnSendHeadersComplete() OVERRIDE;
+  virtual SpdySendStatus OnSendRequestHeadersComplete() OVERRIDE;
   virtual void OnSendBody() OVERRIDE;
-  virtual SpdySendStatus OnSendBodyComplete() OVERRIDE;
+  virtual void OnSendBodyComplete() OVERRIDE;
   virtual int OnResponseReceived(const SpdyHeaderBlock& response,
                                  base::Time response_time,
                                  int status) OVERRIDE;