OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "base/task_scheduler/scheduler_single_thread_task_runner_manager.h" | |
6 | |
7 #include "base/bind.h" | |
8 #include "base/memory/ptr_util.h" | |
9 #include "base/synchronization/lock.h" | |
10 #include "base/synchronization/waitable_event.h" | |
11 #include "base/task_scheduler/delayed_task_manager.h" | |
12 #include "base/task_scheduler/post_task.h" | |
13 #include "base/task_scheduler/scheduler_worker_pool_params.h" | |
14 #include "base/task_scheduler/task_tracker.h" | |
15 #include "base/task_scheduler/task_traits.h" | |
16 #include "base/test/scoped_task_scheduler.h" | |
17 #include "base/test/test_timeouts.h" | |
18 #include "base/threading/thread.h" | |
19 #include "testing/gtest/include/gtest/gtest.h" | |
20 namespace base { | |
gab
2017/02/21 21:39:50
nit empty line above
robliao
2017/02/22 01:04:19
Done.
| |
21 namespace internal { | |
22 | |
23 namespace { | |
24 | |
25 enum WorkerPoolType { | |
26 BACKGROUND_WORKER_POOL = 0, | |
27 FOREGROUND_WORKER_POOL, | |
28 }; | |
29 | |
30 static size_t GetThreadPoolIndexForTraits(const TaskTraits& traits) { | |
31 return traits.priority() == TaskPriority::BACKGROUND ? BACKGROUND_WORKER_POOL | |
32 : FOREGROUND_WORKER_POOL; | |
33 } | |
34 | |
35 class TaskSchedulerSingleThreadTaskRunnerManagerTest : public testing::Test { | |
36 public: | |
37 TaskSchedulerSingleThreadTaskRunnerManagerTest() | |
38 : service_thread_("TaskSchedulerServiceThread") {} | |
39 | |
40 void SetUp() override { | |
41 ASSERT_FALSE(delayed_task_manager_); | |
gab
2017/02/21 21:39:50
It's not typical to ASSERT_FALSE on the fixture's
robliao
2017/02/22 01:04:19
Done.
| |
42 service_thread_.Start(); | |
43 | |
44 using StandbyThreadPolicy = SchedulerWorkerPoolParams::StandbyThreadPolicy; | |
45 | |
46 std::vector<SchedulerWorkerPoolParams> params_vector; | |
47 | |
48 ASSERT_EQ(BACKGROUND_WORKER_POOL, params_vector.size()); | |
49 params_vector.emplace_back("Background", ThreadPriority::BACKGROUND, | |
50 StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max()); | |
51 | |
52 ASSERT_EQ(FOREGROUND_WORKER_POOL, params_vector.size()); | |
53 params_vector.emplace_back("Foreground", ThreadPriority::NORMAL, | |
54 StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max()); | |
55 | |
56 delayed_task_manager_ = | |
57 MakeUnique<DelayedTaskManager>(service_thread_.task_runner()); | |
58 single_thread_task_runner_manager_ = | |
59 MakeUnique<SchedulerSingleThreadTaskRunnerManager>( | |
60 params_vector, Bind(&GetThreadPoolIndexForTraits), &task_tracker_, | |
61 delayed_task_manager_.get()); | |
62 } | |
63 | |
64 void TearDown() override { | |
65 single_thread_task_runner_manager_->JoinForTesting(); | |
66 single_thread_task_runner_manager_.reset(); | |
67 delayed_task_manager_.reset(); | |
68 service_thread_.Stop(); | |
69 } | |
70 | |
71 protected: | |
72 std::unique_ptr<SchedulerSingleThreadTaskRunnerManager> | |
73 single_thread_task_runner_manager_; | |
74 TaskTracker task_tracker_; | |
75 | |
76 private: | |
77 Thread service_thread_; | |
78 std::unique_ptr<DelayedTaskManager> delayed_task_manager_; | |
79 | |
80 DISALLOW_COPY_AND_ASSIGN(TaskSchedulerSingleThreadTaskRunnerManagerTest); | |
81 }; | |
82 | |
83 void CaptureThreadId(PlatformThreadId* thread_id) { | |
84 ASSERT_TRUE(thread_id); | |
85 *thread_id = PlatformThread::CurrentId(); | |
86 } | |
87 | |
88 void CaptureThreadPriority(ThreadPriority* thread_priority) { | |
89 ASSERT_TRUE(thread_priority); | |
90 *thread_priority = PlatformThread::GetCurrentThreadPriority(); | |
91 } | |
92 | |
93 void ShouldNotRunCallback() { | |
gab
2017/02/21 21:39:50
ShouldNotRun() -- i.e. I'd drop "Callback", it's o
robliao
2017/02/22 01:04:18
This was another holdover
https://cs.chromium.org/
| |
94 ADD_FAILURE() << "Ran a task that shouldn't run."; | |
95 } | |
96 | |
97 } // namespace | |
98 | |
99 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, DifferentThreadsUsed) { | |
100 scoped_refptr<SingleThreadTaskRunner> task_runner_1 = | |
101 single_thread_task_runner_manager_ | |
102 ->CreateSingleThreadTaskRunnerWithTraits( | |
103 TaskTraits().WithShutdownBehavior( | |
104 TaskShutdownBehavior::BLOCK_SHUTDOWN)); | |
105 scoped_refptr<SingleThreadTaskRunner> task_runner_2 = | |
106 single_thread_task_runner_manager_ | |
107 ->CreateSingleThreadTaskRunnerWithTraits( | |
108 TaskTraits().WithShutdownBehavior( | |
109 TaskShutdownBehavior::BLOCK_SHUTDOWN)); | |
110 | |
111 PlatformThreadId thread_id_1 = kInvalidThreadId; | |
112 task_runner_1->PostTask(FROM_HERE, Bind(&CaptureThreadId, &thread_id_1)); | |
113 PlatformThreadId thread_id_2 = kInvalidThreadId; | |
114 task_runner_2->PostTask(FROM_HERE, Bind(&CaptureThreadId, &thread_id_2)); | |
115 | |
116 task_tracker_.Shutdown(); | |
117 | |
118 ASSERT_NE(kInvalidThreadId, thread_id_1); | |
119 ASSERT_NE(kInvalidThreadId, thread_id_2); | |
120 EXPECT_NE(thread_id_1, thread_id_2); | |
121 } | |
122 | |
123 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PrioritySetCorrectly) { | |
124 // Why are events used here instead of the task tracker? | |
125 // Shutting down can cause priorities to get raised. This means we have to use | |
126 // events to determine when a task is run. | |
127 scoped_refptr<SingleThreadTaskRunner> task_runner_background = | |
128 single_thread_task_runner_manager_ | |
129 ->CreateSingleThreadTaskRunnerWithTraits( | |
130 TaskTraits().WithPriority(TaskPriority::BACKGROUND)); | |
131 scoped_refptr<SingleThreadTaskRunner> task_runner_user_visible = | |
132 single_thread_task_runner_manager_ | |
133 ->CreateSingleThreadTaskRunnerWithTraits( | |
134 TaskTraits().WithPriority(TaskPriority::USER_VISIBLE)); | |
135 scoped_refptr<SingleThreadTaskRunner> task_runner_user_blocking = | |
136 single_thread_task_runner_manager_ | |
137 ->CreateSingleThreadTaskRunnerWithTraits( | |
138 TaskTraits() | |
139 .WithPriority(TaskPriority::USER_BLOCKING) | |
140 .WithShutdownBehavior(TaskShutdownBehavior::BLOCK_SHUTDOWN)); | |
141 | |
142 ThreadPriority thread_priority_background; | |
143 task_runner_background->PostTask( | |
144 FROM_HERE, Bind(&CaptureThreadPriority, &thread_priority_background)); | |
145 WaitableEvent waitable_event_background( | |
146 WaitableEvent::ResetPolicy::MANUAL, | |
147 WaitableEvent::InitialState::NOT_SIGNALED); | |
148 task_runner_background->PostTask( | |
149 FROM_HERE, | |
150 Bind(&WaitableEvent::Signal, Unretained(&waitable_event_background))); | |
151 | |
152 ThreadPriority thread_priority_user_visible; | |
153 task_runner_user_visible->PostTask( | |
154 FROM_HERE, Bind(&CaptureThreadPriority, &thread_priority_user_visible)); | |
155 WaitableEvent waitable_event_user_visible( | |
156 WaitableEvent::ResetPolicy::MANUAL, | |
157 WaitableEvent::InitialState::NOT_SIGNALED); | |
158 task_runner_user_visible->PostTask( | |
159 FROM_HERE, | |
160 Bind(&WaitableEvent::Signal, Unretained(&waitable_event_user_visible))); | |
161 | |
162 ThreadPriority thread_priority_user_blocking; | |
163 task_runner_user_blocking->PostTask( | |
164 FROM_HERE, Bind(&CaptureThreadPriority, &thread_priority_user_blocking)); | |
165 WaitableEvent waitable_event_user_blocking( | |
166 WaitableEvent::ResetPolicy::MANUAL, | |
167 WaitableEvent::InitialState::NOT_SIGNALED); | |
168 task_runner_user_blocking->PostTask( | |
169 FROM_HERE, | |
170 Bind(&WaitableEvent::Signal, Unretained(&waitable_event_user_blocking))); | |
171 | |
172 waitable_event_background.Wait(); | |
173 waitable_event_user_visible.Wait(); | |
174 waitable_event_user_blocking.Wait(); | |
175 | |
176 if (Lock::HandlesMultipleThreadPriorities()) | |
177 EXPECT_EQ(ThreadPriority::BACKGROUND, thread_priority_background); | |
178 else | |
179 EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_background); | |
180 EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_user_visible); | |
181 EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_user_blocking); | |
182 } | |
183 | |
184 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostTaskAfterShutdown) { | |
185 auto task_runner = single_thread_task_runner_manager_ | |
186 ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits()); | |
187 task_tracker_.Shutdown(); | |
188 EXPECT_FALSE(task_runner->PostTask(FROM_HERE, Bind(&ShouldNotRunCallback))); | |
189 } | |
190 | |
191 // Verify that a Task runs shortly after its delay expires. | |
192 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostDelayedTask) { | |
193 TimeTicks start_time = TimeTicks::Now(); | |
194 | |
195 // Post a task with a short delay. | |
196 WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL, | |
197 WaitableEvent::InitialState::NOT_SIGNALED); | |
198 auto task_runner = single_thread_task_runner_manager_ | |
199 ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits()); | |
200 EXPECT_TRUE(task_runner->PostDelayedTask( | |
201 FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&task_ran)), | |
202 TestTimeouts::tiny_timeout())); | |
203 | |
204 // Wait until the task runs. | |
205 task_ran.Wait(); | |
206 | |
207 // Expect the task to run after its delay expires, but not more than 250 ms | |
208 // after that. | |
209 const TimeDelta actual_delay = TimeTicks::Now() - start_time; | |
210 EXPECT_GE(actual_delay, TestTimeouts::tiny_timeout()); | |
211 EXPECT_LT(actual_delay, | |
212 TimeDelta::FromMilliseconds(250) + TestTimeouts::tiny_timeout()); | |
gab
2017/02/21 21:39:50
Flip as
TestTimeouts::tiny_timeout() + TimeDelta
robliao
2017/02/22 01:04:19
The important part here is the 250ms. This should
| |
213 } | |
214 | |
215 // Verify that the RunsTasksOnCurrentThread() method of a SEQUENCED TaskRunner | |
216 // returns false when called from a task that isn't part of the sequence. Note: | |
217 // Tests that use TestTaskFactory already verify that RunsTasksOnCurrentThread() | |
218 // returns true when appropriate so this method complements it to get full | |
219 // coverage of that method. | |
220 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, | |
221 SequencedRunsTasksOnCurrentThread) { | |
222 test::ScopedTaskScheduler scoped_task_scheduler; | |
223 auto task_runner = single_thread_task_runner_manager_ | |
224 ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits()); | |
225 scoped_refptr<SequencedTaskRunner> sequenced_task_runner( | |
gab
2017/02/21 21:39:50
Perhaps arbitrary but I prefer = instead of () to
robliao
2017/02/22 01:04:18
Done one better and promoted to auto.
Originating
| |
226 CreateSequencedTaskRunnerWithTraits(TaskTraits())); | |
227 | |
228 WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL, | |
229 WaitableEvent::InitialState::NOT_SIGNALED); | |
230 task_runner->PostTask( | |
231 FROM_HERE, | |
232 Bind( | |
233 [](scoped_refptr<TaskRunner> sequenced_task_runner, | |
234 WaitableEvent* task_ran) { | |
235 EXPECT_FALSE(sequenced_task_runner->RunsTasksOnCurrentThread()); | |
236 task_ran->Signal(); | |
237 }, | |
238 sequenced_task_runner, Unretained(&task_ran))); | |
239 task_ran.Wait(); | |
240 } | |
241 | |
242 } // namespace internal | |
243 } // namespace base | |
OLD | NEW |