Remove RequestAnimationFrame from mojo, add delayed tasks to RunLoop

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 18 matching lines @@
   std::vector<MojoHandleSignals> handle_signals;
   MojoDeadline deadline;
 };
 
 struct RunLoop::RunState {
   RunState() : should_quit(false) {}
 
   bool should_quit;
 };
 
-RunLoop::RunLoop() : run_state_(NULL), next_handler_id_(0) {
+RunLoop::RunLoop()
+    : run_state_(NULL), next_handler_id_(0), next_sequence_number_(0) {
   assert(!current());
   current_run_loop.Set(this);
 }
 
 RunLoop::~RunLoop() {
   assert(current() == this);
   current_run_loop.Set(NULL);
 }
 
 // static
@@ skipping 38 matching lines @@
 
 bool RunLoop::HasHandler(const Handle& handle) const {
   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)
+  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) {
-    if (!Wait(true))
+    DoDelayedWork();
+    if (!Wait(true) && delayed_tasks_.empty())
       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();
+    task.task.Run();
+  }
+}
+
 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);
+  MojoTimeTicks run_time = delay + GetTimeTicksNow();
+  delayed_tasks_.push(PendingTask(task, run_time, next_sequence_number_++));
+}
+
 bool RunLoop::Wait(bool non_blocking) {
   const WaitState wait_state = GetWaitState(non_blocking);
-  if (wait_state.handles.empty()) {
+  if (wait_state.handles.empty() && delayed_tasks_.empty()) {
     Quit();
     return false;
   }
 
   const MojoResult result = WaitMany(wait_state.handles,
                                      wait_state.handle_signals,
                                      wait_state.deadline);
   if (result >= 0) {
     const size_t index = static_cast<size_t>(result);
     assert(handler_data_.find(wait_state.handles[index]) !=
@@ skipping 65 matching lines @@
   MojoTimeTicks min_time = kInvalidTimeTicks;
   for (HandleToHandlerData::const_iterator i = handler_data_.begin();
        i != handler_data_.end(); ++i) {
     wait_state.handles.push_back(i->first);
     wait_state.handle_signals.push_back(i->second.handle_signals);
     if (!non_blocking && i->second.deadline != kInvalidTimeTicks &&
         (min_time == kInvalidTimeTicks || i->second.deadline < min_time)) {
       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) {
     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;
 }
 
+RunLoop::PendingTask::PendingTask(const Closure& task,
+                                  MojoTimeTicks run_time,
+                                  uint64_t sequence_number)
+    : task(task), run_time(run_time), sequence_number(sequence_number) {
+}
+
+RunLoop::PendingTask::~PendingTask() {
+}
+
+bool RunLoop::PendingTask::operator<(const RunLoop::PendingTask& other) const {
+  if (run_time != other.run_time) {
+    // 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