Remove custom Task implementations in base.

base/threading/thread.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/threading/thread.h"
 
+#include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/thread_local.h"
 #include "base/synchronization/waitable_event.h"
 
 namespace base {
 
 namespace {
 
 // We use this thread-local variable to record whether or not a thread exited
 // because its Stop method was called.  This allows us to catch cases where
 // MessageLoop::Quit() is called directly, which is unexpected when using a
 // Thread to setup and run a MessageLoop.
 base::LazyInstance<base::ThreadLocalBoolean> lazy_tls_bool =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
-// This task is used to trigger the message loop to exit.
-class ThreadQuitTask : public Task {
- public:
-  virtual void Run() {
-    MessageLoop::current()->Quit();
-    Thread::SetThreadWasQuitProperly(true);
-  }
-};
+// This is used to trigger the message loop to exit.
+void ThreadQuitHelper() {
+  MessageLoop::current()->Quit();
+  Thread::SetThreadWasQuitProperly(true);
+}
 
 // Used to pass data to ThreadMain.  This structure is allocated on the stack
 // from within StartWithOptions.
 struct Thread::StartupData {
   // We get away with a const reference here because of how we are allocated.
   const Thread::Options& options;
 
   // Used to synchronize thread startup.
   WaitableEvent event;
 
@@ skipping 71 matching lines @@
   // We should only be called on the same thread that started us.
 
   // Reading thread_id_ without a lock can lead to a benign data race
   // with ThreadMain, so we annotate it to stay silent under ThreadSanitizer.
   DCHECK_NE(ANNOTATE_UNPROTECTED_READ(thread_id_), PlatformThread::CurrentId());
 
   if (stopping_ || !message_loop_)
     return;
 
   stopping_ = true;
-  message_loop_->PostTask(FROM_HERE, new ThreadQuitTask());
+  message_loop_->PostTask(FROM_HERE, base::Bind(&ThreadQuitHelper));
 }
 
 void Thread::Run(MessageLoop* message_loop) {
   message_loop->Run();
 }
 
 void Thread::SetThreadWasQuitProperly(bool flag) {
   lazy_tls_bool.Pointer()->Set(flag);
 }
 
@@ skipping 23 matching lines @@
 
     startup_data_->event.Signal();
     // startup_data_ can't be touched anymore since the starting thread is now
     // unlocked.
 
     Run(message_loop_);
 
     // Let the thread do extra cleanup.
     CleanUp();
 
-    // Assert that MessageLoop::Quit was called by ThreadQuitTask.
+    // Assert that MessageLoop::Quit was called by ThreadQuitHelper.
     DCHECK(GetThreadWasQuitProperly());
 
     // We can't receive messages anymore.
     message_loop_ = NULL;
   }
   thread_id_ = kInvalidThreadId;
 }
 
 }  // namespace base