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

mojo/public/cpp/utility/run_loop.h

 // 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.
 
 #ifndef MOJO_PUBLIC_CPP_UTILITY_RUN_LOOP_H_
 #define MOJO_PUBLIC_CPP_UTILITY_RUN_LOOP_H_
 
 #include <map>
 #include <queue>
 
@@ skipping 22 matching lines @@
 
   // Registers a RunLoopHandler for the specified handle. Only one handler can
   // be registered for a specified handle.
   void AddHandler(RunLoopHandler* handler,
                   const Handle& handle,
                   MojoHandleSignals handle_signals,
                   MojoDeadline deadline);
   void RemoveHandler(const Handle& handle);
   bool HasHandler(const Handle& handle) const;
 
-  // Runs the loop servicing handles as they are ready. This returns when Quit()
-  // is invoked, or there no more handles.
+  // Runs the loop servicing handles and tasks as they are ready. This returns
+  // when Quit() is invoked, or there are no more handles nor tasks.
   void Run();
 
-  // Runs the loop servicing any handles that are ready. Does not wait for
-  // handles to become ready before returning. Returns early if Quit() is
+  // Runs the loop servicing any handles and tasks that are ready. Does not wait
+  // for handles to become ready before returning. Returns early if Quit() is
   // invoked.
   void RunUntilIdle();
 
   void Quit();
 
   // Adds a task to be performed after delay has elapsed. Must be posted to the
   // current thread's RunLoop.
   void PostDelayedTask(const Closure& task, MojoTimeTicks delay);
 
  private:
@@ skipping 17 matching lines @@
 
   typedef std::map<Handle, HandlerData> HandleToHandlerData;
 
   // Used for NotifyHandlers to specify whether HandlerData's |deadline|
   // should be checked prior to notifying.
   enum CheckDeadline {
     CHECK_DEADLINE,
     IGNORE_DEADLINE
   };
 
+  // Runs the loop servicing any handles that are ready. If |until_idle| is
+  // true, does not wait for handles to become ready before returning. Returns
+  // early if Quit() is invoked.
+  void RunInternal(bool until_idle);
+
   // Do one unit of delayed work, if eligible.
   void DoDelayedWork();
 
-  // Waits for a handle to be ready. Returns after servicing at least one
-  // handle (or there are no more handles) unless |non_blocking| is true,
-  // in which case it will also return if servicing at least one handle
-  // would require blocking. Returns true if a RunLoopHandler was notified.
+  // Waits for a handle to be ready or until the next task must be run. Returns
+  // after servicing at least one handle (or there are no more handles) unless
+  // a task must be run or |non_blocking| is true, in which case it will also
+  // return if no task is registered and servicing at least one handle would
+  // require blocking. Returns true if a RunLoopHandler was notified.
   bool Wait(bool non_blocking);
 
   // Notifies handlers of |error|.  If |check| == CHECK_DEADLINE, this will
   // only notify handlers whose deadline has expired and skips the rest.
   // Returns true if a RunLoopHandler was notified.
   bool NotifyHandlers(MojoResult error, CheckDeadline check);
 
   // Removes the first invalid handle. This is called if MojoWaitMany() finds an
   // invalid handle. Returns true if a RunLoopHandler was notified.
   bool RemoveFirstInvalidHandle(const WaitState& wait_state);
@@ skipping 31 matching lines @@
   uint64_t next_sequence_number_;
   typedef std::priority_queue<PendingTask> DelayedTaskQueue;
   DelayedTaskQueue delayed_tasks_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(RunLoop);
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_UTILITY_RUN_LOOP_H_