Remove after wakeup logic and replace PumpTask with Fences

third_party/WebKit/Source/platform/scheduler/child/idle_helper.cc

 // Copyright 2015 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/child/idle_helper.h"
 
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "platform/scheduler/base/real_time_domain.h"
 #include "public/platform/scheduler/base/task_queue.h"
 #include "platform/scheduler/base/task_queue_manager.h"
 #include "platform/scheduler/child/scheduler_helper.h"
 #include "platform/scheduler/child/scheduler_tqm_delegate.h"
 
 namespace blink {
 namespace scheduler {
 
 IdleHelper::IdleHelper(
     SchedulerHelper* helper,
     Delegate* delegate,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
     const char* idle_period_tracing_name,
     base::TimeDelta required_quiescence_duration_before_long_idle_period)
     : helper_(helper),
       delegate_(delegate),
-      idle_queue_(
-          helper_->NewTaskQueue(TaskQueue::Spec("idle_tq").SetPumpPolicy(
-              TaskQueue::PumpPolicy::MANUAL))),
+      idle_queue_(helper_->NewTaskQueue(TaskQueue::Spec("idle_tq"))),
+      non_nestable_idle_queue_(
+          helper_->NewTaskQueue(TaskQueue::Spec("non_nestable_idle_tq"))),
       state_(helper,
              delegate,
              tracing_category,
              disabled_by_default_tracing_category,
              idle_period_tracing_name),
       required_quiescence_duration_before_long_idle_period_(
           required_quiescence_duration_before_long_idle_period),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
       weak_factory_(this) {
   weak_idle_helper_ptr_ = weak_factory_.GetWeakPtr();
   enable_next_long_idle_period_closure_.Reset(
       base::Bind(&IdleHelper::EnableLongIdlePeriod, weak_idle_helper_ptr_));
   on_idle_task_posted_closure_.Reset(base::Bind(
       &IdleHelper::OnIdleTaskPostedOnMainThread, weak_idle_helper_ptr_));
+  disable_idle_queue_closure_.Reset(
+      base::Bind(&IdleHelper::DisableIdleTaskQueueTask, weak_idle_helper_ptr_));
+  disable_non_nestable_idle_queue_closure_.Reset(base::Bind(
+      &IdleHelper::DisableNonNestableIdleTaskQueueTask, weak_idle_helper_ptr_));
 
   idle_task_runner_ = make_scoped_refptr(new SingleThreadIdleTaskRunner(
-      idle_queue_, helper_->ControlAfterWakeUpTaskRunner(), this,
-      tracing_category));
+      idle_queue_, non_nestable_idle_queue_, this, tracing_category));
 
   idle_queue_->SetQueueEnabled(false);
   idle_queue_->SetQueuePriority(TaskQueue::BEST_EFFORT_PRIORITY);
+  non_nestable_idle_queue_->SetQueueEnabled(false);
+  non_nestable_idle_queue_->SetQueuePriority(TaskQueue::BEST_EFFORT_PRIORITY);
 
   helper_->AddTaskObserver(this);
 }
 
 IdleHelper::~IdleHelper() {
   helper_->RemoveTaskObserver(this);
 }
 
 IdleHelper::Delegate::Delegate() {}
 
 IdleHelper::Delegate::~Delegate() {}
 
