[scheduler] Add WakeupBudgetPool.

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc

 // Copyright 2014 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 "platform/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 206 matching lines @@
       timer_tasks_seem_expensive(false),
       touchstart_expected_soon(false),
       have_seen_a_begin_main_frame(false),
       have_reported_blocking_intervention_in_current_policy(false),
       have_reported_blocking_intervention_since_navigation(false),
       has_visible_render_widget_with_touch_handler(false),
       begin_frame_not_expected_soon(false),
       in_idle_period_for_testing(false),
       use_virtual_time(false),
       is_audio_playing(false),
-      rail_mode_observer(nullptr) {
+      rail_mode_observer(nullptr),
+      wake_up_budget_pool(nullptr) {
   foreground_main_thread_load_tracker.Resume(now);
 }
 
 RendererSchedulerImpl::MainThreadOnly::~MainThreadOnly() {}
 
 RendererSchedulerImpl::AnyThread::AnyThread()
     : awaiting_touch_start_response(false),
       in_idle_period(false),
       begin_main_frame_on_critical_path(false),
       last_gesture_was_compositor_driven(false),
@@ skipping 93 matching lines @@
       GetMainThreadOnly().current_policy.loading_queue_policy.is_enabled);
   loading_task_queue->SetQueuePriority(
       GetMainThreadOnly().current_policy.loading_queue_policy.priority);
   if (GetMainThreadOnly()
           .current_policy.loading_queue_policy.time_domain_type ==
       TimeDomainType::THROTTLED) {
     task_queue_throttler_->IncreaseThrottleRefCount(loading_task_queue.get());
   }
   loading_task_queue->AddTaskObserver(
       &GetMainThreadOnly().loading_task_cost_estimator);
+  AddQueueToWakeUpBudgetPool(loading_task_queue.get());
   return loading_task_queue;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewTimerTaskQueue(
     TaskQueue::QueueType queue_type) {
   helper_.CheckOnValidThread();
   // TODO(alexclarke): Consider using ApplyTaskQueuePolicy() for brevity.
   scoped_refptr<TaskQueue> timer_task_queue(helper_.NewTaskQueue(
       TaskQueue::Spec(queue_type)
           .SetShouldMonitorQuiescence(true)
           .SetShouldReportWhenExecutionBlocked(true)
           .SetTimeDomain(GetMainThreadOnly().use_virtual_time
                              ? GetVirtualTimeDomain()
                              : nullptr)));
   auto insert_result = timer_task_runners_.insert(std::make_pair(
       timer_task_queue, timer_task_queue->CreateQueueEnabledVoter()));
   insert_result.first->second->SetQueueEnabled(
       GetMainThreadOnly().current_policy.timer_queue_policy.is_enabled);
   timer_task_queue->SetQueuePriority(
       GetMainThreadOnly().current_policy.timer_queue_policy.priority);
   if (GetMainThreadOnly().current_policy.timer_queue_policy.time_domain_type ==
       TimeDomainType::THROTTLED) {
     task_queue_throttler_->IncreaseThrottleRefCount(timer_task_queue.get());
   }
   timer_task_queue->AddTaskObserver(
       &GetMainThreadOnly().timer_task_cost_estimator);
+  AddQueueToWakeUpBudgetPool(timer_task_queue.get());
   return timer_task_queue;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewUnthrottledTaskQueue(
     TaskQueue::QueueType queue_type) {
   helper_.CheckOnValidThread();
   scoped_refptr<TaskQueue> unthrottled_task_queue(helper_.NewTaskQueue(
       TaskQueue::Spec(queue_type)
           .SetShouldMonitorQuiescence(true)
           .SetTimeDomain(GetMainThreadOnly().use_virtual_time
@@ skipping 973 matching lines @@
 
 TaskCostEstimator*
 RendererSchedulerImpl::GetTimerTaskCostEstimatorForTesting() {
   return &GetMainThreadOnly().timer_task_cost_estimator;
 }
 
 IdleTimeEstimator* RendererSchedulerImpl::GetIdleTimeEstimatorForTesting() {
   return &GetMainThreadOnly().idle_time_estimator;
 }
 
+WakeUpBudgetPool* RendererSchedulerImpl::GetWakeUpBudgetPoolForTesting() {
+  return GetMainThreadOnly().wake_up_budget_pool;
+}
+
 void RendererSchedulerImpl::SuspendTimerQueue() {
   GetMainThreadOnly().timer_queue_suspend_count++;
   ForceUpdatePolicy();
 #ifndef NDEBUG
   DCHECK(!default_timer_task_runner_->IsQueueEnabled());
   for (const auto& runner : timer_task_runners_) {
     DCHECK(!runner.first->IsQueueEnabled());
   }
 #endif
 }
@@ skipping 511 matching lines @@
     return false;
 
   if (GetMainThreadOnly().is_audio_playing)
     return true;
 
   return GetMainThreadOnly().last_audio_state_change.value() +
              kThrottlingDelayAfterAudioIsPlayed >
          now;
 }
 
+void RendererSchedulerImpl::AddQueueToWakeUpBudgetPool(TaskQueue* queue) {
+  if (!GetMainThreadOnly().wake_up_budget_pool) {
+    GetMainThreadOnly().wake_up_budget_pool =
+        task_queue_throttler()->CreateWakeUpBudgetPool("renderer-wake-up-pool");

[alex clarke (OOO till 29th), 2017/04/26 13:31:55]

I wonder if we should use a builder for WakeUpBudgetPool?  It feels odd having
these two methods which are only supposed to be called during initialisation.

[altimin, 2017/04/26 14:31:29]

I'd like to have an ability to change wakeup rate and wake-up duration
dynamically. With new UpdateQueueThrottlingState this will be very easy to do,
actually.

+    GetMainThreadOnly().wake_up_budget_pool->SetWakeUpRate(1);
+    GetMainThreadOnly().wake_up_budget_pool->SetWakeUpDuration(
+        base::TimeDelta());
+  }
+  GetMainThreadOnly().wake_up_budget_pool->AddQueue(tick_clock()->NowTicks(),
+                                                    queue);
+}
+
 TimeDomain* RendererSchedulerImpl::GetActiveTimeDomain() {
   if (GetMainThreadOnly().use_virtual_time) {
     return GetVirtualTimeDomain();
   } else {
     return real_time_domain();
   }
 }
 
 void RendererSchedulerImpl::OnTraceLogEnabled() {
   CreateTraceEventObjectSnapshot();
@@ skipping 52 matching lines @@
     case TimeDomainType::VIRTUAL:
       return "virtual";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink