OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/bind.h" | 5 #include "base/bind.h" |
6 #include "base/callback.h" | 6 #include "base/callback.h" |
7 #include "base/location.h" | 7 #include "base/location.h" |
8 #include "base/memory/ref_counted.h" | 8 #include "base/memory/ref_counted.h" |
9 #include "base/memory/scoped_ptr.h" | 9 #include "base/memory/scoped_ptr.h" |
10 #include "base/message_loop/message_loop.h" | 10 #include "base/message_loop/message_loop.h" |
11 #include "base/run_loop.h" | 11 #include "base/run_loop.h" |
12 #include "base/sequence_checker_impl.h" | 12 #include "base/sequence_checker_impl.h" |
13 #include "base/sequenced_task_runner.h" | 13 #include "base/sequenced_task_runner.h" |
14 #include "base/synchronization/waitable_event.h" | 14 #include "base/synchronization/waitable_event.h" |
15 #include "base/test/sequenced_worker_pool_owner.h" | 15 #include "base/test/sequenced_worker_pool_owner.h" |
16 #include "base/threading/sequenced_task_runner_handle.h" | 16 #include "base/threading/sequenced_task_runner_handle.h" |
17 #include "base/threading/sequenced_worker_pool.h" | 17 #include "base/threading/sequenced_worker_pool.h" |
18 #include "base/threading/simple_thread.h" | 18 #include "base/threading/simple_thread.h" |
19 #include "testing/gtest/include/gtest/gtest.h" | 19 #include "testing/gtest/include/gtest/gtest.h" |
20 | 20 |
21 namespace base { | 21 namespace base { |
22 namespace { | 22 namespace { |
23 | 23 |
24 class SequencedTaskRunnerHandleTest : public ::testing::Test { | 24 class SequencedTaskRunnerHandleTest : public ::testing::Test { |
25 protected: | 25 protected: |
26 static void GetTaskRunner(const Closure& callback) { | 26 static void VerifyCurrentSequencedTaskRunner(const Closure& callback) { |
27 // Use SequenceCheckerImpl to make sure it's not a no-op in Release builds. | |
28 scoped_ptr<SequenceCheckerImpl> sequence_checker(new SequenceCheckerImpl); | |
29 ASSERT_TRUE(SequencedTaskRunnerHandle::IsSet()); | 27 ASSERT_TRUE(SequencedTaskRunnerHandle::IsSet()); |
30 scoped_refptr<SequencedTaskRunner> task_runner = | 28 scoped_refptr<SequencedTaskRunner> task_runner = |
31 SequencedTaskRunnerHandle::Get(); | 29 SequencedTaskRunnerHandle::Get(); |
32 ASSERT_TRUE(task_runner); | 30 ASSERT_TRUE(task_runner); |
| 31 |
| 32 // Use SequenceCheckerImpl to make sure it's not a no-op in Release builds. |
| 33 scoped_ptr<SequenceCheckerImpl> sequence_checker(new SequenceCheckerImpl); |
33 task_runner->PostTask( | 34 task_runner->PostTask( |
34 FROM_HERE, base::Bind(&SequencedTaskRunnerHandleTest::CheckValidThread, | 35 FROM_HERE, |
35 base::Passed(&sequence_checker), callback)); | 36 base::Bind(&SequencedTaskRunnerHandleTest::CheckValidSequence, |
| 37 base::Passed(&sequence_checker), callback)); |
36 } | 38 } |
37 | 39 |
38 private: | 40 private: |
39 static void CheckValidThread(scoped_ptr<SequenceCheckerImpl> sequence_checker, | 41 static void CheckValidSequence( |
40 const Closure& callback) { | 42 scoped_ptr<SequenceCheckerImpl> sequence_checker, |
| 43 const Closure& callback) { |
41 EXPECT_TRUE(sequence_checker->CalledOnValidSequencedThread()); | 44 EXPECT_TRUE(sequence_checker->CalledOnValidSequencedThread()); |
42 callback.Run(); | 45 callback.Run(); |
43 } | 46 } |
44 | 47 |
45 MessageLoop message_loop_; | 48 MessageLoop message_loop_; |
46 }; | 49 }; |
47 | 50 |
48 TEST_F(SequencedTaskRunnerHandleTest, FromMessageLoop) { | 51 TEST_F(SequencedTaskRunnerHandleTest, FromMessageLoop) { |
49 RunLoop run_loop; | 52 RunLoop run_loop; |
50 GetTaskRunner(run_loop.QuitClosure()); | 53 VerifyCurrentSequencedTaskRunner(run_loop.QuitClosure()); |
51 run_loop.Run(); | 54 run_loop.Run(); |
52 } | 55 } |
53 | 56 |
54 TEST_F(SequencedTaskRunnerHandleTest, FromSequencedWorkerPool) { | 57 TEST_F(SequencedTaskRunnerHandleTest, FromSequencedWorkerPoolTask) { |
55 // Wrap the SequencedWorkerPool to avoid leaks due to its asynchronous | 58 // Wrap the SequencedWorkerPool to avoid leaks due to its asynchronous |
56 // destruction. | 59 // destruction. |
57 SequencedWorkerPoolOwner owner(3, "Test"); | 60 SequencedWorkerPoolOwner owner(3, "Test"); |
58 WaitableEvent event(false, false); | 61 WaitableEvent event(false, false); |
59 owner.pool()->PostSequencedWorkerTask( | 62 owner.pool()->PostSequencedWorkerTask( |
60 owner.pool()->GetSequenceToken(), FROM_HERE, | 63 owner.pool()->GetSequenceToken(), FROM_HERE, |
61 base::Bind(&SequencedTaskRunnerHandleTest::GetTaskRunner, | 64 base::Bind( |
62 base::Bind(&WaitableEvent::Signal, base::Unretained(&event)))); | 65 &SequencedTaskRunnerHandleTest::VerifyCurrentSequencedTaskRunner, |
| 66 base::Bind(&WaitableEvent::Signal, base::Unretained(&event)))); |
| 67 event.Wait(); |
| 68 owner.pool()->Shutdown(); |
| 69 } |
| 70 |
| 71 TEST_F(SequencedTaskRunnerHandleTest, FromUnsequencedTask) { |
| 72 // Wrap the SequencedWorkerPool to avoid leaks due to its asynchronous |
| 73 // destruction. |
| 74 SequencedWorkerPoolOwner owner(3, "Test"); |
| 75 WaitableEvent event(false, false); |
| 76 owner.pool()->PostWorkerTask( |
| 77 FROM_HERE, |
| 78 base::Bind( |
| 79 &SequencedTaskRunnerHandleTest::VerifyCurrentSequencedTaskRunner, |
| 80 base::Bind(&WaitableEvent::Signal, base::Unretained(&event)))); |
63 event.Wait(); | 81 event.Wait(); |
64 } | 82 } |
65 | 83 |
66 class ThreadRunner : public DelegateSimpleThread::Delegate { | 84 class ThreadRunner : public DelegateSimpleThread::Delegate { |
67 public: | 85 public: |
68 void Run() override { | 86 void Run() override { |
69 ASSERT_FALSE(SequencedTaskRunnerHandle::IsSet()); | 87 ASSERT_FALSE(SequencedTaskRunnerHandle::IsSet()); |
70 } | 88 } |
71 | 89 |
72 private: | 90 private: |
73 Closure callback_; | 91 Closure callback_; |
74 }; | 92 }; |
75 | 93 |
76 TEST_F(SequencedTaskRunnerHandleTest, FromSimpleThread) { | 94 TEST_F(SequencedTaskRunnerHandleTest, FromSimpleThread) { |
77 ThreadRunner thread_runner; | 95 ThreadRunner thread_runner; |
78 DelegateSimpleThread thread(&thread_runner, "Background thread"); | 96 DelegateSimpleThread thread(&thread_runner, "Background thread"); |
79 thread.Start(); | 97 thread.Start(); |
80 thread.Join(); | 98 thread.Join(); |
81 } | 99 } |
82 | 100 |
83 } // namespace | 101 } // namespace |
84 } // namespace base | 102 } // namespace base |
OLD | NEW |