Make TestMockTimeTaskRunner run tasks with the same delay in the order they were posted.

base/test/test_mock_time_task_runner.h

 // Copyright 2015 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 BASE_TEST_TEST_MOCK_TIME_TASK_RUNNER_H_
 #define BASE_TEST_TEST_MOCK_TIME_TASK_RUNNER_H_
 
 #include <queue>
 #include <vector>
 
@@ skipping 94 matching lines @@
 
   // Called after the current mock time has been incremented so that subclasses
   // can react to the passing of time.
   virtual void OnAfterTimePassed();
 
   // Called after each task is run so that subclasses may perform additional
   // activities, e.g., pump additional task runners.
   virtual void OnAfterTaskRun();
 
  private:
+  struct TestOrderedPendingTask;
+
   // Predicate that defines a strict weak temporal ordering of tasks.
   class TemporalOrder {
    public:
-    bool operator()(const TestPendingTask& first_task,
-                    const TestPendingTask& second_task) const;
+    bool operator()(const TestOrderedPendingTask& first_task,
+                    const TestOrderedPendingTask& second_task) const;
   };
 
-  typedef std::priority_queue<TestPendingTask,
-                              std::vector<TestPendingTask>,
+  typedef std::priority_queue<TestOrderedPendingTask,
+                              std::vector<TestOrderedPendingTask>,
                               TemporalOrder> TaskPriorityQueue;
 
   // Core of the implementation for all flavors of fast-forward methods. Given a
   // non-negative |max_delta|, runs all tasks with a remaining delay less than
   // or equal to |max_delta|, and moves virtual time forward as needed for each
   // processed task. Pass in TimeDelta::Max() as |max_delta| to run all tasks.
   void ProcessAllTasksNoLaterThan(TimeDelta max_delta);
 
   // Forwards |now_ticks_| until it equals |later_ticks|, and forwards |now_| by
   // the same amount. Calls OnAfterTimePassed() if |later_ticks| > |now_ticks_|.
   // Does nothing if |later_ticks| <= |now_ticks_|.
   void ForwardClocksUntilTickTime(TimeTicks later_ticks);
 
   // Returns the |next_task| to run if there is any with a running time that is
   // at most |reference| + |max_delta|. This additional complexity is required
   // so that |max_delta| == TimeDelta::Max() can be supported.
   bool DequeueNextTask(const TimeTicks& reference,
                        const TimeDelta& max_delta,
                        TestPendingTask* next_task);
 
   ThreadChecker thread_checker_;
   Time now_;
   TimeTicks now_ticks_;
 
   // Temporally ordered heap of pending tasks. Must only be accessed while the
   // |tasks_lock_| is held.
   TaskPriorityQueue tasks_;
+
+  // The ordinal to use for the next task. Must only be accessed while the
+  // |tasks_lock_| is held.
+  size_t next_task_ordinal_;
+
   Lock tasks_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMockTimeTaskRunner);
 };
 
 }  // namespace base
 
 #endif  // BASE_TEST_TEST_MOCK_TIME_TASK_RUNNER_H_