[SPDY] Change SpdyStream::QueueStreamData() To SendStreamData()

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/bind.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ skipping 2977 matching lines @@
   EXPECT_FALSE(stream->send_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(), delegate.TakeReceivedData());
-  EXPECT_EQ(static_cast<int>(kBodyDataSize), delegate.body_data_sent());
+  EXPECT_TRUE(data.at_write_eof());
 }
 
 // Run the resume-after-unstall test with all possible stall and
 // unstall sequences.
 
 TEST_F(SpdySessionSpdy3Test, ResumeAfterUnstallSession31) {
   RunResumeAfterUnstallTest31(
       base::Bind(&SpdySessionSpdy3Test::StallSessionOnly,
                  base::Unretained(this)),
       base::Bind(&SpdySessionSpdy3Test::UnstallSessionOnly,
@@ skipping 162 matching lines @@
 
   data.RunFor(4);
 
   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(), delegate1.TakeReceivedData());
-  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(), delegate2.TakeReceivedData());
-  EXPECT_EQ(static_cast<int>(kBodyDataSize), delegate2.body_data_sent());
+
+  EXPECT_TRUE(data.at_write_eof());
 }
 
 // Delegate that closes a given stream after sending its body.
 class StreamClosingDelegate : public test::StreamDelegateWithBody {
  public:
   StreamClosingDelegate(const base::WeakPtr<SpdyStream>& stream,
                         base::StringPiece data)
       : StreamDelegateWithBody(stream, data) {}
 
   virtual ~StreamClosingDelegate() {}
 
   void set_stream_to_close(const base::WeakPtr<SpdyStream>& stream_to_close) {
     stream_to_close_ = stream_to_close;
   }
 
-  virtual void OnSendBody() OVERRIDE {
-    test::StreamDelegateWithBody::OnSendBody();
+  virtual SpdySendStatus OnSendBodyComplete() OVERRIDE {
+    SpdySendStatus status = test::StreamDelegateWithBody::OnSendBodyComplete();
     if (stream_to_close_) {
       stream_to_close_->Close();
       EXPECT_EQ(NULL, stream_to_close_.get());
     }
+    return status;
   }
 
  private:
   base::WeakPtr<SpdyStream> stream_to_close_;
 };
 
 // Cause a stall by reducing the flow control send window to
 // 0. Unstalling the session should properly handle deleted streams.
 TEST_F(SpdySessionSpdy3Test, SendWindowSizeIncreaseWithDeletedStreams31) {
   const char kStreamUrl[] = "http://www.google.com/";
@@ skipping 116 matching lines @@
   session->CloseActiveStream(stream_id1, ERR_CONNECTION_CLOSED);
   EXPECT_EQ(NULL, stream1.get());
 
   EXPECT_FALSE(session->IsStreamActive(stream_id1));
   EXPECT_TRUE(session->IsStreamActive(stream_id2));
   EXPECT_TRUE(session->IsStreamActive(stream_id3));
 
   // Unstall stream2, which should then close stream3.
   delegate2.set_stream_to_close(stream3);
   UnstallSessionSend(session, kBodyDataSize);
+
+  data.RunFor(1);
   EXPECT_EQ(NULL, stream3.get());
 
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
   EXPECT_FALSE(session->IsStreamActive(stream_id1));
   EXPECT_TRUE(session->IsStreamActive(stream_id2));
   EXPECT_FALSE(session->IsStreamActive(stream_id3));
 
-  data.RunFor(3);
+  data.RunFor(2);
   EXPECT_EQ(NULL, stream2.get());
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate1.WaitForClose());
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate2.WaitForClose());
   EXPECT_EQ(OK, delegate3.WaitForClose());
 
   EXPECT_TRUE(delegate1.send_headers_completed());
   EXPECT_EQ(std::string(), delegate1.TakeReceivedData());
-  EXPECT_EQ(0, 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(), delegate2.TakeReceivedData());
-  EXPECT_EQ(static_cast<int>(kBodyDataSize), delegate2.body_data_sent());
 
   EXPECT_TRUE(delegate3.send_headers_completed());
   EXPECT_EQ(std::string(), delegate3.TakeReceivedData());
-  EXPECT_EQ(0, delegate3.body_data_sent());
+
+  EXPECT_TRUE(data.at_write_eof());
 }
 
 // Cause a stall by reducing the flow control send window to
 // 0. Unstalling the session should properly handle the session itself
 // being closed.
 TEST_F(SpdySessionSpdy3Test, SendWindowSizeIncreaseWithDeletedSession31) {
   const char kStreamUrl[] = "http://www.google.com/";
   GURL url(kStreamUrl);
 
   session_deps_.protocol = kProtoSPDY31;
@@ skipping 88 matching lines @@
   session->CloseSessionOnError(ERR_CONNECTION_CLOSED, true, "Closing session");
   session = NULL;
 
   EXPECT_FALSE(spdy_session_pool_->HasSession(key_));
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate1.WaitForClose());
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate2.WaitForClose());
 
   EXPECT_TRUE(delegate1.send_headers_completed());
   EXPECT_EQ(std::string(), delegate1.TakeReceivedData());
-  EXPECT_EQ(0, delegate1.body_data_sent());
 
   EXPECT_TRUE(delegate2.send_headers_completed());
   EXPECT_EQ(std::string(), delegate2.TakeReceivedData());
-  EXPECT_EQ(0, delegate2.body_data_sent());
+
+  EXPECT_TRUE(data.at_write_eof());
 }
 
 // Tests the case of a non-SPDY request closing an idle SPDY session when no
 // pointers to the idle session are currently held.
 TEST_F(SpdySessionSpdy3Test, CloseOneIdleConnection) {
   ClientSocketPoolManager::set_max_sockets_per_group(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
   ClientSocketPoolManager::set_max_sockets_per_pool(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
 
@@ skipping 222 matching lines @@
   spdy_session_pool_->Remove(session_privacy_enabled);
   EXPECT_FALSE(spdy_session_pool_->HasSession(key_privacy_enabled));
   EXPECT_TRUE(spdy_session_pool_->HasSession(key_privacy_disabled));
 
   spdy_session_pool_->Remove(session_privacy_disabled);
   EXPECT_FALSE(spdy_session_pool_->HasSession(key_privacy_enabled));
   EXPECT_FALSE(spdy_session_pool_->HasSession(key_privacy_disabled));
 }
 
 }  // namespace net