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..f40afab2ed01f18474a5f4cacc736015d2907e88 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,7 +28,8 @@ 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() {}

[Sami, 2015/11/26 19:27:50]

nit: DCHECK that we no longer have a time domain? (or do we need to unregister?)

[alex clarke (OOO till 29th), 2015/11/27 10:01:59]

I added a de-register here too.  It was needed in some of the tests.

@@ -57,10 +58,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 +78,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 +108,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 +165,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,13 +207,15 @@ 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;
     }
   }
 }
-

[Sami, 2015/11/26 19:27:50]

Intentional?

[alex clarke (OOO till 29th), 2015/11/27 10:01:59]

Done.

 bool TaskQueueImpl::TaskIsOlderThanQueuedTasks(const Task* task) {
   // A null task is passed when UpdateQueue is called before any task is run.
   // In this case we don't want to pump an after_wakeup queue, so return true
@@ -505,14 +495,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;
 }