base::Bind: Convert Socket::Read.

BUG=none
TEST=none
R=csilv

Review URL: http://codereview.chromium.org/8801005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@113326 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 112 insertions, 19 deletions

diff --git a/net/udp/udp_client_socket.cc b/net/udp/udp_client_socket.cc
index e5cef3e..4bb3885 100644
--- a/net/udp/udp_client_socket.cc
+++ b/net/udp/udp_client_socket.cc
@@ -27,6 +27,11 @@ int UDPClientSocket::Read(IOBuffer* buf,
                           OldCompletionCallback* callback) {
   return socket_.Read(buf, buf_len, callback);
 }
+int UDPClientSocket::Read(IOBuffer* buf,
+                          int buf_len,
+                          const CompletionCallback& callback) {
+  return socket_.Read(buf, buf_len, callback);
+}
 
 int UDPClientSocket::Write(IOBuffer* buf,
                           int buf_len,
diff --git a/net/udp/udp_client_socket.h b/net/udp/udp_client_socket.h
index cf37a736..b25df63 100644
--- a/net/udp/udp_client_socket.h
+++ b/net/udp/udp_client_socket.h
@@ -24,10 +24,12 @@ class NET_EXPORT_PRIVATE UDPClientSocket : public DatagramClientSocket {
                   const net::NetLog::Source& source);
   virtual ~UDPClientSocket();
 
-  // Implement DatagramClientSocket:
+  // DatagramClientSocket implementation.
   virtual int Connect(const IPEndPoint& address) OVERRIDE;
   virtual int Read(IOBuffer* buf, int buf_len,
                    OldCompletionCallback* callback) OVERRIDE;
+  virtual int Read(IOBuffer* buf, int buf_len,
+                   const CompletionCallback& callback) OVERRIDE;
   virtual int Write(IOBuffer* buf, int buf_len,
                     OldCompletionCallback* callback) OVERRIDE;
   virtual void Close() OVERRIDE;
diff --git a/net/udp/udp_socket_libevent.cc b/net/udp/udp_socket_libevent.cc
index 87cd9f6..a669c37 100644
--- a/net/udp/udp_socket_libevent.cc
+++ b/net/udp/udp_socket_libevent.cc
@@ -47,7 +47,7 @@ UDPSocketLibevent::UDPSocketLibevent(
           read_buf_len_(0),
           recv_from_address_(NULL),
           write_buf_len_(0),
-          read_callback_(NULL),
+          old_read_callback_(NULL),
           write_callback_(NULL),
           net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_UDP_SOCKET)) {
   scoped_refptr<NetLog::EventParameters> params;
@@ -72,7 +72,8 @@ void UDPSocketLibevent::Close() {
   // Zero out any pending read/write callback state.
   read_buf_ = NULL;
   read_buf_len_ = 0;
-  read_callback_ = NULL;
+  old_read_callback_ = NULL;
+  read_callback_.Reset();
   recv_from_address_ = NULL;
   write_buf_ = NULL;
   write_buf_len_ = 0;
@@ -139,6 +140,11 @@ int UDPSocketLibevent::Read(IOBuffer* buf,
                             OldCompletionCallback* callback) {
   return RecvFrom(buf, buf_len, NULL, callback);
 }
+int UDPSocketLibevent::Read(IOBuffer* buf,
+                            int buf_len,
+                            const CompletionCallback& callback) {
+  return RecvFrom(buf, buf_len, NULL, callback);
+}
 
 int UDPSocketLibevent::RecvFrom(IOBuffer* buf,
                                 int buf_len,
@@ -146,7 +152,7 @@ int UDPSocketLibevent::RecvFrom(IOBuffer* buf,
                                 OldCompletionCallback* callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(kInvalidSocket, socket_);
-  DCHECK(!read_callback_);
+  DCHECK(!old_read_callback_ && read_callback_.is_null());
   DCHECK(!recv_from_address_);
   DCHECK(callback);  // Synchronous operation not supported
   DCHECK_GT(buf_len, 0);
@@ -167,6 +173,36 @@ int UDPSocketLibevent::RecvFrom(IOBuffer* buf,
   read_buf_ = buf;
   read_buf_len_ = buf_len;
   recv_from_address_ = address;
+  old_read_callback_ = callback;
+  return ERR_IO_PENDING;
+}
+int UDPSocketLibevent::RecvFrom(IOBuffer* buf,
+                                int buf_len,
+                                IPEndPoint* address,
+                                const CompletionCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK_NE(kInvalidSocket, socket_);
+  DCHECK(!old_read_callback_ && read_callback_.is_null());
+  DCHECK(!recv_from_address_);
+  DCHECK(!callback.is_null());  // Synchronous operation not supported
+  DCHECK_GT(buf_len, 0);
+
+  int nread = InternalRecvFrom(buf, buf_len, address);
+  if (nread != ERR_IO_PENDING)
+    return nread;
+
+  if (!MessageLoopForIO::current()->WatchFileDescriptor(
+          socket_, true, MessageLoopForIO::WATCH_READ,
+          &read_socket_watcher_, &read_watcher_)) {
+    PLOG(ERROR) << "WatchFileDescriptor failed on read";
+    int result = MapSystemError(errno);
+    LogRead(result, NULL, 0, NULL);
+    return result;
+  }
+
+  read_buf_ = buf;
+  read_buf_len_ = buf_len;
+  recv_from_address_ = address;
   read_callback_ = callback;
   return ERR_IO_PENDING;
 }
@@ -287,12 +323,18 @@ bool UDPSocketLibevent::SetSendBufferSize(int32 size) {
 
 void UDPSocketLibevent::DoReadCallback(int rv) {
   DCHECK_NE(rv, ERR_IO_PENDING);
-  DCHECK(read_callback_);
+  DCHECK(old_read_callback_ || !read_callback_.is_null());
 
-  // since Run may result in Read being called, clear read_callback_ up front.
-  OldCompletionCallback* c = read_callback_;
-  read_callback_ = NULL;
-  c->Run(rv);
+  // 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);
+  }
 }
 
 void UDPSocketLibevent::DoWriteCallback(int rv) {
diff --git a/net/udp/udp_socket_libevent.h b/net/udp/udp_socket_libevent.h
index 1b823c76..6cef1c0 100644
--- a/net/udp/udp_socket_libevent.h
+++ b/net/udp/udp_socket_libevent.h
@@ -55,6 +55,7 @@ class UDPSocketLibevent : public base::NonThreadSafe {
   // Only usable from the client-side of a UDP socket, after the socket
   // has been connected.
   int Read(IOBuffer* buf, int buf_len, OldCompletionCallback* callback);
+  int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
 
   // Write to the socket.
   // Only usable from the client-side of a UDP socket, after the socket
@@ -78,6 +79,10 @@ class UDPSocketLibevent : public base::NonThreadSafe {
                int buf_len,
                IPEndPoint* address,
                OldCompletionCallback* callback);
+  int RecvFrom(IOBuffer* buf,
+               int buf_len,
+               IPEndPoint* address,
+               const CompletionCallback& callback);
 
   // Send to a socket with a particular destination.
   // |buf| is the buffer to send
@@ -114,7 +119,7 @@ class UDPSocketLibevent : public base::NonThreadSafe {
     // MessageLoopForIO::Watcher methods
 
     virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE {
-      if (socket_->read_callback_)
+      if (socket_->old_read_callback_ || !socket_->read_callback_.is_null())
         socket_->DidCompleteRead();
     }
 
@@ -209,7 +214,8 @@ class UDPSocketLibevent : public base::NonThreadSafe {
   scoped_ptr<IPEndPoint> send_to_address_;
 
   // External callback; called when read is complete.
-  OldCompletionCallback* read_callback_;
+  OldCompletionCallback* old_read_callback_;
+  CompletionCallback read_callback_;
 
   // External callback; called when write is complete.
   OldCompletionCallback* write_callback_;
diff --git a/net/udp/udp_socket_win.cc b/net/udp/udp_socket_win.cc
index 0a58f6c..88aa23b 100644
--- a/net/udp/udp_socket_win.cc
+++ b/net/udp/udp_socket_win.cc
@@ -51,7 +51,7 @@ UDPSocketWin::UDPSocketWin(DatagramSocket::BindType bind_type,
       ALLOW_THIS_IN_INITIALIZER_LIST(read_delegate_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(write_delegate_(this)),
       recv_from_address_(NULL),
-      read_callback_(NULL),
+      old_read_callback_(NULL),
       write_callback_(NULL),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_UDP_SOCKET)) {
   EnsureWinsockInit();
@@ -79,7 +79,8 @@ void UDPSocketWin::Close() {
     return;
 
   // Zero out any pending read/write callback state.
-  read_callback_ = NULL;
+  old_read_callback_ = NULL;
+  read_callback_.Reset();
   recv_from_address_ = NULL;
   write_callback_ = NULL;
 
@@ -139,6 +140,11 @@ int UDPSocketWin::Read(IOBuffer* buf,
                        OldCompletionCallback* callback) {
   return RecvFrom(buf, buf_len, NULL, callback);
 }
+int UDPSocketWin::Read(IOBuffer* buf,
+                       int buf_len,
+                       const CompletionCallback& callback) {
+  return RecvFrom(buf, buf_len, NULL, callback);
+}
 
 int UDPSocketWin::RecvFrom(IOBuffer* buf,
                            int buf_len,
@@ -146,7 +152,7 @@ int UDPSocketWin::RecvFrom(IOBuffer* buf,
                            OldCompletionCallback* callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(INVALID_SOCKET, socket_);
-  DCHECK(!read_callback_);
+  DCHECK(!old_read_callback_ && read_callback_.is_null());
   DCHECK(!recv_from_address_);
   DCHECK(callback);  // Synchronous operation not supported.
   DCHECK_GT(buf_len, 0);
@@ -156,6 +162,26 @@ int UDPSocketWin::RecvFrom(IOBuffer* buf,
     return nread;
 
   read_iobuffer_ = buf;
+  old_read_callback_ = callback;
+  recv_from_address_ = address;
+  return ERR_IO_PENDING;
+}
+int UDPSocketWin::RecvFrom(IOBuffer* buf,
+                           int buf_len,
+                           IPEndPoint* address,
+                           const CompletionCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK_NE(INVALID_SOCKET, socket_);
+  DCHECK(!old_read_callback_ && read_callback_.is_null());
+  DCHECK(!recv_from_address_);
+  DCHECK(!callback.is_null());  // Synchronous operation not supported.
+  DCHECK_GT(buf_len, 0);
+
+  int nread = InternalRecvFrom(buf, buf_len, address);
+  if (nread != ERR_IO_PENDING)
+    return nread;
+
+  read_iobuffer_ = buf;
   read_callback_ = callback;
   recv_from_address_ = address;
   return ERR_IO_PENDING;
@@ -272,12 +298,18 @@ bool UDPSocketWin::SetSendBufferSize(int32 size) {
 
 void UDPSocketWin::DoReadCallback(int rv) {
   DCHECK_NE(rv, ERR_IO_PENDING);
-  DCHECK(read_callback_);
+  DCHECK(old_read_callback_ || !read_callback_.is_null());
 
   // since Run may result in Read being called, clear read_callback_ up front.
-  OldCompletionCallback* c = read_callback_;
-  read_callback_ = NULL;
-  c->Run(rv);
+  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);
+  }
 }
 
 void UDPSocketWin::DoWriteCallback(int rv) {
diff --git a/net/udp/udp_socket_win.h b/net/udp/udp_socket_win.h
index 5713d97..6aace29 100644
--- a/net/udp/udp_socket_win.h
+++ b/net/udp/udp_socket_win.h
@@ -56,6 +56,7 @@ class UDPSocketWin : public base::NonThreadSafe {
   // Only usable from the client-side of a UDP socket, after the socket
   // has been connected.
   int Read(IOBuffer* buf, int buf_len, OldCompletionCallback* callback);
+  int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
 
   // Write to the socket.
   // Only usable from the client-side of a UDP socket, after the socket
@@ -79,6 +80,10 @@ class UDPSocketWin : public base::NonThreadSafe {
                int buf_len,
                IPEndPoint* address,
                OldCompletionCallback* callback);
+  int RecvFrom(IOBuffer* buf,
+               int buf_len,
+               IPEndPoint* address,
+               const CompletionCallback& callback);
 
   // Send to a socket with a particular destination.
   // |buf| is the buffer to send
@@ -203,7 +208,8 @@ class UDPSocketWin : public base::NonThreadSafe {
   scoped_refptr<IOBuffer> write_iobuffer_;
 
   // External callback; called when read is complete.
-  OldCompletionCallback* read_callback_;
+  OldCompletionCallback* old_read_callback_;
+  CompletionCallback read_callback_;
 
   // External callback; called when write is complete.
   OldCompletionCallback* write_callback_;