Make SchedulerSingleThreadTaskRunner::RunsTasksOnCurrentThread sequence-affine.

base/task_scheduler/scheduler_worker_pool_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/scheduler_worker_pool_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <unordered_set>
@@ skipping 323 matching lines @@
 
   // Expect the task to run after its delay expires, but not more than 250 ms
   // after that.
   const TimeDelta actual_delay = TimeTicks::Now() - start_time;
   EXPECT_GE(actual_delay, TestTimeouts::tiny_timeout());
   EXPECT_LT(actual_delay,
             TimeDelta::FromMilliseconds(250) + TestTimeouts::tiny_timeout());
 }
 
 // Verify that the RunsTasksOnCurrentThread() method of a SEQUENCED TaskRunner
-// returns false when called from a task that isn't part of the sequence.
+// returns false when called from a task that isn't part of the sequence. Note:
+// Tests that use TestTaskFactory already verify that RunsTasksOnCurrentThread()
+// returns true when appropriate so this method complements it to get full
+// coverage of that method.
 TEST_P(TaskSchedulerWorkerPoolImplTest, SequencedRunsTasksOnCurrentThread) {
   scoped_refptr<TaskRunner> task_runner(
       CreateTaskRunnerWithExecutionMode(worker_pool_.get(), GetParam()));
   scoped_refptr<SequencedTaskRunner> sequenced_task_runner(
       worker_pool_->CreateSequencedTaskRunnerWithTraits(TaskTraits()));
 
   WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
                          WaitableEvent::InitialState::NOT_SIGNALED);
   task_runner->PostTask(
       FROM_HERE,
       Bind(
           [](scoped_refptr<TaskRunner> sequenced_task_runner,
              WaitableEvent* task_ran) {
             EXPECT_FALSE(sequenced_task_runner->RunsTasksOnCurrentThread());
-            // Tests that use TestTaskFactory already verify that
-            // RunsTasksOnCurrentThread() returns true when appropriate.
             task_ran->Signal();
           },
           sequenced_task_runner, Unretained(&task_ran)));
   task_ran.Wait();
 }
 
 INSTANTIATE_TEST_CASE_P(Parallel,
                         TaskSchedulerWorkerPoolImplTest,
                         ::testing::Values(test::ExecutionMode::PARALLEL));
 INSTANTIATE_TEST_CASE_P(Sequenced,
                         TaskSchedulerWorkerPoolImplTest,
                         ::testing::Values(test::ExecutionMode::SEQUENCED));
 INSTANTIATE_TEST_CASE_P(
     SingleThreaded,
     TaskSchedulerWorkerPoolImplTest,
     ::testing::Values(test::ExecutionMode::SINGLE_THREADED));
 
 namespace {
 
+// Same as TaskSchedulerWorkerPoolImplTest but its SchedulerWorkerPoolImpl
+// instance uses |max_threads == 1|.
+class TaskSchedulerWorkerPoolImplSingleWorkerTest
+    : public TaskSchedulerWorkerPoolImplTest {
+ public:
+  TaskSchedulerWorkerPoolImplSingleWorkerTest() = default;
+
+ protected:
+  void SetUp() override {
+    InitializeWorkerPool(TimeDelta::Max(), 1);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolImplSingleWorkerTest);
+};
+
+}  // namespace
+
+// Verify that the RunsTasksOnCurrentThread() method of a
+// SchedulerSingleThreadTaskRunner returns false when called from a task that
+// isn't part of its sequence even though it's running on that
+// SchedulerSingleThreadTaskRunner's assigned worker. Note: Tests that use
+// TestTaskFactory already verify that RunsTasksOnCurrentThread() returns true
+// when appropriate so this method complements it to get full coverage of that
+// method.
+TEST_P(TaskSchedulerWorkerPoolImplSingleWorkerTest,
+       SingleThreadRunsTasksOnCurrentThread) {
+  scoped_refptr<TaskRunner> task_runner(
+      CreateTaskRunnerWithExecutionMode(worker_pool_.get(), GetParam()));
+  scoped_refptr<SingleThreadTaskRunner> single_thread_task_runner(
+      worker_pool_->CreateSingleThreadTaskRunnerWithTraits(TaskTraits()));
+
+  WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
+                         WaitableEvent::InitialState::NOT_SIGNALED);
+  task_runner->PostTask(
+      FROM_HERE,
+      Bind(
+          [](scoped_refptr<TaskRunner> single_thread_task_runner,
+             WaitableEvent* task_ran) {
+            EXPECT_FALSE(single_thread_task_runner->RunsTasksOnCurrentThread());
+            task_ran->Signal();
+          },
+          single_thread_task_runner, Unretained(&task_ran)));
+  task_ran.Wait();
+}
+
+INSTANTIATE_TEST_CASE_P(Parallel,
+                        TaskSchedulerWorkerPoolImplSingleWorkerTest,
+                        ::testing::Values(test::ExecutionMode::PARALLEL));
+INSTANTIATE_TEST_CASE_P(Sequenced,
+                        TaskSchedulerWorkerPoolImplSingleWorkerTest,
+                        ::testing::Values(test::ExecutionMode::SEQUENCED));
+INSTANTIATE_TEST_CASE_P(
+    SingleThreaded,
+    TaskSchedulerWorkerPoolImplSingleWorkerTest,
+    ::testing::Values(test::ExecutionMode::SINGLE_THREADED));
+
+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);
 
@@ skipping 370 matching lines @@
 
   // Verify that counts were recorded to the histogram as expected.
   const auto* histogram = worker_pool_->num_tasks_before_detach_histogram();
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(0));
   EXPECT_EQ(1, histogram->SnapshotSamples()->GetCount(3));
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(10));
 }
 
 }  // namespace internal
 }  // namespace base