Add TaskTraits::MayBlock and TaskTraits::WithSyncPrimitives.

base/threading/sequenced_worker_pool.cc

 // Copyright (c) 2012 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/threading/sequenced_worker_pool.h"
 
 #include <stdint.h>
 
 #include <list>
 #include <map>
@@ skipping 794 matching lines @@
                 "TaskShutdownBehavior and WorkerShutdown enum mismatch for "
                 "SKIP_ON_SHUTDOWN.");
   static_assert(static_cast<int>(TaskShutdownBehavior::BLOCK_SHUTDOWN) ==
                     static_cast<int>(BLOCK_SHUTDOWN),
                 "TaskShutdownBehavior and WorkerShutdown enum mismatch for "
                 "BLOCK_SHUTDOWN.");
 
   const TaskShutdownBehavior task_shutdown_behavior =
       static_cast<TaskShutdownBehavior>(sequenced.shutdown_behavior);
   const TaskTraits traits = TaskTraits()
-                                .WithFileIO()
-                                .WithWait()
+                                .MayBlock()
+                                .WithSyncPrimitives()
                                 .WithPriority(task_priority_)
                                 .WithShutdownBehavior(task_shutdown_behavior);
   return GetTaskSchedulerTaskRunner(sequenced.sequence_token_id, traits)
       ->PostDelayedTask(sequenced.posted_from, sequenced.task, delay);
 }
 
 scoped_refptr<TaskRunner>
 SequencedWorkerPool::Inner::GetTaskSchedulerTaskRunner(
     int sequence_token_id,
     const TaskTraits& traits) {
@@ skipping 30 matching lines @@
   }
 
   return task_runner;
 }
 
 bool SequencedWorkerPool::Inner::RunsTasksOnCurrentThread() const {
   AutoLock lock(lock_);
   if (g_all_pools_state == AllPoolsState::REDIRECTED_TO_TASK_SCHEDULER) {
     if (!runs_tasks_on_verifier_) {
       runs_tasks_on_verifier_ = CreateTaskRunnerWithTraits(
-          TaskTraits().WithFileIO().WithWait().WithPriority(task_priority_));
+          TaskTraits().MayBlock().WithSyncPrimitives().WithPriority(
+              task_priority_));
     }
     return runs_tasks_on_verifier_->RunsTasksOnCurrentThread();
   } else {
     return ContainsKey(threads_, PlatformThread::CurrentId());
   }
 }
 
 bool SequencedWorkerPool::Inner::IsRunningSequenceOnCurrentThread(
     SequenceToken sequence_token) const {
   DCHECK(sequence_token.IsValid());
@@ skipping 726 matching lines @@
 bool SequencedWorkerPool::IsShutdownInProgress() {
   return inner_->IsShutdownInProgress();
 }
 
 bool SequencedWorkerPool::IsRunningSequenceOnCurrentThread(
     SequenceToken sequence_token) const {
   return inner_->IsRunningSequenceOnCurrentThread(sequence_token);
 }
 
 }  // namespace base