Fix race condition in TaskSchedulerTaskTrackerTest.WillPostAndRunLongTaskBeforeShutdown.

base/task_scheduler/task_tracker_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/task_tracker.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 245 matching lines @@
   // Run the task.
   EXPECT_EQ(0U, NumTasksExecuted());
   EXPECT_TRUE(tracker_.RunTask(std::move(task), SequenceToken::Create()));
   EXPECT_EQ(1U, NumTasksExecuted());
 
   // Shutdown() shouldn't block.
   tracker_.Shutdown();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, WillPostAndRunLongTaskBeforeShutdown) {
-  // Create a task that will block until |event| is signaled.
-  WaitableEvent event(WaitableEvent::ResetPolicy::AUTOMATIC,
-                      WaitableEvent::InitialState::NOT_SIGNALED);
+  // Create a task that signals |task_scheduled| and blocks until |task_barrier|
+  // is signaled.
+  WaitableEvent task_scheduled(WaitableEvent::ResetPolicy::AUTOMATIC,

[robliao, 2017/04/06 18:26:26]

This might be clearer as task_running.

[fdoray, 2017/04/07 12:26:27]

Done.

+                               WaitableEvent::InitialState::NOT_SIGNALED);
+  WaitableEvent task_barrier(WaitableEvent::ResetPolicy::AUTOMATIC,
+                             WaitableEvent::InitialState::NOT_SIGNALED);
   auto blocked_task = base::MakeUnique<Task>(
-      FROM_HERE, Bind(&WaitableEvent::Wait, Unretained(&event)),
+      FROM_HERE,
+      Bind(
+          [](WaitableEvent* task_scheduled, WaitableEvent* task_barrier) {
+            task_scheduled->Signal();
+            task_barrier->Wait();
+          },
+          Unretained(&task_scheduled), base::Unretained(&task_barrier)),
       TaskTraits().WithBaseSyncPrimitives().WithShutdownBehavior(GetParam()),
       TimeDelta());
 
   // Inform |task_tracker_| that |blocked_task| will be posted.
   EXPECT_TRUE(tracker_.WillPostTask(blocked_task.get()));
 
-  // Run the task asynchronouly.
+  // Create a thread to run the task. Wait until the task starts running.
   ThreadPostingAndRunningTask thread_running_task(
       &tracker_, std::move(blocked_task),
       ThreadPostingAndRunningTask::Action::RUN, false);
   thread_running_task.Start();
+  task_scheduled.Wait();
 
-  // Initiate shutdown while the task is running.
+  // Initiate shutdown after the task has been scheduled.
   CallShutdownAsync();
 
   if (GetParam() == TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN) {
     // Shutdown should complete even with a CONTINUE_ON_SHUTDOWN in progress.
     WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
   } else {
     // Shutdown should block with any non CONTINUE_ON_SHUTDOWN task in progress.
     VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
   }
 
   // Unblock the task.
-  event.Signal();
+  task_barrier.Signal();
   thread_running_task.Join();
 
   // Shutdown should now complete for a non CONTINUE_ON_SHUTDOWN task.
   if (GetParam() != TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
     WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, WillPostBeforeShutdownRunDuringShutdown) {
   // Inform |task_tracker_| that a task will be posted.
   std::unique_ptr<Task> task(CreateTask(GetParam()));
@@ skipping 625 matching lines @@
     ASSERT_TRUE(tracker.WillPostTask(task.get()));
 
     HistogramTester tester;
     EXPECT_TRUE(tracker.RunTask(std::move(task), SequenceToken::Create()));
     tester.ExpectTotalCount(test.expected_histogram, 1);
   }
 }
 
 }  // namespace internal
 }  // namespace base