SchedulerWorker Refcounting for Destruction in Production

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/memory/ref_counted.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/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
+#include "base/threading/simple_thread.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include <objbase.h>
 #endif
 
 using testing::_;
@@ skipping 81 matching lines @@
   std::vector<scoped_refptr<Sequence>> CreatedSequences() {
     AutoSchedulerLock auto_lock(lock_);
     return created_sequences_;
   }
 
   std::vector<scoped_refptr<Sequence>> EnqueuedSequences() {
     AutoSchedulerLock auto_lock(lock_);
     return re_enqueued_sequences_;
   }
 
-  std::unique_ptr<SchedulerWorker> worker_;
+  scoped_refptr<SchedulerWorker> worker_;
 
  private:
   class TestSchedulerWorkerDelegate : public SchedulerWorkerDefaultDelegate {
    public:
     TestSchedulerWorkerDelegate(TaskSchedulerWorkerTest* outer)
         : outer_(outer) {}
 
     ~TestSchedulerWorkerDelegate() override {
       EXPECT_FALSE(IsCallToDidRunTaskExpected());
     }
@@ skipping 213 matching lines @@
                         TaskSchedulerWorkerTest,
                         ::testing::Values(1));
 INSTANTIATE_TEST_CASE_P(TwoTasksPerSequence,
                         TaskSchedulerWorkerTest,
                         ::testing::Values(2));
 
 namespace {
 
 class ControllableDetachDelegate : public SchedulerWorkerDefaultDelegate {
  public:
+  class Controls : public RefCountedThreadSafe<Controls> {
+   public:
+    Controls()
+        : work_running_(WaitableEvent::ResetPolicy::MANUAL,
+                        WaitableEvent::InitialState::SIGNALED),
+          work_processed_(WaitableEvent::ResetPolicy::MANUAL,
+                          WaitableEvent::InitialState::NOT_SIGNALED),
+          detach_requested_(WaitableEvent::ResetPolicy::MANUAL,
+                            WaitableEvent::InitialState::NOT_SIGNALED),
+          detached_(WaitableEvent::ResetPolicy::MANUAL,
+                    WaitableEvent::InitialState::NOT_SIGNALED),
+          can_detach_block_(WaitableEvent::ResetPolicy::MANUAL,
+                            WaitableEvent::InitialState::SIGNALED),
+          destroyed_(WaitableEvent::ResetPolicy::MANUAL,
+                     WaitableEvent::InitialState::NOT_SIGNALED) {}
+
+    void HaveWorkBlock() { work_running_.Reset(); }
+
+    void UnblockWork() { work_running_.Signal(); }
+
+    void MakeCanDetachBlock() { can_detach_block_.Reset(); }
+
+    void UnblockCanDetach() { can_detach_block_.Signal(); }
+
+    void WaitForWorkToRun() { work_processed_.Wait(); }
+
+    void WaitForDetachRequest() { detach_requested_.Wait(); }
+
+    void WaitForDetach() { detached_.Wait(); }
+
+    void WaitForDelegateDestroy() { destroyed_.Wait(); }
+
+    void ResetState() {
+      work_running_.Signal();
+      work_processed_.Reset();
+      detach_requested_.Reset();
+      can_detach_block_.Signal();
+      work_requested_ = false;
+    }
+
+    void set_can_detach(bool can_detach) { can_detach_ = can_detach; }
+
+   private:
+    friend class ControllableDetachDelegate;
+    friend class RefCountedThreadSafe<Controls>;
+    ~Controls() = default;
+
+    WaitableEvent work_running_;
+    WaitableEvent work_processed_;
+    WaitableEvent detach_requested_;
+    WaitableEvent detached_;
+    WaitableEvent can_detach_block_;
+    WaitableEvent destroyed_;
+
+    bool can_detach_ = false;
+    bool work_requested_ = false;
+
+    DISALLOW_COPY_AND_ASSIGN(Controls);
+  };
+
   ControllableDetachDelegate(TaskTracker* task_tracker)
-      : task_tracker_(task_tracker),
-        work_processed_(WaitableEvent::ResetPolicy::MANUAL,
-                        WaitableEvent::InitialState::NOT_SIGNALED),
-        detach_requested_(WaitableEvent::ResetPolicy::MANUAL,
-                          WaitableEvent::InitialState::NOT_SIGNALED),
-        detached_(WaitableEvent::ResetPolicy::MANUAL,
-                  WaitableEvent::InitialState::NOT_SIGNALED) {
-    EXPECT_TRUE(task_tracker_);
-  }
+      : task_tracker_(task_tracker), controls_(new Controls()) {}
 
-  ~ControllableDetachDelegate() override = default;
-
-  // SchedulerWorker::Delegate:
-  MOCK_METHOD1(OnMainEntry, void(SchedulerWorker* worker));
+  ~ControllableDetachDelegate() override { controls_->destroyed_.Signal(); }
 
   scoped_refptr<Sequence> GetWork(SchedulerWorker* worker)
       override {
     // Sends one item of work to signal |work_processed_|. On subsequent calls,
     // sends nullptr to indicate there's no more work to be done.
-    if (work_requested_)
+    if (controls_->work_requested_)
       return nullptr;
 
-    work_requested_ = true;
+    controls_->work_requested_ = true;
     scoped_refptr<Sequence> sequence(new Sequence);
     std::unique_ptr<Task> task(new Task(
-        FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&work_processed_)),
-        TaskTraits(), TimeDelta()));
+        FROM_HERE,
+        Bind(
+            [](WaitableEvent* work_processed, WaitableEvent* work_running) {
+              work_processed->Signal();
+              work_running->Wait();
+            },
+            Unretained(&controls_->work_processed_),
+            Unretained(&controls_->work_running_)),
+        TaskTraits().WithBaseSyncPrimitives().WithShutdownBehavior(
+            TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
+        TimeDelta()));
     EXPECT_TRUE(task_tracker_->WillPostTask(task.get()));
     sequence->PushTask(std::move(task));
     return sequence;
   }
 
   void DidRunTask() override {}
 
   bool CanDetach(SchedulerWorker* worker) override {
-    detach_requested_.Signal();
-    return can_detach_;
+    // Saving |can_detach_| now so that callers waiting on |detach_requested_|
+    // have the thread go to sleep and then allow detachment.
+    bool can_detach = controls_->can_detach_;
+    controls_->detach_requested_.Signal();
+    controls_->can_detach_block_.Wait();
+    return can_detach;
   }
 
   void OnDetach() override {
-    EXPECT_TRUE(can_detach_);
-    EXPECT_TRUE(detach_requested_.IsSignaled());
-    detached_.Signal();
+    EXPECT_TRUE(controls_->can_detach_);
+    EXPECT_TRUE(controls_->detach_requested_.IsSignaled());
+    controls_->detached_.Signal();
   }
 
