base::Bind: Convert StreamSocket::Connect.

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),
-      user_callback_(NULL),
+      old_user_callback_(NULL),
       current_address_(NULL),
       hello_attempts_(0),
       initiate_sent_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(this, &ClientPacketizer::OnIOComplete)),
       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(!user_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) {
+  DCHECK(user_callback_.is_null());
+  DCHECK(!socket_.get());
+  DCHECK(!listener_);
+
   listener_ = listener;
 
   addresses_ = server;
 
   user_callback_ = callback;
   next_state_ = LOOKUP_COOKIE;
 
   return DoLoop(OK);
 }
 
@@ skipping 203 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(user_callback_);
+  DCHECK(old_user_callback_ || !user_callback_.is_null());
 
-  OldCompletionCallback* callback = user_callback_;
-  user_callback_ = NULL;
-  callback->Run(result);
+  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);
+  }
 }
 
 int ClientPacketizer::ConnectNextAddress() {
   // TODO(mbelshe): plumb Netlog information
 
   DCHECK(addresses_.head());
 
   socket_.reset(new UDPClientSocket(DatagramSocket::DEFAULT_BIND,
                                     RandIntCallback(),
                                     NULL,
@@ skipping 83 matching lines @@
   return rv;
 }
 
 void ClientPacketizer::OnIOComplete(int result) {
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING)
     DoCallback(rv);
 }
 
 }  // namespace net