base::Bind: More random cleanups.

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"
 #include "net/curvecp/protocol.h"
 #include "net/udp/udp_client_socket.h"
 
 namespace {
 
 const int kMaxHelloAttempts = 8;
 const int kHelloTimeoutMs[kMaxHelloAttempts] = {
@@ skipping 14 matching lines @@
 ClientPacketizer::ClientPacketizer()
     : Packetizer(),
       next_state_(NONE),
       listener_(NULL),
       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(timers_factory_(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,
@@ skipping 256 matching lines @@
 
   int rv = socket_->Connect(endpoint);
   DCHECK_NE(ERR_IO_PENDING, rv);
 
   return rv;
 }
 
 void ClientPacketizer::StartHelloTimer(int milliseconds) {
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      timers_factory_.NewRunnableMethod(&ClientPacketizer::OnHelloTimeout),
+      base::Bind(&ClientPacketizer::OnHelloTimeout, weak_factory_.GetWeakPtr()),
       milliseconds);
 }
 
 void ClientPacketizer::RevokeHelloTimer() {
-  timers_factory_.RevokeAll();
+  weak_factory_.InvalidateWeakPtrs();
 }
 
 void ClientPacketizer::OnHelloTimeout() {
   DCHECK_EQ(WAITING_COOKIE_COMPLETE, next_state_);
   next_state_ = SENDING_HELLO;
   DLOG(INFO) << "HelloTimeout #" << hello_attempts_;
   int rv = DoLoop(OK);
   if (rv != ERR_IO_PENDING)
     DoCallback(rv);
 }
@@ skipping 45 matching lines @@
   return rv;
 }
 
 void ClientPacketizer::OnIOComplete(int result) {
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING)
     DoCallback(rv);
 }
 
 }  // namespace net