[SPDY] Remove SpdyStream::Delegate::OnSendBody()'s return value

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 2962 matching lines @@
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequest(true));
 
   data.RunFor(3);
 
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 
   stall_fn.Run(session, stream);
 
-  EXPECT_EQ(ERR_IO_PENDING, delegate.OnSendBody());
+  delegate.OnSendBody();
 
   EXPECT_TRUE(stream->send_stalled_by_flow_control());
 
   unstall_fn.Run(session, stream, kBodyDataSize);
 
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 
   data.RunFor(3);
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
@@ skipping 156 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequest(true));
 
   data.RunFor(2);
   EXPECT_EQ(3u, stream2->stream_id());
 
   EXPECT_FALSE(stream1->send_stalled_by_flow_control());
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
 
   StallSessionSend(session);
 
-  EXPECT_EQ(ERR_IO_PENDING, delegate1.OnSendBody());
-  EXPECT_EQ(ERR_IO_PENDING, delegate2.OnSendBody());
+  delegate1.OnSendBody();
+  delegate2.OnSendBody();
 
   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
   EXPECT_TRUE(stream2->send_stalled_by_flow_control());
 
   // This should unstall only stream2.
   UnstallSessionSend(session, kBodyDataSize);
 
   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
 
@@ skipping 32 matching lines @@
   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 int OnSendBody() OVERRIDE {
-    int rv = test::StreamDelegateWithBody::OnSendBody();
+  virtual void OnSendBody() OVERRIDE {
+    test::StreamDelegateWithBody::OnSendBody();
     if (stream_to_close_) {
       stream_to_close_->Close();
       EXPECT_EQ(NULL, stream_to_close_.get());
     }
-    return rv;
   }
 
  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 105 matching lines @@
 
   data.RunFor(2);
   EXPECT_EQ(5u, stream3->stream_id());
 
   EXPECT_FALSE(stream1->send_stalled_by_flow_control());
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
   EXPECT_FALSE(stream3->send_stalled_by_flow_control());
 
   StallSessionSend(session);
 
-  EXPECT_EQ(ERR_IO_PENDING, delegate1.OnSendBody());
-  EXPECT_EQ(ERR_IO_PENDING, delegate2.OnSendBody());
-  EXPECT_EQ(ERR_IO_PENDING, delegate3.OnSendBody());
+  delegate1.OnSendBody();
+  delegate2.OnSendBody();
+  delegate3.OnSendBody();
 
   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
   EXPECT_TRUE(stream2->send_stalled_by_flow_control());
   EXPECT_TRUE(stream3->send_stalled_by_flow_control());
 
   SpdyStreamId stream_id1 = stream1->stream_id();
   SpdyStreamId stream_id2 = stream2->stream_id();
   SpdyStreamId stream_id3 = stream3->stream_id();
 
   // Close stream1 preemptively.
@@ skipping 47 matching lines @@
                          base::StringPiece data)
       : StreamDelegateWithBody(stream, data) {}
 
   virtual ~SessionClosingDelegate() {}
 
   void set_session_to_close(
       const scoped_refptr<SpdySession>& session_to_close) {
     session_to_close_ = session_to_close;
   }
 
-  virtual int OnSendBody() OVERRIDE {
-    int rv = test::StreamDelegateWithBody::OnSendBody();
+  virtual void OnSendBody() OVERRIDE {
+    test::StreamDelegateWithBody::OnSendBody();
     if (session_to_close_) {
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&SpdySession::CloseSessionOnError,
                      session_to_close_,
                      ERR_CONNECTION_CLOSED,
                      true,
                      "Closed by SessionClosingDelegate"));
       session_to_close_ = NULL;
     }
-    return rv;
   }
 
  private:
   scoped_refptr<SpdySession> session_to_close_;
 };
 
 // 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) {
@@ skipping 78 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequest(true));
 
   data.RunFor(2);
   EXPECT_EQ(3u, stream2->stream_id());
 
   EXPECT_FALSE(stream1->send_stalled_by_flow_control());
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
 
   StallSessionSend(session);
 
-  EXPECT_EQ(ERR_IO_PENDING, delegate1.OnSendBody());
-  EXPECT_EQ(ERR_IO_PENDING, delegate2.OnSendBody());
+  delegate1.OnSendBody();
+  delegate2.OnSendBody();
 
   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
   EXPECT_TRUE(stream2->send_stalled_by_flow_control());
 
   EXPECT_TRUE(spdy_session_pool_->HasSession(key_));
 
   // Unstall stream1, which should then post a task to close the
   // session.
   delegate1.set_session_to_close(session);
   UnstallSessionSend(session, kBodyDataSize);
@@ skipping 253 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