-  void WaitForWorkToRun() {
-    work_processed_.Wait();
-  }
-
-  void WaitForDetachRequest() {
-    detach_requested_.Wait();
-  }
-
-  void WaitForDetach() { detached_.Wait(); }
-
-  void ResetState() {
-    work_requested_ = false;
-    work_processed_.Reset();
-    detach_requested_.Reset();
-  }
-
-  void set_can_detach(bool can_detach) { can_detach_ = can_detach; }
+  // ControllableDetachDelegate:
+  scoped_refptr<Controls> controls() { return controls_; }
 
  private:
+  scoped_refptr<Sequence> work_sequence_;
   TaskTracker* const task_tracker_;
-  bool work_requested_ = false;
-  bool can_detach_ = false;
-  WaitableEvent work_processed_;
-  WaitableEvent detach_requested_;
-  WaitableEvent detached_;
+  scoped_refptr<Controls> controls_;
 
   DISALLOW_COPY_AND_ASSIGN(ControllableDetachDelegate);
 };
 
+class MockedControllableDetachDelegate : public ControllableDetachDelegate {
+ public:
+  MockedControllableDetachDelegate(TaskTracker* task_tracker)
+      : ControllableDetachDelegate(task_tracker){};
+  ~MockedControllableDetachDelegate() = default;
+
+  // SchedulerWorker::Delegate:
+  MOCK_METHOD1(OnMainEntry, void(SchedulerWorker* worker));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockedControllableDetachDelegate);
+};
+
 }  // namespace
 
 TEST(TaskSchedulerWorkerTest, WorkerDetaches) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
