Move throttling of background timers into the renderer scheduler

components/scheduler/base/task_queue_impl.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 CONTENT_RENDERER_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_
 #define CONTENT_RENDERER_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_
 
 #include <set>
 
 #include "base/pending_task.h"
 #include "base/threading/thread_checker.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "components/scheduler/base/task_queue.h"
 #include "components/scheduler/scheduler_export.h"
 
 namespace scheduler {
 class LazyNow;
 class TimeDomain;
 class TaskQueueManager;
 
 namespace internal {
 class SCHEDULER_EXPORT TaskQueueImpl final : public TaskQueue {
  public:
   TaskQueueImpl(TaskQueueManager* task_queue_manager,
-                const scoped_refptr<TimeDomain>& time_domain,
+                TimeDomain* time_domain,
                 const Spec& spec,
                 const char* disabled_by_default_tracing_category,
                 const char* disabled_by_default_verbose_tracing_category);
 
   class SCHEDULER_EXPORT Task : public base::PendingTask {
    public:
     Task();
     Task(const tracked_objects::Location& posted_from,
          const base::Closure& task,
          int sequence_number,
@@ skipping 26 matching lines @@
 
   // TaskQueue implementation.
   void UnregisterTaskQueue() override;
   bool RunsTasksOnCurrentThread() const override;
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const base::Closure& task,
                        base::TimeDelta delay) override;
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   const base::Closure& task,
                                   base::TimeDelta delay) override;
-  bool PostDelayedTaskAt(const tracked_objects::Location& from_here,
-                         const base::Closure& task,
-                         base::TimeTicks desired_run_time) override;
 
   bool IsQueueEnabled() const override;
   QueueState GetQueueState() const override;
   void SetQueuePriority(QueuePriority priority) override;
   void PumpQueue() override;
   void SetPumpPolicy(PumpPolicy pump_policy) override;
   void AddTaskObserver(base::MessageLoop::TaskObserver* task_observer) override;
   void RemoveTaskObserver(
       base::MessageLoop::TaskObserver* task_observer) override;
-  void SetTimeDomain(const scoped_refptr<TimeDomain>& time_domain) override;
+  void SetTimeDomain(TimeDomain* time_domain) override;
 
   void UpdateWorkQueue(LazyNow* lazy_now,
                        bool should_trigger_wakeup,
                        const Task* previous_task);
   Task TakeTaskFromWorkQueue();
 
   std::queue<Task>& work_queue() { return main_thread_only().work_queue; }
 
   WakeupPolicy wakeup_policy() const {
     DCHECK(main_thread_checker_.CalledOnValidThread());
@@ skipping 51 matching lines @@
 
  private:
   enum class TaskType {
     NORMAL,
     NON_NESTABLE,
   };
 
   struct AnyThread {
     AnyThread(TaskQueueManager* task_queue_manager,
               PumpPolicy pump_policy,
-              const scoped_refptr<TimeDomain>& time_domain);
+              TimeDomain* time_domain);
     ~AnyThread();
 
     // TaskQueueManager is maintained in two copies: inside AnyThread and inside
     // MainThreadOnly. It can be changed only from main thread, so it should be
     // locked before accessing from other threads.
     TaskQueueManager* task_queue_manager;
 
     std::queue<Task> incoming_queue;
     PumpPolicy pump_policy;
     std::priority_queue<Task> delayed_task_queue;
-    scoped_refptr<TimeDomain> time_domain;
+    TimeDomain* time_domain;
   };
 
   struct MainThreadOnly {
     MainThreadOnly(TaskQueueManager* task_queue_manager);
     ~MainThreadOnly();
 
     // Another copy of TaskQueueManager for lock-free access from the main
     // thread. See description inside struct AnyThread for details.
     TaskQueueManager* task_queue_manager;
 
     std::queue<Task> work_queue;
     base::ObserverList<base::MessageLoop::TaskObserver> task_observers;
     size_t set_index;
   };
 
   ~TaskQueueImpl() override;
 
   bool PostDelayedTaskImpl(const tracked_objects::Location& from_here,
                            const base::Closure& task,
                            base::TimeDelta delay,
                            TaskType task_type);
   bool PostDelayedTaskLocked(LazyNow* lazy_now,
                              const tracked_objects::Location& from_here,
                              const base::Closure& task,
                              base::TimeTicks desired_run_time,
                              TaskType task_type);
-  void ScheduleDelayedWorkTask(const scoped_refptr<TimeDomain> time_domain,
+  void ScheduleDelayedWorkTask(TimeDomain* time_domain,
                                base::TimeTicks desired_run_time);
 
   // Enqueues any delayed tasks which should be run now on the incoming_queue_.
   // Must be called with |any_thread_lock_| locked.
   void MoveReadyDelayedTasksToIncomingQueueLocked(LazyNow* lazy_now);
 
   void PumpQueueLocked();
   bool TaskIsOlderThanQueuedTasks(const Task* task);
   bool ShouldAutoPumpQueueLocked(bool should_trigger_wakeup,
                                  const Task* previous_task);
@@ skipping 47 matching lines @@
   const bool should_monitor_quiescence_;
   const bool should_notify_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskQueueImpl);
 };
 
 }  // namespace internal
 }  // namespace scheduler
 
 #endif  // CONTENT_RENDERER_SCHEDULER_BASE_TASK_QUEUE_IMPL_H_