Prevent multiple pending UpdatePolicy tasks.

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)),
+      delayed_update_policy_runner_(
+          base::Bind(&RendererSchedulerImpl::UpdatePolicy,
+                     base::Unretained(this)),
+          control_task_runner_),
       current_policy_(Policy::NORMAL),
       last_input_type_(blink::WebInputEvent::Undefined),
       input_stream_state_(InputStreamState::INACTIVE),
       policy_may_need_update_(&incoming_signals_lock_),
       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_));
@@ skipping 134 matching lines @@
 void RendererSchedulerImpl::UpdateForInputEvent(
     blink::WebInputEvent::Type type) {
   base::AutoLock lock(incoming_signals_lock_);
 
   InputStreamState new_input_stream_state =
       ComputeNewInputStreamState(input_stream_state_, type, last_input_type_);
 
   if (input_stream_state_ != new_input_stream_state) {
     // Update scheduler policy if we should start a new policy mode.
     input_stream_state_ = new_input_stream_state;
-    policy_may_need_update_.SetWhileLocked(true);
-    PostUpdatePolicyOnControlRunner(base::TimeDelta());
+    EnsureUrgentPolicyUpdatePostedOnMainThread(FROM_HERE);
   }
   last_input_receipt_time_on_compositor_ = Now();
   // Clear the last known input processing time so that we know an input event
   // is still queued up. This timestamp will be updated the next time the
   // compositor commits or becomes quiescent. Note that this function is always
   // called before the input event is processed either on the compositor or
   // main threads.
   last_input_process_time_on_main_ = base::TimeTicks();
   last_input_type_ = type;
 }
 
 void RendererSchedulerImpl::DidProcessInputEvent(
     base::TimeTicks begin_frame_time) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   base::AutoLock lock(incoming_signals_lock_);
   if (input_stream_state_ == InputStreamState::INACTIVE)
     return;
   // Avoid marking input that arrived after the BeginFrame as processed.
   if (!begin_frame_time.is_null() &&
       begin_frame_time < last_input_receipt_time_on_compositor_)
     return;
   last_input_process_time_on_main_ = Now();
-  policy_may_need_update_.SetWhileLocked(true);
+  UpdatePolicyLocked();
 }
 
 bool RendererSchedulerImpl::IsHighPriorityWorkAnticipated() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!task_queue_manager_)
     return false;
 
   MaybeUpdatePolicy();
   // The touchstart and compositor policies indicate a strong likelihood of
   // high-priority work in the near future.
@@ skipping 39 matching lines @@
   return current_policy_;
 }
 
 void RendererSchedulerImpl::MaybeUpdatePolicy() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (policy_may_need_update_.IsSet()) {
     UpdatePolicy();
   }
 }
 
-void RendererSchedulerImpl::PostUpdatePolicyOnControlRunner(
-    base::TimeDelta delay) {
-  control_task_runner_->PostDelayedTask(
-      FROM_HERE, update_policy_closure_, delay);
+void RendererSchedulerImpl::EnsureUrgentPolicyUpdatePostedOnMainThread(
+    const tracked_objects::Location& from_here) {
+  // TODO(scheduler-dev): Check that this method isn't called from the main
+  // thread.
+  incoming_signals_lock_.AssertAcquired();
+  if (!policy_may_need_update_.IsSet()) {
+    policy_may_need_update_.SetWhileLocked(true);
+    control_task_runner_->PostTask(from_here, update_policy_closure_);
+  }
 }
 
 void RendererSchedulerImpl::UpdatePolicy() {
+  base::AutoLock lock(incoming_signals_lock_);
+  UpdatePolicyLocked();
+}
+
+void RendererSchedulerImpl::UpdatePolicyLocked() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
+  incoming_signals_lock_.AssertAcquired();
   if (!task_queue_manager_)
     return;
 
-  base::AutoLock lock(incoming_signals_lock_);
-  base::TimeTicks now;
+  base::TimeTicks now = Now();
   policy_may_need_update_.SetWhileLocked(false);
 
   base::TimeDelta new_policy_duration;
-  Policy new_policy = ComputeNewPolicy(&new_policy_duration);
-  if (new_policy_duration > base::TimeDelta())
-    PostUpdatePolicyOnControlRunner(new_policy_duration);
+  Policy new_policy = ComputeNewPolicy(now, &new_policy_duration);
+  if (new_policy_duration > base::TimeDelta()) {
+    delayed_update_policy_runner_.SetDeadline(FROM_HERE, new_policy_duration,
+                                              now);
+  }
 
   if (new_policy == current_policy_)
     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.
@@ skipping 19 matching lines @@
   current_policy_ = new_policy;
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this, AsValueLocked(now));
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.policy", current_policy_);
 }
 
 RendererSchedulerImpl::Policy RendererSchedulerImpl::ComputeNewPolicy(
+    base::TimeTicks now,
     base::TimeDelta* new_policy_duration) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   incoming_signals_lock_.AssertAcquired();
 
   Policy new_policy = Policy::NORMAL;
   *new_policy_duration = base::TimeDelta();
 
   if (input_stream_state_ == InputStreamState::INACTIVE)
     return new_policy;
 
@@ skipping 10 matching lines @@
   if (last_input_process_time_on_main_.is_null() &&
       !task_queue_manager_->IsQueueEmpty(COMPOSITOR_TASK_QUEUE)) {
     new_policy = input_priority_policy;
     *new_policy_duration = new_priority_duration;
   } else {
     // Otherwise make sure the input prioritization policy ends on time.
     base::TimeTicks new_priority_end(
         std::max(last_input_receipt_time_on_compositor_,
                  last_input_process_time_on_main_) +
         new_priority_duration);
-    base::TimeDelta time_left_in_policy = new_priority_end - Now();
+    base::TimeDelta time_left_in_policy = new_priority_end - now;
 
     if (time_left_in_policy > base::TimeDelta()) {
       new_policy = input_priority_policy;
       *new_policy_duration = time_left_in_policy;
     } else {
       // Reset |input_stream_state_| to ensure
       // DidReceiveInputEventOnCompositorThread will post an UpdatePolicy task
       // when it's next called.
       input_stream_state_ = InputStreamState::INACTIVE;
     }
@@ skipping 185 matching lines @@
 }
 
 void RendererSchedulerImpl::RemoveTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (task_queue_manager_)
     task_queue_manager_->RemoveTaskObserver(task_observer);
 }
 
 }  // namespace content