Remove RequestAnimationFrame from mojo, add delayed tasks to RunLoop

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>
 
+#include "mojo/public/cpp/bindings/callback.h"
 #include "mojo/public/cpp/system/core.h"
 
 namespace mojo {
 
 class RunLoopHandler;
 
 class RunLoop {
  public:
   RunLoop();
   ~RunLoop();
@@ skipping 22 matching lines @@
   // is invoked, or there no more handles.
   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
   // 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:
   struct RunState;
   struct WaitState;
 
   // Contains the data needed to track a request to AddHandler().
   struct HandlerData {
     HandlerData()
         : handler(NULL),
           handle_signals(MOJO_HANDLE_SIGNAL_NONE),
           deadline(0),
           id(0) {}
 
     RunLoopHandler* handler;
     MojoHandleSignals handle_signals;
     MojoTimeTicks deadline;
     // See description of |RunLoop::next_handler_id_| for details.
     int id;
   };
 
   typedef std::map<Handle, HandlerData> HandleToHandlerData;
 
+  // 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.
   bool Wait(bool non_blocking);
 
   // Notifies any handlers whose deadline has expired. Returns true if a
   // RunLoopHandler was notified.
   bool NotifyDeadlineExceeded();
 
@@ skipping 10 matching lines @@
   // stack.
   RunState* run_state_;
 
   // An ever increasing value assigned to each HandlerData::id. Used to detect
   // uniqueness while notifying. That is, while notifying expired timers we copy
   // |handler_data_| and only notify handlers whose id match. If the id does not
   // match it means the handler was removed then added so that we shouldn't
   // notify it.
   int next_handler_id_;
 
+  struct PendingTask {
+    PendingTask(const Closure& task,
+                MojoTimeTicks runtime,
+                uint64_t sequence_number);
+    ~PendingTask();
+
+    bool operator<(const PendingTask& other) const;
+
+    Closure task;
+    MojoTimeTicks run_time;
+    uint64_t sequence_number;
+  };
+  // An ever increasing sequence number attached to each pending task in order
+  // to preserve relative order of tasks posted at the 'same' time.
+  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_