Move throttling of background timers into the renderer scheduler

components/scheduler/base/task_queue_impl.cc

Index: components/scheduler/base/task_queue_impl.cc
diff --git a/components/scheduler/base/task_queue_impl.cc b/components/scheduler/base/task_queue_impl.cc
index 0ad965b00f774201920becfde5d0fb3b24faf0ae..f58fabd99a444a58155c655a3b491d3a0ba4b7a7 100644
--- a/components/scheduler/base/task_queue_impl.cc
+++ b/components/scheduler/base/task_queue_impl.cc
@@ -13,7 +13,7 @@ namespace internal {
 
 TaskQueueImpl::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)
@@ -28,10 +28,15 @@ TaskQueueImpl::TaskQueueImpl(
       wakeup_policy_(spec.wakeup_policy),
       should_monitor_quiescence_(spec.should_monitor_quiescence),
       should_notify_observers_(spec.should_notify_observers) {
-  DCHECK(time_domain.get());
+  DCHECK(time_domain);
+  time_domain->RegisterQueue(this);
 }
 
-TaskQueueImpl::~TaskQueueImpl() {}
+TaskQueueImpl::~TaskQueueImpl() {
+  base::AutoLock lock(any_thread_lock_);
+  if (any_thread().time_domain)
+    any_thread().time_domain->UnregisterQueue(this);
+}
 
 TaskQueueImpl::Task::Task()
     : PendingTask(tracked_objects::Location(),
@@ -57,10 +62,9 @@ TaskQueueImpl::Task::Task(const tracked_objects::Location& posted_from,
   sequence_num = sequence_number;
 }
 
-TaskQueueImpl::AnyThread::AnyThread(
-    TaskQueueManager* task_queue_manager,
-    PumpPolicy pump_policy,
-    const scoped_refptr<TimeDomain>& time_domain)
+TaskQueueImpl::AnyThread::AnyThread(TaskQueueManager* task_queue_manager,
+                                    PumpPolicy pump_policy,
+                                    TimeDomain* time_domain)
     : task_queue_manager(task_queue_manager),
       pump_policy(pump_policy),
       time_domain(time_domain) {}
@@ -78,7 +82,8 @@ void TaskQueueImpl::UnregisterTaskQueue() {
   base::AutoLock lock(any_thread_lock_);
   if (!any_thread().task_queue_manager)
     return;
-  any_thread().time_domain->UnregisterQueue(this);
+  if (any_thread().time_domain)
+    any_thread().time_domain->UnregisterQueue(this);
   any_thread().time_domain = nullptr;
   any_thread().task_queue_manager->UnregisterTaskQueue(this);
 
@@ -107,18 +112,6 @@ bool TaskQueueImpl::PostNonNestableDelayedTask(
   return PostDelayedTaskImpl(from_here, task, delay, TaskType::NON_NESTABLE);
 }
 
-bool TaskQueueImpl::PostDelayedTaskAt(
-    const tracked_objects::Location& from_here,
-    const base::Closure& task,
-    base::TimeTicks desired_run_time) {
-  base::AutoLock lock(any_thread_lock_);
-  if (!any_thread().task_queue_manager)
-    return false;
-  LazyNow lazy_now(any_thread().time_domain->CreateLazyNow());
-  return PostDelayedTaskLocked(&lazy_now, from_here, task, desired_run_time,
-                               TaskType::NORMAL);
-}
-
 bool TaskQueueImpl::PostDelayedTaskImpl(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
@@ -176,9 +169,8 @@ bool TaskQueueImpl::PostDelayedTaskLocked(
   return true;
 }
 
-void TaskQueueImpl::ScheduleDelayedWorkTask(
-    const scoped_refptr<TimeDomain> time_domain,
-    base::TimeTicks desired_run_time) {
+void TaskQueueImpl::ScheduleDelayedWorkTask(TimeDomain* time_domain,
+                                            base::TimeTicks desired_run_time) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   LazyNow lazy_now(time_domain->CreateLazyNow());
   time_domain->ScheduleDelayedWork(this, desired_run_time, &lazy_now);
@@ -219,7 +211,10 @@ TaskQueue::QueueState TaskQueueImpl::GetQueueState() const {
   {
     base::AutoLock lock(any_thread_lock_);
     if (any_thread().incoming_queue.empty()) {
-      return QueueState::EMPTY;
+      if (any_thread().delayed_task_queue.empty())
+        return QueueState::EMPTY;
+      else
+        return QueueState::NO_IMMEDIATE_WORK;
     } else {
       return QueueState::NEEDS_PUMPING;
     }
@@ -505,14 +500,14 @@ void TaskQueueImpl::NotifyDidProcessTask(
                     DidProcessTask(pending_task));
 }
 
-void TaskQueueImpl::SetTimeDomain(
-    const scoped_refptr<TimeDomain>& time_domain) {
+void TaskQueueImpl::SetTimeDomain(TimeDomain* time_domain) {
   base::AutoLock lock(any_thread_lock_);
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (time_domain == any_thread().time_domain)
     return;
 
-  any_thread().time_domain->MigrateQueue(this, time_domain.get());
+  if (time_domain)
+    any_thread().time_domain->MigrateQueue(this, time_domain);
   any_thread().time_domain = time_domain;
 }