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

net/curvecp/server_packetizer.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/curvecp/server_packetizer.h"
 
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/curvecp/protocol.h"
 #include "net/udp/udp_server_socket.h"
 
 namespace net {
 
 ServerPacketizer::ServerPacketizer()
     : Packetizer(),
       state_(NONE),
       listener_(NULL),
-      read_buffer_(new IOBuffer(kMaxPacketLength)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          read_callback_(this, &ServerPacketizer::OnReadComplete)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          write_callback_(this, &ServerPacketizer::OnWriteComplete)) {
+      read_buffer_(new IOBuffer(kMaxPacketLength)) {
 }
 
 ServerPacketizer::~ServerPacketizer() {
 }
 
 int ServerPacketizer::Listen(const IPEndPoint& endpoint,
                              Packetizer::Listener* listener) {
   DCHECK(!listener_);
   listener_ = listener;
   socket_.reset(new UDPServerSocket(NULL, NetLog::Source()));
   int rv = socket_->Listen(endpoint);
   if (rv != OK)
     return rv;
 
   return ReadPackets();
 }
 
 bool ServerPacketizer::Open(ConnectionKey key, Packetizer::Listener* listener) {
   DCHECK(listener_map_.find(key) == listener_map_.end());
   listener_map_[key] = listener;
   return true;
 }
 
 int ServerPacketizer::SendMessage(ConnectionKey key,
                                   const char* data,
                                   size_t length,
-                                  OldCompletionCallback* callback) {
+                                  const CompletionCallback& callback) {
   DCHECK(socket_.get());
   DCHECK_LT(0u, length);
   DCHECK_GT(kMaxPacketLength - sizeof(ServerMessagePacket), length);
 
   ConnectionMap::const_iterator it = connection_map_.find(key);
   if (it == connection_map_.end()) {
     LOG(ERROR) << "Unknown connection key";
     return ERR_FAILED;  // No route to the client!
   }
   IPEndPoint endpoint = it->second;
@@ skipping 70 matching lines @@
   scoped_refptr<IOBuffer> buffer(new IOBuffer(sizeof(struct CookiePacket)));
   struct CookiePacket* data =
       reinterpret_cast<struct CookiePacket*>(buffer->data());
   memset(data, 0, sizeof(struct CookiePacket));
   memcpy(data->id, "RL3aNMXK", 8);
   memcpy(data->client_extension, hello_packet->client_extension, 16);
   // TODO(mbelshe) Fill in the rest of the CookiePacket fields.
 
   // XXXMB - Can't have two pending writes at the same time...
   int rv = socket_->SendTo(buffer, sizeof(struct CookiePacket), recv_address_,
-                           &write_callback_);
+                           base::Bind(&ServerPacketizer::OnWriteComplete,
+                                      base::Unretained(this)));
   DCHECK(rv == ERR_IO_PENDING || rv == sizeof(struct CookiePacket));
 }
 
 void ServerPacketizer::HandleInitiatePacket(Packet* packet, int length) {
   // Handle InitiatePacket
   LOG(ERROR) << "Received Initiate Packet";
 
   InitiatePacket* initiate_packet = reinterpret_cast<InitiatePacket*>(packet);
 
   // We have an active connection.
@@ skipping 62 matching lines @@
 }
 
 int ServerPacketizer::ReadPackets() {
   DCHECK(socket_.get());
 
   int rv;
   while (true) {
     rv = socket_->RecvFrom(read_buffer_,
                            kMaxPacketLength,
                            &recv_address_,
-                           &read_callback_);
+                           base::Bind(&ServerPacketizer::OnReadComplete,
+                                      base::Unretained(this)));
     if (rv <= 0) {
       if (rv != ERR_IO_PENDING)
         LOG(ERROR) << "Error reading listen socket: " << rv;
       return rv;
     }
 
     ProcessRead(rv);
   }
 
   return rv;
 }
 
 void ServerPacketizer::OnReadComplete(int result) {
   if (result > 0)
     ProcessRead(result);
   ReadPackets();
 }
 
 void ServerPacketizer::OnWriteComplete(int result) {
   // TODO(mbelshe): do we need to do anything?
 }
 
 }