[content]: Add CanExceedIdleDeadlineIfRequired function to RendererScheduler.

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 14 matching lines @@
           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)),
       current_policy_(Policy::NORMAL),
-      in_idle_period_(false),
+      idle_period_state_(IdlePeriodState::NOT_WITHIN_IDLE_PERIOD),
       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_));
   initiate_next_long_idle_period_closure_.Reset(base::Bind(
@@ skipping 88 matching lines @@
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::DidCommitFrameToCompositor");
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!task_queue_manager_)
     return;
 
   base::TimeTicks now(Now());
   if (now < estimated_next_frame_begin_) {
     // TODO(rmcilroy): Consider reducing the idle period based on the runtime of
     // the next pending delayed tasks (as currently done in for long idle times)
-    StartIdlePeriod();
+    StartIdlePeriod(IdlePeriodState::WITHIN_IDLE_PERIOD);
     control_task_runner_->PostDelayedTask(FROM_HERE,
                                           end_idle_period_closure_.callback(),
                                           estimated_next_frame_begin_ - now);
   }
 }
 
 void RendererSchedulerImpl::BeginFrameNotExpectedSoon() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::BeginFrameNotExpectedSoon");
   DCHECK(main_thread_checker_.CalledOnValidThread());
@@ skipping 235 matching lines @@
     // 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_) +
         escalated_priority_duration);
     time_left_in_policy = new_priority_end - Now();
   }
   return time_left_in_policy;
 }
 
-bool RendererSchedulerImpl::ShouldStartLongIdlePeriod(
+RendererSchedulerImpl::IdlePeriodState
+RendererSchedulerImpl::ComputeNewLongIdlePeriodState(
     const base::TimeTicks now,
     base::TimeDelta* next_long_idle_period_delay_out) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   MaybeUpdatePolicy();
   if (SchedulerPolicy() == Policy::TOUCHSTART_PRIORITY) {
     // Don't start a long idle task in touch start priority, try again when
     // the policy is scheduled to end.
     *next_long_idle_period_delay_out = current_policy_expiration_time_ - now;
-    return false;
+    return IdlePeriodState::NOT_WITHIN_IDLE_PERIOD;
   }
 
   base::TimeTicks next_pending_delayed_task =
       task_queue_manager_->NextPendingDelayedTaskRunTime();
-
-  base::TimeDelta long_idle_period_duration =
+  base::TimeDelta max_long_idle_period_duration =
       base::TimeDelta::FromMilliseconds(kMaximumIdlePeriodMillis);
+  base::TimeDelta long_idle_period_duration;
   if (!next_pending_delayed_task.is_null()) {

[picksi, 2015/03/05 12:22:08]

It's time for my regular "remove ! and swap if/else bodies" comment :)

[rmcilroy, 2015/03/05 13:25:24]

Done.

-     // Limit the idle period duration to be before the next pending task.
-     long_idle_period_duration = std::min(
-        next_pending_delayed_task - now, long_idle_period_duration);
+    // Limit the idle period duration to be before the next pending task.
+    long_idle_period_duration = std::min(
+       next_pending_delayed_task - now, max_long_idle_period_duration);
+  } else {
+    long_idle_period_duration = max_long_idle_period_duration;
   }
 
   if (long_idle_period_duration > base::TimeDelta()) {
     *next_long_idle_period_delay_out = long_idle_period_duration;
-    return true;
+    return long_idle_period_duration == max_long_idle_period_duration ?

[picksi, 2015/03/05 12:22:08]

It seems slightly non-intuitive to say we're "within" the max-deadline-period
when the code is checking for being right at the end (and not a moment before!)
the deadline period. Maybe a comment to explain this apparent contradiction
would help?

[rmcilroy, 2015/03/05 13:25:24]

I renamed the states (e.g., IN_LONG_IDLE_WITH_MAX_DEADLINE_PERIOD) - does this
make it clearer?

+        IdlePeriodState::WITHIN_MAX_DEADLINE_IDLE_PERIOD:
+        IdlePeriodState::WITHIN_IDLE_PERIOD;
   } else {
     // If we can't start the idle period yet then try again after wakeup.
     *next_long_idle_period_delay_out = base::TimeDelta::FromMilliseconds(
         kRetryInitiateLongIdlePeriodDelayMillis);
-    return false;
+    return IdlePeriodState::NOT_WITHIN_IDLE_PERIOD;
   }
 }
 
 void RendererSchedulerImpl::InitiateLongIdlePeriod() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "InitiateLongIdlePeriod");
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   // End any previous idle period.
   EndIdlePeriod();
 
   base::TimeTicks now(Now());
   base::TimeDelta next_long_idle_period_delay;
