Add TaskScheduler.NumTasksBeforeDetach.[worker pool name] histogram.

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 575 matching lines @@
 namespace {
 
 class TaskSchedulerWorkerPoolHistogramTest
     : public TaskSchedulerWorkerPoolImplTest {
  public:
   TaskSchedulerWorkerPoolHistogramTest() = default;
 
  protected:
   void SetUp() override {}
 
-  void TearDown() override { worker_pool_->JoinForTesting(); }
+  void TearDown() override {
+    if (worker_pool_)

[robliao, 2016/10/13 18:04:04]

Mention that worker pool initialization is handled by the specific test instead
of the test case.

Can be done later: It would be nice if we could move initialization to test case
SetUp.

[fdoray, 2016/10/13 20:38:53]

Done
The problem with that is that now all test cases initialize the worker pool with
the same params. I don't know how to have code in SetUp() that behaves
differently depending on the test case.

+      worker_pool_->JoinForTesting();
+  }
 
  private:
   std::unique_ptr<StatisticsRecorder> statistics_recorder_ =
       StatisticsRecorder::CreateTemporaryForTesting();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolHistogramTest);
 };
 
 }  // namespace
@@ skipping 109 matching lines @@
                 ->GetCount(1));
   EXPECT_EQ(0, worker_pool_->num_tasks_between_waits_histogram_for_testing()
                    ->SnapshotSamples()
                    ->GetCount(10));
 
   tasks_can_exit_event.Signal();
   worker_pool_->WaitForAllWorkersIdleForTesting();
   worker_pool_->DisallowWorkerDetachmentForTesting();
 }
 
+TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBeforeDetach) {
+  InitializeWorkerPool(kReclaimTimeForDetachTests, kNumWorkersInWorkerPool);
+  auto task_runner = worker_pool_->CreateTaskRunnerWithTraits(
+      TaskTraits(), ExecutionMode::SINGLE_THREADED);
+  auto other_task_runner = worker_pool_->CreateTaskRunnerWithTraits(
+      TaskTraits(), ExecutionMode::SINGLE_THREADED);
+
+  // Post 3 tasks and wait until they run.
+  task_runner->PostTask(FROM_HERE, Bind(&DoNothing));
+  task_runner->PostTask(FROM_HERE, Bind(&DoNothing));
+  task_runner->PostTask(FROM_HERE, Bind(&DoNothing));
+  worker_pool_->WaitForAllWorkersIdleForTesting();
+
+  // 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.
+  // - Release |task_runner|.
+  other_task_runner->PostTask(FROM_HERE, Bind(&DoNothing));
+  task_runner = nullptr;
+
+  // Allow the SchedulerWorker to detach.
+  PlatformThread::Sleep(kReclaimTimeForDetachTests + kExtraTimeToWaitForDetach);
+
+  // Join the SchedulerWorkerPool. This forces SchedulerWorkers that detached
+  // during the test to record to the histogram.
+  worker_pool_->WaitForAllWorkersIdleForTesting();
+  worker_pool_->DisallowWorkerDetachmentForTesting();
+  worker_pool_->JoinForTesting();
+  const auto* histogram =
+      worker_pool_->num_tasks_before_detach_histogram_for_testing();
+  other_task_runner = nullptr;
+  worker_pool_.reset();
+
+  // Verify that counts were recorded to the histogram as expected.
+  EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(0));
+  EXPECT_EQ(1, histogram->SnapshotSamples()->GetCount(3));
+  EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(10));
+}
+
 }  // namespace internal
 }  // namespace base