Experimental: Remove chromium shared timers

content/renderer/scheduler/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 "content/renderer/scheduler/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
@@ skipping 13 matching lines @@
       control_task_runner_(
           task_queue_manager_->TaskRunnerForQueue(CONTROL_TASK_QUEUE)),
       control_task_after_wakeup_runner_(task_queue_manager_->TaskRunnerForQueue(
           CONTROL_TASK_AFTER_WAKEUP_QUEUE)),
       default_task_runner_(
           task_queue_manager_->TaskRunnerForQueue(DEFAULT_TASK_QUEUE)),
       compositor_task_runner_(
           task_queue_manager_->TaskRunnerForQueue(COMPOSITOR_TASK_QUEUE)),
       loading_task_runner_(
           task_queue_manager_->TaskRunnerForQueue(LOADING_TASK_QUEUE)),
+      timer_task_runner_(
+          task_queue_manager_->TaskRunnerForQueue(TIMER_TASK_QUEUE)),
       current_policy_(Policy::NORMAL),
       last_input_type_(blink::WebInputEvent::Undefined),
       input_stream_state_(InputStreamState::INACTIVE),
       policy_may_need_update_(&incoming_signals_lock_),
+      timer_queue_suspended_(0),
       weak_factory_(this) {
   weak_renderer_scheduler_ptr_ = weak_factory_.GetWeakPtr();
   update_policy_closure_ = base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                                       weak_renderer_scheduler_ptr_);
   end_idle_period_closure_.Reset(base::Bind(
       &RendererSchedulerImpl::EndIdlePeriod, weak_renderer_scheduler_ptr_));
   idle_task_runner_ = make_scoped_refptr(new SingleThreadIdleTaskRunner(
       task_queue_manager_->TaskRunnerForQueue(IDLE_TASK_QUEUE),
       control_task_after_wakeup_runner_,
       base::Bind(&RendererSchedulerImpl::CurrentIdleTaskDeadlineCallback,
@@ skipping 53 matching lines @@
   DCHECK(main_thread_checker_.CalledOnValidThread());
   return idle_task_runner_;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererSchedulerImpl::LoadingTaskRunner() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   return loading_task_runner_;
 }
 
+scoped_refptr<base::SingleThreadTaskRunner>
+RendererSchedulerImpl::TimerTaskRunner() {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  return timer_task_runner_;
+}
+
 void RendererSchedulerImpl::WillBeginFrame(const cc::BeginFrameArgs& args) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::WillBeginFrame", "args", args.AsValue());
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!task_queue_manager_)
     return;
 
   EndIdlePeriod();
   estimated_next_frame_begin_ = args.frame_time + args.interval;
   // TODO(skyostil): Wire up real notification of input events processing
@@ skipping 171 matching lines @@
     return;
 
   switch (new_policy) {
     case Policy::COMPOSITOR_PRIORITY:
       renderer_task_queue_selector_->SetQueuePriority(
           COMPOSITOR_TASK_QUEUE, RendererTaskQueueSelector::HIGH_PRIORITY);
       // TODO(scheduler-dev): Add a task priority between HIGH and BEST_EFFORT
       // that still has some guarantee of running.
       renderer_task_queue_selector_->SetQueuePriority(
           LOADING_TASK_QUEUE, RendererTaskQueueSelector::BEST_EFFORT_PRIORITY);
+      MaybeEnableTimerQueue();
       break;
     case Policy::TOUCHSTART_PRIORITY:
       renderer_task_queue_selector_->SetQueuePriority(
           COMPOSITOR_TASK_QUEUE, RendererTaskQueueSelector::HIGH_PRIORITY);
       renderer_task_queue_selector_->DisableQueue(LOADING_TASK_QUEUE);
+      renderer_task_queue_selector_->DisableQueue(TIMER_TASK_QUEUE);
       break;
     case Policy::NORMAL:
       renderer_task_queue_selector_->SetQueuePriority(
           COMPOSITOR_TASK_QUEUE, RendererTaskQueueSelector::NORMAL_PRIORITY);
       renderer_task_queue_selector_->SetQueuePriority(
           LOADING_TASK_QUEUE, RendererTaskQueueSelector::NORMAL_PRIORITY);
+      MaybeEnableTimerQueue();
       break;
   }
   DCHECK(renderer_task_queue_selector_->IsQueueEnabled(COMPOSITOR_TASK_QUEUE));
   if (new_policy != Policy::TOUCHSTART_PRIORITY)
     DCHECK(renderer_task_queue_selector_->IsQueueEnabled(LOADING_TASK_QUEUE));
 
   current_policy_ = new_policy;
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
@@ skipping 231 matching lines @@
     task_queue_manager_->AddTaskObserver(task_observer);
 }
 
 void RendererSchedulerImpl::RemoveTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (task_queue_manager_)
     task_queue_manager_->RemoveTaskObserver(task_observer);
 }
 
+void RendererSchedulerImpl::SuspendTimerQueue() {
+  timer_queue_suspended_++;
+  renderer_task_queue_selector_->DisableQueue(TIMER_TASK_QUEUE);
+}
+
+void RendererSchedulerImpl::ResumeTimerQueue() {
+  timer_queue_suspended_--;
+
+  MaybeUpdatePolicy();
+  if (SchedulerPolicy() != Policy::TOUCHSTART_PRIORITY)
+    MaybeEnableTimerQueue();
+}
+
+void RendererSchedulerImpl::MaybeEnableTimerQueue() {
+  if (timer_queue_suspended_ == 0)
+    renderer_task_queue_selector_->SetQueuePriority(
+        TIMER_TASK_QUEUE, RendererTaskQueueSelector::NORMAL_PRIORITY);
+}
+
 }  // namespace content