-  if (ShouldStartLongIdlePeriod(now, &next_long_idle_period_delay)) {
+  IdlePeriodState new_idle_period_state = ComputeNewLongIdlePeriodState(
+      now, &next_long_idle_period_delay);
+  if (new_idle_period_state != IdlePeriodState::NOT_WITHIN_IDLE_PERIOD) {

[picksi, 2015/03/05 12:22:08]

(More "!" comments)... I find this double negative (not not within the idle
period) tricky to get my head around (and it appears in a couple of places). It
might be clearer to have a function called
isWithinIdlePeriod(new_idle_period_state) to wrap this.

[rmcilroy, 2015/03/05 13:25:24]

Done.

     estimated_next_frame_begin_ = now + next_long_idle_period_delay;
-    StartIdlePeriod();
+    StartIdlePeriod(new_idle_period_state);
   }
 
   if (task_queue_manager_->IsQueueEmpty(IDLE_TASK_QUEUE)) {
     // If there are no current idle tasks then post the call to initiate the
     // next idle for execution after wakeup (at which point after-wakeup idle
     // tasks might be eligible to run or more idle tasks posted).
     control_task_after_wakeup_runner_->PostDelayedTask(
         FROM_HERE,
         initiate_next_long_idle_period_after_wakeup_closure_.callback(),
         next_long_idle_period_delay);
   } else {
     // Otherwise post on the normal control task queue.
     control_task_runner_->PostDelayedTask(
         FROM_HERE,
         initiate_next_long_idle_period_closure_.callback(),
         next_long_idle_period_delay);
   }
 }
 
 void RendererSchedulerImpl::InitiateLongIdlePeriodAfterWakeup() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "AfterWakeupInitiateLongIdlePeriod");
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
-  if (in_idle_period_) {
+  if (idle_period_state_ != IdlePeriodState::NOT_WITHIN_IDLE_PERIOD) {
     // Since we were asleep until now, end the async idle period trace event at
     // the time when it would have ended were we awake.
     TRACE_EVENT_ASYNC_END_WITH_TIMESTAMP0(
         "renderer.scheduler", "RendererSchedulerIdlePeriod", this,
         std::min(estimated_next_frame_begin_, Now()).ToInternalValue());
   }
 
   // Post a task to initiate the next long idle period rather than calling it
   // directly to allow all pending PostIdleTaskAfterWakeup tasks to get enqueued
   // on the idle task queue before the next idle period starts so they are
   // eligible to be run during the new idle period.
   control_task_runner_->PostTask(
       FROM_HERE,
       initiate_next_long_idle_period_closure_.callback());
 }
 
