Migrate net/socket/socket.h, net/socket/stream_socket.h to base::Bind().

net/socket/tcp_client_socket_libevent.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/socket/tcp_client_socket.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
@@ skipping 112 matching lines @@
 TCPClientSocketLibevent::TCPClientSocketLibevent(
     const AddressList& addresses,
     net::NetLog* net_log,
     const net::NetLog::Source& source)
     : socket_(kInvalidSocket),
       bound_socket_(kInvalidSocket),
       addresses_(addresses),
       current_ai_(NULL),
       read_watcher_(this),
       write_watcher_(this),
-      old_read_callback_(NULL),
-      old_write_callback_(NULL),
       next_connect_state_(CONNECT_STATE_NONE),
       connect_os_error_(0),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)),
       previously_disconnected_(false),
       use_tcp_fastopen_(false),
       tcp_fastopen_connected_(false),
       num_bytes_read_(0) {
   scoped_refptr<NetLog::EventParameters> params;
   if (source.is_valid())
     params = new NetLogSourceParameter("source_dependency", source);
@@ skipping 50 matching lines @@
       PLOG(ERROR) << "close";
     bound_socket_ = kInvalidSocket;
     return MapSystemError(error);
   }
 
   bind_address_.reset(new IPEndPoint(address));
 
   return 0;
 }
 
-int TCPClientSocketLibevent::Connect(OldCompletionCallback* callback) {
-  DCHECK(CalledOnValidThread());
-
-  // If already connected, then just return OK.
-  if (socket_ != kInvalidSocket)
-    return OK;
-
-  base::StatsCounter connects("tcp.connect");
-  connects.Increment();
-
-  DCHECK(!waiting_connect());
-
-  net_log_.BeginEvent(
-      NetLog::TYPE_TCP_CONNECT,
-      make_scoped_refptr(new AddressListNetLogParam(addresses_)));
-
-  // We will try to connect to each address in addresses_. Start with the
-  // first one in the list.
-  next_connect_state_ = CONNECT_STATE_CONNECT;
-  current_ai_ = addresses_.head();
-
-  int rv = DoConnectLoop(OK);
-  if (rv == ERR_IO_PENDING) {
-    // Synchronous operation not supported.
-    DCHECK(callback);
-    old_write_callback_ = callback;
-  } else {
-    LogConnectCompletion(rv);
-  }
-
-  return rv;
-}
 int TCPClientSocketLibevent::Connect(const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
 
   // If already connected, then just return OK.
   if (socket_ != kInvalidSocket)
     return OK;
 
   base::StatsCounter connects("tcp.connect");
   connects.Increment();
 
@@ skipping 207 matching lines @@
   if (rv >= 0)
     return false;
   if (errno != EAGAIN && errno != EWOULDBLOCK)
     return false;
 
   return true;
 }
 
 int TCPClientSocketLibevent::Read(IOBuffer* buf,
                                   int buf_len,
-                                  OldCompletionCallback* callback) {
-  DCHECK(CalledOnValidThread());
-  DCHECK_NE(kInvalidSocket, socket_);
-  DCHECK(!waiting_connect());
-  DCHECK(!old_read_callback_ && read_callback_.is_null());
-  // Synchronous operation not supported
-  DCHECK(callback);
-  DCHECK_GT(buf_len, 0);
-
-  int nread = HANDLE_EINTR(read(socket_, buf->data(), buf_len));
-  if (nread >= 0) {
-    base::StatsCounter read_bytes("tcp.read_bytes");
-    read_bytes.Add(nread);
-    num_bytes_read_ += static_cast<int64>(nread);
-    if (nread > 0)
-      use_history_.set_was_used_to_convey_data();
-    net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, nread,
-                                  buf->data());
-    return nread;
-  }
-  if (errno != EAGAIN && errno != EWOULDBLOCK) {
-    DVLOG(1) << "read failed, errno " << errno;
-    return MapSystemError(errno);
-  }
-
-  if (!MessageLoopForIO::current()->WatchFileDescriptor(
-          socket_, true, MessageLoopForIO::WATCH_READ,
-          &read_socket_watcher_, &read_watcher_)) {
-    DVLOG(1) << "WatchFileDescriptor failed on read, errno " << errno;
-    return MapSystemError(errno);
-  }
-
-  read_buf_ = buf;
-  read_buf_len_ = buf_len;
-  old_read_callback_ = callback;
-  return ERR_IO_PENDING;
-}
-int TCPClientSocketLibevent::Read(IOBuffer* buf,
-                                  int buf_len,
                                   const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(kInvalidSocket, socket_);
   DCHECK(!waiting_connect());
-  DCHECK(!old_read_callback_ && read_callback_.is_null());
+  DCHECK(read_callback_.is_null());
   // Synchronous operation not supported
   DCHECK(!callback.is_null());
   DCHECK_GT(buf_len, 0);
 
   int nread = HANDLE_EINTR(read(socket_, buf->data(), buf_len));
   if (nread >= 0) {
     base::StatsCounter read_bytes("tcp.read_bytes");
     read_bytes.Add(nread);
     num_bytes_read_ += static_cast<int64>(nread);
     if (nread > 0)
@@ skipping 15 matching lines @@
   }
 
   read_buf_ = buf;
   read_buf_len_ = buf_len;
   read_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int TCPClientSocketLibevent::Write(IOBuffer* buf,
                                    int buf_len,
-                                   OldCompletionCallback* callback) {
+                                   const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(kInvalidSocket, socket_);
   DCHECK(!waiting_connect());
-  DCHECK(!old_write_callback_ && write_callback_.is_null());
+  DCHECK(write_callback_.is_null());
   // Synchronous operation not supported
-  DCHECK(callback);
+  DCHECK(!callback.is_null());
   DCHECK_GT(buf_len, 0);
 
   int nwrite = InternalWrite(buf, buf_len);
   if (nwrite >= 0) {
     base::StatsCounter write_bytes("tcp.write_bytes");
     write_bytes.Add(nwrite);
     if (nwrite > 0)
       use_history_.set_was_used_to_convey_data();
     net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT, nwrite,
                                   buf->data());
     return nwrite;
   }
   if (errno != EAGAIN && errno != EWOULDBLOCK)
     return MapSystemError(errno);
 
   if (!MessageLoopForIO::current()->WatchFileDescriptor(
           socket_, true, MessageLoopForIO::WATCH_WRITE,
           &write_socket_watcher_, &write_watcher_)) {
     DVLOG(1) << "WatchFileDescriptor failed on write, errno " << errno;
     return MapSystemError(errno);
   }
 
   write_buf_ = buf;
   write_buf_len_ = buf_len;
-  old_write_callback_ = callback;
+  write_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int TCPClientSocketLibevent::InternalWrite(IOBuffer* buf, int buf_len) {
   int nwrite;
   if (use_tcp_fastopen_ && !tcp_fastopen_connected_) {
     // We have a limited amount of data to send in the SYN packet.
     int kMaxFastOpenSendLength = 1420;
 
     buf_len = std::min(kMaxFastOpenSendLength, buf_len);
@@ skipping 65 matching lines @@
           reinterpret_cast<const struct sockaddr*>(&source_address),
           sizeof(source_address));
   net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT,
                     make_scoped_refptr(new NetLogStringParameter(
                         "source address",
                         source_address_str)));
 }
 
 void TCPClientSocketLibevent::DoReadCallback(int rv) {
   DCHECK_NE(rv, ERR_IO_PENDING);
-  DCHECK(old_read_callback_ || !read_callback_.is_null());
+  DCHECK(!read_callback_.is_null());
 
   // since Run may result in Read being called, clear read_callback_ up front.
-  if (old_read_callback_) {
-    OldCompletionCallback* c = old_read_callback_;
-    old_read_callback_ = NULL;
-    c->Run(rv);
-  } else {
-    CompletionCallback c = read_callback_;
-    read_callback_.Reset();
-    c.Run(rv);
-  }
+  CompletionCallback c = read_callback_;
+  read_callback_.Reset();
+  c.Run(rv);
 }
 
 void TCPClientSocketLibevent::DoWriteCallback(int rv) {
   DCHECK_NE(rv, ERR_IO_PENDING);
-  DCHECK(old_write_callback_ || !write_callback_.is_null());
+  DCHECK(!write_callback_.is_null());
 
   // since Run may result in Write being called, clear write_callback_ up front.
-  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);
-  }
+  CompletionCallback c = write_callback_;
+  write_callback_.Reset();
+  c.Run(rv);
 }
 
 void TCPClientSocketLibevent::DidCompleteConnect() {
   DCHECK_EQ(next_connect_state_, CONNECT_STATE_CONNECT_COMPLETE);
 
   // Get the error that connect() completed with.
   int os_error = 0;
   socklen_t len = sizeof(os_error);
   if (getsockopt(socket_, SOL_SOCKET, SO_ERROR, &os_error, &len) < 0)
     os_error = errno;
@@ skipping 114 matching lines @@
 
 int64 TCPClientSocketLibevent::NumBytesRead() const {
   return num_bytes_read_;
 }
 
 base::TimeDelta TCPClientSocketLibevent::GetConnectTimeMicros() const {
   return connect_time_micros_;
 }
 
 }  // namespace net