Introduce TaskRunnerHandle.

base/threading/task_runner_handle_unittest.cc

+// Copyright 2015 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/threading/task_runner_handle.h"
+
+#include "base/memory/ref_counted.h"
+#include "base/sequenced_task_runner.h"
+#include "base/single_thread_task_runner.h"
+#include "base/task_runner.h"
+#include "base/test/test_simple_task_runner.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+
+TEST(TaskRunnerHandleTest, TaskScope) {
+  scoped_refptr<TaskRunner> test_task_runner(new TestSimpleTaskRunner);
+  EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());
+  {
+    TaskRunnerHandle::TaskScope task_scope(test_task_runner);
+
+    EXPECT_TRUE(TaskRunnerHandle::HasTaskScope());
+    EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());
+    EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());
+
+    EXPECT_EQ(test_task_runner, TaskRunnerHandle::Get());
+  }
+  EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());
+}
+
+TEST(TaskRunnerHandleTest, SequencedTaskScope) {
+  scoped_refptr<SequencedTaskRunner> test_task_runner(new TestSimpleTaskRunner);
+  EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());
+  {
+    TaskRunnerHandle::SequencedTaskScope task_scope(test_task_runner);
+
+    EXPECT_TRUE(TaskRunnerHandle::HasTaskScope());
+    EXPECT_TRUE(TaskRunnerHandle::HasSequencedTaskScope());
+    EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());
+
+    EXPECT_EQ(test_task_runner, TaskRunnerHandle::Get());
+    EXPECT_EQ(test_task_runner, TaskRunnerHandle::GetSequenced());
+  }
+  EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());
+}
+
+TEST(TaskRunnerHandleTest, SingleThreadTaskScope) {
+  scoped_refptr<SingleThreadTaskRunner> test_task_runner(
+      new TestSimpleTaskRunner);
+  EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());
+  {
+    TaskRunnerHandle::SingleThreadTaskScope task_scope(test_task_runner);
+
+    EXPECT_TRUE(TaskRunnerHandle::HasTaskScope());
+    EXPECT_TRUE(TaskRunnerHandle::HasSequencedTaskScope());
+    EXPECT_TRUE(TaskRunnerHandle::HasSingleThreadTaskScope());
+
+    EXPECT_EQ(test_task_runner, TaskRunnerHandle::Get());
+    EXPECT_EQ(test_task_runner, TaskRunnerHandle::GetSequenced());
+    EXPECT_EQ(test_task_runner, TaskRunnerHandle::GetSingleThreaded());
+  }
+  EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());
+}
+
+TEST(TaskRunnerHandleTest, SequencedTaskRunnerHandleSupport) {
+  scoped_refptr<SequencedTaskRunner> test_task_runner(new TestSimpleTaskRunner);
+  EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());
+  {
+    SequencedTaskRunnerHandle handle(test_task_runner);
+
+    EXPECT_TRUE(TaskRunnerHandle::HasTaskScope());
+    EXPECT_TRUE(TaskRunnerHandle::HasSequencedTaskScope());
+    EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());
+
+    EXPECT_EQ(test_task_runner, TaskRunnerHandle::Get());
+    EXPECT_EQ(test_task_runner, TaskRunnerHandle::GetSequenced());
+  }
+  EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());
+}
+
+TEST(TaskRunnerHandleTest, ThreadTaskRunnerHandleSupport) {
+  scoped_refptr<SingleThreadTaskRunner> test_task_runner(
+      new TestSimpleTaskRunner);
+  EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());
+  {
+    ThreadTaskRunnerHandle handle(test_task_runner);
+
+    EXPECT_TRUE(TaskRunnerHandle::HasTaskScope());
+    EXPECT_TRUE(TaskRunnerHandle::HasSequencedTaskScope());
+    EXPECT_TRUE(TaskRunnerHandle::HasSingleThreadTaskScope());
+
+    EXPECT_EQ(test_task_runner, TaskRunnerHandle::Get());
+    EXPECT_EQ(test_task_runner, TaskRunnerHandle::GetSequenced());
+    EXPECT_EQ(test_task_runner, TaskRunnerHandle::GetSingleThreaded());
+  }
+  EXPECT_FALSE(TaskRunnerHandle::HasTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSequencedTaskScope());
+  EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());
+}

[fdoray, 2016/06/17 14:29:02]

Maybe instantiate a SequencedWorkerPool?

void TestTask() {
  EXPECT_TRUE(TaskRunnerHandle::HasTaskScope());
  EXPECT_TRUE(TaskRunnerHandle::HasSequencedTaskScope());
  EXPECT_FALSE(TaskRunnerHandle::HasSingleThreadTaskScope());

  EXPECT_TRUE(!!TaskRunnerHandle::Get());
  EXPECT_TRUE(!!TaskRunnerHandle::GetSequenced());
}

scoped_refptr<SequencedWorkerPool> sequenced_worker_pool(new
SequencedWorkerPool(1, "name"));
sequenced_worker_pool->PostTask(FROM_HERE, Bind(&TestTask));
sequenced_worker_pool->FlushForTesting();

[gab, 2016/06/20 19:55:36]

This is already tested by SequencedTaskRunnerHandle's unittests (which now use
this code by redirection). Those will be migrated here when it's removed.

+
+}  // namespace base