OLD | NEW |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | 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 | 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/task_scheduler/scheduler_single_thread_task_runner_manager.h" | 5 #include "base/task_scheduler/scheduler_single_thread_task_runner_manager.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/memory/ptr_util.h" | 8 #include "base/memory/ptr_util.h" |
9 #include "base/synchronization/lock.h" | 9 #include "base/synchronization/lock.h" |
10 #include "base/synchronization/waitable_event.h" | 10 #include "base/synchronization/waitable_event.h" |
11 #include "base/task_scheduler/delayed_task_manager.h" | 11 #include "base/task_scheduler/delayed_task_manager.h" |
12 #include "base/task_scheduler/post_task.h" | 12 #include "base/task_scheduler/post_task.h" |
13 #include "base/task_scheduler/scheduler_worker_pool_params.h" | 13 #include "base/task_scheduler/scheduler_worker_pool_params.h" |
14 #include "base/task_scheduler/task_tracker.h" | 14 #include "base/task_scheduler/task_tracker.h" |
15 #include "base/task_scheduler/task_traits.h" | 15 #include "base/task_scheduler/task_traits.h" |
16 #include "base/test/test_timeouts.h" | 16 #include "base/test/test_timeouts.h" |
17 #include "base/threading/simple_thread.h" | 17 #include "base/threading/simple_thread.h" |
18 #include "base/threading/thread.h" | 18 #include "base/threading/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 internal { | 22 namespace internal { |
23 | 23 |
24 namespace { | 24 namespace { |
25 | 25 |
26 enum WorkerPoolType : size_t { | |
27 BACKGROUND_WORKER_POOL = 0, | |
28 FOREGROUND_WORKER_POOL, | |
29 }; | |
30 | |
31 static size_t GetThreadPoolIndexForTraits(const TaskTraits& traits) { | |
32 return traits.priority() == TaskPriority::BACKGROUND ? BACKGROUND_WORKER_POOL | |
33 : FOREGROUND_WORKER_POOL; | |
34 } | |
35 | |
36 std::vector<SchedulerWorkerPoolParams> GetParamsVector() { | |
37 using StandbyThreadPolicy = SchedulerWorkerPoolParams::StandbyThreadPolicy; | |
38 | |
39 std::vector<SchedulerWorkerPoolParams> params_vector; | |
40 | |
41 DCHECK_EQ(BACKGROUND_WORKER_POOL, params_vector.size()); | |
42 params_vector.emplace_back("Background", ThreadPriority::BACKGROUND, | |
43 StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max()); | |
44 | |
45 DCHECK_EQ(FOREGROUND_WORKER_POOL, params_vector.size()); | |
46 params_vector.emplace_back("Foreground", ThreadPriority::NORMAL, | |
47 StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max()); | |
48 | |
49 return params_vector; | |
50 } | |
51 | |
52 class TaskSchedulerSingleThreadTaskRunnerManagerTest : public testing::Test { | 26 class TaskSchedulerSingleThreadTaskRunnerManagerTest : public testing::Test { |
53 public: | 27 public: |
54 TaskSchedulerSingleThreadTaskRunnerManagerTest() | 28 TaskSchedulerSingleThreadTaskRunnerManagerTest() |
55 : service_thread_("TaskSchedulerServiceThread") {} | 29 : service_thread_("TaskSchedulerServiceThread") {} |
56 | 30 |
57 void SetUp() override { | 31 void SetUp() override { |
58 service_thread_.Start(); | 32 service_thread_.Start(); |
59 | |
60 delayed_task_manager_ = | 33 delayed_task_manager_ = |
61 MakeUnique<DelayedTaskManager>(service_thread_.task_runner()); | 34 MakeUnique<DelayedTaskManager>(service_thread_.task_runner()); |
62 single_thread_task_runner_manager_ = | 35 single_thread_task_runner_manager_ = |
63 MakeUnique<SchedulerSingleThreadTaskRunnerManager>( | 36 MakeUnique<SchedulerSingleThreadTaskRunnerManager>( |
64 GetParamsVector(), Bind(&GetThreadPoolIndexForTraits), | |
65 &task_tracker_, delayed_task_manager_.get()); | 37 &task_tracker_, delayed_task_manager_.get()); |
66 } | 38 } |
67 | 39 |
68 void TearDown() override { | 40 void TearDown() override { |
69 TearDownSingleThreadTaskRunnerManager(); | 41 TearDownSingleThreadTaskRunnerManager(); |
70 delayed_task_manager_.reset(); | 42 delayed_task_manager_.reset(); |
71 service_thread_.Stop(); | 43 service_thread_.Stop(); |
72 } | 44 } |
73 | 45 |
74 protected: | 46 protected: |
(...skipping 26 matching lines...) Expand all Loading... |
101 void ShouldNotRun() { | 73 void ShouldNotRun() { |
102 ADD_FAILURE() << "Ran a task that shouldn't run."; | 74 ADD_FAILURE() << "Ran a task that shouldn't run."; |
103 } | 75 } |
104 | 76 |
105 } // namespace | 77 } // namespace |
106 | 78 |
107 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, DifferentThreadsUsed) { | 79 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, DifferentThreadsUsed) { |
108 scoped_refptr<SingleThreadTaskRunner> task_runner_1 = | 80 scoped_refptr<SingleThreadTaskRunner> task_runner_1 = |
109 single_thread_task_runner_manager_ | 81 single_thread_task_runner_manager_ |
110 ->CreateSingleThreadTaskRunnerWithTraits( | 82 ->CreateSingleThreadTaskRunnerWithTraits( |
| 83 "A", ThreadPriority::NORMAL, |
111 TaskTraits().WithShutdownBehavior( | 84 TaskTraits().WithShutdownBehavior( |
112 TaskShutdownBehavior::BLOCK_SHUTDOWN)); | 85 TaskShutdownBehavior::BLOCK_SHUTDOWN)); |
113 scoped_refptr<SingleThreadTaskRunner> task_runner_2 = | 86 scoped_refptr<SingleThreadTaskRunner> task_runner_2 = |
114 single_thread_task_runner_manager_ | 87 single_thread_task_runner_manager_ |
115 ->CreateSingleThreadTaskRunnerWithTraits( | 88 ->CreateSingleThreadTaskRunnerWithTraits( |
| 89 "B", ThreadPriority::NORMAL, |
116 TaskTraits().WithShutdownBehavior( | 90 TaskTraits().WithShutdownBehavior( |
117 TaskShutdownBehavior::BLOCK_SHUTDOWN)); | 91 TaskShutdownBehavior::BLOCK_SHUTDOWN)); |
118 | 92 |
119 PlatformThreadRef thread_ref_1; | 93 PlatformThreadRef thread_ref_1; |
120 task_runner_1->PostTask(FROM_HERE, Bind(&CaptureThreadRef, &thread_ref_1)); | 94 task_runner_1->PostTask(FROM_HERE, Bind(&CaptureThreadRef, &thread_ref_1)); |
121 PlatformThreadRef thread_ref_2; | 95 PlatformThreadRef thread_ref_2; |
122 task_runner_2->PostTask(FROM_HERE, Bind(&CaptureThreadRef, &thread_ref_2)); | 96 task_runner_2->PostTask(FROM_HERE, Bind(&CaptureThreadRef, &thread_ref_2)); |
123 | 97 |
124 task_tracker_.Shutdown(); | 98 task_tracker_.Shutdown(); |
125 | 99 |
126 ASSERT_FALSE(thread_ref_1.is_null()); | 100 ASSERT_FALSE(thread_ref_1.is_null()); |
127 ASSERT_FALSE(thread_ref_2.is_null()); | 101 ASSERT_FALSE(thread_ref_2.is_null()); |
128 EXPECT_NE(thread_ref_1, thread_ref_2); | 102 EXPECT_NE(thread_ref_1, thread_ref_2); |
129 } | 103 } |
130 | 104 |
131 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PrioritySetCorrectly) { | 105 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PrioritySetCorrectly) { |
132 // Why are events used here instead of the task tracker? | 106 // Why are events used here instead of the task tracker? |
133 // Shutting down can cause priorities to get raised. This means we have to use | 107 // Shutting down can cause priorities to get raised. This means we have to use |
134 // events to determine when a task is run. | 108 // events to determine when a task is run. |
135 scoped_refptr<SingleThreadTaskRunner> task_runner_background = | 109 scoped_refptr<SingleThreadTaskRunner> task_runner_background = |
136 single_thread_task_runner_manager_ | 110 single_thread_task_runner_manager_ |
137 ->CreateSingleThreadTaskRunnerWithTraits( | 111 ->CreateSingleThreadTaskRunnerWithTraits( |
138 TaskTraits().WithPriority(TaskPriority::BACKGROUND)); | 112 "Background", ThreadPriority::BACKGROUND, TaskTraits()); |
139 scoped_refptr<SingleThreadTaskRunner> task_runner_user_visible = | 113 scoped_refptr<SingleThreadTaskRunner> task_runner_normal = |
140 single_thread_task_runner_manager_ | 114 single_thread_task_runner_manager_ |
141 ->CreateSingleThreadTaskRunnerWithTraits( | 115 ->CreateSingleThreadTaskRunnerWithTraits( |
142 TaskTraits().WithPriority(TaskPriority::USER_VISIBLE)); | 116 "Normal", ThreadPriority::NORMAL, TaskTraits()); |
143 scoped_refptr<SingleThreadTaskRunner> task_runner_user_blocking = | |
144 single_thread_task_runner_manager_ | |
145 ->CreateSingleThreadTaskRunnerWithTraits( | |
146 TaskTraits() | |
147 .WithPriority(TaskPriority::USER_BLOCKING) | |
148 .WithShutdownBehavior(TaskShutdownBehavior::BLOCK_SHUTDOWN)); | |
149 | 117 |
150 ThreadPriority thread_priority_background; | 118 ThreadPriority thread_priority_background; |
151 task_runner_background->PostTask( | 119 task_runner_background->PostTask( |
152 FROM_HERE, Bind(&CaptureThreadPriority, &thread_priority_background)); | 120 FROM_HERE, Bind(&CaptureThreadPriority, &thread_priority_background)); |
153 WaitableEvent waitable_event_background( | 121 WaitableEvent waitable_event_background( |
154 WaitableEvent::ResetPolicy::MANUAL, | 122 WaitableEvent::ResetPolicy::MANUAL, |
155 WaitableEvent::InitialState::NOT_SIGNALED); | 123 WaitableEvent::InitialState::NOT_SIGNALED); |
156 task_runner_background->PostTask( | 124 task_runner_background->PostTask( |
157 FROM_HERE, | 125 FROM_HERE, |
158 Bind(&WaitableEvent::Signal, Unretained(&waitable_event_background))); | 126 Bind(&WaitableEvent::Signal, Unretained(&waitable_event_background))); |
159 | 127 |
160 ThreadPriority thread_priority_user_visible; | 128 ThreadPriority thread_priority_normal; |
161 task_runner_user_visible->PostTask( | 129 task_runner_normal->PostTask( |
162 FROM_HERE, Bind(&CaptureThreadPriority, &thread_priority_user_visible)); | 130 FROM_HERE, Bind(&CaptureThreadPriority, &thread_priority_normal)); |
163 WaitableEvent waitable_event_user_visible( | 131 WaitableEvent waitable_event_normal( |
164 WaitableEvent::ResetPolicy::MANUAL, | 132 WaitableEvent::ResetPolicy::MANUAL, |
165 WaitableEvent::InitialState::NOT_SIGNALED); | 133 WaitableEvent::InitialState::NOT_SIGNALED); |
166 task_runner_user_visible->PostTask( | 134 task_runner_normal->PostTask( |
167 FROM_HERE, | 135 FROM_HERE, |
168 Bind(&WaitableEvent::Signal, Unretained(&waitable_event_user_visible))); | 136 Bind(&WaitableEvent::Signal, Unretained(&waitable_event_normal))); |
169 | |
170 ThreadPriority thread_priority_user_blocking; | |
171 task_runner_user_blocking->PostTask( | |
172 FROM_HERE, Bind(&CaptureThreadPriority, &thread_priority_user_blocking)); | |
173 WaitableEvent waitable_event_user_blocking( | |
174 WaitableEvent::ResetPolicy::MANUAL, | |
175 WaitableEvent::InitialState::NOT_SIGNALED); | |
176 task_runner_user_blocking->PostTask( | |
177 FROM_HERE, | |
178 Bind(&WaitableEvent::Signal, Unretained(&waitable_event_user_blocking))); | |
179 | 137 |
180 waitable_event_background.Wait(); | 138 waitable_event_background.Wait(); |
181 waitable_event_user_visible.Wait(); | 139 waitable_event_normal.Wait(); |
182 waitable_event_user_blocking.Wait(); | |
183 | 140 |
184 if (Lock::HandlesMultipleThreadPriorities()) | 141 if (Lock::HandlesMultipleThreadPriorities()) |
185 EXPECT_EQ(ThreadPriority::BACKGROUND, thread_priority_background); | 142 EXPECT_EQ(ThreadPriority::BACKGROUND, thread_priority_background); |
186 else | 143 else |
187 EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_background); | 144 EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_background); |
188 EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_user_visible); | 145 EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_normal); |
189 EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_user_blocking); | |
190 } | 146 } |
191 | 147 |
192 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostTaskAfterShutdown) { | 148 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostTaskAfterShutdown) { |
193 auto task_runner = single_thread_task_runner_manager_ | 149 auto task_runner = single_thread_task_runner_manager_ |
194 ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits()); | 150 ->CreateSingleThreadTaskRunnerWithTraits( |
| 151 "Thread", ThreadPriority::NORMAL, TaskTraits()); |
195 task_tracker_.Shutdown(); | 152 task_tracker_.Shutdown(); |
196 EXPECT_FALSE(task_runner->PostTask(FROM_HERE, Bind(&ShouldNotRun))); | 153 EXPECT_FALSE(task_runner->PostTask(FROM_HERE, Bind(&ShouldNotRun))); |
197 } | 154 } |
198 | 155 |
199 // Verify that a Task runs shortly after its delay expires. | 156 // Verify that a Task runs shortly after its delay expires. |
200 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostDelayedTask) { | 157 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostDelayedTask) { |
201 TimeTicks start_time = TimeTicks::Now(); | 158 TimeTicks start_time = TimeTicks::Now(); |
202 | 159 |
203 // Post a task with a short delay. | 160 // Post a task with a short delay. |
204 WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL, | 161 WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL, |
205 WaitableEvent::InitialState::NOT_SIGNALED); | 162 WaitableEvent::InitialState::NOT_SIGNALED); |
206 auto task_runner = single_thread_task_runner_manager_ | 163 auto task_runner = single_thread_task_runner_manager_ |
207 ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits()); | 164 ->CreateSingleThreadTaskRunnerWithTraits( |
| 165 "Thread", ThreadPriority::NORMAL, TaskTraits()); |
208 EXPECT_TRUE(task_runner->PostDelayedTask( | 166 EXPECT_TRUE(task_runner->PostDelayedTask( |
209 FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&task_ran)), | 167 FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&task_ran)), |
210 TestTimeouts::tiny_timeout())); | 168 TestTimeouts::tiny_timeout())); |
211 | 169 |
212 // Wait until the task runs. | 170 // Wait until the task runs. |
213 task_ran.Wait(); | 171 task_ran.Wait(); |
214 | 172 |
215 // Expect the task to run after its delay expires, but not more than 250 ms | 173 // Expect the task to run after its delay expires, but not more than 250 ms |
216 // after that. | 174 // after that. |
217 const TimeDelta actual_delay = TimeTicks::Now() - start_time; | 175 const TimeDelta actual_delay = TimeTicks::Now() - start_time; |
218 EXPECT_GE(actual_delay, TestTimeouts::tiny_timeout()); | 176 EXPECT_GE(actual_delay, TestTimeouts::tiny_timeout()); |
219 EXPECT_LT(actual_delay, | 177 EXPECT_LT(actual_delay, |
220 TimeDelta::FromMilliseconds(250) + TestTimeouts::tiny_timeout()); | 178 TimeDelta::FromMilliseconds(250) + TestTimeouts::tiny_timeout()); |
221 } | 179 } |
222 | 180 |
223 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, | 181 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, |
224 RunsTasksOnCurrentThread) { | 182 RunsTasksOnCurrentThread) { |
225 scoped_refptr<SingleThreadTaskRunner> task_runner_1 = | 183 scoped_refptr<SingleThreadTaskRunner> task_runner_1 = |
226 single_thread_task_runner_manager_ | 184 single_thread_task_runner_manager_ |
227 ->CreateSingleThreadTaskRunnerWithTraits( | 185 ->CreateSingleThreadTaskRunnerWithTraits( |
| 186 "Thread", ThreadPriority::NORMAL, |
228 TaskTraits().WithShutdownBehavior( | 187 TaskTraits().WithShutdownBehavior( |
229 TaskShutdownBehavior::BLOCK_SHUTDOWN)); | 188 TaskShutdownBehavior::BLOCK_SHUTDOWN)); |
230 scoped_refptr<SingleThreadTaskRunner> task_runner_2 = | 189 scoped_refptr<SingleThreadTaskRunner> task_runner_2 = |
231 single_thread_task_runner_manager_ | 190 single_thread_task_runner_manager_ |
232 ->CreateSingleThreadTaskRunnerWithTraits( | 191 ->CreateSingleThreadTaskRunnerWithTraits( |
| 192 "Thread", ThreadPriority::NORMAL, |
233 TaskTraits().WithShutdownBehavior( | 193 TaskTraits().WithShutdownBehavior( |
234 TaskShutdownBehavior::BLOCK_SHUTDOWN)); | 194 TaskShutdownBehavior::BLOCK_SHUTDOWN)); |
235 | 195 |
236 EXPECT_FALSE(task_runner_1->RunsTasksOnCurrentThread()); | 196 EXPECT_FALSE(task_runner_1->RunsTasksOnCurrentThread()); |
237 EXPECT_FALSE(task_runner_2->RunsTasksOnCurrentThread()); | 197 EXPECT_FALSE(task_runner_2->RunsTasksOnCurrentThread()); |
238 | 198 |
239 task_runner_1->PostTask( | 199 task_runner_1->PostTask( |
240 FROM_HERE, Bind( | 200 FROM_HERE, Bind( |
241 [](scoped_refptr<SingleThreadTaskRunner> task_runner_1, | 201 [](scoped_refptr<SingleThreadTaskRunner> task_runner_1, |
242 scoped_refptr<SingleThreadTaskRunner> task_runner_2) { | 202 scoped_refptr<SingleThreadTaskRunner> task_runner_2) { |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
306 // Exercises the codepath where the workers are unavailable for unregistration | 266 // Exercises the codepath where the workers are unavailable for unregistration |
307 // because of a Join call. | 267 // because of a Join call. |
308 WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL, | 268 WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL, |
309 WaitableEvent::InitialState::NOT_SIGNALED); | 269 WaitableEvent::InitialState::NOT_SIGNALED); |
310 WaitableEvent task_blocking(WaitableEvent::ResetPolicy::MANUAL, | 270 WaitableEvent task_blocking(WaitableEvent::ResetPolicy::MANUAL, |
311 WaitableEvent::InitialState::NOT_SIGNALED); | 271 WaitableEvent::InitialState::NOT_SIGNALED); |
312 | 272 |
313 { | 273 { |
314 auto task_runner = single_thread_task_runner_manager_ | 274 auto task_runner = single_thread_task_runner_manager_ |
315 ->CreateSingleThreadTaskRunnerWithTraits( | 275 ->CreateSingleThreadTaskRunnerWithTraits( |
| 276 "Thread", ThreadPriority::NORMAL, |
316 TaskTraits().WithBaseSyncPrimitives()); | 277 TaskTraits().WithBaseSyncPrimitives()); |
317 EXPECT_TRUE(task_runner->PostTask( | 278 EXPECT_TRUE(task_runner->PostTask( |
318 FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&task_running)))); | 279 FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&task_running)))); |
319 EXPECT_TRUE(task_runner->PostTask( | 280 EXPECT_TRUE(task_runner->PostTask( |
320 FROM_HERE, Bind(&WaitableEvent::Wait, Unretained(&task_blocking)))); | 281 FROM_HERE, Bind(&WaitableEvent::Wait, Unretained(&task_blocking)))); |
321 } | 282 } |
322 | 283 |
323 task_running.Wait(); | 284 task_running.Wait(); |
324 CallJoinFromDifferentThread join_from_different_thread( | 285 CallJoinFromDifferentThread join_from_different_thread( |
325 single_thread_task_runner_manager_.get()); | 286 single_thread_task_runner_manager_.get()); |
326 join_from_different_thread.Start(); | 287 join_from_different_thread.Start(); |
327 join_from_different_thread.WaitForRunToStart(); | 288 join_from_different_thread.WaitForRunToStart(); |
328 task_blocking.Signal(); | 289 task_blocking.Signal(); |
329 join_from_different_thread.Join(); | 290 join_from_different_thread.Join(); |
330 } | 291 } |
331 | 292 |
332 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerJoinTest, | 293 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerJoinTest, |
333 ConcurrentJoinExtraSkippedTask) { | 294 ConcurrentJoinExtraSkippedTask) { |
334 // Tests to make sure that tasks are properly cleaned up at Join, allowing | 295 // Tests to make sure that tasks are properly cleaned up at Join, allowing |
335 // SingleThreadTaskRunners to unregister themselves. | 296 // SingleThreadTaskRunners to unregister themselves. |
336 WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL, | 297 WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL, |
337 WaitableEvent::InitialState::NOT_SIGNALED); | 298 WaitableEvent::InitialState::NOT_SIGNALED); |
338 WaitableEvent task_blocking(WaitableEvent::ResetPolicy::MANUAL, | 299 WaitableEvent task_blocking(WaitableEvent::ResetPolicy::MANUAL, |
339 WaitableEvent::InitialState::NOT_SIGNALED); | 300 WaitableEvent::InitialState::NOT_SIGNALED); |
340 | 301 |
341 { | 302 { |
342 auto task_runner = single_thread_task_runner_manager_ | 303 auto task_runner = single_thread_task_runner_manager_ |
343 ->CreateSingleThreadTaskRunnerWithTraits( | 304 ->CreateSingleThreadTaskRunnerWithTraits( |
| 305 "Thread", ThreadPriority::NORMAL, |
344 TaskTraits().WithBaseSyncPrimitives()); | 306 TaskTraits().WithBaseSyncPrimitives()); |
345 EXPECT_TRUE(task_runner->PostTask( | 307 EXPECT_TRUE(task_runner->PostTask( |
346 FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&task_running)))); | 308 FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&task_running)))); |
347 EXPECT_TRUE(task_runner->PostTask( | 309 EXPECT_TRUE(task_runner->PostTask( |
348 FROM_HERE, Bind(&WaitableEvent::Wait, Unretained(&task_blocking)))); | 310 FROM_HERE, Bind(&WaitableEvent::Wait, Unretained(&task_blocking)))); |
349 EXPECT_TRUE(task_runner->PostTask(FROM_HERE, Bind(&DoNothing))); | 311 EXPECT_TRUE(task_runner->PostTask(FROM_HERE, Bind(&DoNothing))); |
350 } | 312 } |
351 | 313 |
352 task_running.Wait(); | 314 task_running.Wait(); |
353 CallJoinFromDifferentThread join_from_different_thread( | 315 CallJoinFromDifferentThread join_from_different_thread( |
354 single_thread_task_runner_manager_.get()); | 316 single_thread_task_runner_manager_.get()); |
355 join_from_different_thread.Start(); | 317 join_from_different_thread.Start(); |
356 join_from_different_thread.WaitForRunToStart(); | 318 join_from_different_thread.WaitForRunToStart(); |
357 task_blocking.Signal(); | 319 task_blocking.Signal(); |
358 join_from_different_thread.Join(); | 320 join_from_different_thread.Join(); |
359 } | 321 } |
360 | 322 |
361 } // namespace internal | 323 } // namespace internal |
362 } // namespace base | 324 } // namespace base |
OLD | NEW |