Introduce RunLoop::Delegate splitting RunLoop/MessageLoop some more.

base/message_loop/message_loop.cc

 // Copyright 2013 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/message_loop/message_loop.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 79 matching lines @@
 MessageLoop::~MessageLoop() {
   // If |pump_| is non-null, this message loop has been bound and should be the
   // current one on this thread. Otherwise, this loop is being destructed before
   // it was bound to a thread, so a different message loop (or no loop at all)
   // may be current.
   DCHECK((pump_ && current() == this) || (!pump_ && current() != this));
 
   // iOS just attaches to the loop, it doesn't Run it.
   // TODO(stuartmorgan): Consider wiring up a Detach().
 #if !defined(OS_IOS)
-  DCHECK(!run_loop_);
+  // There should be no active RunLoops on this thread, unless this MessageLoop
+  // isn't bound to the current thread (see other condition at the top of this
+  // method).
+  DCHECK((!pump_ && current() != this) ||
+         !run_loop_client_->GetTopMostRunLoop());
 #endif
 
 #if defined(OS_WIN)
   if (in_high_res_mode_)
     Time::ActivateHighResolutionTimer(false);
 #endif
   // Clean up any unprocessed tasks, but take care: deleting a task could
   // result in the addition of more tasks (e.g., via DeleteSoon).  We set a
   // limit on the number of times we will allow a deleted task to generate more
   // tasks.  Normally, we should only pass through this loop once or twice.  If
@@ skipping 18 matching lines @@
 
   // Tell the incoming queue that we are dying.
   incoming_task_queue_->WillDestroyCurrentMessageLoop();
   incoming_task_queue_ = NULL;
   unbound_task_runner_ = NULL;
   task_runner_ = NULL;
 
   // OK, now make it so that no one can find us.
   if (current() == this)
     GetTLSMessageLoop()->Set(nullptr);
-
-  RunLoop::ResetTLSState();
 }
 
 // static
 MessageLoop* MessageLoop::current() {
   // TODO(darin): sadly, we cannot enable this yet since people call us even
   // when they have no intention of using us.
   // DCHECK(loop) << "Ouch, did you forget to initialize me?";
   return GetTLSMessageLoop()->Get();
 }
 
@@ skipping 58 matching lines @@
 }
 
 void MessageLoop::RemoveDestructionObserver(
     DestructionObserver* destruction_observer) {
   DCHECK_EQ(this, current());
   destruction_observers_.RemoveObserver(destruction_observer);
 }
 
 void MessageLoop::QuitWhenIdle() {
   DCHECK_EQ(this, current());
-  if (run_loop_) {
-    run_loop_->QuitWhenIdle();
-  } else {
-    NOTREACHED() << "Must be inside Run to call QuitWhenIdle";
-  }
+  DCHECK(run_loop_client_->GetTopMostRunLoop())
+      << "Must be inside Run to call QuitWhenIdle";
+  run_loop_client_->GetTopMostRunLoop()->QuitWhenIdle();
 }
 
 void MessageLoop::QuitNow() {
   DCHECK_EQ(this, current());
-  if (run_loop_) {
-    pump_->Quit();
-  } else {
-    NOTREACHED() << "Must be inside Run to call Quit";
-  }
+  DCHECK(run_loop_client_->GetTopMostRunLoop())
+      << "Must be inside Run to call Quit";
+  pump_->Quit();
 }
 
 bool MessageLoop::IsType(Type type) const {
   return type_ == type;
 }
 
 static void QuitCurrentWhenIdle() {
   MessageLoop::current()->QuitWhenIdle();
 }
 
 // static
 Closure MessageLoop::QuitWhenIdleClosure() {
   return Bind(&QuitCurrentWhenIdle);
 }
 
 void MessageLoop::SetNestableTasksAllowed(bool allowed) {
   if (allowed) {
-    CHECK(base::RunLoop::IsNestingAllowedOnCurrentThread());
+    CHECK(RunLoop::IsNestingAllowedOnCurrentThread());
 
     // Kick the native pump just in case we enter a OS-driven nested message
     // loop.
     pump_->ScheduleWork();
   }
   nestable_tasks_allowed_ = allowed;
 }
 
 bool MessageLoop::NestableTasksAllowed() const {
   return nestable_tasks_allowed_;
@@ skipping 34 matching lines @@
 }
 
 MessageLoop::MessageLoop(Type type, MessagePumpFactoryCallback pump_factory)
     : type_(type),
 #if defined(OS_WIN)
       pending_high_res_tasks_(0),
       in_high_res_mode_(false),
 #endif
       nestable_tasks_allowed_(true),
       pump_factory_(std::move(pump_factory)),
-      run_loop_(nullptr),
       current_pending_task_(nullptr),
       incoming_task_queue_(new internal::IncomingTaskQueue(this)),
       unbound_task_runner_(
           new internal::MessageLoopTaskRunner(incoming_task_queue_)),
       task_runner_(unbound_task_runner_),
       thread_id_(kInvalidThreadId) {
   // If type is TYPE_CUSTOM non-null pump_factory must be given.
   DCHECK(type_ != TYPE_CUSTOM || !pump_factory_.is_null());
 }
 
 void MessageLoop::BindToCurrentThread() {
   DCHECK(!pump_);
   if (!pump_factory_.is_null())
     pump_ = std::move(pump_factory_).Run();
   else
     pump_ = CreateMessagePumpForType(type_);
 
   DCHECK(!current()) << "should only have one message loop per thread";
   GetTLSMessageLoop()->Set(this);
 
   incoming_task_queue_->StartScheduling();
   unbound_task_runner_->BindToCurrentThread();
   unbound_task_runner_ = nullptr;
   SetThreadTaskRunnerHandle();
   thread_id_ = PlatformThread::CurrentId();
+
+  run_loop_client_ = RunLoop::RegisterDelegateForCurrentThread(this);
 }
 
 std::string MessageLoop::GetThreadName() const {
   DCHECK_NE(kInvalidThreadId, thread_id_)
       << "GetThreadName() must only be called after BindToCurrentThread()'s "
       << "side-effects have been synchronized with this thread.";
   return ThreadIdNameManager::GetInstance()->GetName(thread_id_);
 }
 
 void MessageLoop::SetTaskRunner(
     scoped_refptr<SingleThreadTaskRunner> task_runner) {
   DCHECK_EQ(this, current());
   DCHECK(task_runner);
   DCHECK(task_runner->BelongsToCurrentThread());
   DCHECK(!unbound_task_runner_);
   task_runner_ = std::move(task_runner);
   SetThreadTaskRunnerHandle();
 }
 
 void MessageLoop::ClearTaskRunnerForTesting() {
   DCHECK_EQ(this, current());
   DCHECK(!unbound_task_runner_);
   task_runner_ = nullptr;
   thread_task_runner_handle_.reset();
 }
 
+void MessageLoop::Run() {
+  DCHECK_EQ(this, current());
+  pump_->Run(this);
+}
+
+void MessageLoop::Quit() {
+  DCHECK_EQ(this, current());
+  QuitNow();
+}
+
 void MessageLoop::SetThreadTaskRunnerHandle() {
   DCHECK_EQ(this, current());
   // Clear the previous thread task runner first, because only one can exist at
   // a time.
   thread_task_runner_handle_.reset();
   thread_task_runner_handle_.reset(new ThreadTaskRunnerHandle(task_runner_));
 }
 
-void MessageLoop::RunHandler() {
-  DCHECK_EQ(this, current());
-  DCHECK(run_loop_);
-  pump_->Run(this);
-}
-
 bool MessageLoop::ProcessNextDelayedNonNestableTask() {
-  if (is_nested_)
+  if (run_loop_client_->IsNested())
     return false;
 
   if (deferred_non_nestable_work_queue_.empty())
     return false;
 
   PendingTask pending_task =
       std::move(deferred_non_nestable_work_queue_.front());
   deferred_non_nestable_work_queue_.pop();
 
   RunTask(&pending_task);
@@ skipping 21 matching lines @@
   task_annotator_.RunTask("MessageLoop::PostTask", pending_task);
   for (auto& observer : task_observers_)
     observer.DidProcessTask(*pending_task);
 
   nestable_tasks_allowed_ = true;
 
   current_pending_task_ = nullptr;
 }
 
 bool MessageLoop::DeferOrRunPendingTask(PendingTask pending_task) {
-  if (pending_task.nestable || !is_nested_) {
+  if (pending_task.nestable || !run_loop_client_->IsNested()) {
     RunTask(&pending_task);
     // Show that we ran a task (Note: a new one might arrive as a
     // consequence!).
     return true;
   }
 
   // We couldn't run the task now because we're in a nested run loop
   // and the task isn't nestable.
   deferred_non_nestable_work_queue_.push(std::move(pending_task));
   return false;
@@ skipping 114 matching lines @@
   if (!delayed_work_queue_.empty())
     *next_delayed_work_time = delayed_work_queue_.top().delayed_run_time;
 
   return DeferOrRunPendingTask(std::move(pending_task));
 }
 
 bool MessageLoop::DoIdleWork() {
   if (ProcessNextDelayedNonNestableTask())
     return true;
 
-  if (run_loop_->quit_when_idle_received_)
+  if (run_loop_client_->GetTopMostRunLoop()->quit_when_idle_received_)
     pump_->Quit();
 
   // When we return we will do a kernel wait for more tasks.
 #if defined(OS_WIN)
   // On Windows we activate the high resolution timer so that the wait
   // _if_ triggered by the timer happens with good resolution. If we don't
   // do this the default resolution is 15ms which might not be acceptable
   // for some tasks.
   bool high_res = pending_high_res_tasks_ > 0;
   if (high_res != in_high_res_mode_) {
@@ skipping 82 matching lines @@
       persistent,
       mode,
       controller,
       delegate);
 }
 #endif
 
 #endif  // !defined(OS_NACL_SFI)
 
 }  // namespace base