base::Bind: Convert jingle/.

jingle/notifier/base/chrome_async_socket.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 "jingle/notifier/base/chrome_async_socket.h"
 
 #include <algorithm>
 #include <cstring>
 #include <cstdlib>
 
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "jingle/notifier/base/resolving_client_socket_factory.h"
 #include "net/base/address_list.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_util.h"
 #include "net/base/ssl_config_service.h"
 #include "net/base/sys_addrinfo.h"
@@ skipping 14 matching lines @@
       read_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
                      &ChromeAsyncSocket::ProcessReadDone),
       write_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
                      &ChromeAsyncSocket::ProcessWriteDone),
       ssl_connect_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
                             &ChromeAsyncSocket::ProcessSSLConnectDone),
       client_socket_factory_(client_socket_factory),
       state_(STATE_CLOSED),
       error_(ERROR_NONE),
       net_error_(net::OK),
-      scoped_runnable_method_factory_(
-          ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       read_state_(IDLE),
       read_buf_(new net::IOBufferWithSize(read_buf_size)),
       read_start_(0U),
       read_end_(0U),
       write_state_(IDLE),
       write_buf_(new net::IOBufferWithSize(write_buf_size)),
       write_end_(0U) {
   DCHECK(client_socket_factory_.get());
   DCHECK_GT(read_buf_size, 0U);
   DCHECK_GT(write_buf_size, 0U);
@@ skipping 47 matching lines @@
     DoNonNetError(ERROR_DNS);
     return false;
   }
 
   DCHECK_EQ(state_, buzz::AsyncSocket::STATE_CLOSED);
   DCHECK_EQ(read_state_, IDLE);
   DCHECK_EQ(write_state_, IDLE);
 
   state_ = STATE_CONNECTING;
 
-  DCHECK(scoped_runnable_method_factory_.empty());
-  scoped_runnable_method_factory_.RevokeAll();
+  DCHECK_EQ(false, weak_factory_.HasWeakPtrs());
 
   net::HostPortPair dest_host_port_pair(address.IPAsString(), address.port());
 
   transport_socket_.reset(
       client_socket_factory_->CreateTransportClientSocket(
           dest_host_port_pair));
   int status = transport_socket_->Connect(&connect_callback_);
   if (status != net::ERR_IO_PENDING) {
     // We defer execution of ProcessConnectDone instead of calling it
     // directly here as the caller may not expect an error/close to
     // happen here.  This is okay, as from the caller's point of view,
     // the connect always happens asynchronously.
     MessageLoop* message_loop = MessageLoop::current();
     CHECK(message_loop);
-    message_loop->PostTask(
-        FROM_HERE,
-        scoped_runnable_method_factory_.NewRunnableMethod(
-            &ChromeAsyncSocket::ProcessConnectDone, status));
+    message_loop->PostTask(FROM_HERE,
+                           base::Bind(&ChromeAsyncSocket::ProcessConnectDone,
+                                      weak_factory_.GetWeakPtr(), status));
   }
   return true;
 }
 
 // STATE_CONNECTING -> STATE_OPEN
 // read_state_ == IDLE -> read_state_ == POSTED (via PostDoRead())
 
 void ChromeAsyncSocket::ProcessConnectDone(int status) {
   DCHECK_NE(status, net::ERR_IO_PENDING);
   DCHECK_EQ(read_state_, IDLE);
@@ skipping 15 matching lines @@
 
 void ChromeAsyncSocket::PostDoRead() {
   DCHECK(IsOpen());
   DCHECK_EQ(read_state_, IDLE);
   DCHECK_EQ(read_start_, 0U);
   DCHECK_EQ(read_end_, 0U);
   MessageLoop* message_loop = MessageLoop::current();
   CHECK(message_loop);
   message_loop->PostTask(
       FROM_HERE,
-      scoped_runnable_method_factory_.NewRunnableMethod(
-          &ChromeAsyncSocket::DoRead));
+      base::Bind(&ChromeAsyncSocket::DoRead, weak_factory_.GetWeakPtr()));
   read_state_ = POSTED;
 }
 
 // read_state_ == POSTED -> read_state_ == PENDING
 
 void ChromeAsyncSocket::DoRead() {
   DCHECK(IsOpen());
   DCHECK_EQ(read_state_, POSTED);
   DCHECK_EQ(read_start_, 0U);
   DCHECK_EQ(read_end_, 0U);
@@ skipping 110 matching lines @@
 // write_state_ == IDLE -> write_state_ == POSTED
 
 void ChromeAsyncSocket::PostDoWrite() {
   DCHECK(IsOpen());
   DCHECK_EQ(write_state_, IDLE);
   DCHECK_GT(write_end_, 0U);
   MessageLoop* message_loop = MessageLoop::current();
   CHECK(message_loop);
   message_loop->PostTask(
       FROM_HERE,
-      scoped_runnable_method_factory_.NewRunnableMethod(
-          &ChromeAsyncSocket::DoWrite));
+      base::Bind(&ChromeAsyncSocket::DoWrite, weak_factory_.GetWeakPtr()));
   write_state_ = POSTED;
 }
 
 // write_state_ == POSTED -> write_state_ == PENDING
 
 void ChromeAsyncSocket::DoWrite() {
   DCHECK(IsOpen());
   DCHECK_EQ(write_state_, POSTED);
   DCHECK_GT(write_end_, 0U);
   // Once we call Write(), we cannot call StartTls() until the write
@@ skipping 46 matching lines @@
 // * -> STATE_CLOSED
 
 bool ChromeAsyncSocket::Close() {
   DoClose();
   return true;
 }
 
 // (not STATE_CLOSED) -> STATE_CLOSED
 
 void ChromeAsyncSocket::DoClose() {
-  scoped_runnable_method_factory_.RevokeAll();
+  weak_factory_.InvalidateWeakPtrs();
   if (transport_socket_.get()) {
     transport_socket_->Disconnect();
   }
   transport_socket_.reset();
   read_state_ = IDLE;
   read_start_ = 0U;
   read_end_ = 0U;
   write_state_ = IDLE;
   write_end_ = 0U;
   if (state_ != STATE_CLOSED) {
@@ skipping 16 matching lines @@
     return false;
   }
 
   state_ = STATE_TLS_CONNECTING;
   read_state_ = IDLE;
   read_start_ = 0U;
   read_end_ = 0U;
   DCHECK_EQ(write_end_, 0U);
 
   // Clear out any posted DoRead() tasks.
-  scoped_runnable_method_factory_.RevokeAll();
+  weak_factory_.InvalidateWeakPtrs();
 
   DCHECK(transport_socket_.get());
   net::ClientSocketHandle* socket_handle = new net::ClientSocketHandle();
   socket_handle->set_socket(transport_socket_.release());
   transport_socket_.reset(
       client_socket_factory_->CreateSSLClientSocket(
           socket_handle, net::HostPortPair(domain_name, 443)));
   int status = transport_socket_->Connect(&ssl_connect_callback_);
   if (status != net::ERR_IO_PENDING) {
     MessageLoop* message_loop = MessageLoop::current();
     CHECK(message_loop);
-    message_loop->PostTask(
-        FROM_HERE,
-        scoped_runnable_method_factory_.NewRunnableMethod(
-            &ChromeAsyncSocket::ProcessSSLConnectDone, status));
+    message_loop->PostTask(FROM_HERE,
+                           base::Bind(&ChromeAsyncSocket::ProcessSSLConnectDone,
+                                      weak_factory_.GetWeakPtr(), status));
   }
   return true;
 }
 
 // STATE_TLS_CONNECTING -> STATE_TLS_OPEN
 // read_state_ == IDLE -> read_state_ == POSTED (via PostDoRead())
 // (maybe) write_state_ == IDLE -> write_state_ == POSTED (via
 // PostDoWrite())
 
 void ChromeAsyncSocket::ProcessSSLConnectDone(int status) {
@@ skipping 10 matching lines @@
   }
   state_ = STATE_TLS_OPEN;
   PostDoRead();
   if (write_end_ > 0U) {
     PostDoWrite();
   }
   SignalSSLConnected();
 }
 
 }  // namespace notifier