-  ControllableDetachDelegate* delegate =
-      new StrictMock<ControllableDetachDelegate>(&task_tracker);
-  delegate->set_can_detach(true);
+  MockedControllableDetachDelegate* delegate =
+      new StrictMock<MockedControllableDetachDelegate>(&task_tracker);
+  scoped_refptr<ControllableDetachDelegate::Controls> controls =
+      delegate->controls();
+  controls->set_can_detach(true);
   EXPECT_CALL(*delegate, OnMainEntry(_));
-  std::unique_ptr<SchedulerWorker> worker =
-      SchedulerWorker::Create(
-          ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
-          SchedulerWorker::InitialState::ALIVE);
-  worker->WakeUp();
-  delegate->WaitForWorkToRun();
+  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
+      ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
+      SchedulerWorker::InitialState::ALIVE);
+  worker->WakeUp();
+  controls->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
-  delegate->WaitForDetachRequest();
-  delegate->WaitForDetach();
+  controls->WaitForDetachRequest();
+  controls->WaitForDetach();
   ASSERT_FALSE(worker->ThreadAliveForTesting());
 }
 
+TEST(TaskSchedulerWorkerTest, WorkerReleasesBeforeDetach) {
+  TaskTracker task_tracker;
+  // Will be owned by SchedulerWorker.
+  // No mock here as that's reasonably covered by other tests and the delegate
+  // may destroy on a different thread. Mocks aren't designed with that in mind.
+  std::unique_ptr<ControllableDetachDelegate> delegate =
+      MakeUnique<ControllableDetachDelegate>(&task_tracker);
+  scoped_refptr<ControllableDetachDelegate::Controls> controls =
+      delegate->controls();
+
+  controls->set_can_detach(true);
+  controls->MakeCanDetachBlock();
+
+  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker,
+      SchedulerWorker::InitialState::ALIVE);
+  worker->WakeUp();
+
+  controls->WaitForDetachRequest();
+  worker->Cleanup();
+  worker = nullptr;
+  controls->UnblockCanDetach();
+  controls->WaitForDelegateDestroy();
+}
+
+TEST(TaskSchedulerWorkerTest, WorkerDetachesAndSelfDestroysAfterDetach) {
+  TaskTracker task_tracker;
+  // Will be owned by SchedulerWorker.
+  // No mock here as that's reasonably covered by other tests and the delegate
+  // may destroy on a different thread. Mocks aren't designed with that in mind.
+  std::unique_ptr<ControllableDetachDelegate> delegate =
+      MakeUnique<ControllableDetachDelegate>(&task_tracker);
+  scoped_refptr<ControllableDetachDelegate::Controls> controls =
+      delegate->controls();
+
+  controls->set_can_detach(true);
+
+  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker,
+      SchedulerWorker::InitialState::ALIVE);
+  worker->WakeUp();
+
+  controls->WaitForDetach();
+  worker->Cleanup();
+  worker = nullptr;
+  controls->WaitForDelegateDestroy();
+}
+
+TEST(TaskSchedulerWorkerTest, WorkerDetachesAndSelfDestroysDuringWork) {
+  TaskTracker task_tracker;
+  // Will be owned by SchedulerWorker.
+  // No mock here as that's reasonably covered by other tests and the delegate
+  // may destroy on a different thread. Mocks aren't designed with that in mind.
+  std::unique_ptr<ControllableDetachDelegate> delegate =
+      MakeUnique<ControllableDetachDelegate>(&task_tracker);
+  scoped_refptr<ControllableDetachDelegate::Controls> controls =
+      delegate->controls();
+
+  controls->set_can_detach(true);
+  controls->HaveWorkBlock();
+
+  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker,
+      SchedulerWorker::InitialState::ALIVE);
+  worker->WakeUp();
+
+  controls->WaitForWorkToRun();
+  worker->Cleanup();
+  worker = nullptr;
+  controls->UnblockWork();
+  controls->WaitForDelegateDestroy();
+}
+
+TEST(TaskSchedulerWorkerTest, WorkerDetachesAndSelfDestroysDuringWait) {
+  TaskTracker task_tracker;
+  // Will be owned by SchedulerWorker.
+  // No mock here as that's reasonably covered by other tests and the delegate
+  // may destroy on a different thread. Mocks aren't designed with that in mind.
+  std::unique_ptr<ControllableDetachDelegate> delegate =
+      MakeUnique<ControllableDetachDelegate>(&task_tracker);
+  scoped_refptr<ControllableDetachDelegate::Controls> controls =
+      delegate->controls();
+
+  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker,
+      SchedulerWorker::InitialState::ALIVE);
+  worker->WakeUp();
+
+  controls->WaitForDetachRequest();
+  controls->set_can_detach(true);
+  worker->Cleanup();
+  worker = nullptr;
+  controls->WaitForDelegateDestroy();
+}
+
+TEST(TaskSchedulerWorkerTest, WorkerDetachesAndSelfDestroysDuringShutdown) {
+  TaskTracker task_tracker;
+  // Will be owned by SchedulerWorker.
+  // No mock here as that's reasonably covered by other tests and the delegate
+  // may destroy on a different thread. Mocks aren't designed with that in mind.
+  std::unique_ptr<ControllableDetachDelegate> delegate =
+      MakeUnique<ControllableDetachDelegate>(&task_tracker);
+  scoped_refptr<ControllableDetachDelegate::Controls> controls =
+      delegate->controls();
+
+  controls->HaveWorkBlock();
+
+  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker,
+      SchedulerWorker::InitialState::ALIVE);
+  worker->WakeUp();
+
+  controls->WaitForWorkToRun();
+  task_tracker.Shutdown();
+  worker->Cleanup();
+  worker = nullptr;
+  controls->UnblockWork();
+  controls->WaitForDelegateDestroy();
+}
+
+namespace {
+
+class CallJoinFromDifferentThread : public SimpleThread {
+ public:
+  CallJoinFromDifferentThread(SchedulerWorker* worker_to_join)
+      : SimpleThread("SchedulerWorkerJoinThread"),
+        worker_to_join_(worker_to_join),
+        run_started_event_(WaitableEvent::ResetPolicy::MANUAL,
+                           WaitableEvent::InitialState::NOT_SIGNALED) {}
+
+  ~CallJoinFromDifferentThread() override = default;
+
+  void Run() override {
+    run_started_event_.Signal();
+    worker_to_join_->JoinForTesting();
+  }
+
+  void WaitForRunToStart() { run_started_event_.Wait(); }
+
+ private:
+  SchedulerWorker* const worker_to_join_;
+  WaitableEvent run_started_event_;
+  DISALLOW_COPY_AND_ASSIGN(CallJoinFromDifferentThread);
+};
+
+}  // namespace
+
+TEST(TaskSchedulerWorkerTest, WorkerDetachesAndSelfDestroysDuringJoin) {

[gab, 2017/02/23 21:52:54]

As discussed offline, need to tweak test or adjust name, the code below doesn't
"detach".

[robliao, 2017/02/23 22:00:03]

Nice. This was here since the first revision. Adjusted to WorkerCleanup*.

+  TaskTracker task_tracker;
+  // Will be owned by SchedulerWorker.
+  // No mock here as that's reasonably covered by other tests and the
+  // delegate may destroy on a different thread. Mocks aren't designed with that
+  // in mind.
+  std::unique_ptr<ControllableDetachDelegate> delegate =
+      MakeUnique<ControllableDetachDelegate>(&task_tracker);
+  scoped_refptr<ControllableDetachDelegate::Controls> controls =
+      delegate->controls();
+
+  controls->HaveWorkBlock();
+
+  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
+      ThreadPriority::NORMAL, std::move(delegate), &task_tracker,
+      SchedulerWorker::InitialState::ALIVE);
+  worker->WakeUp();
+
+  controls->WaitForWorkToRun();
+  CallJoinFromDifferentThread join_from_different_thread(worker.get());
+  join_from_different_thread.Start();
+  join_from_different_thread.WaitForRunToStart();
+  // Yield here to give the other thread a chance to call JoinForTesting().
+  // Receiving a signal that Run() was called doesn't mean JoinForTesting() was
+  // necessarily called, and we can't signal after JoinForTesting() as
+  // JoinForTesting() blocks until we call UnblockWork().
+  PlatformThread::YieldCurrentThread();

