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

base/threading/sequenced_worker_pool_unittest.cc

 // Copyright (c) 2012 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/sequenced_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 886 matching lines @@
   // Should be fine to call on an idle instance with all threads created, and
   // spamming the method shouldn't deadlock or confuse the class.
   pool()->FlushForTesting();
   pool()->FlushForTesting();
 
   // Should be fine to call after shutdown too.
   pool()->Shutdown();
   pool()->FlushForTesting();
 }
 
-namespace {
-
-void CheckWorkerPoolAndSequenceToken(
-    const scoped_refptr<SequencedWorkerPool>& expected_pool,
-    SequencedWorkerPool::SequenceToken expected_token) {
-  SequencedWorkerPool::SequenceToken token =
-      SequencedWorkerPool::GetSequenceTokenForCurrentThread();
-  EXPECT_EQ(expected_token.ToString(), token.ToString());
-
-  scoped_refptr<SequencedWorkerPool> pool =
-      SequencedWorkerPool::GetWorkerPoolForCurrentThread();
-  EXPECT_EQ(expected_pool, pool);
+// Helper method for VerifyCurrentSequencedTaskRunner().
+void VerifySequencedTaskRunnerRunsOnCurrentThread(
+    const scoped_refptr<SequencedTaskRunner>& task_runner) {
+  EXPECT_TRUE(task_runner->RunsTasksOnCurrentThread());
 }
 
-}  // namespace
+void VerifyCurrentSequencedTaskRunner(
+    scoped_refptr<SequencedTaskRunner> expected_task_runner) {
+  scoped_refptr<SequencedTaskRunner> task_runner =
+      SequencedWorkerPool::GetSequencedTaskRunnerForCurrentThread();
 
-TEST_F(SequencedWorkerPoolTest, GetWorkerPoolAndSequenceTokenForCurrentThread) {
+  // 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();
+  }
+
+  // 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, 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);
 
-  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));
+  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.

 
-  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) {
   MessageLoop loop;
   scoped_refptr<SequencedWorkerPool> pool(new SequencedWorkerPool(3, "Pool"));
   scoped_refptr<SequencedTaskRunner> task_runner =
       pool->GetSequencedTaskRunnerWithShutdownBehavior(
           pool->GetSequenceToken(),
           base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
 
@@ skipping 120 matching lines @@
     SequencedWorkerPoolSequencedTaskRunner, SequencedTaskRunnerTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPoolSequencedTaskRunner,
     SequencedTaskRunnerDelayedTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 
 }  // namespace
 
 }  // namespace base