Convert NewRunnableFunction/NewRunnableMethod calls to use base::Bind().

content/test/test_url_fetcher_factory.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 "content/test/test_url_fetcher_factory.h"
 
 #include <string>
 
+#include "base/bind.h"
 #include "base/compiler_specific.h"
+#include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "content/common/net/url_fetcher_impl.h"
 #include "content/public/common/url_fetcher_delegate.h"
 #include "net/base/host_port_pair.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_status.h"
 
 ScopedURLFetcherFactory::ScopedURLFetcherFactory(
     content::URLFetcherFactory* factory) {
   DCHECK(!URLFetcherImpl::factory());
@@ skipping 205 matching lines @@
 }
 
 // This class is used by the FakeURLFetcherFactory below.
 class FakeURLFetcher : public TestURLFetcher {
  public:
   // Normal URL fetcher constructor but also takes in a pre-baked response.
   FakeURLFetcher(const GURL& url,
                  content::URLFetcherDelegate* d,
                  const std::string& response_data, bool success)
     : TestURLFetcher(0, url, d),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
     set_status(net::URLRequestStatus(
         success ? net::URLRequestStatus::SUCCESS :
             net::URLRequestStatus::FAILED,
         0));
     set_response_code(success ? 200 : 500);
     SetResponseString(response_data);
   }
 
   // Start the request.  This will call the given delegate asynchronously
   // with the pre-baked response as parameter.
   virtual void Start() OVERRIDE {
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        method_factory_.NewRunnableMethod(&FakeURLFetcher::RunDelegate));
+        base::Bind(&FakeURLFetcher::RunDelegate, weak_factory_.GetWeakPtr()));
   }
 
   virtual const GURL& GetURL() const OVERRIDE {
     return TestURLFetcher::GetOriginalURL();
   }
 
  private:
   virtual ~FakeURLFetcher() {
   }
 
   // This is the method which actually calls the delegate that is passed in the
   // constructor.
   void RunDelegate() {
     delegate()->OnURLFetchComplete(this);
   }
 
-  // Method factory used to run the delegate.
-  ScopedRunnableMethodFactory<FakeURLFetcher> method_factory_;
+  base::WeakPtrFactory<FakeURLFetcher> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeURLFetcher);
 };
 
 FakeURLFetcherFactory::FakeURLFetcherFactory()
     : ScopedURLFetcherFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 FakeURLFetcherFactory::FakeURLFetcherFactory(
     content::URLFetcherFactory* default_factory)
@@ skipping 36 matching lines @@
 
 URLFetcherImplFactory::~URLFetcherImplFactory() {}
 
 content::URLFetcher* URLFetcherImplFactory::CreateURLFetcher(
     int id,
     const GURL& url,
     content::URLFetcher::RequestType request_type,
     content::URLFetcherDelegate* d) {
   return new URLFetcherImpl(url, request_type, d);
 }