[gab, 2017/02/23 19:25:24]

I'm not convinced yielding is necessary/better. I'd assume most kernels don't
preempt a thread that signals (I'd noticed Android seemed to do that but not
others -- an "android only" failure it took me days to track down when doing the
BrowserThread redirect CL which was actually an all platform race which resolved
worse on Android because of this); as such JoinForTesting() has likely already
been called (and yielding merely alters the race conditions).

[robliao, 2017/02/23 21:04:22]

Let's go with PlatformThread::Sleep to hammer the point home.

+  worker->Cleanup();
+  worker = nullptr;
+  controls->UnblockWork();
+  controls->WaitForDelegateDestroy();
+  join_from_different_thread.Join();
+}
+
 TEST(TaskSchedulerWorkerTest, WorkerDetachesAndWakes) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
-  ControllableDetachDelegate* delegate =
-      new StrictMock<ControllableDetachDelegate>(&task_tracker);
-  delegate->set_can_detach(true);
+  MockedControllableDetachDelegate* delegate =
+      new StrictMock<MockedControllableDetachDelegate>(&task_tracker);
+  scoped_refptr<ControllableDetachDelegate::Controls> controls =
+      delegate->controls();
+
+  controls->set_can_detach(true);
   EXPECT_CALL(*delegate, OnMainEntry(_));
