base::Bind: Convert Socket::Write.

net/udp/udp_socket_win.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/udp/udp_socket_win.h"
 
 #include <mstcpip.h>
 
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
@@ skipping 34 matching lines @@
                            const RandIntCallback& rand_int_cb,
                            net::NetLog* net_log,
                            const net::NetLog::Source& source)
     : socket_(INVALID_SOCKET),
       bind_type_(bind_type),
       rand_int_cb_(rand_int_cb),
       ALLOW_THIS_IN_INITIALIZER_LIST(read_delegate_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(write_delegate_(this)),
       recv_from_address_(NULL),
       old_read_callback_(NULL),
-      write_callback_(NULL),
+      old_write_callback_(NULL),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_UDP_SOCKET)) {
   EnsureWinsockInit();
   scoped_refptr<NetLog::EventParameters> params;
   if (source.is_valid())
     params = new NetLogSourceParameter("source_dependency", source);
   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE, params);
   memset(&read_overlapped_, 0, sizeof(read_overlapped_));
   read_overlapped_.hEvent = WSACreateEvent();
   memset(&write_overlapped_, 0, sizeof(write_overlapped_));
   write_overlapped_.hEvent = WSACreateEvent();
   if (bind_type == DatagramSocket::RANDOM_BIND)
     DCHECK(!rand_int_cb.is_null());
 }
 
 UDPSocketWin::~UDPSocketWin() {
   Close();
   net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE, NULL);
 }
 
 void UDPSocketWin::Close() {
   DCHECK(CalledOnValidThread());
 
   if (!is_connected())
     return;
 
   // Zero out any pending read/write callback state.
   old_read_callback_ = NULL;
   read_callback_.Reset();
   recv_from_address_ = NULL;
-  write_callback_ = NULL;
+  old_write_callback_ = NULL;
+  write_callback_.Reset();
 
   read_watcher_.StopWatching();
   write_watcher_.StopWatching();
 
   closesocket(socket_);
   socket_ = INVALID_SOCKET;
 }
 
 int UDPSocketWin::GetPeerAddress(IPEndPoint* address) const {
   DCHECK(CalledOnValidThread());
@@ skipping 89 matching lines @@
   read_callback_ = callback;
   recv_from_address_ = address;
   return ERR_IO_PENDING;
 }
 
 int UDPSocketWin::Write(IOBuffer* buf,
                         int buf_len,
                         OldCompletionCallback* callback) {
   return SendToOrWrite(buf, buf_len, NULL, callback);
 }
+int UDPSocketWin::Write(IOBuffer* buf,
+                        int buf_len,
+                        const CompletionCallback& callback) {
+  return SendToOrWrite(buf, buf_len, NULL, callback);
+}
 
 int UDPSocketWin::SendTo(IOBuffer* buf,
                          int buf_len,
                          const IPEndPoint& address,
                          OldCompletionCallback* callback) {
   return SendToOrWrite(buf, buf_len, &address, callback);
 }
 
 int UDPSocketWin::SendToOrWrite(IOBuffer* buf,
                                 int buf_len,
                                 const IPEndPoint* address,
                                 OldCompletionCallback* callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(INVALID_SOCKET, socket_);
-  DCHECK(!write_callback_);
+  DCHECK(!old_write_callback_ && write_callback_.is_null());
   DCHECK(callback);  // Synchronous operation not supported.
   DCHECK_GT(buf_len, 0);
   DCHECK(!send_to_address_.get());
 
   int nwrite = InternalSendTo(buf, buf_len, address);
   if (nwrite != ERR_IO_PENDING)
     return nwrite;
 
   if (address)
     send_to_address_.reset(new IPEndPoint(*address));
   write_iobuffer_ = buf;
+  old_write_callback_ = callback;
+  return ERR_IO_PENDING;
+}
+int UDPSocketWin::SendToOrWrite(IOBuffer* buf,
+                                int buf_len,
+                                const IPEndPoint* address,
+                                const CompletionCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK_NE(INVALID_SOCKET, socket_);
+  DCHECK(!old_write_callback_ && write_callback_.is_null());
+  DCHECK(!callback.is_null());  // Synchronous operation not supported.
+  DCHECK_GT(buf_len, 0);
+  DCHECK(!send_to_address_.get());
+
+  int nwrite = InternalSendTo(buf, buf_len, address);
+  if (nwrite != ERR_IO_PENDING)
+    return nwrite;
+
+  if (address)
+    send_to_address_.reset(new IPEndPoint(*address));
+  write_iobuffer_ = buf;
   write_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int UDPSocketWin::Connect(const IPEndPoint& address) {
   net_log_.BeginEvent(
       NetLog::TYPE_UDP_CONNECT,
       make_scoped_refptr(new NetLogStringParameter("address",
                                                    address.ToString())));
   int rv = InternalConnect(address);
@@ skipping 76 matching lines @@
     c->Run(rv);
   } else {
     CompletionCallback c = read_callback_;
     read_callback_.Reset();
     c.Run(rv);
   }
 }
 
 void UDPSocketWin::DoWriteCallback(int rv) {
   DCHECK_NE(rv, ERR_IO_PENDING);
-  DCHECK(write_callback_);
+  DCHECK(old_write_callback_ && !write_callback_.is_null());
 
   // since Run may result in Write being called, clear write_callback_ up front.
-  OldCompletionCallback* c = write_callback_;
-  write_callback_ = NULL;
-  c->Run(rv);
+  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);
+  }
 }
 
 void UDPSocketWin::DidCompleteRead() {
   DWORD num_bytes, flags;
   BOOL ok = WSAGetOverlappedResult(socket_, &read_overlapped_,
                                    &num_bytes, FALSE, &flags);
   WSAResetEvent(read_overlapped_.hEvent);
   int result = ok ? num_bytes : MapSystemError(WSAGetLastError());
   // Convert address.
   if (recv_from_address_ && result >= 0) {
@@ skipping 170 matching lines @@
   return DoBind(IPEndPoint(ip, 0));
 }
 
 bool UDPSocketWin::ReceiveAddressToIPEndpoint(IPEndPoint* address) const {
   const struct sockaddr* addr =
       reinterpret_cast<const struct sockaddr*>(&recv_addr_storage_);
   return address->FromSockAddr(addr, recv_addr_len_);
 }
 
 }  // namespace net