Implement PostDelayedTaskAt for guaranteed timer ordering

components/scheduler/child/scheduler_helper.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 COMPONENTS_SCHEDULER_CHILD_SCHEDULER_HELPER_H_
 #define COMPONENTS_SCHEDULER_CHILD_SCHEDULER_HELPER_H_
 
 #include "components/scheduler/child/prioritizing_task_queue_selector.h"
 #include "components/scheduler/child/task_queue_manager.h"
 #include "components/scheduler/scheduler_export.h"
@@ skipping 14 matching lines @@
   // literals). They may not include " chars.
   SchedulerHelper(
       scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner,
       const char* tracing_category,
       const char* disabled_by_default_tracing_category,
       const char* disabled_by_default_verbose_tracing_category,
       size_t total_task_queue_count);
   ~SchedulerHelper();
 
   // Returns the default task runner.
-  scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner();
+  scoped_refptr<TaskQueue> DefaultTaskRunner();
 
   // Returns the control task runner.  Tasks posted to this runner are executed
   // with the highest priority. Care must be taken to avoid starvation of other
   // task queues.
   scoped_refptr<base::SingleThreadTaskRunner> ControlTaskRunner();
 
   // Returns the control task after wakeup runner.  Tasks posted to this runner
   // are executed with the highest priority but do not cause the scheduler to
   // wake up. Care must be taken to avoid starvation of other task queues.
   scoped_refptr<base::SingleThreadTaskRunner> ControlAfterWakeUpTaskRunner();
@@ skipping 23 matching lines @@
   };
 
   static const char* TaskQueueIdToString(QueueId queue_id);
 
   void CheckOnValidThread() const {
     DCHECK(thread_checker_.CalledOnValidThread());
   }
 
   // Accessor methods.
   base::TimeTicks Now() const;
-  scoped_refptr<base::SingleThreadTaskRunner> TaskRunnerForQueue(
-      size_t queue_index) const;
+  scoped_refptr<TaskQueue> TaskRunnerForQueue(size_t queue_index) const;
   base::TimeTicks NextPendingDelayedTaskRunTime() const;
   void SetQueueName(size_t queue_index, const char* name);
   bool IsQueueEmpty(size_t queue_index) const;
   TaskQueueManager::QueueState GetQueueState(size_t queue_index) const;
   void SetQueuePriority(size_t queue_index,
                         PrioritizingTaskQueueSelector::QueuePriority priority);
   void EnableQueue(size_t queue_index,
                    PrioritizingTaskQueueSelector::QueuePriority priority);
   void DisableQueue(size_t queue_index);
   bool IsQueueEnabled(size_t queue_index) const;
@@ skipping 14 matching lines @@
   friend class SchedulerHelperTest;
 
   base::ThreadChecker thread_checker_;
   scoped_ptr<PrioritizingTaskQueueSelector> task_queue_selector_;
   scoped_ptr<TaskQueueManager> task_queue_manager_;
 
   uint64 quiescence_monitored_task_queue_mask_;
 
   scoped_refptr<base::SingleThreadTaskRunner> control_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> control_after_wakeup_task_runner_;
-  scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
+  scoped_refptr<TaskQueue> default_task_runner_;
 
   scoped_ptr<base::TickClock> time_source_;
 
   const char* tracing_category_;
   const char* disabled_by_default_tracing_category_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerHelper);
 };
 
 }  // namespace scheduler
 
 #endif  // COMPONENTS_SCHEDULER_CHILD_SCHEDULER_HELPER_H_