-  std::unique_ptr<SchedulerWorker> worker =
-      SchedulerWorker::Create(
-          ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
-          SchedulerWorker::InitialState::ALIVE);
-  worker->WakeUp();
-  delegate->WaitForWorkToRun();
+  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
+      ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
+      SchedulerWorker::InitialState::ALIVE);
+  worker->WakeUp();
+  controls->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
-  delegate->WaitForDetachRequest();
-  delegate->WaitForDetach();
+  controls->WaitForDetachRequest();
+  controls->WaitForDetach();
   ASSERT_FALSE(worker->ThreadAliveForTesting());
 
-  delegate->ResetState();
-  delegate->set_can_detach(false);
+  controls->ResetState();
+  controls->set_can_detach(false);
   // Expect OnMainEntry() to be called when SchedulerWorker recreates its
   // thread.
   EXPECT_CALL(*delegate, OnMainEntry(worker.get()));
   worker->WakeUp();
-  delegate->WaitForWorkToRun();
+  controls->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
-  delegate->WaitForDetachRequest();
-  delegate->WaitForDetach();
+  controls->WaitForDetachRequest();
+  controls->WaitForDetach();
   ASSERT_TRUE(worker->ThreadAliveForTesting());
   worker->JoinForTesting();
 }
 
 TEST(TaskSchedulerWorkerTest, CreateDetached) {
   TaskTracker task_tracker;
   // Will be owned by SchedulerWorker.
-  ControllableDetachDelegate* delegate =
-      new StrictMock<ControllableDetachDelegate>(&task_tracker);
-  std::unique_ptr<SchedulerWorker> worker =
-      SchedulerWorker::Create(
-          ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
-          SchedulerWorker::InitialState::DETACHED);
+  MockedControllableDetachDelegate* delegate =
+      new StrictMock<MockedControllableDetachDelegate>(&task_tracker);
+  scoped_refptr<ControllableDetachDelegate::Controls> controls =
+      delegate->controls();
+  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
+      ThreadPriority::NORMAL, WrapUnique(delegate), &task_tracker,
+      SchedulerWorker::InitialState::DETACHED);
   ASSERT_FALSE(worker->ThreadAliveForTesting());
   EXPECT_CALL(*delegate, OnMainEntry(worker.get()));
   worker->WakeUp();
