Add TaskTraits::MayBlock and TaskTraits::WithSyncPrimitives.

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 246 matching lines @@
   // 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);
   auto blocked_task = base::MakeUnique<Task>(
       FROM_HERE, Bind(&WaitableEvent::Wait, Unretained(&event)),
-      TaskTraits().WithWait().WithShutdownBehavior(GetParam()), TimeDelta());
+      TaskTraits().WithSyncPrimitives().WithShutdownBehavior(GetParam()),
+      TimeDelta());
 
   // Inform |task_tracker_| that |blocked_task| will be posted.
   EXPECT_TRUE(tracker_.WillPostTask(blocked_task.get()));
 
   // Run the task asynchronouly.
   ThreadPostingAndRunningTask thread_running_task(
       &tracker_, std::move(blocked_task),
       ThreadPostingAndRunningTask::Action::RUN, false);
   thread_running_task.Start();
 
@@ skipping 146 matching lines @@
 
   // Running the task should fail iff the task isn't allowed to use singletons.
   if (can_use_singletons) {
     EXPECT_TRUE(tracker.RunTask(std::move(task), SequenceToken::Create()));
   } else {
     EXPECT_DCHECK_DEATH(
         { tracker.RunTask(std::move(task), SequenceToken::Create()); });
   }
 }
 
-// Verify that AssertIOAllowed() succeeds only for a WithFileIO() task.
+// Verify that AssertIOAllowed() succeeds only for a MayBlock() task.
 TEST_P(TaskSchedulerTaskTrackerTest, IOAllowed) {
   TaskTracker tracker;
 
   // Unset the IO allowed bit. Expect TaskTracker to set it before running a
-  // task with the WithFileIO() trait.
+  // task with the MayBlock() trait.
   ThreadRestrictions::SetIOAllowed(false);
-  auto task_with_file_io = MakeUnique<Task>(
+  auto task_with_may_block = MakeUnique<Task>(
       FROM_HERE, Bind([]() {
         // Shouldn't fail.
         ThreadRestrictions::AssertIOAllowed();
       }),
-      TaskTraits().WithFileIO().WithShutdownBehavior(GetParam()), TimeDelta());
-  EXPECT_TRUE(tracker.WillPostTask(task_with_file_io.get()));
-  tracker.RunTask(std::move(task_with_file_io), SequenceToken::Create());
+      TaskTraits().MayBlock().WithShutdownBehavior(GetParam()), TimeDelta());
+  EXPECT_TRUE(tracker.WillPostTask(task_with_may_block.get()));
+  tracker.RunTask(std::move(task_with_may_block), SequenceToken::Create());
 
   // Set the IO allowed bit. Expect TaskTracker to unset it before running a
-  // task without the WithFileIO() trait.
+  // task without the MayBlock() trait.
   ThreadRestrictions::SetIOAllowed(true);
-  auto task_without_file_io = MakeUnique<Task>(
+  auto task_without_may_block = MakeUnique<Task>(
       FROM_HERE, Bind([]() {
         EXPECT_DCHECK_DEATH({ ThreadRestrictions::AssertIOAllowed(); });
       }),
       TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());
-  EXPECT_TRUE(tracker.WillPostTask(task_without_file_io.get()));
-  tracker.RunTask(std::move(task_without_file_io), SequenceToken::Create());
+  EXPECT_TRUE(tracker.WillPostTask(task_without_may_block.get()));
+  tracker.RunTask(std::move(task_without_may_block), SequenceToken::Create());
 }
 
 static void RunTaskRunnerHandleVerificationTask(
     TaskTracker* tracker,
     std::unique_ptr<Task> verify_task) {
   // Pretend |verify_task| is posted to respect TaskTracker's contract.
   EXPECT_TRUE(tracker->WillPostTask(verify_task.get()));
 
   // Confirm that the test conditions are right (no TaskRunnerHandles set
   // already).
@@ skipping 366 matching lines @@
 
 class WaitAllowedTestThread : public SimpleThread {
  public:
   WaitAllowedTestThread() : SimpleThread("WaitAllowedTestThread") {}
 
  private:
   void Run() override {
     TaskTracker tracker;
 
     // Waiting is allowed by default. Expect TaskTracker to disallow it before
-    // running a task without the WithWait() trait.
+    // running a task without the WithSyncPrimitives() trait.
     ThreadRestrictions::AssertWaitAllowed();
-    auto task_without_wait = MakeUnique<Task>(
+    auto task_without_sync_primitives = MakeUnique<Task>(
         FROM_HERE, Bind([]() {
           EXPECT_DCHECK_DEATH({ ThreadRestrictions::AssertWaitAllowed(); });
         }),
         TaskTraits(), TimeDelta());
-    EXPECT_TRUE(tracker.WillPostTask(task_without_wait.get()));
-    tracker.RunTask(std::move(task_without_wait), SequenceToken::Create());
+    EXPECT_TRUE(tracker.WillPostTask(task_without_sync_primitives.get()));
+    tracker.RunTask(std::move(task_without_sync_primitives),
+                    SequenceToken::Create());
 
     // Disallow waiting. Expect TaskTracker to allow it before running a task
-    // with the WithWait() trait.
+    // with the WithSyncPrimitives() trait.
     ThreadRestrictions::DisallowWaiting();
-    auto task_with_wait =
+    auto task_with_sync_primitives =
         MakeUnique<Task>(FROM_HERE, Bind([]() {
                            // Shouldn't fail.
                            ThreadRestrictions::AssertWaitAllowed();
                          }),
-                         TaskTraits().WithWait(), TimeDelta());
-    EXPECT_TRUE(tracker.WillPostTask(task_with_wait.get()));
-    tracker.RunTask(std::move(task_with_wait), SequenceToken::Create());
+                         TaskTraits().WithSyncPrimitives(), TimeDelta());
+    EXPECT_TRUE(tracker.WillPostTask(task_with_sync_primitives.get()));
+    tracker.RunTask(std::move(task_with_sync_primitives),
+                    SequenceToken::Create());
   }
 
   DISALLOW_COPY_AND_ASSIGN(WaitAllowedTestThread);
 };
 
 }  // namespace
 
-// Verify that AssertIOAllowed() succeeds for a WithWait() task.
+// Verify that AssertIOAllowed() succeeds only for a WithSyncPrimitives() task.
 TEST(TaskSchedulerTaskTrackerWaitAllowedTest, WaitAllowed) {
   // Run the test on the separate thread since it is not possible to reset the
   // "wait allowed" bit of a thread without being a friend of
   // ThreadRestrictions.
   WaitAllowedTestThread wait_allowed_test_thread;
   wait_allowed_test_thread.Start();
   wait_allowed_test_thread.Join();
 }
 
 }  // namespace internal
 }  // namespace base