Add TaskTraits::MayBlock and TaskTraits::WithSyncPrimitives.

base/task_scheduler/task_tracker.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 <limits>
 
 #include "base/callback.h"
 #include "base/debug/task_annotator.h"
@@ skipping 207 matching lines @@
       task->traits.shutdown_behavior();
   const bool can_run_task = BeforeRunTask(shutdown_behavior);
   const bool is_delayed = !task->delayed_run_time.is_null();
 
   if (can_run_task) {
     const bool previous_singleton_allowed =
         ThreadRestrictions::SetSingletonAllowed(
             task->traits.shutdown_behavior() !=
             TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN);
     const bool previous_io_allowed =
-        ThreadRestrictions::SetIOAllowed(task->traits.with_file_io());
+        ThreadRestrictions::SetIOAllowed(task->traits.may_block());
     const bool previous_wait_allowed =

[robliao, 2016/12/19 22:04:56]

Rename this while we're here.

[fdoray, 2016/12/20 13:32:24]

This variable still contains the previous value of the "wait allowed" thread
restriction. I plan to rename ThreadRestrictions::SetWaitAllowed and this
variable in a separate CL.

-        ThreadRestrictions::SetWaitAllowed(task->traits.with_wait());
+        ThreadRestrictions::SetWaitAllowed(task->traits.with_sync_primitives());
 
     {
       ScopedSetSequenceTokenForCurrentThread
           scoped_set_sequence_token_for_current_thread(sequence_token);
       ScopedSetTaskPriorityForCurrentThread
           scoped_set_task_priority_for_current_thread(task->traits.priority());
 
       // Set up TaskRunnerHandle as expected for the scope of the task.
       std::unique_ptr<SequencedTaskRunnerHandle> sequenced_task_runner_handle;
       std::unique_ptr<ThreadTaskRunnerHandle> single_thread_task_runner_handle;
@@ skipping 209 matching lines @@
       subtle::NoBarrier_AtomicIncrement(&num_pending_undelayed_tasks_, -1);
   DCHECK_GE(new_num_pending_undelayed_tasks, 0);
   if (new_num_pending_undelayed_tasks == 0) {
     AutoSchedulerLock auto_lock(flush_lock_);
     flush_cv_->Signal();
   }
 }
 
 }  // namespace internal
 }  // namespace base