-  delegate->WaitForWorkToRun();
+  controls->WaitForWorkToRun();
   Mock::VerifyAndClear(delegate);
-  delegate->WaitForDetachRequest();
+  controls->WaitForDetachRequest();
   ASSERT_TRUE(worker->ThreadAliveForTesting());
   worker->JoinForTesting();
 }
 
 namespace {
 
 class ExpectThreadPriorityDelegate : public SchedulerWorkerDefaultDelegate {
  public:
   ExpectThreadPriorityDelegate()
       : priority_verified_in_get_work_event_(
@@ skipping 42 matching lines @@
   TaskTracker task_tracker;
 
   std::unique_ptr<ExpectThreadPriorityDelegate> delegate(
       new ExpectThreadPriorityDelegate);
   ExpectThreadPriorityDelegate* delegate_raw = delegate.get();
   delegate_raw->SetExpectedThreadPriority(
       PlatformThread::CanIncreaseCurrentThreadPriority()
           ? ThreadPriority::BACKGROUND
           : ThreadPriority::NORMAL);
 
-  std::unique_ptr<SchedulerWorker> worker = SchedulerWorker::Create(
+  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
       ThreadPriority::BACKGROUND, std::move(delegate), &task_tracker,
       SchedulerWorker::InitialState::ALIVE);
 
   // Verify that the initial thread priority is BACKGROUND (or NORMAL if thread
   // priority can't be increased).
   worker->WakeUp();
   delegate_raw->WaitForPriorityVerifiedInGetWork();
 
   // Verify that the thread priority is bumped to NORMAL during shutdown.
   delegate_raw->SetExpectedThreadPriority(ThreadPriority::NORMAL);
   task_tracker.SetHasShutdownStartedForTesting();
   worker->WakeUp();
   delegate_raw->WaitForPriorityVerifiedInGetWork();
 
   worker->JoinForTesting();
 }
 
 TEST(TaskSchedulerWorkerTest, BumpPriorityOfDetachedThreadDuringShutdown) {
   TaskTracker task_tracker;
 
   std::unique_ptr<ExpectThreadPriorityDelegate> delegate(
       new ExpectThreadPriorityDelegate);
   ExpectThreadPriorityDelegate* delegate_raw = delegate.get();
   delegate_raw->SetExpectedThreadPriority(ThreadPriority::NORMAL);
 
   // Create a DETACHED thread.
-  std::unique_ptr<SchedulerWorker> worker = SchedulerWorker::Create(
+  scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
       ThreadPriority::BACKGROUND, std::move(delegate), &task_tracker,
       SchedulerWorker::InitialState::DETACHED);
 
   // Pretend that shutdown has started.
   task_tracker.SetHasShutdownStartedForTesting();
 
   // Wake up the thread and verify that its priority is NORMAL when
   // OnMainEntry() and GetWork() are called.
   worker->WakeUp();
   delegate_raw->WaitForPriorityVerifiedInGetWork();
@@ skipping 75 matching lines @@
   // COM library wasn't already initialized on the thread.
   EXPECT_EQ(S_OK, delegate_raw->coinitialize_hresult());
 
   worker->JoinForTesting();
 }
 
 #endif  // defined(OS_WIN)
 
 }  // namespace internal
 }  // namespace base