TaskScheduler: Match behavior of SequencedWorkerPool in RunsTasksOnCurrentThread().

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 309 matching lines @@
 
   // Fast-forward time and post tasks that are ripe for execution.
   delayed_task_manager_.SetCurrentTime(
       delayed_task_manager_.GetDelayedRunTime());
   delayed_task_manager_.PostReadyTasks();
 
   // The task should run.
   task_ran.Wait();
 }
 
+// Verify that the RunsTasksOnCurrentThread() method of a SEQUENCED TaskRunner
+// returns false when called from a task that isn't part of the sequence.
+TEST_P(TaskSchedulerWorkerPoolImplTest, SequencedRunsTasksOnCurrentThread) {
+  scoped_refptr<TaskRunner> task_runner(
+      worker_pool_->CreateTaskRunnerWithTraits(TaskTraits(), GetParam()));
+  scoped_refptr<TaskRunner> sequenced_task_runner(
+      worker_pool_->CreateTaskRunnerWithTraits(TaskTraits(),
+                                               ExecutionMode::SEQUENCED));
+
+  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());

[robliao, 2016/09/14 15:50:27]

We only ever check for false for RunsTasksOnCurrentThread. Let's add a true
check as well.

[fdoray, 2016/09/14 16:56:44]

This is already tested by
https://cs.chromium.org/chromium/src/base/task_scheduler/test_task_factory.cc...
EXPECT_TRUE(task_runner_->RunsTasksOnCurrentThread());

(Many TaskSchedulerWorkerPoolImplTest use TestTaskFactory)

[robliao, 2016/09/14 17:20:42]

Gotcha. Let's add a quick comment about that here since we explicitly test for
false here.

[fdoray, 2016/09/15 12:19:01]

Done. Added comment about TestTaskFactory in this test.

+            task_ran->Signal();
+          },
+          sequenced_task_runner, Unretained(&task_ran)));
+  task_ran.Wait();
+}
+
 INSTANTIATE_TEST_CASE_P(Parallel,
                         TaskSchedulerWorkerPoolImplTest,
                         ::testing::Values(ExecutionMode::PARALLEL));
 INSTANTIATE_TEST_CASE_P(Sequenced,
                         TaskSchedulerWorkerPoolImplTest,
                         ::testing::Values(ExecutionMode::SEQUENCED));
 INSTANTIATE_TEST_CASE_P(SingleThreaded,
                         TaskSchedulerWorkerPoolImplTest,
                         ::testing::Values(ExecutionMode::SINGLE_THREADED));
 
@@ skipping 208 matching lines @@
     count_waiter->Wait();
 
   EXPECT_GT(subtle::NoBarrier_Load(&zero_tls_values_), 0);
 
   // Release tasks waiting on |waiter_|.
   waiter_.Signal();
 }
 
 }  // namespace internal
 }  // namespace base