Adds a SHUTDOWN_TASK_QUEUE and a PreShutdown api to the scheduler.

components/scheduler/child/scheduler_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 "components/scheduler/child/scheduler_helper.h"
 
+#include "base/synchronization/waitable_event.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "components/scheduler/child/nestable_single_thread_task_runner.h"
 #include "components/scheduler/child/prioritizing_task_queue_selector.h"
 #include "components/scheduler/child/time_source.h"
 
 namespace scheduler {
 
 SchedulerHelper::SchedulerHelper(
     scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner,
@@ skipping 10 matching lines @@
                                task_queue_selector_.get(),
                                disabled_by_default_tracing_category)),
       idle_period_state_(IdlePeriodState::NOT_IN_IDLE_PERIOD),
       scheduler_helper_delegate_(scheduler_helper_delegate),
       control_task_runner_(
           task_queue_manager_->TaskRunnerForQueue(QueueId::CONTROL_TASK_QUEUE)),
       control_task_after_wakeup_runner_(task_queue_manager_->TaskRunnerForQueue(
           QueueId::CONTROL_TASK_AFTER_WAKEUP_QUEUE)),
       default_task_runner_(
           task_queue_manager_->TaskRunnerForQueue(QueueId::DEFAULT_TASK_QUEUE)),