-void RendererSchedulerImpl::StartIdlePeriod() {
+void RendererSchedulerImpl::StartIdlePeriod(IdlePeriodState new_state) {
   TRACE_EVENT_ASYNC_BEGIN0("renderer.scheduler",
                            "RendererSchedulerIdlePeriod", this);
   DCHECK(main_thread_checker_.CalledOnValidThread());
+  // TODO(rmcilroy): Change this to DCHECK_EQ when crbug.com/463869 is fixed.
+  DCHECK(new_state != IdlePeriodState::NOT_WITHIN_IDLE_PERIOD);
+  idle_period_state_ = new_state;
   renderer_task_queue_selector_->EnableQueue(
       IDLE_TASK_QUEUE, RendererTaskQueueSelector::BEST_EFFORT_PRIORITY);
   task_queue_manager_->PumpQueue(IDLE_TASK_QUEUE);
-  in_idle_period_ = true;
 }
 
 void RendererSchedulerImpl::EndIdlePeriod() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   end_idle_period_closure_.Cancel();
   initiate_next_long_idle_period_closure_.Cancel();
   initiate_next_long_idle_period_after_wakeup_closure_.Cancel();
 
-  if (!in_idle_period_)
+  if (idle_period_state_ == IdlePeriodState::NOT_WITHIN_IDLE_PERIOD)

[picksi, 2015/03/05 12:22:08]

Is this a silent failure? Should this be a DCHECK or is it OK to end a
non-existent idle period?

[rmcilroy, 2015/03/05 13:25:24]

No, it's allowable to call EndIdlePeriod even if you aren't within wone
currently - it is just an early-out.  Added a comment.

     return;
 
+  idle_period_state_ = IdlePeriodState::NOT_WITHIN_IDLE_PERIOD;
   renderer_task_queue_selector_->DisableQueue(IDLE_TASK_QUEUE);
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED("renderer.scheduler", &is_tracing);
   if (is_tracing && !estimated_next_frame_begin_.is_null() &&
       base::TimeTicks::Now() > estimated_next_frame_begin_) {
     TRACE_EVENT_ASYNC_STEP_INTO_WITH_TIMESTAMP0(
         "renderer.scheduler",
         "RendererSchedulerIdlePeriod",
         this,
         "DeadlineOverrun",
         estimated_next_frame_begin_.ToInternalValue());
   }
   TRACE_EVENT_ASYNC_END0("renderer.scheduler",
                          "RendererSchedulerIdlePeriod", this);
 }
 
+bool RendererSchedulerImpl::CanExceedIdleDeadlineIfRequired() const {
+  return idle_period_state_ == IdlePeriodState::WITHIN_MAX_DEADLINE_IDLE_PERIOD;
+}
+
 void RendererSchedulerImpl::SetTimeSourceForTesting(
     scoped_refptr<cc::TestNowSource> time_source) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   time_source_ = time_source;
   task_queue_manager_->SetTimeSourceForTesting(time_source);
 }
 
 void RendererSchedulerImpl::SetWorkBatchSizeForTesting(size_t work_batch_size) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   task_queue_manager_->SetWorkBatchSize(work_batch_size);
@@ skipping 65 matching lines @@
     case InputStreamState::ACTIVE:
       return "active";
     case InputStreamState::ACTIVE_AND_AWAITING_TOUCHSTART_RESPONSE:
       return "active_and_awaiting_touchstart_response";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
+const char* RendererSchedulerImpl::IdlePeriodStateToString(
+    IdlePeriodState state) {

[picksi, 2015/03/05 12:22:08]

nit: rename state to idle_period_state

[rmcilroy, 2015/03/05 13:25:24]

Done.

+  switch (state) {
+    case IdlePeriodState::NOT_WITHIN_IDLE_PERIOD:
+      return "not_within_idle_period";
+    case IdlePeriodState::WITHIN_IDLE_PERIOD:
+      return "within_idle_period";
+    case IdlePeriodState::WITHIN_MAX_DEADLINE_IDLE_PERIOD:
+      return "within_max_deadline_idle_period";
+    default:
+      NOTREACHED();
+      return nullptr;
+  }
+}
+
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 RendererSchedulerImpl::AsValueLocked(base::TimeTicks optional_now) const {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   incoming_signals_lock_.AssertAcquired();
 
   if (optional_now.is_null())
     optional_now = Now();
   scoped_refptr<base::trace_event::TracedValue> state =
       new base::trace_event::TracedValue();
 
   state->SetString("current_policy", PolicyToString(current_policy_));
-  state->SetBoolean("in_idle_period", in_idle_period_);
+  state->SetString("idle_period_state",
+                   IdlePeriodStateToString(idle_period_state_));
   state->SetString("input_stream_state",
                    InputStreamStateToString(input_stream_state_));
   state->SetDouble("now", (optional_now - base::TimeTicks()).InMillisecondsF());
   state->SetDouble("last_input_receipt_time_on_compositor_",
                    (last_input_receipt_time_on_compositor_ - base::TimeTicks())
                        .InMillisecondsF());
   state->SetDouble(
       "last_input_process_time_on_main_",
       (last_input_process_time_on_main_ - base::TimeTicks()).InMillisecondsF());
   state->SetDouble(
@@ skipping 47 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