Revert 113699 - base::Bind: Convert Socket::Write.

net/spdy/spdy_proxy_client_socket.cc

 // Copyright (c) 2011 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/logging.h"
 #include "base/string_util.h"
@@ skipping 16 matching lines @@
     const HostPortPair& endpoint,
     const GURL& url,
     const HostPortPair& proxy_server,
     HttpAuthCache* auth_cache,
     HttpAuthHandlerFactory* auth_handler_factory)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(this, &SpdyProxyClientSocket::OnIOComplete)),
       next_state_(STATE_DISCONNECTED),
       spdy_stream_(spdy_stream),
       old_read_callback_(NULL),
-      old_write_callback_(NULL),
+      write_callback_(NULL),
       endpoint_(endpoint),
       auth_(
           new HttpAuthController(HttpAuth::AUTH_PROXY,
                                  GURL("https://" + proxy_server.ToString()),
                                  auth_cache,
                                  auth_handler_factory)),
       user_buffer_(NULL),
       write_buffer_len_(0),
       write_bytes_outstanding_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
@@ skipping 71 matching lines @@
 }
 
 void SpdyProxyClientSocket::Disconnect() {
   read_buffer_.clear();
   user_buffer_ = NULL;
   old_read_callback_ = NULL;
   read_callback_.Reset();
 
   write_buffer_len_ = 0;
   write_bytes_outstanding_ = 0;
-  old_write_callback_ = NULL;
-  write_callback_.Reset();
+  write_callback_ = NULL;
 
   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();
 }
 
 bool SpdyProxyClientSocket::IsConnected() const {
@@ skipping 97 matching lines @@
     } else {
       data->DidConsume(bytes_to_copy);
     }
   }
 
   return user_buffer_->BytesConsumed();
 }
 
 int SpdyProxyClientSocket::Write(IOBuffer* buf, int buf_len,
                                  OldCompletionCallback* callback) {
-  DCHECK(!old_write_callback_ && write_callback_.is_null());
+  DCHECK(!write_callback_);
   if (next_state_ != STATE_OPEN)
     return ERR_SOCKET_NOT_CONNECTED;
 
   DCHECK(spdy_stream_);
   write_bytes_outstanding_= buf_len;
   if (buf_len <= kMaxSpdyFrameChunkSize) {
     int rv = spdy_stream_->WriteStreamData(buf, buf_len, spdy::DATA_FLAG_NONE);
     if (rv == ERR_IO_PENDING) {
-      old_write_callback_ = callback;
-      write_buffer_len_ = buf_len;
-    }
-    return rv;
-  }
-
-  // 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);
-    int rv = spdy_stream_->WriteStreamData(iobuf, len, spdy::DATA_FLAG_NONE);
-    if (rv > 0) {
-      write_bytes_outstanding_ -= rv;
-    } else if (rv != ERR_IO_PENDING) {
-      return rv;
-    }
-  }
-  if (write_bytes_outstanding_ > 0) {
-    old_write_callback_ = callback;
-    write_buffer_len_ = buf_len;
-    return ERR_IO_PENDING;
-  } else {
-    return buf_len;
-  }
-}
-int SpdyProxyClientSocket::Write(IOBuffer* buf, int buf_len,
-                                 const CompletionCallback& callback) {
-  DCHECK(!old_write_callback_ && 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) {
-    int rv = spdy_stream_->WriteStreamData(buf, buf_len, spdy::DATA_FLAG_NONE);
-    if (rv == ERR_IO_PENDING) {
       write_callback_ = callback;
       write_buffer_len_ = buf_len;
     }
     return rv;
   }
 
   // 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);
@@ skipping 259 matching lines @@
   } else if (!read_callback_.is_null()) {
     int rv = PopulateUserReadBuffer();
     CompletionCallback c = read_callback_;
     read_callback_.Reset();
     user_buffer_ = NULL;
     c.Run(rv);
   }
 }
 
 void SpdyProxyClientSocket::OnDataSent(int length)  {
-  DCHECK(old_write_callback_ || !write_callback_.is_null());
+  DCHECK(write_callback_);
 
   write_bytes_outstanding_ -= length;
 
   DCHECK_GE(write_bytes_outstanding_, 0);
 
   if (write_bytes_outstanding_ == 0) {
     int rv = write_buffer_len_;
     write_buffer_len_ = 0;
     write_bytes_outstanding_ = 0;
-    if (old_write_callback_) {
-      OldCompletionCallback* c = old_write_callback_;
-      old_write_callback_ = NULL;
-      c->Run(rv);
-    } else {
-      CompletionCallback c = write_callback_;
-      write_callback_.Reset();
-      c.Run(rv);
-    }
+    OldCompletionCallback* c = write_callback_;
+    write_callback_ = NULL;
+    c->Run(rv);
   }
 }
 
 void SpdyProxyClientSocket::OnClose(int status)  {
   DCHECK(spdy_stream_);
   was_ever_used_ = spdy_stream_->WasEverUsed();
   spdy_stream_ = NULL;
 
   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();
-  OldCompletionCallback* old_write_callback = old_write_callback_;
-  CompletionCallback write_callback = write_callback_;
-  old_write_callback_ = NULL;
-  write_callback_.Reset();
+  OldCompletionCallback* write_callback = write_callback_;
+  write_callback_ = NULL;
   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(old_read_callback_ || !read_callback_.is_null());
     if (old_read_callback_) {
       OldCompletionCallback* read_callback = old_read_callback_;
       old_read_callback_ = NULL;
       read_callback->Run(status);
     } else {
       CompletionCallback read_callback = read_callback_;
       read_callback_.Reset();
       read_callback.Run(status);
     }
   } else if (old_read_callback_ || !read_callback_.is_null()) {
     // If we have a read_callback_, the we need to make sure we call it back.
     OnDataReceived(NULL, 0);
   }
   // This may have been deleted by read_callback_, so check first.
-  if (weak_ptr && (old_write_callback || !write_callback.is_null())) {
-    if (old_write_callback)
-      old_write_callback->Run(ERR_CONNECTION_CLOSED);
-    else
-      write_callback.Run(ERR_CONNECTION_CLOSED);
-  }
+  if (weak_ptr && write_callback)
+    write_callback->Run(ERR_CONNECTION_CLOSED);
 }
 
 void SpdyProxyClientSocket::set_chunk_callback(ChunkCallback* /*callback*/) {
 }
 
 }  // namespace net