base::Bind: Remove NewRunnableFunction.

base/memory/weak_ptr_unittest.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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "base/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 
 namespace base {
 namespace {
 
 template <class T>
 class OffThreadObjectCreator {
  public:
   static T* NewObject() {
     T* result;
     {
       Thread creator_thread("creator_thread");
       creator_thread.Start();
       creator_thread.message_loop()->PostTask(
           FROM_HERE,
-          NewRunnableFunction(OffThreadObjectCreator::CreateObject, &result));
+          base::Bind(OffThreadObjectCreator::CreateObject, &result));
     }
     DCHECK(result);  // We synchronized on thread destruction above.
     return result;
   }
  private:
   static void CreateObject(T** result) {
     *result = new T;
   }
 };
 
@@ skipping 12 matching lines @@
   }
 
   ~BackgroundThread() {
     Stop();
   }
 
   void CreateConsumerFromProducer(Consumer** consumer, Producer* producer) {
     WaitableEvent completion(true, false);
     message_loop()->PostTask(
         FROM_HERE,
-        NewRunnableFunction(&BackgroundThread::DoCreateFromProducer,
-                            consumer,
-                            producer,
-                            &completion));
+        base::Bind(&BackgroundThread::DoCreateFromProducer, consumer, producer,
+                   &completion));
     completion.Wait();
   }
 
   void CreateConsumerFromConsumer(Consumer** consumer, const Consumer* other) {
     WaitableEvent completion(true, false);
     message_loop()->PostTask(
         FROM_HERE,
-        NewRunnableFunction(&BackgroundThread::DoCreateFromConsumer,
-                            consumer,
-                            other,
-                            &completion));
+        base::Bind(&BackgroundThread::DoCreateFromConsumer, consumer, other,
+                   &completion));
     completion.Wait();
   }
 
   void DeleteProducer(Producer* object) {
     WaitableEvent completion(true, false);
     message_loop()->PostTask(
         FROM_HERE,
-        NewRunnableFunction(&BackgroundThread::DoDeleteProducer,
-                            object,
-                            &completion));
+        base::Bind(&BackgroundThread::DoDeleteProducer, object, &completion));
     completion.Wait();
   }
 
   void DeleteConsumer(Consumer* object) {
     WaitableEvent completion(true, false);
     message_loop()->PostTask(
         FROM_HERE,
-        NewRunnableFunction(&BackgroundThread::DoDeleteConsumer,
-                            object,
-                            &completion));
+        base::Bind(&BackgroundThread::DoDeleteConsumer, object, &completion));
     completion.Wait();
   }
 
   Producer* DeRef(const Consumer* consumer) {
     WaitableEvent completion(true, false);
     Producer* result = NULL;
     message_loop()->PostTask(
         FROM_HERE,
-        NewRunnableFunction(&BackgroundThread::DoDeRef,
-                            consumer,
-                            &result,
-                            &completion));
+        base::Bind(&BackgroundThread::DoDeRef, consumer, &result, &completion));
     completion.Wait();
     return result;
   }
 
  protected:
   static void DoCreateFromConsumer(Consumer** consumer,
                                    const Consumer* other,
                                    WaitableEvent* completion) {
     *consumer = new Consumer;
     **consumer = *other;
@@ skipping 224 matching lines @@
     Producer producer;
     Consumer consumer;
     consumer.producer = producer.AsWeakPtr();
     thread.CreateConsumerFromConsumer(&consumer_copy, &consumer);
   }
   EXPECT_TRUE(consumer_copy->producer == NULL);
   thread.DeleteConsumer(consumer_copy);
 }
 
 }  // namespace base