base::Bind fixes

chrome/browser/net/network_stats.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 "chrome/browser/net/network_stats.h"
 
+#include "base/bind.h"
 #include "base/callback_old.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "base/task.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "base/tuple.h"
@@ skipping 65 matching lines @@
       bytes_to_send_(0),
       encoded_message_(""),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           resolve_callback_(this, &NetworkStats::OnResolveComplete)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           read_callback_(this, &NetworkStats::OnReadComplete)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           write_callback_(this, &NetworkStats::OnWriteComplete)),
       finished_callback_(NULL),
       start_time_(base::TimeTicks::Now()),
-      ALLOW_THIS_IN_INITIALIZER_LIST(timers_factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 NetworkStats::~NetworkStats() {
   socket_.reset();
 }
 
 bool NetworkStats::Start(net::HostResolver* host_resolver,
                          const net::HostPortPair& server_host_port_pair,
                          uint32 bytes_to_send,
                          net::OldCompletionCallback* finished_callback) {
@@ skipping 97 matching lines @@
 
 void NetworkStats::OnReadComplete(int result) {
   if (!ReadComplete(result)) {
     // Called ReadData() via PostDelayedTask() to avoid recursion. Added a delay
     // of 1ms so that the time-out will fire before we have time to really hog
     // the CPU too extensively (waiting for the time-out) in case of an infinite
     // loop.
     const int kReadDataDelayMs = 1;
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
-        timers_factory_.NewRunnableMethod(&NetworkStats::ReadData),
+        base::Bind(&NetworkStats::ReadData, weak_factory_.GetWeakPtr()),
         kReadDataDelayMs);
   }
 }
 
 void NetworkStats::OnWriteComplete(int result) {
   DCHECK(socket_.get());
   DCHECK_NE(net::ERR_IO_PENDING, result);
   if (result < 0) {
     Finish(WRITE_FAILED, result);
     return;
@@ skipping 55 matching lines @@
     bytes_to_send_ -= rv;
     if (!write_buffer_->BytesRemaining())
       write_buffer_ = NULL;
   } while (bytes_to_send_);
   return net::OK;
 }
 
 void NetworkStats::StartReadDataTimer(int milliseconds) {
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      timers_factory_.NewRunnableMethod(&NetworkStats::OnReadDataTimeout),
+      base::Bind(&NetworkStats::OnReadDataTimeout, weak_factory_.GetWeakPtr()),
       milliseconds);
 }
 
 void NetworkStats::OnReadDataTimeout() {
   Finish(READ_TIMED_OUT, net::ERR_INVALID_ARGUMENT);
 }
 
 void NetworkStats::GetEchoRequest(net::IOBuffer* io_buffer) {
   // Copy the <version> into the io_buffer starting from the kVersionStart
   // position.
@@ skipping 226 matching lines @@
                          IOThread* io_thread) {
   if (network_stats_server.empty())
     return;
 
   // If we are not on IO Thread, then post a task to call CollectNetworkStats on
   // IO Thread.
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
-        NewRunnableFunction(
+        base::Bind(
             &CollectNetworkStats, network_stats_server, io_thread));
     return;
   }
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Check that there is a network connection. We get called only if UMA upload
   // to the server has succeeded.
   DCHECK(!net::NetworkChangeNotifier::IsOffline());
 
@@ skipping 54 matching lines @@
   TCPStatsClient* small_tcp_client = new TCPStatsClient();
   small_tcp_client->Start(
       host_resolver, tcp_server_address, kSmallTestBytesToSend, NULL);
 
   TCPStatsClient* large_tcp_client = new TCPStatsClient();
   large_tcp_client->Start(
       host_resolver, tcp_server_address, kLargeTestBytesToSend, NULL);
 }
 
 }  // namespace chrome_browser_net