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"))),
       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_));
 
-  idle_task_runner_ = make_scoped_refptr(new SingleThreadIdleTaskRunner(
-      idle_queue_, helper_->ControlAfterWakeUpTaskRunner(), this,
-      tracing_category));
+  idle_task_runner_ = make_scoped_refptr(
+      new SingleThreadIdleTaskRunner(idle_queue_, this, tracing_category));
 
   idle_queue_->SetQueueEnabled(false);
   idle_queue_->SetQueuePriority(TaskQueue::BEST_EFFORT_PRIORITY);
 
   helper_->AddTaskObserver(this);
 }
 
 IdleHelper::~IdleHelper() {
   helper_->RemoveTaskObserver(this);
 }
@@ skipping 48 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 38 matching lines @@
       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);
+  // Use a fence to make sure any idle tasks posted after this point do not run
+  // until the next idle period.
+  idle_queue_->InsertFence();
 
   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();
@@ skipping 33 matching lines @@
   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_->BlockedByFence()) {
     // 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 225 matching lines @@
     case IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED:
       return "in_long_idle_period_paused";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink