[content]: Add CanExceedIdleDeadlineIfRequired function to RendererScheduler.

content/renderer/scheduler/renderer_scheduler_impl.cc

Index: content/renderer/scheduler/renderer_scheduler_impl.cc
diff --git a/content/renderer/scheduler/renderer_scheduler_impl.cc b/content/renderer/scheduler/renderer_scheduler_impl.cc
index c105d7749b246842cd0284768a03028825ffbaa4..8f4f076217d74fa463fed02224f01089a54f1842 100644
--- a/content/renderer/scheduler/renderer_scheduler_impl.cc
+++ b/content/renderer/scheduler/renderer_scheduler_impl.cc
@@ -138,7 +138,7 @@ void RendererSchedulerImpl::DidCommitFrameToCompositor() {
 
   base::TimeTicks now(Now());
   if (now < estimated_next_frame_begin_) {
-    StartIdlePeriod();
+    StartIdlePeriod(IdlePeriodState::WITHIN_IDLE_PERIOD);
     control_task_runner_->PostDelayedTask(FROM_HERE,
                                           end_idle_period_closure_.callback(),
                                           estimated_next_frame_begin_ - now);
@@ -394,7 +394,8 @@ base::TimeDelta RendererSchedulerImpl::TimeLeftInInputEscalatedPolicy() const {
   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());
@@ -404,28 +405,32 @@ bool RendererSchedulerImpl::ShouldStartLongIdlePeriod(
     // 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()) {
-     // 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 ?
+        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;
   }
 }
 
@@ -439,9 +444,11 @@ void RendererSchedulerImpl::InitiateLongIdlePeriod() {
 
   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) {
     estimated_next_frame_begin_ = now + next_long_idle_period_delay;
-    StartIdlePeriod();
+    StartIdlePeriod(new_idle_period_state);
   }
 
   if (task_queue_manager_->IsQueueEmpty(IDLE_TASK_QUEUE)) {
@@ -466,7 +473,7 @@ void RendererSchedulerImpl::InitiateLongIdlePeriodAfterWakeup() {
                "AfterWakeupInitiateLongIdlePeriod");
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
-  if (in_idle_period_) {
+  if (idle_period_state_ != IdlePeriodState::NOT_WITHIN_IDLE_PERIOD) {

[Sami, 2015/03/05 11:59:32]

Should we still mark the async event as ended here so EndIdlePeriod() won't try
to do it again?

[rmcilroy, 2015/03/05 13:50:19]

No (for the reasons discussed on the other CL).

     // 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(
@@ -483,14 +490,16 @@ void RendererSchedulerImpl::InitiateLongIdlePeriodAfterWakeup() {
       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() {
@@ -500,9 +509,10 @@ void RendererSchedulerImpl::EndIdlePeriod() {
   initiate_next_long_idle_period_closure_.Cancel();
   after_wakeup_initiate_next_long_idle_period_closure_.Cancel();
 
-  if (!in_idle_period_)
+  if (idle_period_state_ == IdlePeriodState::NOT_WITHIN_IDLE_PERIOD)
     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);
@@ -519,6 +529,10 @@ void RendererSchedulerImpl::EndIdlePeriod() {
                          "RendererSchedulerIdlePeriod", this);
 }
 
+bool RendererSchedulerImpl::CanExceedIdleDeadlineIfRequired() const {
+  return idle_period_state_ == IdlePeriodState::WITHIN_MAX_DEADLINE_IDLE_PERIOD;

[Sami, 2015/03/05 11:59:32]

DCHECK(main_thread_checker_.CalledOnValidThread());

[rmcilroy, 2015/03/05 13:50:19]

Done.

+}
+
 void RendererSchedulerImpl::SetTimeSourceForTesting(
     scoped_refptr<cc::TestNowSource> time_source) {
   DCHECK(main_thread_checker_.CalledOnValidThread());