mojo: Allow basic RunLoop to be quit from a posted task.

mojo/public/cpp/utility/lib/run_loop.cc

 // Copyright 2014 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 "mojo/public/cpp/utility/run_loop.h"
 
 #include <assert.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 75 matching lines @@
 void RunLoop::RemoveHandler(const Handle& handle) {
   assert(current() == this);
   handler_data_.erase(handle);
 }
 
 bool RunLoop::HasHandler(const Handle& handle) const {
   return handler_data_.find(handle) != handler_data_.end();
 }
 
 void RunLoop::Run() {
+  RunInternal(false);
+}
+
+void RunLoop::RunUntilIdle() {
+  RunInternal(true);
+}
+
+void RunLoop::RunInternal(bool until_idle) {

[jamesr, 2014/09/24 08:04:32]

could we make this a 2-state enum instead of a bool? RunInternal(true) is a lot
harder to understand than RunInternal(UNTIL_IDLE)

[qsr, 2014/09/24 09:14:15]

Done.

   assert(current() == this);
   RunState* old_state = run_state_;
   RunState run_state;
   run_state_ = &run_state;
-  while (!run_state.should_quit) {
-    DoDelayedWork();
-    Wait(false);
-  }
-  run_state_ = old_state;
-}
-
-void RunLoop::RunUntilIdle() {
-  assert(current() == this);
-  RunState* old_state = run_state_;
-  RunState run_state;
-  run_state_ = &run_state;
-  while (!run_state.should_quit) {
-    DoDelayedWork();
-    if (!Wait(true) && delayed_tasks_.empty())
+  for (;;) {
+    bool did_work = DoDelayedWork();
+    if (run_state.should_quit)
+      break;
+    did_work |= Wait(until_idle);
+    if (run_state.should_quit)
+      break;
+    if (!did_work && until_idle)
       break;
   }
   run_state_ = old_state;
 }
 
-void RunLoop::DoDelayedWork() {
+bool RunLoop::DoDelayedWork() {
   MojoTimeTicks now = GetTimeTicksNow();
   if (!delayed_tasks_.empty() && delayed_tasks_.top().run_time <= now) {
     PendingTask task = delayed_tasks_.top();
     delayed_tasks_.pop();
     task.task.Run();
+    return true;
   }
+  return false;
 }
 
 void RunLoop::Quit() {
   assert(current() == this);
   if (run_state_)
     run_state_->should_quit = true;
 }
 
 void RunLoop::PostDelayedTask(const Closure& task, MojoTimeTicks delay) {
   assert(current() == this);
@@ skipping 129 matching lines @@
     // std::priority_queue<> puts the least element at the end of the queue. We
     // want the soonest eligible task to be at the head of the queue, so
     // run_times further in the future are considered lesser.
     return run_time > other.run_time;
   }
 
   return sequence_number > other.sequence_number;
 }
 
 }  // namespace mojo