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

net/spdy/spdy_stream_test_util.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_stream_test_util.h"
 
 #include <cstddef>
 
 #include "base/stl_util.h"
 #include "net/base/completion_callback.h"
 #include "net/spdy/spdy_stream.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace test {
 
 ClosingDelegate::ClosingDelegate(
     const base::WeakPtr<SpdyStream>& stream) : stream_(stream) {}
 
 ClosingDelegate::~ClosingDelegate() {}
 
 SpdySendStatus ClosingDelegate::OnSendHeadersComplete() {
   return NO_MORE_DATA_TO_SEND;
 }
 
-int ClosingDelegate::OnSendBody() {
-  return OK;
+void ClosingDelegate::OnSendBody() {
+  ADD_FAILURE() << "OnSendBody should not be called";
 }
 
 SpdySendStatus ClosingDelegate::OnSendBodyComplete(size_t /*bytes_sent*/) {
   return NO_MORE_DATA_TO_SEND;
 }
 
 int ClosingDelegate::OnResponseReceived(const SpdyHeaderBlock& response,
                                         base::Time response_time,
                                         int status) {
   return OK;
@@ skipping 85 matching lines @@
   return (it == response_.end()) ? std::string() : it->second;
 }
 
 StreamDelegateDoNothing::StreamDelegateDoNothing(
     const base::WeakPtr<SpdyStream>& stream)
     : StreamDelegateBase(stream) {}
 
 StreamDelegateDoNothing::~StreamDelegateDoNothing() {
 }
 
-int StreamDelegateDoNothing::OnSendBody() {
-  return OK;
+void StreamDelegateDoNothing::OnSendBody() {
+  ADD_FAILURE() << "OnSendBody should not be called";
 }
+
 SpdySendStatus StreamDelegateDoNothing::OnSendBodyComplete(
     size_t /*bytes_sent*/) {
   return NO_MORE_DATA_TO_SEND;
 }
 
 StreamDelegateSendImmediate::StreamDelegateSendImmediate(
     const base::WeakPtr<SpdyStream>& stream,
     scoped_ptr<SpdyHeaderBlock> headers,
     base::StringPiece data)
     : StreamDelegateBase(stream),
       headers_(headers.Pass()),
       data_(data) {}
 
 StreamDelegateSendImmediate::~StreamDelegateSendImmediate() {
 }
 
-int StreamDelegateSendImmediate::OnSendBody() {
+void StreamDelegateSendImmediate::OnSendBody() {
   ADD_FAILURE() << "OnSendBody should not be called";
-  return ERR_UNEXPECTED;
 }
+
 SpdySendStatus StreamDelegateSendImmediate::OnSendBodyComplete(
     size_t /*bytes_sent*/) {
   ADD_FAILURE() << "OnSendBodyComplete should not be called";
   return NO_MORE_DATA_TO_SEND;
 }
 
 int StreamDelegateSendImmediate::OnResponseReceived(
     const SpdyHeaderBlock& response,
     base::Time response_time,
     int status) {
@@ skipping 18 matching lines @@
       body_data_sent_(0) {}
 
 StreamDelegateWithBody::~StreamDelegateWithBody() {
 }
 
 SpdySendStatus StreamDelegateWithBody::OnSendHeadersComplete() {
   StreamDelegateBase::OnSendHeadersComplete();
   return MORE_DATA_TO_SEND;
 }
 
-int StreamDelegateWithBody::OnSendBody() {
+void StreamDelegateWithBody::OnSendBody() {
   stream()->QueueStreamData(buf_.get(), buf_->BytesRemaining(),
                             DATA_FLAG_NONE);
-  return ERR_IO_PENDING;
 }
 
 SpdySendStatus StreamDelegateWithBody::OnSendBodyComplete(size_t bytes_sent) {
   EXPECT_GT(bytes_sent, 0u);
 
   buf_->DidConsume(bytes_sent);
   body_data_sent_ += bytes_sent;
   if (buf_->BytesRemaining() > 0) {
     // Go back to OnSendBody() to send the remaining data.
     return MORE_DATA_TO_SEND;
   }
 
   return NO_MORE_DATA_TO_SEND;
 }
 
 } // namespace test
 
 } // namespace net