Run ScopedTaskScheduler tasks synchronously.

base/test/scoped_task_scheduler_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/test/scoped_task_scheduler.h"
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/run_loop.h"
+#include "base/sequence_checker.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/task_scheduler/test_utils.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "base/threading/thread_checker.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+namespace test {
+
+namespace {
+
+class ScopedTaskSchedulerTest : public testing::Test {
+ public:
+  ScopedTaskSchedulerTest() {
+    sequence_checker_.DetachFromSequence();
+    thread_checker_.DetachFromThread();

[gab, 2016/12/08 20:15:45]

Why detach?

[fdoray, 2016/12/09 16:26:42]

Added comment.

+  }
+
+  SequenceCheckerImpl sequence_checker_;
+  ThreadCheckerImpl thread_checker_;

[gab, 2016/12/08 20:15:45]

If all you need is these two members and they're used in 2/3 tests, feels like
you can inline them in tests that need them and do without the fixture?

[fdoray, 2016/12/09 16:26:42]

Done.

+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ScopedTaskSchedulerTest);
+};
+
+}  // namespace
+
+TEST_F(ScopedTaskSchedulerTest, PostTask) {
+  ScopedTaskScheduler scoped_task_scheduler;
+  bool first_task_ran = false;
+  bool second_task_ran = false;
+
+  PostTask(FROM_HERE,
+           Bind(
+               [](ScopedTaskSchedulerTest* test, bool* first_task_ran) {
+                 EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
+                 EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
+                 EXPECT_TRUE(test->sequence_checker_.CalledOnValidSequence());
+                 EXPECT_TRUE(test->thread_checker_.CalledOnValidThread());
+                 *first_task_ran = true;
+               },
+               Unretained(this), Unretained(&first_task_ran)));
+
+  PostTask(FROM_HERE,
+           Bind(
+               [](ScopedTaskSchedulerTest* test, bool* second_task_ran) {
+                 EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
+                 EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
+                 EXPECT_FALSE(test->sequence_checker_.CalledOnValidSequence());
+                 EXPECT_FALSE(test->thread_checker_.CalledOnValidThread());
+                 *second_task_ran = true;
+               },
+               Unretained(this), Unretained(&second_task_ran)));
+
+  RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(first_task_ran);
+  EXPECT_TRUE(second_task_ran);
+}
+
+TEST_F(ScopedTaskSchedulerTest, CreateTaskRunnerAndPostTask) {
+  ScopedTaskScheduler scoped_task_scheduler;
+  auto task_runner = CreateTaskRunnerWithTraits(TaskTraits());
+  bool first_task_ran = false;
+  bool second_task_ran = false;
+
+  task_runner->PostTask(
+      FROM_HERE,
+      Bind(
+          [](ScopedTaskSchedulerTest* test, bool* first_task_ran) {
+            EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
+            EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
+            EXPECT_TRUE(test->sequence_checker_.CalledOnValidSequence());
+            EXPECT_TRUE(test->thread_checker_.CalledOnValidThread());
+            *first_task_ran = true;
+          },
+          Unretained(this), Unretained(&first_task_ran)));
+
+  task_runner->PostTask(
+      FROM_HERE,
+      Bind(
+          [](ScopedTaskSchedulerTest* test, bool* second_task_ran) {
+            EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
+            EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
+            EXPECT_FALSE(test->sequence_checker_.CalledOnValidSequence());
+            EXPECT_FALSE(test->thread_checker_.CalledOnValidThread());
+            *second_task_ran = true;
+          },
+          Unretained(this), Unretained(&second_task_ran)));
+
+  RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(first_task_ran);
+  EXPECT_TRUE(second_task_ran);
+}
+
+TEST_F(ScopedTaskSchedulerTest, CreateSequencedTaskRunnerAndPostTask) {
+  ScopedTaskScheduler scoped_task_scheduler;
+  auto task_runner = CreateSequencedTaskRunnerWithTraits(TaskTraits());
+  bool first_task_ran = false;
+  bool second_task_ran = false;
+
+  task_runner->PostTask(
+      FROM_HERE,
+      Bind(
+          [](ScopedTaskSchedulerTest* test, bool* first_task_ran) {
+            EXPECT_TRUE(SequencedTaskRunnerHandle::IsSet());
+            EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
+            EXPECT_TRUE(test->sequence_checker_.CalledOnValidSequence());
+            EXPECT_TRUE(test->thread_checker_.CalledOnValidThread());
+            *first_task_ran = true;
+          },
+          Unretained(this), Unretained(&first_task_ran)));
+
+  task_runner->PostTask(
+      FROM_HERE,
+      Bind(
+          [](ScopedTaskSchedulerTest* test, bool* second_task_ran) {
+            EXPECT_TRUE(SequencedTaskRunnerHandle::IsSet());
+            EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
+            EXPECT_TRUE(test->sequence_checker_.CalledOnValidSequence());
+            EXPECT_FALSE(test->thread_checker_.CalledOnValidThread());
+            *second_task_ran = true;
+          },
+          Unretained(this), Unretained(&second_task_ran)));
+
+  RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(first_task_ran);
+  EXPECT_TRUE(second_task_ran);
+}
+
+TEST_F(ScopedTaskSchedulerTest, CreateSingleThreadTaskRunnerAndPostTask) {
+  ScopedTaskScheduler scoped_task_scheduler;
+  auto task_runner = CreateSingleThreadTaskRunnerWithTraits(TaskTraits());
+  bool first_task_ran = false;
+  bool second_task_ran = false;
+
+  task_runner->PostTask(
+      FROM_HERE,
+      Bind(
+          [](ScopedTaskSchedulerTest* test, bool* first_task_ran) {
+            EXPECT_TRUE(SequencedTaskRunnerHandle::IsSet());
+            EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
+            EXPECT_TRUE(test->sequence_checker_.CalledOnValidSequence());
+            EXPECT_TRUE(test->thread_checker_.CalledOnValidThread());
+            *first_task_ran = true;
+          },
+          Unretained(this), Unretained(&first_task_ran)));
+
+  task_runner->PostTask(
+      FROM_HERE,
+      Bind(
+          [](ScopedTaskSchedulerTest* test, bool* second_task_ran) {
+            EXPECT_TRUE(SequencedTaskRunnerHandle::IsSet());
+            EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
+            EXPECT_TRUE(test->sequence_checker_.CalledOnValidSequence());
+            EXPECT_TRUE(test->thread_checker_.CalledOnValidThread());
+            *second_task_ran = true;
+          },
+          Unretained(this), Unretained(&second_task_ran)));
+
+  RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(first_task_ran);
+  EXPECT_TRUE(second_task_ran);
+}
+
+TEST_F(ScopedTaskSchedulerTest, ShutdownBehavior) {
+  bool block_shutdown_task_ran = false;
+  {
+    ScopedTaskScheduler scoped_task_scheduler;
+    PostTaskWithTraits(
+        FROM_HERE, TaskTraits().WithShutdownBehavior(
+                       TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
+        Bind([]() {
+          ADD_FAILURE() << "CONTINUE_ON_SHUTDOWN task should not run";
+        }));
+    PostTaskWithTraits(FROM_HERE, TaskTraits().WithShutdownBehavior(
+                                      TaskShutdownBehavior::SKIP_ON_SHUTDOWN),
+                       Bind([]() {
+                         ADD_FAILURE()
+                             << "SKIP_ON_SHUTDOWN task should not run";
+                       }));
+    PostTaskWithTraits(FROM_HERE, TaskTraits().WithShutdownBehavior(
+                                      TaskShutdownBehavior::BLOCK_SHUTDOWN),
+                       Bind(
+                           [](bool* block_shutdown_task_ran) {
+                             *block_shutdown_task_ran = true;
+                           },
+                           Unretained(&block_shutdown_task_ran)));
+  }
+  EXPECT_TRUE(block_shutdown_task_ran);
+}
+
+}  // namespace test
+}  // namespace base