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

net/udp/udp_socket_unittest.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_client_socket.h"
 #include "net/udp/udp_server_socket.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
@@ skipping 14 matching lines @@
 namespace {
 
 class UDPSocketTest : public PlatformTest {
  public:
   UDPSocketTest()
       : buffer_(new IOBufferWithSize(kMaxRead)) {
   }
 
   // Blocks until data is read from the socket.
   std::string RecvFromSocket(UDPServerSocket* socket) {
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
 
     int rv = socket->RecvFrom(buffer_, kMaxRead, &recv_from_address_,
-                              &callback);
+                              callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
       return "";  // error!
     return std::string(buffer_->data(), rv);
   }
 
   // Loop until |msg| has been written to the socket or until an
   // error occurs.
   // If |address| is specified, then it is used for the destination
   // to send to. Otherwise, will send to the last socket this server
   // received from.
   int SendToSocket(UDPServerSocket* socket, std::string msg) {
     return SendToSocket(socket, msg, recv_from_address_);
   }
 
   int SendToSocket(UDPServerSocket* socket,
                    std::string msg,
                    const IPEndPoint& address) {
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
 
     int length = msg.length();
     scoped_refptr<StringIOBuffer> io_buffer(new StringIOBuffer(msg));
     scoped_refptr<DrainableIOBuffer> buffer(
         new DrainableIOBuffer(io_buffer, length));
 
     int bytes_sent = 0;
     while (buffer->BytesRemaining()) {
       int rv = socket->SendTo(buffer, buffer->BytesRemaining(),
-                              address, &callback);
+                              address, callback.callback());
       if (rv == ERR_IO_PENDING)
         rv = callback.WaitForResult();
       if (rv <= 0)
         return bytes_sent > 0 ? bytes_sent : rv;
       bytes_sent += rv;
       buffer->DidConsume(rv);
     }
     return bytes_sent;
   }
 
   std::string ReadSocket(UDPClientSocket* socket) {
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
 
-    int rv = socket->Read(buffer_, kMaxRead, &callback);
+    int rv = socket->Read(buffer_, kMaxRead, callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
       return "";  // error!
     return std::string(buffer_->data(), rv);
   }
 
   // Loop until |msg| has been written to the socket or until an
   // error occurs.
   int WriteSocket(UDPClientSocket* socket, std::string msg) {
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
 
     int length = msg.length();
     scoped_refptr<StringIOBuffer> io_buffer(new StringIOBuffer(msg));
     scoped_refptr<DrainableIOBuffer> buffer(
         new DrainableIOBuffer(io_buffer, length));
 
     int bytes_sent = 0;
     while (buffer->BytesRemaining()) {
-      int rv = socket->Write(buffer, buffer->BytesRemaining(), &callback);
+      int rv = socket->Write(buffer, buffer->BytesRemaining(),
+                             callback.callback());
       if (rv == ERR_IO_PENDING)
         rv = callback.WaitForResult();
       if (rv <= 0)
         return bytes_sent > 0 ? bytes_sent : rv;
       bytes_sent += rv;
       buffer->DidConsume(rv);
     }
     return bytes_sent;
   }
 
@@ skipping 313 matching lines @@
 }
 
 // Close the socket while read is pending.
 TEST_F(UDPSocketTest, CloseWithPendingRead) {
   IPEndPoint bind_address;
   CreateUDPAddress("127.0.0.1", 0, &bind_address);
   UDPServerSocket server(NULL, NetLog::Source());
   int rv = server.Listen(bind_address);
   EXPECT_EQ(OK, rv);
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   IPEndPoint from;
-  rv = server.RecvFrom(buffer_, kMaxRead, &from, &callback);
+  rv = server.RecvFrom(buffer_, kMaxRead, &from, callback.callback());
   EXPECT_EQ(rv, ERR_IO_PENDING);
 
   server.Close();
 
   EXPECT_FALSE(callback.have_result());
 }
 
 }  // namespace
 
 }  // namespace net