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

base/task_scheduler/scheduler_worker_pool_impl_unittest.cc

Index: base/task_scheduler/scheduler_worker_pool_impl_unittest.cc
diff --git a/base/task_scheduler/scheduler_worker_pool_impl_unittest.cc b/base/task_scheduler/scheduler_worker_pool_impl_unittest.cc
index 9983cad5c166bb1f11ff5e79d7a1c0802482812c..ade99044ea085e0ebfd54793f792cde0249c37e2 100644
--- a/base/task_scheduler/scheduler_worker_pool_impl_unittest.cc
+++ b/base/task_scheduler/scheduler_worker_pool_impl_unittest.cc
@@ -58,7 +58,6 @@ constexpr TimeDelta kReclaimTimeForDetachTests =
 constexpr TimeDelta kExtraTimeToWaitForDetach =
     TimeDelta::FromSeconds(1);
 
-using IORestriction = SchedulerWorkerPoolParams::IORestriction;
 using StandbyThreadPolicy = SchedulerWorkerPoolParams::StandbyThreadPolicy;
 
 class TaskSchedulerWorkerPoolImplTest
@@ -85,9 +84,9 @@ class TaskSchedulerWorkerPoolImplTest
     delayed_task_manager_ =
         base::MakeUnique<DelayedTaskManager>(service_thread_.task_runner());
     worker_pool_ = SchedulerWorkerPoolImpl::Create(
-        SchedulerWorkerPoolParams(
-            "TestWorkerPool", ThreadPriority::NORMAL, IORestriction::ALLOWED,
-            StandbyThreadPolicy::LAZY, num_workers, suggested_reclaim_time),
+        SchedulerWorkerPoolParams("TestWorkerPool", ThreadPriority::NORMAL,
+                                  StandbyThreadPolicy::LAZY, num_workers,
+                                  suggested_reclaim_time),
         Bind(&TaskSchedulerWorkerPoolImplTest::ReEnqueueSequenceCallback,
              Unretained(this)),
         &task_tracker_, delayed_task_manager_.get());
@@ -438,67 +437,6 @@ INSTANTIATE_TEST_CASE_P(
 
 namespace {
 
-void NotReachedReEnqueueSequenceCallback(scoped_refptr<Sequence> sequence) {
-  ADD_FAILURE()
-      << "Unexpected invocation of NotReachedReEnqueueSequenceCallback.";
-}
-
-// Verifies that the current thread allows I/O if |io_restriction| is ALLOWED
-// and disallows it otherwise. Signals |event| before returning.
-void ExpectIORestriction(IORestriction io_restriction, WaitableEvent* event) {
-  DCHECK(event);
-
-  if (io_restriction == IORestriction::ALLOWED) {
-    ThreadRestrictions::AssertIOAllowed();
-  } else {
-    EXPECT_DCHECK_DEATH({ ThreadRestrictions::AssertIOAllowed(); });
-  }
-
-  event->Signal();
-}
-
-class TaskSchedulerWorkerPoolImplIORestrictionTest
-    : public testing::TestWithParam<IORestriction> {
- public:
-  TaskSchedulerWorkerPoolImplIORestrictionTest() = default;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolImplIORestrictionTest);
-};
-
-}  // namespace
-
-TEST_P(TaskSchedulerWorkerPoolImplIORestrictionTest, IORestriction) {
-  TaskTracker task_tracker;
-  DelayedTaskManager delayed_task_manager(
-      make_scoped_refptr(new TestSimpleTaskRunner));
-
-  auto worker_pool = SchedulerWorkerPoolImpl::Create(
-      SchedulerWorkerPoolParams(
-          "TestWorkerPoolWithParam", ThreadPriority::NORMAL, GetParam(),
-          StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max()),
-      Bind(&NotReachedReEnqueueSequenceCallback), &task_tracker,
-      &delayed_task_manager);
-  ASSERT_TRUE(worker_pool);
-
-  WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
-                         WaitableEvent::InitialState::NOT_SIGNALED);
-  worker_pool->CreateTaskRunnerWithTraits(TaskTraits())
-      ->PostTask(FROM_HERE, Bind(&ExpectIORestriction, GetParam(), &task_ran));
-  task_ran.Wait();
-
-  worker_pool->JoinForTesting();
-}
-
-INSTANTIATE_TEST_CASE_P(IOAllowed,
-                        TaskSchedulerWorkerPoolImplIORestrictionTest,
-                        ::testing::Values(IORestriction::ALLOWED));
-INSTANTIATE_TEST_CASE_P(IODisallowed,
-                        TaskSchedulerWorkerPoolImplIORestrictionTest,
-                        ::testing::Values(IORestriction::DISALLOWED));
-
-namespace {
-
 class TaskSchedulerWorkerPoolSingleThreadedTest
     : public TaskSchedulerWorkerPoolImplTest {
  public:
@@ -779,6 +717,11 @@ TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBetweenWaitsWithDetach) {
 
 namespace {
 
+void NotReachedReEnqueueSequenceCallback(scoped_refptr<Sequence> sequence) {
+  ADD_FAILURE()
+      << "Unexpected invocation of NotReachedReEnqueueSequenceCallback.";
+}
+
 void CaptureThreadId(PlatformThreadId* thread_id) {
   ASSERT_TRUE(thread_id);
   *thread_id = PlatformThread::CurrentId();
@@ -832,7 +775,6 @@ TEST(TaskSchedulerWorkerPoolStandbyPolicyTest, InitLazy) {
       make_scoped_refptr(new TestSimpleTaskRunner));
   auto worker_pool = SchedulerWorkerPoolImpl::Create(
       SchedulerWorkerPoolParams("LazyPolicyWorkerPool", ThreadPriority::NORMAL,
-                                IORestriction::DISALLOWED,
                                 StandbyThreadPolicy::LAZY, 8U,
                                 TimeDelta::Max()),
       Bind(&NotReachedReEnqueueSequenceCallback), &task_tracker,
@@ -848,7 +790,6 @@ TEST(TaskSchedulerWorkerPoolStandbyPolicyTest, InitOne) {
       make_scoped_refptr(new TestSimpleTaskRunner));
   auto worker_pool = SchedulerWorkerPoolImpl::Create(
       SchedulerWorkerPoolParams("LazyPolicyWorkerPool", ThreadPriority::NORMAL,
-                                IORestriction::DISALLOWED,
                                 StandbyThreadPolicy::ONE, 8U, TimeDelta::Max()),
       Bind(&NotReachedReEnqueueSequenceCallback), &task_tracker,
       &delayed_task_manager);