TaskScheduler: Bump thread priority during shutdown.

base/task_scheduler/scheduler_worker_unittest.cc

Index: base/task_scheduler/scheduler_worker_unittest.cc
diff --git a/base/task_scheduler/scheduler_worker_unittest.cc b/base/task_scheduler/scheduler_worker_unittest.cc
index 437bbedfdb5472dd74a6e45def138c4667dee6b9..b0d1149def00197cd74a0bf94b63ab4e05d73db7 100644
--- a/base/task_scheduler/scheduler_worker_unittest.cc
+++ b/base/task_scheduler/scheduler_worker_unittest.cc
@@ -14,10 +14,12 @@
 #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"
 
@@ -421,6 +423,49 @@ TEST(TaskSchedulerWorkerTest, CreateDetached) {
   worker->JoinForTesting();
 }
 
+namespace {
+
+class ExpectNormalPriorityDelegate : public SchedulerWorker::Delegate {
+ public:
+  ExpectNormalPriorityDelegate()
+      : get_work_event_(WaitableEvent::ResetPolicy::MANUAL,
+                        WaitableEvent::InitialState::NOT_SIGNALED) {}
+
+  void WaitForGetWork() { get_work_event_.Wait(); }
+
+  // SchedulerWorker::Delegate:
+  void OnMainEntry(SchedulerWorker* worker) override {}
+  scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override {
+    EXPECT_EQ(ThreadPriority::NORMAL,
+              PlatformThread::GetCurrentThreadPriority());
+    get_work_event_.Signal();
+    return nullptr;
+  }
+  void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override {}
+  TimeDelta GetSleepTimeout() override { return TimeDelta::Max(); }
+  bool CanDetach(SchedulerWorker* worker) override { return false; }
+
+ private:
+  WaitableEvent get_work_event_;
+
+  DISALLOW_COPY_AND_ASSIGN(ExpectNormalPriorityDelegate);
+};
+
+}  // namespace
+
+TEST(TaskSchedulerWorkerTest, BumpPriorityDuringShutdown) {
+  TaskTracker task_tracker;
+  task_tracker.SetHasShutdownStartedForTesting();

[gab, 2016/07/20 18:35:36]

Just to make sure, if you comment out this line, the test fails, right?

I'd be more comfortable if the test was tested, currently it could pass in a
number of ways with a bug elsewhere in the code it feels.

How about have an ExpectPriorityDelegate on which the expectation can be
updated. Then verify that a first task runs in BACKGROUND mode, then set
shutdown, and verify priority of next task?

Also, instead of doing the verifications in the Delegate I think we should post
actual tasks and do the verification inside of them -- so maybe this test
belongs more as an integration test at the SWPool level.

[fdoray, 2016/07/20 20:30:37]

As discussed offline, implemented ExpectPriorityDelegate.

+
+  ExpectNormalPriorityDelegate* delegate = new ExpectNormalPriorityDelegate;

[gab, 2016/07/20 18:35:36]

Bind to unique_ptr here and move it below (or WrapUnique the inline new call --
that's what WrapUnique is meant for)

[fdoray, 2016/07/20 20:30:37]

Done.

+  std::unique_ptr<SchedulerWorker> worker = SchedulerWorker::Create(
+      ThreadPriority::BACKGROUND, WrapUnique(delegate), &task_tracker,
+      SchedulerWorker::InitialState::ALIVE);
+  worker->WakeUp();
+  delegate->WaitForGetWork();
+  worker->JoinForTesting();
+}
+
 }  // namespace
 }  // namespace internal
 }  // namespace base