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

net/spdy/spdy_proxy_client_socket.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_proxy_client_socket.h"
 
 #include <algorithm>  // min
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/auth.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_util.h"
 #include "net/http/http_auth_cache.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_response_headers.h"
@@ skipping 13 matching lines @@
     : next_state_(STATE_DISCONNECTED),
       spdy_stream_(spdy_stream),
       endpoint_(endpoint),
       auth_(
           new HttpAuthController(HttpAuth::AUTH_PROXY,
                                  GURL("https://" + proxy_server.ToString()),
                                  auth_cache,
                                  auth_handler_factory)),
       user_buffer_len_(0),
       write_buffer_len_(0),
-      write_bytes_outstanding_(0),
       weak_factory_(this),
       net_log_(BoundNetLog::Make(spdy_stream->net_log().net_log(),
                                  NetLog::SOURCE_PROXY_CLIENT_SOCKET)) {
   request_.method = "CONNECT";
   request_.url = url;
   if (!user_agent.empty())
     request_.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
                                      user_agent);
 
   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
@@ skipping 71 matching lines @@
   return rv;
 }
 
 void SpdyProxyClientSocket::Disconnect() {
   read_buffer_queue_.Clear();
   user_buffer_ = NULL;
   user_buffer_len_ = 0;
   read_callback_.Reset();
 
   write_buffer_len_ = 0;
-  write_bytes_outstanding_ = 0;
   write_callback_.Reset();
 
   next_state_ = STATE_DISCONNECTED;
 
   if (spdy_stream_) {
     // This will cause OnClose to be invoked, which takes care of
     // cleaning up all the internal state.
     spdy_stream_->Cancel();
     DCHECK(!spdy_stream_);
   }
@@ skipping 73 matching lines @@
   return read_buffer_queue_.Dequeue(data, len);
 }
 
 int SpdyProxyClientSocket::Write(IOBuffer* buf, int buf_len,
                                  const CompletionCallback& callback) {
   DCHECK(write_callback_.is_null());
   if (next_state_ != STATE_OPEN)
     return ERR_SOCKET_NOT_CONNECTED;
 
   DCHECK(spdy_stream_);
-  write_bytes_outstanding_= buf_len;
-  if (buf_len <= kMaxSpdyFrameChunkSize) {
-    spdy_stream_->QueueStreamData(buf, buf_len, DATA_FLAG_NONE);
-    net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT,
-                                  buf_len, buf->data());
-    write_callback_ = callback;
-    write_buffer_len_ = buf_len;
-    return ERR_IO_PENDING;
-  }
-
-  // Since a SPDY Data frame can only include kMaxSpdyFrameChunkSize bytes
-  // we need to send multiple data frames
-  for (int i = 0; i < buf_len; i += kMaxSpdyFrameChunkSize) {
-    int len = std::min(kMaxSpdyFrameChunkSize, buf_len - i);
-    scoped_refptr<DrainableIOBuffer> iobuf(new DrainableIOBuffer(buf, i + len));
-    iobuf->SetOffset(i);
-    spdy_stream_->QueueStreamData(iobuf, len, DATA_FLAG_NONE);
-    net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT,
-                                  len, buf->data());
-  }
-  if (write_bytes_outstanding_ > 0) {
-    write_callback_ = callback;
-    write_buffer_len_ = buf_len;
-    return ERR_IO_PENDING;
-  } else {
-    return buf_len;
-  }
+  spdy_stream_->SendStreamData(buf, buf_len, DATA_FLAG_NONE);
+  net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT,
+                                buf_len, buf->data());
+  write_callback_ = callback;
+  write_buffer_len_ = buf_len;
+  return ERR_IO_PENDING;
 }
 
 bool SpdyProxyClientSocket::SetReceiveBufferSize(int32 size) {
   // Since this StreamSocket sits on top of a shared SpdySession, it
   // is not safe for callers to set change this underlying socket.
   return false;
 }
 
 bool SpdyProxyClientSocket::SetSendBufferSize(int32 size) {
   // Since this StreamSocket sits on top of a shared SpdySession, it
@@ skipping 200 matching lines @@
   // STATE_OPEN (ala WebSockets).
   return NO_MORE_DATA_TO_SEND;
 }
 
 void SpdyProxyClientSocket::OnSendBody() {
   // Because we use |spdy_stream_| via STATE_OPEN (ala WebSockets)
   // OnSendBody() must never be called.
   CHECK(false);
 }
 
-SpdySendStatus SpdyProxyClientSocket::OnSendBodyComplete(
-    size_t /*bytes_sent*/) {
+SpdySendStatus 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(
     const SpdyHeaderBlock& response,
     base::Time response_time,
     int status) {
@@ skipping 32 matching lines @@
     int rv = PopulateUserReadBuffer(user_buffer_->data(), user_buffer_len_);
     CompletionCallback c = read_callback_;
     read_callback_.Reset();
     user_buffer_ = NULL;
     user_buffer_len_ = 0;
     c.Run(rv);
   }
   return OK;
 }
 
-void SpdyProxyClientSocket::OnDataSent(size_t bytes_sent)  {
+void SpdyProxyClientSocket::OnDataSent()  {
   DCHECK(!write_callback_.is_null());
 
-  DCHECK_LE(static_cast<int>(bytes_sent), write_bytes_outstanding_);
-  write_bytes_outstanding_ -= static_cast<int>(bytes_sent);
-
-  if (write_bytes_outstanding_ == 0) {
-    int rv = write_buffer_len_;
-    write_buffer_len_ = 0;
-    write_bytes_outstanding_ = 0;
-    CompletionCallback c = write_callback_;
-    write_callback_.Reset();
-    c.Run(rv);
-  }
+  int rv = write_buffer_len_;
+  write_buffer_len_ = 0;
+  ResetAndReturn(&write_callback_).Run(rv);
 }
 
 void SpdyProxyClientSocket::OnClose(int status)  {
   was_ever_used_ = spdy_stream_->WasEverUsed();
   spdy_stream_.reset();
 
   bool connecting = next_state_ != STATE_DISCONNECTED &&
       next_state_ < STATE_OPEN;
   if (next_state_ == STATE_OPEN)
     next_state_ = STATE_CLOSED;
   else
     next_state_ = STATE_DISCONNECTED;
 
   base::WeakPtr<SpdyProxyClientSocket> weak_ptr = weak_factory_.GetWeakPtr();
   CompletionCallback write_callback = write_callback_;
   write_callback_.Reset();
   write_buffer_len_ = 0;
-  write_bytes_outstanding_ = 0;
 
   // If we're in the middle of connecting, we need to make sure
   // we invoke the connect callback.
   if (connecting) {
     DCHECK(!read_callback_.is_null());
     CompletionCallback read_callback = read_callback_;
     read_callback_.Reset();
     read_callback.Run(status);
   } else if (!read_callback_.is_null()) {
     // If we have a read_callback_, the we need to make sure we call it back.
     OnDataReceived(scoped_ptr<SpdyBuffer>());
   }
   // This may have been deleted by read_callback_, so check first.
   if (weak_ptr && !write_callback.is_null())
     write_callback.Run(ERR_CONNECTION_CLOSED);
 }
 
 }  // namespace net