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

net/curvecp/client_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/client_packetizer.h"
 
 #include "base/bind.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/sys_addrinfo.h"
@@ skipping 15 matching lines @@
 };
 
 }  // namespace
 
 namespace net {
 
 ClientPacketizer::ClientPacketizer()
     : Packetizer(),
       next_state_(NONE),
       listener_(NULL),
-      old_user_callback_(NULL),
       current_address_(NULL),
       hello_attempts_(0),
       initiate_sent_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          io_callback_(this, &ClientPacketizer::OnIOComplete)),
+          io_callback_(base::Bind(&ClientPacketizer::OnIOComplete,
+                                  base::Unretained(this)))),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   // TODO(mbelshe): Initialize our keys and such properly.
   //     for now we use random values to keep them unique.
   for (int i = 0; i < 32; ++i)
     shortterm_public_key_[i] = rand() % 26 + 'a';
 }
 
 ClientPacketizer::~ClientPacketizer() {
 }
 
 int ClientPacketizer::Connect(const AddressList& server,
                               Packetizer::Listener* listener,
-                              OldCompletionCallback* callback) {
-  DCHECK(!old_user_callback_);
-  DCHECK(!socket_.get());
-  DCHECK(!listener_);
-
-  listener_ = listener;
-
-  addresses_ = server;
-
-  old_user_callback_ = callback;
-  next_state_ = LOOKUP_COOKIE;
-
-  return DoLoop(OK);
-}
-int ClientPacketizer::Connect(const AddressList& server,
-                              Packetizer::Listener* listener,
-                              const net::CompletionCallback& callback) {
+                              const CompletionCallback& callback) {
   DCHECK(user_callback_.is_null());
   DCHECK(!socket_.get());
   DCHECK(!listener_);
 
   listener_ = listener;
 
   addresses_ = server;
 
   user_callback_ = callback;
   next_state_ = LOOKUP_COOKIE;
 
   return DoLoop(OK);
 }
 
 int ClientPacketizer::SendMessage(ConnectionKey key,
                                   const char* data,
                                   size_t length,
-                                  OldCompletionCallback* callback) {
+                                  const CompletionCallback& callback) {
   // We can't send messages smaller than 16 bytes.
   if (length < 16)
     return ERR_UNEXPECTED;
 
   if (!initiate_sent_) {
     const size_t kMaxMessageInInitiatePacket =
         kMaxPacketLength - sizeof(InitiatePacket);
 
     if (length > kMaxMessageInInitiatePacket) {
       NOTREACHED();
       return ERR_UNEXPECTED;
     }
 
     initiate_sent_ = true;
 
     // Bundle this message into the Initiate Packet.
     scoped_refptr<IOBuffer> buffer(new IOBuffer(kMaxPacketLength));
     InitiatePacket* packet = reinterpret_cast<InitiatePacket*>(buffer->data());
     memset(packet, 0, sizeof(InitiatePacket));
     memcpy(packet->id, "QvnQ5XlI", 8);
     memcpy(packet->client_shortterm_public_key, shortterm_public_key_,
            sizeof(shortterm_public_key_));
     // TODO(mbelshe): Fill in rest of Initiate fields here
     // TODO(mbelshe): Fill in rest of message
     //
     // TODO(mbelshe) - this is just broken to make it work with cleartext
     memcpy(&buffer->data()[sizeof(InitiatePacket)], data, length);
     int packet_length = sizeof(InitiatePacket) + length;
-    int rv = socket_->Write(buffer, packet_length, &io_callback_);
+    int rv = socket_->Write(buffer, packet_length, io_callback_);
     if (rv <= 0)
       return rv;
     CHECK_EQ(packet_length, rv);  // We must send all data.
     return length;
   }
 
   if (length > static_cast<size_t>(kMaxMessageLength)) {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
   // Bundle this message into the Initiate Packet.
   scoped_refptr<IOBuffer> buffer(new IOBuffer(kMaxPacketLength));
   ClientMessagePacket* packet =
       reinterpret_cast<ClientMessagePacket*>(buffer->data());
   memset(packet, 0, sizeof(ClientMessagePacket));
   memcpy(packet->id, "QvnQ5XlM", 8);
   memcpy(packet->client_shortterm_public_key, shortterm_public_key_,
          sizeof(shortterm_public_key_));
   // TODO(mbelshe): Fill in rest of Initiate fields here
   // TODO(mbelshe): Fill in rest of message
   memcpy(&buffer->data()[sizeof(ClientMessagePacket)], data, length);
   int packet_length = sizeof(ClientMessagePacket) + length;
-  int rv = socket_->Write(buffer, packet_length, &io_callback_);
+  int rv = socket_->Write(buffer, packet_length, io_callback_);
   if (rv <= 0)
     return rv;
   CHECK_EQ(packet_length, rv);  // We must send all data.
   return length;
 }
 
 void ClientPacketizer::Close(ConnectionKey key) {
   // TODO(mbelshe): implement me
   NOTIMPLEMENTED();
 }
@@ skipping 72 matching lines @@
   // Construct Hello Packet
   scoped_refptr<IOBuffer> buffer(new IOBuffer(sizeof(struct HelloPacket)));
   struct HelloPacket* data =
       reinterpret_cast<struct HelloPacket*>(buffer->data());
   memset(data, 0, sizeof(struct HelloPacket));
   memcpy(data->id, "QvnQ5XlH", 8);
   memcpy(data->client_shortterm_public_key, shortterm_public_key_,
          sizeof(shortterm_public_key_));
   // TODO(mbelshe): populate all other fields of the HelloPacket.
 
-  return socket_->Write(buffer, sizeof(struct HelloPacket), &io_callback_);
+  return socket_->Write(buffer, sizeof(struct HelloPacket), io_callback_);
 }
 
 int ClientPacketizer::DoSendingHelloComplete(int rv) {
   next_state_ = NONE;
 
   if (rv < 0)
     return rv;
 
   // Writing to UDP should not result in a partial datagram.
   if (rv != sizeof(struct HelloPacket))
     return ERR_FAILED;
 
   next_state_ = WAITING_COOKIE;
   return OK;
 }
 
 int ClientPacketizer::DoWaitingCookie() {
   next_state_ = WAITING_COOKIE_COMPLETE;
 
   StartHelloTimer(kHelloTimeoutMs[hello_attempts_++]);
 
   read_buffer_ = new IOBuffer(kMaxPacketLength);
-  return socket_->Read(read_buffer_, kMaxPacketLength, &io_callback_);
+  return socket_->Read(read_buffer_, kMaxPacketLength, io_callback_);
 }
 
 int ClientPacketizer::DoWaitingCookieComplete(int rv) {
   // TODO(mbelshe): Add Histogram for hello_attempts_.
   RevokeHelloTimer();
 
   // TODO(mbelshe): Validate the cookie here
   if (rv < 0)
     return rv;
 
@@ skipping 20 matching lines @@
 
 int ClientPacketizer::DoConnected(int rv) {
   DCHECK(next_state_ == CONNECTED);
   if (rv > 0)
     ProcessRead(rv);
   return ReadPackets();
 }
 
 void ClientPacketizer::DoCallback(int result) {
   DCHECK_NE(result, ERR_IO_PENDING);
-  DCHECK(old_user_callback_ || !user_callback_.is_null());
+  DCHECK(!user_callback_.is_null());
 
-  if (old_user_callback_) {
-    OldCompletionCallback* callback = old_user_callback_;
-    old_user_callback_ = NULL;
-    callback->Run(result);
-  } else {
-    CompletionCallback callback = user_callback_;
-    user_callback_.Reset();
-    callback.Run(result);
-  }
+  CompletionCallback callback = user_callback_;
+  user_callback_.Reset();
+  callback.Run(result);
 }
 
 int ClientPacketizer::ConnectNextAddress() {
   // TODO(mbelshe): plumb Netlog information
 
   DCHECK(addresses_.head());
 
   socket_.reset(new UDPClientSocket(DatagramSocket::DEFAULT_BIND,
                                     RandIntCallback(),
                                     NULL,
@@ skipping 65 matching lines @@
                        length);
 }
 
 int ClientPacketizer::ReadPackets() {
   DCHECK(socket_.get());
 
   int rv;
   while (true) {
     rv = socket_->Read(read_buffer_,
                        kMaxPacketLength,
-                       &io_callback_);
+                       io_callback_);
     if (rv <= 0) {
       if (rv != ERR_IO_PENDING)
         LOG(ERROR) << "Error reading socket:" << rv;
       return rv;
     }
     ProcessRead(rv);
   }
   return rv;
 }
 
 void ClientPacketizer::OnIOComplete(int result) {
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING)
     DoCallback(rv);
 }
 
 }  // namespace net