TaskScheduler: Set the IO allowed bit in TaskTracker::RunTask().

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 201 matching lines @@
                           const SequenceToken& sequence_token) {
   DCHECK(task);
   DCHECK(sequence_token.IsValid());
 
   const TaskShutdownBehavior shutdown_behavior =
       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) {
-    // All tasks run through here and the scheduler itself doesn't use
-    // singletons. Therefore, it isn't necessary to reset the singleton allowed
-    // bit after running the task.
-    ThreadRestrictions::SetSingletonAllowed(
-        task->traits.shutdown_behavior() !=
-        TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN);
+    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());
 
     {
       // Set up SequenceToken as expected for the scope of the task.
       ScopedSetSequenceTokenForCurrentThread
           scoped_set_sequence_token_for_current_thread(sequence_token);
 
       // 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;
       DCHECK(!task->sequenced_task_runner_ref ||
@@ skipping 16 matching lines @@
       // TODO(gab): In a better world this would be tacked on as an extra arg
       // to the trace event generated above. This is not possible however until
       // http://crbug.com/652692 is resolved.
       TRACE_EVENT1("task_scheduler", "TaskTracker::RunTask", "task_info",
                    MakeUnique<TaskTracingInfo>(task->traits, execution_mode,
                                                sequence_token));
 
       PerformRunTask(std::move(task));
     }
 
+    ThreadRestrictions::SetSingletonAllowed(previous_singleton_allowed);

[robliao, 2016/11/28 22:17:41]

I presume this will change with the other CL that touches this?

[fdoray, 2016/11/28 22:36:15]

Done. Reordered in this CL.

+    ThreadRestrictions::SetIOAllowed(previous_io_allowed);
+
     AfterRunTask(shutdown_behavior);
   }
 
   if (!is_delayed)
     DecrementNumPendingUndelayedTasks();
 
   return can_run_task;
 }
 
 bool TaskTracker::HasShutdownStarted() const {
@@ skipping 168 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