+      shutdown_task_runner_(task_queue_manager_->TaskRunnerForQueue(
+          QueueId::SHUTDOWN_TASK_QUEUE)),
+      total_task_queue_count_(total_task_queue_count),
       quiescence_monitored_task_queue_mask_(
           ((1ull << total_task_queue_count) - 1ull) &
           ~(1ull << QueueId::IDLE_TASK_QUEUE) &
           ~(1ull << QueueId::CONTROL_TASK_QUEUE) &
           ~(1ull << QueueId::CONTROL_TASK_AFTER_WAKEUP_QUEUE)),
       required_quiescence_duration_before_long_idle_period_(
           required_quiescence_duration_before_long_idle_period),
       time_source_(new TimeSource),
       tracing_category_(tracing_category),
       disabled_by_default_tracing_category_(
@@ skipping 43 matching lines @@
 
 SchedulerHelper::~SchedulerHelper() {
 }
 
 SchedulerHelper::SchedulerHelperDelegate::SchedulerHelperDelegate() {
 }
 
 SchedulerHelper::SchedulerHelperDelegate::~SchedulerHelperDelegate() {
 }
 
+void SchedulerHelper::PreShutdown() {

[Sami, 2015/04/23 13:14:03]

Can we make the client ensure that this is called on the right thread? We don't
really have this pattern for any other method here. It seems scary if unrelated
threads are trying to initiate shutdown on the target thread.

[alex clarke (OOO till 29th), 2015/04/23 17:34:32]

I was able to do this blink side instead.

[Sami, 2015/04/23 18:47:49]

Great, thanks.

+  TRACE_EVENT0(disabled_by_default_tracing_category_, "PreShutdown");
+  if (shutdown_task_runner_->BelongsToCurrentThread()) {
+    PreShutdownInternal(nullptr);
+  } else {
+    base::WaitableEvent completion(false, false);
+    shutdown_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&SchedulerHelper::PreShutdownInternal,
+                              base::Unretained(this), &completion));
+    completion.Wait();
+  }
+}
+
+void SchedulerHelper::PreShutdownInternal(base::WaitableEvent* completion) {
+  TRACE_EVENT0(disabled_by_default_tracing_category_, "PreShutdownInternal");
+  CheckOnValidThread();
+  EndIdlePeriod();

[Sami, 2015/04/23 13:14:02]

Do we actually need to end the idle period? The idle tasks won't get run because
the queue is disabled?

[alex clarke (OOO till 29th), 2015/04/23 17:34:32]

Yes I think so because enable_next_long_idle_period_closure_ gets posted on the
control_task_runner_ as does end_idle_period_closure_ (but that's not such a big
deal).

[Sami, 2015/04/23 18:47:49]

We could just let those run. I don't think there should be any bad side effects.

[alex clarke (OOO till 29th), 2015/04/24 09:32:35]

The reason I wrote this patch in the first place is because I got a segfault in
a GC idle task running in the gap between WorkerThread::stop and the thread
actually getting shut down.  We need to stop idle tasks.  Simply disabling the
idle queue isn't enough because there often will be a
enable_next_long_idle_period_closure_ posted on the control queue which we don't
disable.

[Sami, 2015/04/24 10:38:40]

That sounds like an instance of the bug I was worried about: something goes and
changes the set of enabled queues after this task has run. I think we need to
guard against that in a more sound way. As we add new scheduling primitives it's
very easy to forget to account for them here.

[alex clarke (OOO till 29th), 2015/04/24 14:10:04]

Done.

+  task_queue_selector_->DisableQueue(QueueId::CONTROL_TASK_AFTER_WAKEUP_QUEUE);
+  task_queue_selector_->DisableQueue(QueueId::DEFAULT_TASK_QUEUE);
+  for (size_t i = TASK_QUEUE_COUNT; i < total_task_queue_count_; i++) {

[Sami, 2015/04/23 13:14:02]

Can we get a policy update that undoes all of this?

[alex clarke (OOO till 29th), 2015/04/23 17:34:32]

Yes, but only on the render thread where this isn't intended for use. I think
there is an argument that this should be specific to the worker scheduler, but
that's awkward to surface in blink since there's no worker specific WebThread.

[Sami, 2015/04/24 10:38:40]

Looks like my reply here got lost somehow: I don't think we can rely on the fact
that this only happens in a Worker here. Maybe we can isolate the selector so
that it becomes impossible to enable any additional queues after this function
has been called?

[alex clarke (OOO till 29th), 2015/04/24 14:10:04]

Done.

+    task_queue_selector_->DisableQueue(i);
+  }
+  if (completion)
+    completion->Signal();
+}
+
 void SchedulerHelper::Shutdown() {
   CheckOnValidThread();
   task_queue_manager_.reset();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 SchedulerHelper::DefaultTaskRunner() {
   CheckOnValidThread();
   return default_task_runner_;
 }
 
 scoped_refptr<SingleThreadIdleTaskRunner> SchedulerHelper::IdleTaskRunner() {
   CheckOnValidThread();
   return idle_task_runner_;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
+SchedulerHelper::ShutdownTaskRunner() {
+  CheckOnValidThread();
+  return shutdown_task_runner_;
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
 SchedulerHelper::ControlTaskRunner() {
   return control_task_runner_;
 }
 
 void SchedulerHelper::CurrentIdleTaskDeadlineCallback(
     base::TimeTicks* deadline_out) const {
   CheckOnValidThread();
   *deadline_out = idle_period_deadline_;
 }
 
@@ skipping 230 matching lines @@
   return task_queue_manager_->IsQueueEmpty(queue_index);
 }
 
 // static
 const char* SchedulerHelper::TaskQueueIdToString(QueueId queue_id) {
   switch (queue_id) {
     case DEFAULT_TASK_QUEUE:
       return "default_tq";
     case IDLE_TASK_QUEUE:
       return "idle_tq";
+    case SHUTDOWN_TASK_QUEUE:
+      return "shutdown_tq";
     case CONTROL_TASK_QUEUE:
       return "control_tq";
     case CONTROL_TASK_AFTER_WAKEUP_QUEUE:
       return "control_after_wakeup_tq";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
@@ skipping 25 matching lines @@
 }
 
 void SchedulerHelper::RemoveTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   CheckOnValidThread();
   if (task_queue_manager_)
     task_queue_manager_->RemoveTaskObserver(task_observer);
 }
 
 }  // namespace scheduler