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) {
   assert(current() == this);
   RunState* old_state = run_state_;
   RunState run_state;
   run_state_ = &run_state;
-  while (!run_state.should_quit) {
+  for (;;) {
     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())
+    if (run_state.should_quit)
+      break;
+    bool did_notify = Wait(until_idle);
+    if (run_state.should_quit)
+      break;
+    if (!did_notify && until_idle && delayed_tasks_.empty())

[jamesr, 2014/09/24 04:23:10]

RunUntilIdle does not mean run until the delayed task queue is empty, it means
run until the loop cannot make any more progress without sleeping.  Look at
base::MessageLoop for reference.

This isn't right.

       break;
   }
   run_state_ = old_state;
 }
 
 void RunLoop::DoDelayedWork() {
   MojoTimeTicks now = GetTimeTicksNow();
   if (!delayed_tasks_.empty() && delayed_tasks_.top().run_time <= now) {
     PendingTask task = delayed_tasks_.top();
     delayed_tasks_.pop();
@@ skipping 108 matching lines @@
       min_time = i->second.deadline;
     }
   }
   if (!delayed_tasks_.empty()) {
     MojoTimeTicks delayed_min_time = delayed_tasks_.top().run_time;
     if (min_time == kInvalidTimeTicks)
       min_time = delayed_min_time;
     else
       min_time = std::min(min_time, delayed_min_time);
   }
-  if (non_blocking) {
+  if (non_blocking && delayed_tasks_.empty()) {
     wait_state.deadline = static_cast<MojoDeadline>(0);
   } else if (min_time != kInvalidTimeTicks) {
     const MojoTimeTicks now = GetTimeTicksNow();
     if (min_time < now)
       wait_state.deadline = static_cast<MojoDeadline>(0);
     else
       wait_state.deadline = static_cast<MojoDeadline>(min_time - now);
   }
   return wait_state;
 }
@@ skipping 12 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