base::Bind fixes

chrome/browser/net/connection_tester.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/connection_tester.h"
 
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/importer/firefox_proxy_settings.h"
 #include "chrome/common/chrome_switches.h"
 #include "net/base/cert_verifier.h"
@@ skipping 238 matching lines @@
 // ConnectionTester::TestRunner ----------------------------------------------
 
 // TestRunner is a helper class for running an individual experiment. It can
 // be deleted any time after it is started, and this will abort the request.
 class ConnectionTester::TestRunner : public net::URLRequest::Delegate {
  public:
   // |tester| must remain alive throughout the TestRunner's lifetime.
   // |tester| will be notified of completion.
   explicit TestRunner(ConnectionTester* tester)
       : tester_(tester),
-        ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {}
+        ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
 
   // Starts running |experiment|. Notifies tester->OnExperimentCompleted() when
   // it is done.
   void Run(const Experiment& experiment);
 
   // Overridden from net::URLRequest::Delegate:
   virtual void OnResponseStarted(net::URLRequest* request);
   virtual void OnReadCompleted(net::URLRequest* request, int bytes_read);
   // TODO(eroman): handle cases requiring authentication.
 
  private:
   // The number of bytes to read each response body chunk.
   static const int kReadBufferSize = 1024;
 
   // Starts reading the response's body (and keeps reading until an error or
   // end of stream).
   void ReadBody(net::URLRequest* request);
 
   // Called when the request has completed (for both success and failure).
   void OnResponseCompleted(net::URLRequest* request);
   void OnExperimentCompletedWithResult(int result);
 
   ConnectionTester* tester_;
   scoped_ptr<net::URLRequest> request_;
 
-  ScopedRunnableMethodFactory<TestRunner> method_factory_;
+  base::WeakPtrFactory<TestRunner> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRunner);
 };
 
 void ConnectionTester::TestRunner::OnResponseStarted(net::URLRequest* request) {
   if (!request->status().is_success()) {
     OnResponseCompleted(request);
     return;
   }
 
@@ skipping 31 matching lines @@
   if (!request->status().is_success()) {
     DCHECK_NE(net::ERR_IO_PENDING, request->status().error());
     result = request->status().error();
   }
 
   // Post a task to notify the parent rather than handling it right away,
   // to avoid re-entrancy problems with URLRequest. (Don't want the caller
   // to end up deleting the URLRequest while in the middle of processing).
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      method_factory_.NewRunnableMethod(
-          &TestRunner::OnExperimentCompletedWithResult, result));
+      base::Bind(&TestRunner::OnExperimentCompletedWithResult,
+                 weak_factory_.GetWeakPtr(), result));
 }
 
 void ConnectionTester::TestRunner::OnExperimentCompletedWithResult(int result) {
   tester_->OnExperimentCompleted(result);
 }
 
 void ConnectionTester::TestRunner::Run(const Experiment& experiment) {
   // Try to create a net::URLRequestContext for this experiment.
   scoped_refptr<ExperimentURLRequestContext> context(
       new ExperimentURLRequestContext(tester_->proxy_request_context_));
@@ skipping 108 matching lines @@
 
   // Notify the delegate of completion.
   delegate_->OnCompletedConnectionTestExperiment(current, result);
 
   if (remaining_experiments_.empty()) {
     delegate_->OnCompletedConnectionTestSuite();
   } else {
     StartNextExperiment();
   }
 }