Allow SequencedTaskRunnerHandle::Get() while running unsequenced tasks.

base/threading/sequenced_worker_pool_unittest.cc

Index: base/threading/sequenced_worker_pool_unittest.cc
diff --git a/base/threading/sequenced_worker_pool_unittest.cc b/base/threading/sequenced_worker_pool_unittest.cc
index 5812ee75ac5f84df1fc7df48d107b1a1c69d84e8..6ce593127ae2e57bc86e7d0fad9ecb552e37a23a 100644
--- a/base/threading/sequenced_worker_pool_unittest.cc
+++ b/base/threading/sequenced_worker_pool_unittest.cc
@@ -904,47 +904,55 @@ TEST_F(SequencedWorkerPoolTest, FlushForTesting) {
   pool()->FlushForTesting();
 }
 
-namespace {
+// Helper method for VerifyCurrentSequencedTaskRunner().
+void VerifySequencedTaskRunnerRunsOnCurrentThread(
+    const scoped_refptr<SequencedTaskRunner>& task_runner) {
+  EXPECT_TRUE(task_runner->RunsTasksOnCurrentThread());
+}
 
-void CheckWorkerPoolAndSequenceToken(
-    const scoped_refptr<SequencedWorkerPool>& expected_pool,
-    SequencedWorkerPool::SequenceToken expected_token) {
-  SequencedWorkerPool::SequenceToken token =
-      SequencedWorkerPool::GetSequenceTokenForCurrentThread();
-  EXPECT_EQ(expected_token.ToString(), token.ToString());
+void VerifyCurrentSequencedTaskRunner(
+    scoped_refptr<SequencedTaskRunner> expected_task_runner) {
+  scoped_refptr<SequencedTaskRunner> task_runner =
+      SequencedWorkerPool::GetSequencedTaskRunnerForCurrentThread();
 
-  scoped_refptr<SequencedWorkerPool> pool =
-      SequencedWorkerPool::GetWorkerPoolForCurrentThread();
-  EXPECT_EQ(expected_pool, pool);
-}
+  // If the expected task runner is null, get another one for the current
+  // thread. They should be the same.
+  if (!expected_task_runner) {
+    expected_task_runner =
+        SequencedWorkerPool::GetSequencedTaskRunnerForCurrentThread();
+  }
 
-}  // namespace
+  // SequencedTaskRunner does not allow directly checking for equality, but we
+  // can post a task to one task runner and verify that the other task runner
+  // is on the same sequence.
+  task_runner->PostTask(
+      FROM_HERE, base::Bind(&VerifySequencedTaskRunnerRunsOnCurrentThread,
+                            expected_task_runner));
+}
 
-TEST_F(SequencedWorkerPoolTest, GetWorkerPoolAndSequenceTokenForCurrentThread) {
+TEST_F(SequencedWorkerPoolTest, GetSequencedTaskRunnerForCurrentThread) {
   EnsureAllWorkersCreated();
 
-  // The current thread should have neither a worker pool nor a sequence token.
-  SequencedWorkerPool::SequenceToken local_token =
-      SequencedWorkerPool::GetSequenceTokenForCurrentThread();
-  scoped_refptr<SequencedWorkerPool> local_pool =
-      SequencedWorkerPool::GetWorkerPoolForCurrentThread();
-  EXPECT_FALSE(local_token.IsValid()) << local_token.ToString();
-  EXPECT_FALSE(local_pool);
+  // The current thread should not have a sequenced task runner from a
+  // worker pool.
+  scoped_refptr<SequencedTaskRunner> local_task_runner =
+      SequencedWorkerPool::GetSequencedTaskRunnerForCurrentThread();
+  EXPECT_FALSE(local_task_runner);
+
+  scoped_refptr<SequencedTaskRunner> task_runner_1 =
+      pool()->GetSequencedTaskRunner(SequencedWorkerPool::GetSequenceToken());
+  scoped_refptr<SequencedTaskRunner> task_runner_2 =
+      pool()->GetSequencedTaskRunner(SequencedWorkerPool::GetSequenceToken());
+  task_runner_1->PostTask(
+      FROM_HERE, base::Bind(&VerifyCurrentSequencedTaskRunner, task_runner_1));
+  task_runner_2->PostTask(
+      FROM_HERE, base::Bind(&VerifyCurrentSequencedTaskRunner, task_runner_2));

[gab, 2015/11/12 01:33:56]

Would be nice to also verify inequality (i.e. task_runner_1 vs task_runner_2)?

[Bernhard Bauer, 2015/11/12 02:23:39]

Done.

 
-  SequencedWorkerPool::SequenceToken token1 = pool()->GetSequenceToken();
-  SequencedWorkerPool::SequenceToken token2 = pool()->GetSequenceToken();
-  pool()->PostSequencedWorkerTask(
-      token1, FROM_HERE,
-      base::Bind(&CheckWorkerPoolAndSequenceToken, pool(), token1));
-  pool()->PostSequencedWorkerTask(
-      token2, FROM_HERE,
-      base::Bind(&CheckWorkerPoolAndSequenceToken, pool(), token2));
-
-  pool()->PostWorkerTask(FROM_HERE,
-                         base::Bind(&CheckWorkerPoolAndSequenceToken, pool(),
-                                    SequencedWorkerPool::SequenceToken()));
+  pool()->PostWorkerTask(
+      FROM_HERE, base::Bind(&VerifyCurrentSequencedTaskRunner, nullptr));
 
   pool()->FlushForTesting();

[gab, 2015/11/12 01:33:56]

This seems risky as if the PostTask on 928 posts to an incorrect sequence
somehow (i.e. not on this pool()) then the test would finish without catching
this.

Feels some kind of WaitableEvent like in your other test would preferable to
confirm that the post chain is truly complete.

[Bernhard Bauer, 2015/11/12 02:23:39]

Done.

+  pool()->Shutdown();
 }
 
 TEST(SequencedWorkerPoolRefPtrTest, ShutsDownCleanWithContinueOnShutdown) {