Remove calls to MessageLoop::current() in base.

base/threading/thread.cc

 // Copyright (c) 2012 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/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/thread_id_name_manager.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #endif
 
 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::QuitWhenIdle() 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 is used to trigger the message loop to exit.
-void ThreadQuitHelper() {
-  MessageLoop::current()->QuitWhenIdle();
-  Thread::SetThreadWasQuitProperly(true);
-}
-
 Thread::Options::Options()
     : message_loop_type(MessageLoop::TYPE_DEFAULT),
       timer_slack(TIMER_SLACK_NONE),
       stack_size(0),
       priority(ThreadPriority::NORMAL) {
 }
 
 Thread::Options::Options(MessageLoop::Type type,
                          size_t size)
     : message_loop_type(type),
@@ skipping 120 matching lines @@
 
 void Thread::StopSoon() {
   // We should only be called on the same thread that started us.
 
   DCHECK_NE(GetThreadId(), PlatformThread::CurrentId());
 
   if (stopping_ || !message_loop_)
     return;
 
   stopping_ = true;
-  task_runner()->PostTask(FROM_HERE, base::Bind(&ThreadQuitHelper));
+  task_runner()->PostTask(
+      FROM_HERE, base::Bind(&Thread::ThreadQuitHelper, Unretained(this)));
 }
 
 PlatformThreadId Thread::GetThreadId() const {
   // If the thread is created but not started yet, wait for |id_| being ready.
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   id_event_.Wait();
   return id_;
 }
 
 bool Thread::IsRunning() const {
   // If the thread's already started (i.e. message_loop_ is non-null) and
   // not yet requested to stop (i.e. stopping_ is false) we can just return
   // true. (Note that stopping_ is touched only on the same thread that
   // starts / started the new thread so we need no locking here.)
   if (message_loop_ && !stopping_)
     return true;
   // Otherwise check the running_ flag, which is set to true by the new thread
   // only while it is inside Run().
   AutoLock lock(running_lock_);
   return running_;
 }
 
-void Thread::Run(MessageLoop* message_loop) {
-  RunLoop().Run();
+void Thread::Run(RunLoop* run_loop) {
+  run_loop->Run();
 }
 
 void Thread::SetThreadWasQuitProperly(bool flag) {
   lazy_tls_bool.Pointer()->Set(flag);
 }
 
 bool Thread::GetThreadWasQuitProperly() {
   bool quit_properly = true;
 #ifndef NDEBUG
   quit_properly = lazy_tls_bool.Pointer()->Get();
@@ skipping 30 matching lines @@
   // Let the thread do extra initialization.
   Init();
 
   {
     AutoLock lock(running_lock_);
     running_ = true;
   }
 
   start_event_.Signal();
 
-  Run(message_loop_);
+  RunLoop run_loop;
+  run_loop_ = &run_loop;
+  Run(run_loop_);
 
   {
     AutoLock lock(running_lock_);
     running_ = false;
   }
 
   // Let the thread do extra cleanup.
   CleanUp();
 
 #if defined(OS_WIN)
   com_initializer.reset();
 #endif
 
   if (message_loop->type() != MessageLoop::TYPE_CUSTOM) {
-    // Assert that MessageLoop::QuitWhenIdle was called by ThreadQuitHelper.
-    // Don't check for custom message pumps, because their shutdown might not
-    // allow this.
+    // Assert that RunLoop::QuitWhenIdle was called by ThreadQuitHelper. Don't
+    // check for custom message pumps, because their shutdown might not allow
+    // this.
     DCHECK(GetThreadWasQuitProperly());
   }
 
   // We can't receive messages anymore.
   // (The message loop is destructed at the end of this block)
   message_loop_ = nullptr;
+  run_loop_ = nullptr;
+}
+
+void Thread::ThreadQuitHelper() {
+  DCHECK(run_loop_);
+  run_loop_->QuitWhenIdle();
+  SetThreadWasQuitProperly(true);
 }
 
 }  // namespace base