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 81 matching lines @@
   return handler_data_.find(handle) != handler_data_.end();
 }
 
 void RunLoop::Run() {
   assert(current() == this);
   RunState* old_state = run_state_;
   RunState run_state;
   run_state_ = &run_state;
   while (!run_state.should_quit) {
     DoDelayedWork();
-    Wait(false);
+    if (!run_state.should_quit)
+      Wait(false);

[jamesr, 2014/09/22 22:30:18]

hmm, i think this would be cleaner if it was structured more like the base/
version, but this seems ok

   }
   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 && !Wait(true) && delayed_tasks_.empty())

[jamesr, 2014/09/22 22:30:18]

this is getting too hard to follow IMO, especially since the thing that actually
does work here is buried in the middle of the if. why would we want to keep
looping here if we should quit? 

how about:

bool keep_running = true;

do {
  // Try to do one unit of work without blocking and if we did, keep running.
  keep_running = Wait(true);
  if (run_state.should_quit)
    break;
  // Try to do a unit of delayed work.
  keep_running |= DoDelayedWork();
} while (keep_running && !run_state.should_quit);

and have ::DoDelayedWork() return true if it actually ran a task?  then this
loop would continue until nothing happened in Wait(true) and DoDelayedWork()

[qsr, 2014/09/23 10:40:15]

 That would be incorrect though. This must continue until we do not do anything
on Wait and the queue is empty. By the way, I just realized that the current
implementation is doing a busy loop. Let me try to refactor all of this.

       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 141 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