base::Bind: Convert ServerSocket::Accept.

BUG=none
TEST=none
R=csilv

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

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

content/browser/renderer_host/p2p/socket_host_tcp_server.cc

@@ -4,6 +4,8 @@
 
 #include "content/browser/renderer_host/p2p/socket_host_tcp_server.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/p2p/socket_host_tcp.h"
 #include "content/common/p2p_messages.h"
@@ -24,8 +26,9 @@ P2PSocketHostTcpServer::P2PSocketHostTcpServer(
     int routing_id, int id)
     : P2PSocketHost(message_sender, routing_id, id),
       socket_(new net::TCPServerSocket(NULL, net::NetLog::Source())),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          accept_callback_(this, &P2PSocketHostTcpServer::OnAccepted)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(accept_callback_(
+          base::Bind(&P2PSocketHostTcpServer::OnAccepted,
+                     base::Unretained(this)))) {
 }
 
 P2PSocketHostTcpServer::~P2PSocketHostTcpServer() {
@@ -76,7 +79,7 @@ void P2PSocketHostTcpServer::OnError() {
 
 void P2PSocketHostTcpServer::DoAccept() {
   while (true) {
-    int result = socket_->Accept(&accept_socket_, &accept_callback_);
+    int result = socket_->Accept(&accept_socket_, accept_callback_);
     if (result == net::ERR_IO_PENDING) {
       break;
     } else {

content/browser/renderer_host/p2p/socket_host_tcp_server.h

@@ -14,6 +14,7 @@
 #include "content/browser/renderer_host/p2p/socket_host.h"
 #include "content/common/content_export.h"
 #include "content/common/p2p_sockets.h"
+#include "net/base/completion_callback.h"
 #include "net/socket/tcp_server_socket.h"
 
 namespace net {
@@ -55,7 +56,7 @@ class CONTENT_EXPORT P2PSocketHostTcpServer : public P2PSocketHost {
   scoped_ptr<net::StreamSocket> accept_socket_;
   AcceptedSocketsMap accepted_sockets_;
 
-  net::OldCompletionCallbackImpl<P2PSocketHostTcpServer> accept_callback_;
+  net::CompletionCallback accept_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(P2PSocketHostTcpServer);
 };

content/browser/renderer_host/p2p/socket_host_tcp_server_unittest.cc

@@ -6,6 +6,7 @@
 
 #include "content/browser/renderer_host/p2p/socket_host_tcp.h"
 #include "content/browser/renderer_host/p2p/socket_host_test_utils.h"
+#include "net/base/completion_callback.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -20,22 +21,25 @@ class FakeServerSocket : public net::ServerSocket {
  public:
   FakeServerSocket()
       : listening_(false),
-        accept_socket_(NULL),
-        accept_callback_(NULL) {
+        accept_socket_(NULL) {
   }
 
-  ~FakeServerSocket() { }
+  virtual ~FakeServerSocket() {}
 
   bool listening() { return listening_; }
 
   void AddIncoming(net::StreamSocket* socket) {
-    if (accept_callback_) {
+    if (!accept_callback_.is_null()) {
       DCHECK(incoming_sockets_.empty());
       accept_socket_->reset(socket);
       accept_socket_ = NULL;
-      net::OldCompletionCallback* cb = accept_callback_;
-      accept_callback_ = NULL;
-      cb->Run(net::OK);
+
+      // This copy is necessary because this implementation of ServerSocket
+      // bases logic on the null-ness of |accept_callback_| in the bound
+      // callback.
+      net::CompletionCallback cb = accept_callback_;
+      accept_callback_.Reset();
+      cb.Run(net::OK);
     } else {
       incoming_sockets_.push_back(socket);
     }
@@ -54,7 +58,7 @@ class FakeServerSocket : public net::ServerSocket {
   }
 
   virtual int Accept(scoped_ptr<net::StreamSocket>* socket,
-                     net::OldCompletionCallback* callback) OVERRIDE {
+                     const net::CompletionCallback& callback) OVERRIDE {
     DCHECK(socket);
     if (!incoming_sockets_.empty()) {
       socket->reset(incoming_sockets_.front());
@@ -73,7 +77,7 @@ class FakeServerSocket : public net::ServerSocket {
   net::IPEndPoint local_address_;
 
   scoped_ptr<net::StreamSocket>* accept_socket_;
-  net::OldCompletionCallback* accept_callback_;
+  net::CompletionCallback accept_callback_;
 
   std::list<net::StreamSocket*> incoming_sockets_;
 };

net/socket/server_socket.h

@@ -29,7 +29,7 @@ class NET_EXPORT ServerSocket {
   // Accept connection. Callback is called when new connection is
   // accepted.
   virtual int Accept(scoped_ptr<StreamSocket>* socket,
-                     OldCompletionCallback* callback) = 0;
+                     const CompletionCallback& callback) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServerSocket);

net/socket/tcp_client_socket_unittest.cc

@@ -41,9 +41,9 @@ TEST(TCPClientSocketTest, BindLoopbackToLoopback) {
   TestOldCompletionCallback connect_callback;
   EXPECT_EQ(ERR_IO_PENDING, socket.Connect(&connect_callback));
 
-  TestOldCompletionCallback accept_callback;
+  TestCompletionCallback accept_callback;
   scoped_ptr<StreamSocket> accepted_socket;
-  int result = server.Accept(&accepted_socket, &accept_callback);
+  int result = server.Accept(&accepted_socket, accept_callback.callback());
   if (result == ERR_IO_PENDING)
     result = accept_callback.WaitForResult();
   ASSERT_EQ(OK, result);

net/socket/tcp_server_socket_libevent.cc

@@ -34,7 +34,6 @@ TCPServerSocketLibevent::TCPServerSocketLibevent(
     const net::NetLog::Source& source)
     : socket_(kInvalidSocket),
       accept_socket_(NULL),
-      accept_callback_(NULL),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {
   scoped_refptr<NetLog::EventParameters> params;
   if (source.is_valid())
@@ -106,11 +105,11 @@ int TCPServerSocketLibevent::GetLocalAddress(IPEndPoint* address) const {
 }
 
 int TCPServerSocketLibevent::Accept(
-    scoped_ptr<StreamSocket>* socket, OldCompletionCallback* callback) {
+    scoped_ptr<StreamSocket>* socket, const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(socket);
-  DCHECK(callback);
-  DCHECK(!accept_callback_);
+  DCHECK(!callback.is_null());
+  DCHECK(accept_callback_.is_null());
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_ACCEPT, NULL);
 
@@ -185,12 +184,11 @@ void TCPServerSocketLibevent::OnFileCanReadWithoutBlocking(int fd) {
 
   int result = AcceptInternal(accept_socket_);
   if (result != ERR_IO_PENDING) {
-    OldCompletionCallback* c = accept_callback_;
-    accept_callback_ = NULL;
     accept_socket_ = NULL;
     bool ok = accept_socket_watcher_.StopWatchingFileDescriptor();
     DCHECK(ok);
-    c->Run(result);
+    accept_callback_.Run(result);
+    accept_callback_.Reset();
   }
 }
 

net/socket/tcp_server_socket_libevent.h

@@ -29,7 +29,7 @@ class NET_EXPORT_PRIVATE TCPServerSocketLibevent
   virtual int Listen(const net::IPEndPoint& address, int backlog) OVERRIDE;
   virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
   virtual int Accept(scoped_ptr<StreamSocket>* socket,
-                     OldCompletionCallback* callback) OVERRIDE;
+                     const CompletionCallback& callback) OVERRIDE;
 
   // MessageLoopForIO::Watcher implementation.
   virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
@@ -44,7 +44,7 @@ class NET_EXPORT_PRIVATE TCPServerSocketLibevent
   MessageLoopForIO::FileDescriptorWatcher accept_socket_watcher_;
 
   scoped_ptr<StreamSocket>* accept_socket_;
-  OldCompletionCallback* accept_callback_;
+  CompletionCallback accept_callback_;
 
   BoundNetLog net_log_;
 };

net/socket/tcp_server_socket_unittest.cc

@@ -82,9 +82,9 @@ TEST_F(TCPServerSocketTest, Accept) {
                                     NULL, NetLog::Source());
   connecting_socket.Connect(&connect_callback);
 
-  TestOldCompletionCallback accept_callback;
+  TestCompletionCallback accept_callback;
   scoped_ptr<StreamSocket> accepted_socket;
-  int result = socket_.Accept(&accepted_socket, &accept_callback);
+  int result = socket_.Accept(&accepted_socket, accept_callback.callback());
   if (result == ERR_IO_PENDING)
     result = accept_callback.WaitForResult();
   ASSERT_EQ(OK, result);
@@ -102,10 +102,11 @@ TEST_F(TCPServerSocketTest, Accept) {
 TEST_F(TCPServerSocketTest, AcceptAsync) {
   ASSERT_NO_FATAL_FAILURE(SetUpIPv4());
 
-  TestOldCompletionCallback accept_callback;
+  TestCompletionCallback accept_callback;
   scoped_ptr<StreamSocket> accepted_socket;
 
-  ASSERT_EQ(ERR_IO_PENDING, socket_.Accept(&accepted_socket, &accept_callback));
+  ASSERT_EQ(ERR_IO_PENDING,
+            socket_.Accept(&accepted_socket, accept_callback.callback()));
 
   TestOldCompletionCallback connect_callback;
   TCPClientSocket connecting_socket(local_address_list(),
@@ -126,11 +127,11 @@ TEST_F(TCPServerSocketTest, AcceptAsync) {
 TEST_F(TCPServerSocketTest, Accept2Connections) {
   ASSERT_NO_FATAL_FAILURE(SetUpIPv4());
 
-  TestOldCompletionCallback accept_callback;
+  TestCompletionCallback accept_callback;
   scoped_ptr<StreamSocket> accepted_socket;
 
   ASSERT_EQ(ERR_IO_PENDING,
-            socket_.Accept(&accepted_socket, &accept_callback));
+            socket_.Accept(&accepted_socket, accept_callback.callback()));
 
   TestOldCompletionCallback connect_callback;
   TCPClientSocket connecting_socket(local_address_list(),
@@ -144,9 +145,9 @@ TEST_F(TCPServerSocketTest, Accept2Connections) {
 
   EXPECT_EQ(OK, accept_callback.WaitForResult());
 
-  TestOldCompletionCallback accept_callback2;
+  TestCompletionCallback accept_callback2;
   scoped_ptr<StreamSocket> accepted_socket2;
-  int result = socket_.Accept(&accepted_socket2, &accept_callback2);
+  int result = socket_.Accept(&accepted_socket2, accept_callback2.callback());
   if (result == ERR_IO_PENDING)
     result = accept_callback2.WaitForResult();
   ASSERT_EQ(OK, result);
@@ -174,9 +175,9 @@ TEST_F(TCPServerSocketTest, AcceptIPv6) {
                                     NULL, NetLog::Source());
   connecting_socket.Connect(&connect_callback);
 
-  TestOldCompletionCallback accept_callback;
+  TestCompletionCallback accept_callback;
   scoped_ptr<StreamSocket> accepted_socket;
-  int result = socket_.Accept(&accepted_socket, &accept_callback);
+  int result = socket_.Accept(&accepted_socket, accept_callback.callback());
   if (result == ERR_IO_PENDING)
     result = accept_callback.WaitForResult();
   ASSERT_EQ(OK, result);

net/socket/tcp_server_socket_win.cc

@@ -20,7 +20,6 @@ TCPServerSocketWin::TCPServerSocketWin(net::NetLog* net_log,
     : socket_(INVALID_SOCKET),
       socket_event_(WSA_INVALID_EVENT),
       accept_socket_(NULL),
-      accept_callback_(NULL),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {
   scoped_refptr<NetLog::EventParameters> params;
   if (source.is_valid())
@@ -99,11 +98,11 @@ int TCPServerSocketWin::GetLocalAddress(IPEndPoint* address) const {
 }
 
 int TCPServerSocketWin::Accept(
-    scoped_ptr<StreamSocket>* socket, OldCompletionCallback* callback) {
+    scoped_ptr<StreamSocket>* socket, const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(socket);
-  DCHECK(callback);
-  DCHECK(!accept_callback_);
+  DCHECK(!callback.is_null());
+  DCHECK(accept_callback_.is_null());
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_ACCEPT, NULL);
 
@@ -182,10 +181,9 @@ void TCPServerSocketWin::OnObjectSignaled(HANDLE object) {
   if (ev.lNetworkEvents & FD_ACCEPT) {
     int result = AcceptInternal(accept_socket_);
     if (result != ERR_IO_PENDING) {
-      OldCompletionCallback* c = accept_callback_;
-      accept_callback_ = NULL;
       accept_socket_ = NULL;
-      c->Run(result);
+      accept_callback_.Run(result);
+      accept_callback_.Reset();
     }
   }
 }

net/socket/tcp_server_socket_win.h

@@ -11,6 +11,7 @@
 #include "base/message_loop.h"
 #include "base/win/object_watcher.h"
 #include "base/threading/non_thread_safe.h"
+#include "net/base/completion_callback.h"
 #include "net/base/net_log.h"
 #include "net/socket/server_socket.h"
 
@@ -31,7 +32,7 @@ class NET_EXPORT_PRIVATE TCPServerSocketWin
   virtual int Listen(const net::IPEndPoint& address, int backlog);
   virtual int GetLocalAddress(IPEndPoint* address) const;
   virtual int Accept(scoped_ptr<StreamSocket>* socket,
-                     OldCompletionCallback* callback);
+                     const CompletionCallback& callback);
 
   // base::ObjectWatcher::Delegate implementation.
   virtual void OnObjectSignaled(HANDLE object);
@@ -46,7 +47,7 @@ class NET_EXPORT_PRIVATE TCPServerSocketWin
   base::win::ObjectWatcher accept_watcher_;
 
   scoped_ptr<StreamSocket>* accept_socket_;
-  OldCompletionCallback* accept_callback_;
+  CompletionCallback accept_callback_;
 
   BoundNetLog net_log_;
 };