Add TaskScheduler::JoinForTesting().

base/task_scheduler/scheduler_worker_pool_impl_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_pool_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <unordered_set>
@@ skipping 467 matching lines @@
   WaitableEvent task_waiter(WaitableEvent::ResetPolicy::AUTOMATIC,
                             WaitableEvent::InitialState::NOT_SIGNALED);
   single_thread_task_runner->PostTask(
       FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&task_waiter)));
   task_waiter.Wait();
   worker_pool_->WaitForAllWorkersIdleForTesting();
 
   // Give the worker pool a chance to reclaim its threads.
   PlatformThread::Sleep(kReclaimTimeForDetachTests + kExtraTimeToWaitForDetach);
 
-  worker_pool_->DisallowWorkerDetachmentForTesting();
-
   single_thread_task_runner->PostTask(
       FROM_HERE,
       Bind(&TaskSchedulerWorkerPoolSingleThreadedTest::CheckValidThread,
            Unretained(this)));
   single_thread_task_runner->PostTask(
       FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&task_waiter)));
   task_waiter.Wait();
 }
 
 namespace {
@@ skipping 56 matching lines @@
   // Release tasks waiting on |waiter_|.
   waiter_.Signal();
   worker_pool_->WaitForAllWorkersIdleForTesting();
 
   // All threads should be done running by now, so reset for the next phase.
   waiter_.Reset();
 
   // Give the worker pool a chance to detach its threads.
   PlatformThread::Sleep(kReclaimTimeForDetachTests + kExtraTimeToWaitForDetach);
 
-  worker_pool_->DisallowWorkerDetachmentForTesting();
-
   // Saturate and count the threads that do not have the magic TLS value. If the
   // value is not there, that means we're at a new thread.
   std::vector<std::unique_ptr<WaitableEvent>> count_waiters;
   for (auto& factory : factories) {
     count_waiters.push_back(WrapUnique(new WaitableEvent(
         WaitableEvent::ResetPolicy::MANUAL,
         WaitableEvent::InitialState::NOT_SIGNALED)));
     ASSERT_TRUE(factory->PostTask(
           PostNestedTask::NO,
           Bind(&TaskSchedulerWorkerPoolCheckTlsReuse::CountZeroTlsValuesAndWait,
@@ skipping 130 matching lines @@
   //   the sleep timeout expires.
   EXPECT_GE(histogram->SnapshotSamples()->GetCount(0), 1);
   // - The "1" bucket has a count of |kNumWorkersInWorkerPool| because each
   //   SchedulerWorker ran a task before waiting on its WaitableEvent at the
   //   beginning of the test.
   EXPECT_EQ(static_cast<int>(kNumWorkersInWorkerPool),
             histogram->SnapshotSamples()->GetCount(1));
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(10));
 
   tasks_can_exit_event.Signal();
+
+  // Do not let |tasks_can_exit_event| go out of scope before all workers are
+  // idle.
   worker_pool_->WaitForAllWorkersIdleForTesting();
-  worker_pool_->DisallowWorkerDetachmentForTesting();
 }
 
 namespace {
 
 void NotReachedReEnqueueSequenceCallback(scoped_refptr<Sequence> sequence) {
   ADD_FAILURE()
       << "Unexpected invocation of NotReachedReEnqueueSequenceCallback.";
 }
 
 void CaptureThreadId(PlatformThreadId* thread_id) {
@@ skipping 27 matching lines @@
   // To allow the SchedulerWorker associated with |task_runner| to detach:
   // - Make sure it isn't on top of the idle stack by waking up another
   //   SchedulerWorker and waiting until it goes back to sleep.
   // - Release |task_runner|.
   other_task_runner->PostTask(FROM_HERE, Bind(&VerifyThreadIdIsNot, thread_id));
   worker_pool_->WaitForAllWorkersIdleForTesting();
   task_runner = nullptr;
 
   // Allow the SchedulerWorker that was associated with |task_runner| to detach.
   PlatformThread::Sleep(kReclaimTimeForDetachTests + kExtraTimeToWaitForDetach);
-  worker_pool_->DisallowWorkerDetachmentForTesting();
 
   // Verify that counts were recorded to the histogram as expected.
   const auto* histogram = worker_pool_->num_tasks_before_detach_histogram();
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(0));
   EXPECT_EQ(1, histogram->SnapshotSamples()->GetCount(3));
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(10));
 }
 
 TEST(TaskSchedulerWorkerPoolStandbyPolicyTest, InitLazy) {
   TaskTracker task_tracker;
@@ skipping 19 matching lines @@
                                 StandbyThreadPolicy::ONE, 8U, TimeDelta::Max()),
       Bind(&NotReachedReEnqueueSequenceCallback), &task_tracker,
       &delayed_task_manager);
   ASSERT_TRUE(worker_pool);
   EXPECT_EQ(1U, worker_pool->NumberOfAliveWorkersForTesting());
   worker_pool->JoinForTesting();
 }
 
 }  // namespace internal
 }  // namespace base