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..ae743b5b19a25e83647fe925e372f878561249cc 100644 |
--- a/base/threading/sequenced_worker_pool_unittest.cc |
+++ b/base/threading/sequenced_worker_pool_unittest.cc |
@@ -13,6 +13,7 @@ |
#include "base/message_loop/message_loop.h" |
#include "base/synchronization/condition_variable.h" |
#include "base/synchronization/lock.h" |
+#include "base/synchronization/waitable_event.h" |
#include "base/test/sequenced_task_runner_test_template.h" |
#include "base/test/sequenced_worker_pool_owner.h" |
#include "base/test/task_runner_test_template.h" |
@@ -904,47 +905,71 @@ TEST_F(SequencedWorkerPoolTest, FlushForTesting) { |
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( |
+ SequencedTaskRunner* task_runner, |
+ bool should_run_on_current_thread, |
+ const Closure& callback) { |
+ EXPECT_EQ(should_run_on_current_thread, |
+ task_runner->RunsTasksOnCurrentThread()); |
+ callback.Run(); |
} |
-} // namespace |
- |
-TEST_F(SequencedWorkerPoolTest, GetWorkerPoolAndSequenceTokenForCurrentThread) { |
- EnsureAllWorkersCreated(); |
+void VerifyCurrentSequencedTaskRunner( |
+ scoped_refptr<SequencedTaskRunner> expected_task_runner, |
danakj
2015/11/20 19:18:43
Sorry I meant you can take a SequencedTaskRunner*
|
+ bool expected_equal, |
+ const Closure& callback) { |
+ scoped_refptr<SequencedTaskRunner> task_runner = |
+ SequencedWorkerPool::GetSequencedTaskRunnerForCurrentThread(); |
- // 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); |
+ // 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(); |
+ } |
- 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)); |
+ // 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, |
+ Bind(&VerifySequencedTaskRunnerRunsOnCurrentThread, |
+ std::move(expected_task_runner), expected_equal, callback)); |
+} |
- pool()->PostWorkerTask(FROM_HERE, |
- base::Bind(&CheckWorkerPoolAndSequenceToken, pool(), |
- SequencedWorkerPool::SequenceToken())); |
+TEST_F(SequencedWorkerPoolTest, GetSequencedTaskRunnerForCurrentThread) { |
+ EnsureAllWorkersCreated(); |
- pool()->FlushForTesting(); |
+ // 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); |
+ |
+ WaitableEvent event(false, false); |
+ Closure signal = Bind(&WaitableEvent::Signal, Unretained(&event)); |
+ 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, Bind(&VerifyCurrentSequencedTaskRunner, |
+ base::Unretained(task_runner_1.get()), true, signal)); |
+ event.Wait(); |
+ task_runner_2->PostTask( |
+ FROM_HERE, Bind(&VerifyCurrentSequencedTaskRunner, |
+ base::Unretained(task_runner_2.get()), true, signal)); |
+ event.Wait(); |
+ |
+ task_runner_1->PostTask( |
+ FROM_HERE, Bind(&VerifyCurrentSequencedTaskRunner, |
+ base::Unretained(task_runner_2.get()), false, signal)); |
+ event.Wait(); |
+ |
+ pool()->PostWorkerTask(FROM_HERE, Bind(&VerifyCurrentSequencedTaskRunner, |
+ nullptr, true, signal)); |
+ event.Wait(); |
} |
TEST(SequencedWorkerPoolRefPtrTest, ShutsDownCleanWithContinueOnShutdown) { |