Move throttling of background timers into the renderer scheduler

components/scheduler/base/time_domain.cc

 // 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.
 
 #include "components/scheduler/base/time_domain.h"
 
 #include <set>
 
 #include "components/scheduler/base/task_queue_impl.h"
 #include "components/scheduler/base/task_queue_manager_delegate.h"
 #include "components/scheduler/scheduler_export.h"
 
 namespace scheduler {
 
-TimeDomain::TimeDomain() {}
+TimeDomain::TimeDomain() : observer_(nullptr) {}
 
 TimeDomain::~TimeDomain() {}
 
 void TimeDomain::UnregisterQueue(internal::TaskQueueImpl* queue) {
   // We need to remove |task_queue| from delayed_wakeup_multimap_ which is a
   // little awkward since it's keyed by time. O(n) running time.
   for (DelayedWakeupMultimap::iterator iter = delayed_wakeup_multimap_.begin();
        iter != delayed_wakeup_multimap_.end();) {
     if (iter->second == queue) {
       DelayedWakeupMultimap::iterator temp = iter;
@@ skipping 39 matching lines @@
 void TimeDomain::ScheduleDelayedWork(internal::TaskQueueImpl* queue,
                                      base::TimeTicks delayed_run_time,
                                      LazyNow* lazy_now) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   if (delayed_wakeup_multimap_.empty() ||
       delayed_run_time < delayed_wakeup_multimap_.begin()->first) {
     base::TimeDelta delay =
         std::max(base::TimeDelta(), delayed_run_time - lazy_now->Now());
     RequestWakeup(lazy_now, delay);
+    if (observer_)
+      observer_->OnRequestWakeup();
   }
   delayed_wakeup_multimap_.insert(std::make_pair(delayed_run_time, queue));
 }
 
 void TimeDomain::RegisterAsUpdatableTaskQueue(internal::TaskQueueImpl* queue) {
-  base::AutoLock lock(newly_updatable_lock_);
-  newly_updatable_.push_back(queue);
+  {
+    base::AutoLock lock(newly_updatable_lock_);
+    newly_updatable_.push_back(queue);
+  }
+  if (observer_)
+    observer_->OnRegisterAsUpdatableTaskQueue();
 }
 
 void TimeDomain::UnregisterAsUpdatableTaskQueue(
     internal::TaskQueueImpl* queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   MoveNewlyUpdatableQueuesIntoUpdatableQueueSet();
 #ifndef NDEBUG
   {
     base::AutoLock lock(newly_updatable_lock_);
     DCHECK(!(updatable_queue_set_.find(queue) == updatable_queue_set_.end() &&
@@ skipping 49 matching lines @@
     // deduping calls to MoveReadyDelayedTasksToIncomingQueue since it takes a
     // lock.  NOTE the order in which these are called matters since the order
     // in which EnqueueTaskLocks is called is respected when choosing which
     // queue to execute a task from.
     if (dedup_set.insert(next_wakeup->second).second)
       next_wakeup->second->MoveReadyDelayedTasksToIncomingQueue(lazy_now);
     delayed_wakeup_multimap_.erase(next_wakeup);
   }
 }
 
+void TimeDomain::SetObserver(Observer* observer) {

[Sami, 2015/11/24 12:48:48]

Can we require this to be passed in at construction time and to outlive the time
domain? Otherwise this needs a lock :\

Guaranteeing the lifetime will be tricky with TimeDomain being refcounted,
though. I wonder if that can be changed?

[alex clarke (OOO till 29th), 2015/11/25 12:29:36]

Agreed this is a bit subtle thanks to the ownership.

I think we are OK with this being passed in via the constructor.

+  observer_ = observer;
+}
+
 bool TimeDomain::NextScheduledRunTime(base::TimeTicks* out_time) const {
   if (delayed_wakeup_multimap_.empty())
     return false;
 
   *out_time = delayed_wakeup_multimap_.begin()->first;
   return true;
 }
 
 bool TimeDomain::NextScheduledTaskQueue(TaskQueue** out_task_queue) const {
   if (delayed_wakeup_multimap_.empty())
     return false;
 
   *out_task_queue = delayed_wakeup_multimap_.begin()->second;
   return true;
 }
 
 void TimeDomain::AsValueInto(base::trace_event::TracedValue* state) const {
   state->BeginDictionary();
   state->SetString("name", GetName());
   state->BeginArray("updatable_queue_set");
   for (auto& queue : updatable_queue_set_)
     state->AppendString(queue->GetName());
   state->EndArray();
   AsValueIntoInternal(state);
   state->EndDictionary();
 }
 
 }  // namespace scheduler