Add TaskTraits::MayBlock and TaskTraits::WithSyncPrimitives.

base/task_scheduler/task_scheduler_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/task_scheduler_impl.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 49 matching lines @@
 
   EXPECT_EQ(supports_background_priority &&
                     traits.priority() == TaskPriority::BACKGROUND
                 ? ThreadPriority::BACKGROUND
                 : ThreadPriority::NORMAL,
             PlatformThread::GetCurrentThreadPriority());
 
 #if DCHECK_IS_ON()
   // The #if above is required because GetIOAllowed() always returns true when
   // !DCHECK_IS_ON(), even when |traits| don't allow file I/O.
-  EXPECT_EQ(traits.with_file_io(), GetIOAllowed());
+  EXPECT_EQ(traits.may_block(), GetIOAllowed());
 #endif
 
   // Verify that the thread the task is running on is named as expected.
   const std::string current_thread_name(PlatformThread::GetName());
   EXPECT_NE(std::string::npos, current_thread_name.find("TaskScheduler"));
   EXPECT_NE(std::string::npos,
             current_thread_name.find(
                 traits.priority() == TaskPriority::BACKGROUND ? "Background"
                                                               : "Foreground"));
-  EXPECT_EQ(traits.with_file_io(),
-            current_thread_name.find("FileIO") != std::string::npos);
+  EXPECT_EQ(traits.may_block(),
+            current_thread_name.find("Blocking") != std::string::npos);
 }
 
 void VerifyTaskEnvironementAndSignalEvent(const TaskTraits& traits,
                                           WaitableEvent* event) {
   DCHECK(event);
   VerifyTaskEnvironement(traits);
   event->Signal();
 }
 
 scoped_refptr<TaskRunner> CreateTaskRunnerWithTraitsAndExecutionMode(
@@ skipping 39 matching lines @@
     }
   }
 
   const TaskTraits traits_;
   test::TestTaskFactory factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPostingTasks);
 };
 
 // Returns a vector with a TraitsExecutionModePair for each valid
-// combination of {ExecutionMode, TaskPriority, WithFileIO()}.
+// combination of {ExecutionMode, TaskPriority, MayBlock()}.
 std::vector<TraitsExecutionModePair> GetTraitsExecutionModePairs() {
   std::vector<TraitsExecutionModePair> params;
 
   const test::ExecutionMode execution_modes[] = {
       test::ExecutionMode::PARALLEL, test::ExecutionMode::SEQUENCED,
       test::ExecutionMode::SINGLE_THREADED};
 
   for (test::ExecutionMode execution_mode : execution_modes) {
     for (size_t priority_index = static_cast<size_t>(TaskPriority::LOWEST);
          priority_index <= static_cast<size_t>(TaskPriority::HIGHEST);
          ++priority_index) {
       const TaskPriority priority = static_cast<TaskPriority>(priority_index);
       params.push_back(TraitsExecutionModePair(
           TaskTraits().WithPriority(priority), execution_mode));
       params.push_back(TraitsExecutionModePair(
-          TaskTraits().WithPriority(priority).WithFileIO(), execution_mode));
+          TaskTraits().WithPriority(priority).MayBlock(), execution_mode));
     }
   }
 
   return params;
 }
 
 enum WorkerPoolType {
   BACKGROUND_WORKER_POOL = 0,
-  BACKGROUND_FILE_IO_WORKER_POOL,
+  BACKGROUND_BLOCKING_WORKER_POOL,
   FOREGROUND_WORKER_POOL,
-  FOREGROUND_FILE_IO_WORKER_POOL,
+  FOREGROUND_BLOCKING_WORKER_POOL,
 };
 
 size_t GetThreadPoolIndexForTraits(const TaskTraits& traits) {
-  if (traits.with_file_io()) {
+  if (traits.may_block()) {
     return traits.priority() == TaskPriority::BACKGROUND
-               ? BACKGROUND_FILE_IO_WORKER_POOL
-               : FOREGROUND_FILE_IO_WORKER_POOL;
+               ? BACKGROUND_BLOCKING_WORKER_POOL
+               : FOREGROUND_BLOCKING_WORKER_POOL;
   }
   return traits.priority() == TaskPriority::BACKGROUND ? BACKGROUND_WORKER_POOL
                                                        : FOREGROUND_WORKER_POOL;
 }
 
 class TaskSchedulerImplTest
     : public testing::TestWithParam<TraitsExecutionModePair> {
  protected:
   TaskSchedulerImplTest() = default;
 
   void SetUp() override {
     using StandbyThreadPolicy = SchedulerWorkerPoolParams::StandbyThreadPolicy;
 
     std::vector<SchedulerWorkerPoolParams> params_vector;
 
     ASSERT_EQ(BACKGROUND_WORKER_POOL, params_vector.size());
     params_vector.emplace_back("Background", ThreadPriority::BACKGROUND,
                                StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max());
 
-    ASSERT_EQ(BACKGROUND_FILE_IO_WORKER_POOL, params_vector.size());
-    params_vector.emplace_back("BackgroundFileIO", ThreadPriority::BACKGROUND,
+    ASSERT_EQ(BACKGROUND_BLOCKING_WORKER_POOL, params_vector.size());
+    params_vector.emplace_back("BackgroundBlocking", ThreadPriority::BACKGROUND,
                                StandbyThreadPolicy::LAZY, 3U, TimeDelta::Max());
 
     ASSERT_EQ(FOREGROUND_WORKER_POOL, params_vector.size());
     params_vector.emplace_back("Foreground", ThreadPriority::NORMAL,
                                StandbyThreadPolicy::LAZY, 4U, TimeDelta::Max());
 
-    ASSERT_EQ(FOREGROUND_FILE_IO_WORKER_POOL, params_vector.size());
-    params_vector.emplace_back("ForegroundFileIO", ThreadPriority::NORMAL,
+    ASSERT_EQ(FOREGROUND_BLOCKING_WORKER_POOL, params_vector.size());
+    params_vector.emplace_back("ForegroundBlocking", ThreadPriority::NORMAL,
                                StandbyThreadPolicy::LAZY, 12U,
                                TimeDelta::Max());
 
     scheduler_ = TaskSchedulerImpl::Create(params_vector,
                                            Bind(&GetThreadPoolIndexForTraits));
     ASSERT_TRUE(scheduler_);
   }
 
   void TearDown() override { scheduler_->JoinForTesting(); }
 
@@ skipping 58 matching lines @@
     thread->WaitForAllTasksToRun();
     thread->Join();
   }
 }
 
 // TODO(fdoray): Add tests with Sequences that move around worker pools once
 // child TaskRunners are supported.
 
 }  // namespace internal
 }  // namespace base