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 { | |
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_); | |
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() { | |
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(TaskTraits()); | |
103 scoped_refptr<SingleThreadTaskRunner> task_runner_2 = | |
104 single_thread_task_runner_manager_ | |
105 ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits()); | |
106 | |
107 PlatformThreadId thread_id_1 = kInvalidThreadId; | |
108 task_runner_1->PostTask(FROM_HERE, Bind(&CaptureThreadId, &thread_id_1)); | |
109 PlatformThreadId thread_id_2 = kInvalidThreadId; | |
110 task_runner_2->PostTask(FROM_HERE, Bind(&CaptureThreadId, &thread_id_2)); | |
111 single_thread_task_runner_manager_->WaitForAllWorkersIdleForTesting(); | |
fdoray
2017/02/08 17:59:01
Could replace CaptureThreadId -> CaptureThreadIdAn
robliao
2017/02/14 21:30:07
Actually, I think we can just use the task tracker
| |
112 | |
113 ASSERT_NE(kInvalidThreadId, thread_id_1); | |
114 ASSERT_NE(kInvalidThreadId, thread_id_2); | |
115 EXPECT_NE(thread_id_1, thread_id_2); | |
116 } | |
117 | |
118 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PrioritySetCorrectly) { | |
119 scoped_refptr<SingleThreadTaskRunner> task_runner_background = | |
120 single_thread_task_runner_manager_ | |
121 ->CreateSingleThreadTaskRunnerWithTraits( | |
122 TaskTraits().WithPriority(TaskPriority::BACKGROUND)); | |
fdoray
2017/02/08 17:59:01
.WithShutdownBehavior(base::TaskShutdownBehavior::
robliao
2017/02/14 21:30:07
Used everywhere now.
| |
123 scoped_refptr<SingleThreadTaskRunner> task_runner_user_visible = | |
124 single_thread_task_runner_manager_ | |
125 ->CreateSingleThreadTaskRunnerWithTraits( | |
126 TaskTraits().WithPriority(TaskPriority::USER_VISIBLE)); | |
127 scoped_refptr<SingleThreadTaskRunner> task_runner_user_blocking = | |
128 single_thread_task_runner_manager_ | |
129 ->CreateSingleThreadTaskRunnerWithTraits( | |
130 TaskTraits().WithPriority(TaskPriority::USER_BLOCKING)); | |
131 | |
132 ThreadPriority thread_priority_background; | |
133 task_runner_background->PostTask( | |
134 FROM_HERE, Bind(&CaptureThreadPriority, &thread_priority_background)); | |
fdoray
2017/02/08 17:59:01
Bind([] () {
if (Lock::HandlesMultipleThreadPrio
robliao
2017/02/14 21:30:07
Covered below.
| |
135 ThreadPriority thread_priority_user_visible; | |
136 task_runner_user_visible->PostTask( | |
137 FROM_HERE, Bind(&CaptureThreadPriority, &thread_priority_user_visible)); | |
138 ThreadPriority thread_priority_user_blocking; | |
139 task_runner_user_blocking->PostTask( | |
140 FROM_HERE, Bind(&CaptureThreadPriority, &thread_priority_user_blocking)); | |
141 single_thread_task_runner_manager_->WaitForAllWorkersIdleForTesting(); | |
fdoray
2017/02/08 17:59:01
Replace WaitForAllWorkersIdleForTesting() with tas
robliao
2017/02/14 21:30:07
Yep! Done.
| |
142 | |
143 if (Lock::HandlesMultipleThreadPriorities()) | |
144 EXPECT_EQ(ThreadPriority::BACKGROUND, thread_priority_background); | |
145 else | |
146 EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_background); | |
147 EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_user_visible); | |
148 EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_user_blocking); | |
149 } | |
150 | |
151 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostTaskAfterShutdown) { | |
152 auto task_runner = single_thread_task_runner_manager_ | |
153 ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits()); | |
154 task_tracker_.Shutdown(); | |
155 EXPECT_FALSE(task_runner->PostTask(FROM_HERE, Bind(&ShouldNotRunCallback))); | |
156 } | |
157 | |
158 // Verify that a Task runs shortly after its delay expires. | |
159 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostDelayedTask) { | |
160 TimeTicks start_time = TimeTicks::Now(); | |
161 | |
162 // Post a task with a short delay. | |
163 WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL, | |
164 WaitableEvent::InitialState::NOT_SIGNALED); | |
165 auto task_runner = single_thread_task_runner_manager_ | |
166 ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits()); | |
167 EXPECT_TRUE(task_runner->PostDelayedTask( | |
168 FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&task_ran)), | |
169 TestTimeouts::tiny_timeout())); | |
170 | |
171 // Wait until the task runs. | |
172 task_ran.Wait(); | |
173 | |
174 // Expect the task to run after its delay expires, but not more than 250 ms | |
175 // after that. | |
176 const TimeDelta actual_delay = TimeTicks::Now() - start_time; | |
177 EXPECT_GE(actual_delay, TestTimeouts::tiny_timeout()); | |
178 EXPECT_LT(actual_delay, | |
179 TimeDelta::FromMilliseconds(250) + TestTimeouts::tiny_timeout()); | |
180 } | |
181 | |
182 // Verify that the RunsTasksOnCurrentThread() method of a SEQUENCED TaskRunner | |
183 // returns false when called from a task that isn't part of the sequence. Note: | |
184 // Tests that use TestTaskFactory already verify that RunsTasksOnCurrentThread() | |
185 // returns true when appropriate so this method complements it to get full | |
186 // coverage of that method. | |
fdoray
2017/02/08 17:59:01
This tests interactions between SchedulerSequenced
robliao
2017/02/14 21:30:07
Done. Moved the test there instead. Unfortunately,
| |
187 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, | |
188 SequencedRunsTasksOnCurrentThread) { | |
189 test::ScopedTaskScheduler scoped_task_scheduler; | |
190 auto task_runner = single_thread_task_runner_manager_ | |
191 ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits()); | |
192 scoped_refptr<SequencedTaskRunner> sequenced_task_runner( | |
193 CreateSequencedTaskRunnerWithTraits(TaskTraits())); | |
194 | |
195 WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL, | |
196 WaitableEvent::InitialState::NOT_SIGNALED); | |
197 task_runner->PostTask( | |
198 FROM_HERE, | |
199 Bind( | |
200 [](scoped_refptr<TaskRunner> sequenced_task_runner, | |
201 WaitableEvent* task_ran) { | |
202 EXPECT_FALSE(sequenced_task_runner->RunsTasksOnCurrentThread()); | |
203 task_ran->Signal(); | |
204 }, | |
205 sequenced_task_runner, Unretained(&task_ran))); | |
206 task_ran.Wait(); | |
207 } | |
208 | |
209 } // namespace internal | |
210 } // namespace base | |
OLD | NEW |