TaskScheduler: Bump thread priority during shutdown.

base/task_scheduler/scheduler_worker_unittest.cc

 // Copyright 2016 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 "base/task_scheduler/scheduler_worker.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/synchronization/condition_variable.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/task_scheduler/scheduler_lock.h"
 #include "base/task_scheduler/sequence.h"
 #include "base/task_scheduler/task.h"
 #include "base/task_scheduler/task_tracker.h"
+#include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace internal {
 namespace {
 
 const size_t kNumSequencesPerTest = 150;
 
 // The test parameter is the number of Tasks per Sequence returned by GetWork().
@@ skipping 383 matching lines @@
           ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
           SchedulerWorker::InitialState::DETACHED);
   ASSERT_FALSE(worker->ThreadAliveForTesting());
   worker->WakeUp();
   delegate->WaitForWorkToRun();
   delegate->WaitForDetachRequest();
   ASSERT_TRUE(worker->ThreadAliveForTesting());
   worker->JoinForTesting();
 }
 
+namespace {
+
+class ExpectNormalPriorityDelegate : public SchedulerWorker::Delegate {
+ public:
+  ExpectNormalPriorityDelegate()
+      : done_(WaitableEvent::ResetPolicy::MANUAL,
+              WaitableEvent::InitialState::NOT_SIGNALED) {}
+
+  void WaitDone() { done_.Wait(); }

[robliao, 2016/07/19 22:41:28]

Nit: Maybe WaitForGetWork

[fdoray, 2016/07/20 18:22:21]

Done.

+
+  // SchedulerWorker::Delegate:
+  void OnMainEntry(SchedulerWorker* worker) override {}
+  scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override {
+    EXPECT_EQ(ThreadPriority::NORMAL,
+              PlatformThread::GetCurrentThreadPriority());
+    done_.Signal();
+    return nullptr;
+  }
+  void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override {}
+  TimeDelta GetSleepTimeout() override { return TimeDelta(); }

[robliao, 2016/07/19 22:41:28]

Would be safer to return TimeDelta::Max()

[fdoray, 2016/07/20 18:22:21]

Done.

+  bool CanDetach(SchedulerWorker* worker) override { return false; }
+
+ private:
+  WaitableEvent done_;
+
+  DISALLOW_COPY_AND_ASSIGN(ExpectNormalPriorityDelegate);
+};
+
+}  // namespace
+
+TEST(TaskSchedulerWorkerTest, BumpPriorityDuringShutdown) {
+  TaskTracker task_tracker;
+  task_tracker.SetIsShutdownInProgressForTesting();
+
+  ExpectNormalPriorityDelegate* delegate = new ExpectNormalPriorityDelegate;
+  std::unique_ptr<SchedulerWorker> worker = SchedulerWorker::Create(
+      ThreadPriority::BACKGROUND, WrapUnique(delegate), &task_tracker,
+      SchedulerWorker::InitialState::ALIVE);
+  worker->WakeUp();
+  delegate->WaitDone();
+  worker->JoinForTesting();
+}
+
 }  // namespace
 }  // namespace internal
 }  // namespace base