Make sure scheduler shutdown prevents idle tasks from running

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"
@@ skipping 18 matching lines @@
           helper_->NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::IDLE))),
       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),
+      is_shutdown_(false),
       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_, this, tracing_category));
 
   idle_queue_->SetQueueEnabled(false);
   idle_queue_->SetQueuePriority(TaskQueue::BEST_EFFORT_PRIORITY);
 
   helper_->AddTaskObserver(this);
 }
 
 IdleHelper::~IdleHelper() {
+  Shutdown();
+}
+
+void IdleHelper::Shutdown() {
+  if (is_shutdown_)
+    return;
+
+  EndIdlePeriod();
+  is_shutdown_ = true;
+  weak_factory_.InvalidateWeakPtrs();
+  // Belt & braces, might not be needed.
+  idle_queue_->SetQueueEnabled(false);
   helper_->RemoveTaskObserver(this);
 }
 
 IdleHelper::Delegate::Delegate() {}
 
 IdleHelper::Delegate::~Delegate() {}
 
 scoped_refptr<SingleThreadIdleTaskRunner> IdleHelper::IdleTaskRunner() {
   helper_->CheckOnValidThread();
   return idle_task_runner_;
@@ skipping 36 matching lines @@
     // If we can't start the idle period yet then try again after wakeup.
     *next_long_idle_period_delay_out = base::TimeDelta::FromMilliseconds(
         kRetryEnableLongIdlePeriodDelayMillis);
     return IdlePeriodState::NOT_IN_IDLE_PERIOD;
   }
 }
 
 bool IdleHelper::ShouldWaitForQuiescence() {
   helper_->CheckOnValidThread();
 
-  if (helper_->IsShutdown())
-    return false;
-
   if (required_quiescence_duration_before_long_idle_period_ ==
       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();
-  if (helper_->IsShutdown())
+  if (is_shutdown_)
     return;
 
   // End any previous idle period.
   EndIdlePeriod();
 
   if (ShouldWaitForQuiescence()) {
     helper_->ControlTaskRunner()->PostDelayedTask(
         FROM_HERE, enable_next_long_idle_period_closure_.callback(),
         required_quiescence_duration_before_long_idle_period_);
     delegate_->IsNotQuiescent();
@@ skipping 11 matching lines @@
     // Otherwise wait for the next long idle period delay before trying again.
     helper_->ControlTaskRunner()->PostDelayedTask(
         FROM_HERE, enable_next_long_idle_period_closure_.callback(),
         next_long_idle_period_delay);
   }
 }
 
 void IdleHelper::StartIdlePeriod(IdlePeriodState new_state,
                                  base::TimeTicks now,
                                  base::TimeTicks idle_period_deadline) {
+  DCHECK(!is_shutdown_);
   DCHECK_GT(idle_period_deadline, now);
   helper_->CheckOnValidThread();
   DCHECK(IsInIdlePeriod(new_state));
 
   base::TimeDelta idle_period_duration(idle_period_deadline - now);
   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);
   // 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() {
+  if (is_shutdown_)
+    return;
+
   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;
 
   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::WillProcessTask(const base::PendingTask& pending_task) {
+  DCHECK(!is_shutdown_);
+}
 
 void IdleHelper::DidProcessTask(const base::PendingTask& pending_task) {
   helper_->CheckOnValidThread();
+  DCHECK(!is_shutdown_);
   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() {
   helper_->CheckOnValidThread();
+  DCHECK(!is_shutdown_);
   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_->BlockedByFence()) {
@@ skipping 21 matching lines @@
   }
 }
 
 base::TimeTicks IdleHelper::CurrentIdleTaskDeadline() const {
   helper_->CheckOnValidThread();
   return state_.idle_period_deadline();
 }
 
 void IdleHelper::OnIdleTaskPosted() {
   TRACE_EVENT0(disabled_by_default_tracing_category_, "OnIdleTaskPosted");
+  if (is_shutdown_)
+    return;
   if (idle_task_runner_->RunsTasksOnCurrentThread()) {
     OnIdleTaskPostedOnMainThread();
   } else {
     helper_->ControlTaskRunner()->PostTask(
         FROM_HERE, on_idle_task_posted_closure_.callback());
   }
 }
 
 void IdleHelper::OnIdleTaskPostedOnMainThread() {
   TRACE_EVENT0(disabled_by_default_tracing_category_,
                "OnIdleTaskPostedOnMainThread");
+  if (is_shutdown_)
+    return;
   if (state_.idle_period_state() ==
       IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED) {
     // Restart long idle period ticks.
     helper_->ControlTaskRunner()->PostTask(
         FROM_HERE, enable_next_long_idle_period_closure_.callback());
   }
 }
 
 base::TimeTicks IdleHelper::WillProcessIdleTask() {
   helper_->CheckOnValidThread();
+  DCHECK(!is_shutdown_);
   state_.TraceIdleIdleTaskStart();
   return CurrentIdleTaskDeadline();
 }
 
 void IdleHelper::DidProcessIdleTask() {
   helper_->CheckOnValidThread();
+  if (is_shutdown_)
+    return;
   state_.TraceIdleIdleTaskEnd();
   if (IsInLongIdlePeriod(state_.idle_period_state())) {
     UpdateLongIdlePeriodStateAfterIdleTask();
   }
 }
 
 // static
 bool IdleHelper::IsInIdlePeriod(IdlePeriodState state) {
   return state != IdlePeriodState::NOT_IN_IDLE_PERIOD;
 }
@@ skipping 166 matching lines @@
     case IdlePeriodState::IN_LONG_IDLE_PERIOD_PAUSED:
       return "in_long_idle_period_paused";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink