Revert 194560 "[SPDY] Replace SpdyIOBuffer with new SpdyBuffer c..."

trunk/src/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"
@@ skipping 21 matching lines @@
     HttpAuthCache* auth_cache,
     HttpAuthHandlerFactory* auth_handler_factory)
     : 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),
+      user_buffer_(NULL),
       write_buffer_len_(0),
       write_bytes_outstanding_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(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);
@@ skipping 67 matching lines @@
   DCHECK_EQ(STATE_DISCONNECTED, next_state_);
   next_state_ = STATE_GENERATE_AUTH_TOKEN;
 
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     read_callback_ = callback;
   return rv;
 }
 
 void SpdyProxyClientSocket::Disconnect() {
-  read_buffer_queue_.Clear();
+  read_buffer_.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_.get());
   }
 }
 
 bool SpdyProxyClientSocket::IsConnected() const {
   return next_state_ == STATE_OPEN;
 }
 
 bool SpdyProxyClientSocket::IsConnectedAndIdle() const {
-  return IsConnected() && read_buffer_queue_.IsEmpty() &&
-      spdy_stream_->is_idle();
+  return IsConnected() && read_buffer_.empty() && spdy_stream_->is_idle();
 }
 
 const BoundNetLog& SpdyProxyClientSocket::NetLog() const {
   return net_log_;
 }
 
 void SpdyProxyClientSocket::SetSubresourceSpeculation() {
   // TODO(rch): what should this implementation be?
 }
 
@@ skipping 25 matching lines @@
 }
 
 int SpdyProxyClientSocket::Read(IOBuffer* buf, int buf_len,
                                 const CompletionCallback& callback) {
   DCHECK(read_callback_.is_null());
   DCHECK(!user_buffer_);
 
   if (next_state_ == STATE_DISCONNECTED)
     return ERR_SOCKET_NOT_CONNECTED;
 
-  if (next_state_ == STATE_CLOSED && read_buffer_queue_.IsEmpty()) {
+  if (next_state_ == STATE_CLOSED && read_buffer_.empty()) {
     return 0;
   }
 
   DCHECK(next_state_ == STATE_OPEN || next_state_ == STATE_CLOSED);
   DCHECK(buf);
-  size_t result = PopulateUserReadBuffer(buf->data(), buf_len);
+  user_buffer_ = new DrainableIOBuffer(buf, buf_len);
+  int result = PopulateUserReadBuffer();
   if (result == 0) {
-    user_buffer_ = buf;
-    user_buffer_len_ = static_cast<size_t>(buf_len);
     DCHECK(!callback.is_null());
     read_callback_ = callback;
     return ERR_IO_PENDING;
   }
   user_buffer_ = NULL;
   return result;
 }
 
-size_t SpdyProxyClientSocket::PopulateUserReadBuffer(char* data, size_t len) {
-  size_t bytes_consumed = read_buffer_queue_.Dequeue(data, len);
+int SpdyProxyClientSocket::PopulateUserReadBuffer() {
+  if (!user_buffer_)
+    return ERR_IO_PENDING;
 
-  if (bytes_consumed > 0 && spdy_stream_)
-    spdy_stream_->IncreaseRecvWindowSize(bytes_consumed);
+  int bytes_read = 0;
+  while (!read_buffer_.empty() && user_buffer_->BytesRemaining() > 0) {
+    scoped_refptr<DrainableIOBuffer> data = read_buffer_.front();
+    const int bytes_to_copy = std::min(user_buffer_->BytesRemaining(),
+                                       data->BytesRemaining());
+    memcpy(user_buffer_->data(), data->data(), bytes_to_copy);
+    user_buffer_->DidConsume(bytes_to_copy);
+    bytes_read += bytes_to_copy;
+    if (data->BytesRemaining() == bytes_to_copy) {
+      // Consumed all data from this buffer
+      read_buffer_.pop_front();
+    } else {
+      data->DidConsume(bytes_to_copy);
+    }
+  }
 
-  return bytes_consumed;
+  if (bytes_read > 0 && spdy_stream_)
+    spdy_stream_->IncreaseRecvWindowSize(bytes_read);
+
+  return user_buffer_->BytesConsumed();
 }
 
 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;
@@ skipping 269 matching lines @@
 
   OnIOComplete(status);
   return OK;
 }
 
 void SpdyProxyClientSocket::OnHeadersSent() {
   // Proxy client sockets don't send any HEADERS frame.
   NOTREACHED();
 }
 
-// Called when data is received or on EOF (if |buffer| is NULL).
-int SpdyProxyClientSocket::OnDataReceived(scoped_ptr<SpdyBuffer> buffer) {
-  if (buffer) {
-    net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED,
-                                  buffer->GetRemainingSize(),
-                                  buffer->GetRemainingData());
-    read_buffer_queue_.Enqueue(buffer.Pass());
-  } else {
-    net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, 0, NULL);
+// Called when data is received.
+int SpdyProxyClientSocket::OnDataReceived(const char* data, int length) {
+  net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED,
+                                length, data);
+  if (length > 0) {
+    // Save the received data.
+    scoped_refptr<IOBuffer> io_buffer(new IOBuffer(length));
+    memcpy(io_buffer->data(), data, length);
+    read_buffer_.push_back(
+        make_scoped_refptr(new DrainableIOBuffer(io_buffer, length)));
   }
 
   if (!read_callback_.is_null()) {
-    int rv = PopulateUserReadBuffer(user_buffer_->data(), user_buffer_len_);
+    int rv = PopulateUserReadBuffer();
     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)  {
   DCHECK(!write_callback_.is_null());
 
   DCHECK_LE(static_cast<int>(bytes_sent), write_bytes_outstanding_);
   write_bytes_outstanding_ -= static_cast<int>(bytes_sent);
@@ skipping 28 matching lines @@
 
   // 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>());
+    OnDataReceived(NULL, 0);
   }
   // 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