+void IdleHelper::DisableIdleTaskQueueTask() {
+  idle_queue_->SetQueueEnabled(false);
+  if (IsInLongIdlePeriod(state_.idle_period_state())) {
+    UpdateLongIdlePeriodStateAfterIdleTask();
+  }
+}
+
+void IdleHelper::DisableNonNestableIdleTaskQueueTask() {
+  non_nestable_idle_queue_->SetQueueEnabled(false);
+  if (IsInLongIdlePeriod(state_.idle_period_state())) {
+    UpdateLongIdlePeriodStateAfterIdleTask();
+  }
+}
+
 scoped_refptr<SingleThreadIdleTaskRunner> IdleHelper::IdleTaskRunner() {
   helper_->CheckOnValidThread();
   return idle_task_runner_;
 }
 
 IdleHelper::IdlePeriodState IdleHelper::ComputeNewLongIdlePeriodState(
     const base::TimeTicks now,
     base::TimeDelta* next_long_idle_period_delay_out) {
   helper_->CheckOnValidThread();
 
@@ skipping 33 matching lines @@
   }
 }
 
 bool IdleHelper::ShouldWaitForQuiescence() {
   helper_->CheckOnValidThread();
 
   if (helper_->IsShutdown())
     return false;
 
   if (required_quiescence_duration_before_long_idle_period_ ==
-      base::TimeDelta())
+      base::TimeDelta()) {
     return false;
+  }
 
   bool system_is_quiescent = helper_->GetAndClearSystemIsQuiescentBit();
   TRACE_EVENT1(disabled_by_default_tracing_category_, "ShouldWaitForQuiescence",
                "system_is_quiescent", system_is_quiescent);
   return !system_is_quiescent;
 }
 
 void IdleHelper::EnableLongIdlePeriod() {
   TRACE_EVENT0(disabled_by_default_tracing_category_, "EnableLongIdlePeriod");
   helper_->CheckOnValidThread();
@@ skipping 37 matching lines @@
   if (idle_period_duration <
       base::TimeDelta::FromMilliseconds(kMinimumIdlePeriodDurationMillis)) {
     TRACE_EVENT1(disabled_by_default_tracing_category_,
                  "NotStartingIdlePeriodBecauseDeadlineIsTooClose",
                  "idle_period_duration_ms",
                  idle_period_duration.InMillisecondsF());
     return;
   }
 
   TRACE_EVENT0(disabled_by_default_tracing_category_, "StartIdlePeriod");
-  idle_queue_->SetQueueEnabled(true);
-  LazyNow lazy_now(now);
-  idle_queue_->PumpQueue(&lazy_now, true);
+
+  // Make sure any idle tasks poster after this do not run until the next idle
+  // period.  With nested message loops it's possible there are pending disable
+  // tasks, we don't want that so cancel them.
+  disable_idle_queue_closure_.Cancel();
+  disable_non_nestable_idle_queue_closure_.Cancel();
+  if (idle_queue_->HasPendingImmediateWork()) {
+    idle_queue_->PostTask(FROM_HERE, disable_idle_queue_closure_.callback());

[Sami, 2016/08/25 15:54:12]

I wonder if this could have a failure mode where we try to start an idle period
once a frame but don't actually get to run any tasks. In this case we'd get a
pileup of cancellation tasks.

One way to fix this would be to keep track of whether any new idle tasks have
been posted after the cancellation and avoid posting another one if not.

[alex clarke (OOO till 29th), 2016/08/26 13:29:08]

I've replaced this mechanism with something akin to pumping, but implemented in
a way that doesn't prevent the queue optimizations I want to explore.

+    idle_queue_->SetQueueEnabled(true);
+  }
+  if (non_nestable_idle_queue_->HasPendingImmediateWork()) {
+    non_nestable_idle_queue_->PostNonNestableTask(
+        FROM_HERE, disable_non_nestable_idle_queue_closure_.callback());
+    non_nestable_idle_queue_->SetQueueEnabled(true);
+  }
 
   state_.UpdateState(new_state, idle_period_deadline, now);
 }
 
 void IdleHelper::EndIdlePeriod() {
   helper_->CheckOnValidThread();
   TRACE_EVENT0(disabled_by_default_tracing_category_, "EndIdlePeriod");
 
   enable_next_long_idle_period_closure_.Cancel();
   on_idle_task_posted_closure_.Cancel();
 
   // If we weren't already within an idle period then early-out.
   if (!IsInIdlePeriod(state_.idle_period_state()))
     return;
 
+  // Cancel any pending calls to disable the idle queues in favor of disabling
+  // now.
+  disable_idle_queue_closure_.Cancel();

[Sami, 2016/08/25 15:54:13]

This means we might not run UpdateLongIdlePeriodStateAfterIdleTask in this
period anymore? Is that okay?

[alex clarke (OOO till 29th), 2016/08/26 13:29:08]

Acknowledged.

+  disable_non_nestable_idle_queue_closure_.Cancel();
   idle_queue_->SetQueueEnabled(false);
+  non_nestable_idle_queue_->SetQueueEnabled(false);
   state_.UpdateState(IdlePeriodState::NOT_IN_IDLE_PERIOD, base::TimeTicks(),
                      base::TimeTicks());
 }
 
 void IdleHelper::WillProcessTask(const base::PendingTask& pending_task) {}
 
 void IdleHelper::DidProcessTask(const base::PendingTask& pending_task) {
   helper_->CheckOnValidThread();
   TRACE_EVENT0(disabled_by_default_tracing_category_, "DidProcessTask");
   if (IsInIdlePeriod(state_.idle_period_state()) &&
       state_.idle_period_state() !=
           IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED &&
       helper_->scheduler_tqm_delegate()->NowTicks() >=
           state_.idle_period_deadline()) {
     // If the idle period deadline has now been reached, either end the idle
     // period or trigger a new long-idle period.
     if (IsInLongIdlePeriod(state_.idle_period_state())) {
       EnableLongIdlePeriod();
     } else {
       DCHECK(IdlePeriodState::IN_SHORT_IDLE_PERIOD ==
              state_.idle_period_state());
       EndIdlePeriod();
     }
   }
 }
 
 void IdleHelper::UpdateLongIdlePeriodStateAfterIdleTask() {

[Sami, 2016/08/25 15:54:13]

This should probably be renamed since we no longer run this after every task.
(That's intended, right?)

[alex clarke (OOO till 29th), 2016/08/26 13:29:08]

Acknowledged.

   helper_->CheckOnValidThread();
   DCHECK(IsInLongIdlePeriod(state_.idle_period_state()));
   TRACE_EVENT0(disabled_by_default_tracing_category_,
                "UpdateLongIdlePeriodStateAfterIdleTask");
 
   if (!idle_queue_->HasPendingImmediateWork()) {
     // If there are no more idle tasks then pause long idle period ticks until a
     // new idle task is posted.
     state_.UpdateState(IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED,
                        state_.idle_period_deadline(), base::TimeTicks());
-  } else if (idle_queue_->NeedsPumping()) {
+  } else if (!idle_queue_->IsEmpty()) {
     // If there is still idle work to do then just start the next idle period.
     base::TimeDelta next_long_idle_period_delay;
     if (state_.idle_period_state() ==
         IdlePeriodState::IN_LONG_IDLE_PERIOD_WITH_MAX_DEADLINE) {
       // If we are in a max deadline long idle period then start the next
       // idle period immediately.
       next_long_idle_period_delay = base::TimeDelta();
     } else {
       // Otherwise ensure that we kick the scheduler at the right time to
       // initiate the next idle period.
@@ skipping 39 matching lines @@
 
 base::TimeTicks IdleHelper::WillProcessIdleTask() {
   helper_->CheckOnValidThread();
   state_.TraceIdleIdleTaskStart();
   return CurrentIdleTaskDeadline();
 }
 
 void IdleHelper::DidProcessIdleTask() {
   helper_->CheckOnValidThread();
   state_.TraceIdleIdleTaskEnd();
-  if (IsInLongIdlePeriod(state_.idle_period_state())) {
-    UpdateLongIdlePeriodStateAfterIdleTask();
-  }
 }
 
 // static
 bool IdleHelper::IsInIdlePeriod(IdlePeriodState state) {
   return state != IdlePeriodState::NOT_IN_IDLE_PERIOD;
 }
 
 // static
 bool IdleHelper::IsInLongIdlePeriod(IdlePeriodState state) {
   return state == IdlePeriodState::IN_LONG_IDLE_PERIOD ||
@@ skipping 163 matching lines @@
     case IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED:
       return "in_long_idle_period_paused";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink