Fix TaskSchedulerWorkerPoolHistogramTest.NumTasksBeforeDetach

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 701 matching lines @@
   //   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();
   worker_pool_->WaitForAllWorkersIdleForTesting();
   worker_pool_->DisallowWorkerDetachmentForTesting();
 }
 
 // TODO(crbug.com/698046): disabled due to flakyness.

[gab, 2017/03/15 19:23:11]

rm comment

[robliao, 2017/03/15 20:05:55]

Done in https://codereview.chromium.org/2750103004/

-TEST_F(TaskSchedulerWorkerPoolHistogramTest, DISABLED_NumTasksBeforeDetach) {
+TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBeforeDetach) {
   InitializeWorkerPool(kReclaimTimeForDetachTests, kNumWorkersInWorkerPool);
 
   auto histogrammed_thread_task_runner =
       worker_pool_->CreateSequencedTaskRunnerWithTraits(
           TaskTraits().WithBaseSyncPrimitives());
 
   // Post 3 tasks and hold the thread for idle thread stack ordering.
   // This test assumes |histogrammed_thread_task_runner| gets assigned the same
   // thread for each of its tasks.
   PlatformThreadRef thread_ref;
   histogrammed_thread_task_runner->PostTask(
       FROM_HERE, Bind(
                      [](PlatformThreadRef* thread_ref) {
                        ASSERT_TRUE(thread_ref);
                        *thread_ref = PlatformThread::CurrentRef();
                      },
                      Unretained(&thread_ref)));
   histogrammed_thread_task_runner->PostTask(
       FROM_HERE, Bind(
-                     [](PlatformThreadRef thread_ref) {
-                       EXPECT_EQ(thread_ref, PlatformThreadRef());
+                     [](PlatformThreadRef* thread_ref) {
+                       ASSERT_FALSE(thread_ref->is_null());
+                       EXPECT_EQ(*thread_ref, PlatformThread::CurrentRef());
                      },
-                     thread_ref));
+                     Unretained(&thread_ref)));
+
   WaitableEvent detach_thread_running(
       WaitableEvent::ResetPolicy::MANUAL,
       WaitableEvent::InitialState::NOT_SIGNALED);
   WaitableEvent detach_thread_continue(
       WaitableEvent::ResetPolicy::MANUAL,
       WaitableEvent::InitialState::NOT_SIGNALED);
   histogrammed_thread_task_runner->PostTask(
       FROM_HERE,
       Bind(
-          [](PlatformThreadRef thread_ref, WaitableEvent* detach_thread_running,
+          [](PlatformThreadRef* thread_ref,
+             WaitableEvent* detach_thread_running,
              WaitableEvent* detach_thread_continue) {
-            EXPECT_EQ(thread_ref, PlatformThreadRef());
+            ASSERT_FALSE(thread_ref->is_null());
+            EXPECT_EQ(*thread_ref, PlatformThread::CurrentRef());
             detach_thread_running->Signal();
             detach_thread_continue->Wait();
           },
-          thread_ref, Unretained(&detach_thread_running),
+          Unretained(&thread_ref), Unretained(&detach_thread_running),
           Unretained(&detach_thread_continue)));
 
   detach_thread_running.Wait();
 
   // To allow the SchedulerWorker associated with
   // |histogrammed_thread_task_runner| to detach, make sure it isn't on top of
   // the idle stack by waking up another SchedulerWorker via
   // |task_runner_for_top_idle|. |histogrammed_thread_task_runner| should
   // release and go idle first and then |task_runner_for_top_idle| should
   // release and go idle. This allows the SchedulerWorker associated with
   // |histogrammed_thread_task_runner| to detach.
   WaitableEvent top_idle_thread_running(
       WaitableEvent::ResetPolicy::MANUAL,
       WaitableEvent::InitialState::NOT_SIGNALED);
   WaitableEvent top_idle_thread_continue(
       WaitableEvent::ResetPolicy::MANUAL,
       WaitableEvent::InitialState::NOT_SIGNALED);
   auto task_runner_for_top_idle =
       worker_pool_->CreateSequencedTaskRunnerWithTraits(
           TaskTraits().WithBaseSyncPrimitives());
   task_runner_for_top_idle->PostTask(
       FROM_HERE, Bind(
                      [](PlatformThreadRef thread_ref,
                         WaitableEvent* top_idle_thread_running,
                         WaitableEvent* top_idle_thread_continue) {
+                       ASSERT_FALSE(thread_ref.is_null());
                        EXPECT_NE(thread_ref, PlatformThread::CurrentRef())
                            << "Worker reused. Thread will not detach and the "
                               "histogram value will be wrong.";
                        top_idle_thread_running->Signal();
                        top_idle_thread_continue->Wait();
                      },
                      thread_ref, Unretained(&top_idle_thread_running),
                      Unretained(&top_idle_thread_continue)));
   top_idle_thread_running.Wait();
   detach_thread_continue.Signal();
@@ skipping 53 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