1 // Copyright 2017 The Chromium Authors
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/single_thread_task_runner.h"
6
7 #include "base/memory/scoped_refptr.h"
8 #include "base/run_loop.h"
9 #include "base/task/sequenced_task_runner.h"
10 #include "base/task/single_thread_task_runner.h"
11 #include "base/test/gtest_util.h"
12 #include "base/test/task_environment.h"
13 #include "base/test/test_simple_task_runner.h"
14 #include "testing/gtest/include/gtest/gtest.h"
15
16 namespace base {
17
TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest,Basic)18 TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest, Basic) {
19 scoped_refptr<SingleThreadTaskRunner> task_runner(
20 MakeRefCounted<TestSimpleTaskRunner>());
21
22 EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
23 {
24 SingleThreadTaskRunner::CurrentDefaultHandle sttcd1(task_runner);
25 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
26 EXPECT_EQ(task_runner, SingleThreadTaskRunner::GetCurrentDefault());
27 }
28 EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
29 }
30
31 // Verify that instantiating a `CurrentDefaultHandle` without `MayAlreadyExist`
32 // fails if there is already a current default `SingleThreadTaskRunner`.
TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest,DeathOnImplicitOverride)33 TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest, DeathOnImplicitOverride) {
34 scoped_refptr<SingleThreadTaskRunner> task_runner(
35 MakeRefCounted<TestSimpleTaskRunner>());
36 scoped_refptr<SingleThreadTaskRunner> overidding_task_runner(
37 MakeRefCounted<TestSimpleTaskRunner>());
38
39 SingleThreadTaskRunner::CurrentDefaultHandle sttcd(task_runner);
40 EXPECT_DCHECK_DEATH({
41 SingleThreadTaskRunner::CurrentDefaultHandle overriding_sttcd(
42 overidding_task_runner);
43 });
44 }
45
46 // Verify nested instantiations of `CurrentHandleOverrideForTesting` in a scope
47 // with a `CurrentDefaultHandle`.
TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest,NestedOverrideForTesting)48 TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest, NestedOverrideForTesting) {
49 scoped_refptr<SingleThreadTaskRunner> task_runner_1(
50 MakeRefCounted<TestSimpleTaskRunner>());
51 scoped_refptr<SingleThreadTaskRunner> task_runner_2(
52 MakeRefCounted<TestSimpleTaskRunner>());
53 scoped_refptr<SingleThreadTaskRunner> task_runner_3(
54 MakeRefCounted<TestSimpleTaskRunner>());
55 scoped_refptr<SingleThreadTaskRunner> task_runner_4(
56 MakeRefCounted<TestSimpleTaskRunner>());
57
58 EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
59 {
60 // STTCD in place prior to override.
61 SingleThreadTaskRunner::CurrentDefaultHandle sttcd1(task_runner_1);
62 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
63 EXPECT_EQ(task_runner_1, SingleThreadTaskRunner::GetCurrentDefault());
64
65 {
66 // Override.
67 SingleThreadTaskRunner::CurrentHandleOverrideForTesting sttcd_override_2(
68 task_runner_2);
69 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
70 EXPECT_EQ(task_runner_2, SingleThreadTaskRunner::GetCurrentDefault());
71
72 {
73 // Nested override.
74 SingleThreadTaskRunner::CurrentHandleOverrideForTesting
75 sttcd_override_3(task_runner_3);
76 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
77 EXPECT_EQ(task_runner_3, SingleThreadTaskRunner::GetCurrentDefault());
78 }
79
80 // Back to single override.
81 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
82 EXPECT_EQ(task_runner_2, SingleThreadTaskRunner::GetCurrentDefault());
83
84 {
85 // Backup to double override with another STTCD.
86 SingleThreadTaskRunner::CurrentHandleOverrideForTesting
87 sttcd_override_4(task_runner_4);
88 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
89 EXPECT_EQ(task_runner_4, SingleThreadTaskRunner::GetCurrentDefault());
90 }
91 }
92
93 // Back to simple STTCD.
94 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
95 EXPECT_EQ(task_runner_1, SingleThreadTaskRunner::GetCurrentDefault());
96 }
97 EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
98 }
99
100 // Same as above, but using `CurrentDefaultHandle` with `MayAlreadyExist`
101 // instead of `CurrentHandleOverrideForTesting`.
TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest,NestedOverrideWithMayAlreadyExist)102 TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest,
103 NestedOverrideWithMayAlreadyExist) {
104 scoped_refptr<SingleThreadTaskRunner> task_runner_1(
105 MakeRefCounted<TestSimpleTaskRunner>());
106 scoped_refptr<SingleThreadTaskRunner> task_runner_2(
107 MakeRefCounted<TestSimpleTaskRunner>());
108 scoped_refptr<SingleThreadTaskRunner> task_runner_3(
109 MakeRefCounted<TestSimpleTaskRunner>());
110 scoped_refptr<SingleThreadTaskRunner> task_runner_4(
111 MakeRefCounted<TestSimpleTaskRunner>());
112
113 EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
114 {
115 // STTCD in place prior to override.
116 SingleThreadTaskRunner::CurrentDefaultHandle sttcd1(task_runner_1);
117 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
118 EXPECT_EQ(task_runner_1, SingleThreadTaskRunner::GetCurrentDefault());
119
120 {
121 // Override.
122 SingleThreadTaskRunner::CurrentDefaultHandle sttcd_override_2(
123 task_runner_2,
124 SingleThreadTaskRunner::CurrentDefaultHandle::MayAlreadyExist{});
125 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
126 EXPECT_EQ(task_runner_2, SingleThreadTaskRunner::GetCurrentDefault());
127
128 {
129 // Nested override.
130 SingleThreadTaskRunner::CurrentDefaultHandle sttcd_override_3(
131 task_runner_3,
132 SingleThreadTaskRunner::CurrentDefaultHandle::MayAlreadyExist{});
133 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
134 EXPECT_EQ(task_runner_3, SingleThreadTaskRunner::GetCurrentDefault());
135 }
136
137 // Back to single override.
138 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
139 EXPECT_EQ(task_runner_2, SingleThreadTaskRunner::GetCurrentDefault());
140
141 {
142 // Backup to double override with another STTCD.
143 SingleThreadTaskRunner::CurrentDefaultHandle sttcd_override_4(
144 task_runner_4,
145 SingleThreadTaskRunner::CurrentDefaultHandle::MayAlreadyExist{});
146 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
147 EXPECT_EQ(task_runner_4, SingleThreadTaskRunner::GetCurrentDefault());
148 }
149 }
150
151 // Back to simple STTCD.
152 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
153 EXPECT_EQ(task_runner_1, SingleThreadTaskRunner::GetCurrentDefault());
154 }
155 EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
156 }
157
158 // Verify that `CurrentDefaultHandle` can be used to set the current default
159 // `SingleThreadTaskRunner` and `SequencedTaskRunner` to null in a scope that
160 // already has a default.
TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest,OverrideWithNull)161 TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest, OverrideWithNull) {
162 auto tr1 = MakeRefCounted<TestSimpleTaskRunner>();
163
164 SingleThreadTaskRunner::CurrentDefaultHandle handle(
165 tr1, SingleThreadTaskRunner::CurrentDefaultHandle::MayAlreadyExist{});
166 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
167 EXPECT_EQ(tr1, SingleThreadTaskRunner::GetCurrentDefault());
168 EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
169 EXPECT_EQ(tr1, SequencedTaskRunner::GetCurrentDefault());
170
171 {
172 SingleThreadTaskRunner::CurrentDefaultHandle nested_handle(
173 nullptr,
174 SingleThreadTaskRunner::CurrentDefaultHandle::MayAlreadyExist{});
175 EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
176 EXPECT_CHECK_DEATH(
177 { auto tr2 = SingleThreadTaskRunner::GetCurrentDefault(); });
178 EXPECT_FALSE(SequencedTaskRunner::HasCurrentDefault());
179 EXPECT_CHECK_DEATH(
180 { auto tr2 = SequencedTaskRunner::GetCurrentDefault(); });
181 }
182
183 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
184 EXPECT_EQ(tr1, SingleThreadTaskRunner::GetCurrentDefault());
185 EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
186 EXPECT_EQ(tr1, SequencedTaskRunner::GetCurrentDefault());
187 }
188
189 // Verify that `CurrentDefaultHandle` can be used to set the current default
190 // `SingleThreadTaskRunner` and `SequencedTaskRunner` to a non-null value in a
191 // scope that already has a default.
TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest,OverrideWithNonNull)192 TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest, OverrideWithNonNull) {
193 auto tr1 = MakeRefCounted<TestSimpleTaskRunner>();
194 auto tr2 = MakeRefCounted<TestSimpleTaskRunner>();
195
196 SingleThreadTaskRunner::CurrentDefaultHandle handle(
197 tr1, SingleThreadTaskRunner::CurrentDefaultHandle::MayAlreadyExist{});
198 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
199 EXPECT_EQ(tr1, SingleThreadTaskRunner::GetCurrentDefault());
200 EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
201 EXPECT_EQ(tr1, SequencedTaskRunner::GetCurrentDefault());
202
203 {
204 SingleThreadTaskRunner::CurrentDefaultHandle nested_handle(
205 tr2, SingleThreadTaskRunner::CurrentDefaultHandle::MayAlreadyExist{});
206 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
207 EXPECT_EQ(tr2, SingleThreadTaskRunner::GetCurrentDefault());
208 EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
209 EXPECT_EQ(tr2, SequencedTaskRunner::GetCurrentDefault());
210 }
211
212 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
213 EXPECT_EQ(tr1, SingleThreadTaskRunner::GetCurrentDefault());
214 EXPECT_TRUE(SequencedTaskRunner::HasCurrentDefault());
215 EXPECT_EQ(tr1, SequencedTaskRunner::GetCurrentDefault());
216 }
217
218 // Verify nested instantiations of `CurrentHandleOverrideForTesting` in a scope
219 // without a `CurrentDefaultHandle`.
TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest,OverrideNoExistingSTTCD)220 TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest, OverrideNoExistingSTTCD) {
221 scoped_refptr<SingleThreadTaskRunner> task_runner_1(
222 MakeRefCounted<TestSimpleTaskRunner>());
223 scoped_refptr<SingleThreadTaskRunner> task_runner_2(
224 MakeRefCounted<TestSimpleTaskRunner>());
225
226 EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
227 {
228 // Override with no STTCD in place.
229 SingleThreadTaskRunner::CurrentHandleOverrideForTesting sttcd_override_1(
230 task_runner_1);
231 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
232 EXPECT_EQ(task_runner_1, SingleThreadTaskRunner::GetCurrentDefault());
233
234 {
235 // Nested override works the same.
236 SingleThreadTaskRunner::CurrentHandleOverrideForTesting sttcd_override_2(
237 task_runner_2);
238 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
239 EXPECT_EQ(task_runner_2, SingleThreadTaskRunner::GetCurrentDefault());
240 }
241
242 // Back to single override.
243 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
244 EXPECT_EQ(task_runner_1, SingleThreadTaskRunner::GetCurrentDefault());
245 }
246 EXPECT_FALSE(SingleThreadTaskRunner::HasCurrentDefault());
247 }
248
249 // Verify that `CurrentDefaultHandle` can't be instantiated without
250 // `MayAlreadyExist` in the scope of a `CurrentHandleOverrideForTesting`.
TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest,DeathOnSTTCDOverOverride)251 TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest, DeathOnSTTCDOverOverride) {
252 scoped_refptr<SingleThreadTaskRunner> task_runner(
253 MakeRefCounted<TestSimpleTaskRunner>());
254 scoped_refptr<SingleThreadTaskRunner> overidding_task_runner(
255 MakeRefCounted<TestSimpleTaskRunner>());
256
257 SingleThreadTaskRunner::CurrentHandleOverrideForTesting sttcd_override(
258 task_runner);
259 EXPECT_DCHECK_DEATH({
260 SingleThreadTaskRunner::CurrentDefaultHandle overriding_sttrcd(
261 overidding_task_runner);
262 });
263 }
264
265 // Verify that running a `RunLoop` is supported in the scope of a
266 // `CurrentDefaultHandle` with `MayAlreadyExist`.
TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest,NestedRunLoopAllowedUnderHandleOverride)267 TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest,
268 NestedRunLoopAllowedUnderHandleOverride) {
269 test::SingleThreadTaskEnvironment task_environment;
270 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
271 scoped_refptr<SingleThreadTaskRunner> task_runner(
272 MakeRefCounted<TestSimpleTaskRunner>());
273 SingleThreadTaskRunner::CurrentDefaultHandle sttrcd_override(
274 task_runner,
275 SingleThreadTaskRunner::CurrentDefaultHandle::MayAlreadyExist{});
276 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
277 EXPECT_EQ(task_runner, SingleThreadTaskRunner::GetCurrentDefault());
278 EXPECT_EQ(task_runner, SequencedTaskRunner::GetCurrentDefault());
279 RunLoop().RunUntilIdle();
280 }
281
282 // Verify that running a `RunLoop` fails in the scope of a
283 // `CurrentHandleOverrideForTesting`.
TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest,NestedRunLoopDisallowedUnderHandleOverrideForTesting)284 TEST(SingleThreadTaskRunnerCurrentDefaultHandleTest,
285 NestedRunLoopDisallowedUnderHandleOverrideForTesting) {
286 test::SingleThreadTaskEnvironment task_environment;
287 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
288 scoped_refptr<SingleThreadTaskRunner> task_runner(
289 MakeRefCounted<TestSimpleTaskRunner>());
290 SingleThreadTaskRunner::CurrentHandleOverrideForTesting sttcd_override(
291 task_runner);
292 EXPECT_TRUE(SingleThreadTaskRunner::HasCurrentDefault());
293 EXPECT_EQ(task_runner, SingleThreadTaskRunner::GetCurrentDefault());
294 EXPECT_EQ(task_runner, SequencedTaskRunner::GetCurrentDefault());
295 EXPECT_DCHECK_DEATH({ RunLoop().RunUntilIdle(); });
296 }
297
298 } // namespace base
299