1 // Copyright 2018 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/sequence_manager/sequence_manager_impl.h"
6
7 #include <stddef.h>
8 #include <memory>
9 #include <string>
10 #include <utility>
11 #include <vector>
12
13 #include "base/auto_reset.h"
14 #include "base/bind.h"
15 #include "base/callback.h"
16 #include "base/callback_helpers.h"
17 #include "base/cancelable_callback.h"
18 #include "base/location.h"
19 #include "base/memory/ref_counted_memory.h"
20 #include "base/memory/scoped_refptr.h"
21 #include "base/message_loop/message_pump_default.h"
22 #include "base/message_loop/message_pump_type.h"
23 #include "base/optional.h"
24 #include "base/run_loop.h"
25 #include "base/single_thread_task_runner.h"
26 #include "base/strings/strcat.h"
27 #include "base/strings/string_number_conversions.h"
28 #include "base/strings/stringprintf.h"
29 #include "base/synchronization/waitable_event.h"
30 #include "base/task/current_thread.h"
31 #include "base/task/sequence_manager/real_time_domain.h"
32 #include "base/task/sequence_manager/sequence_manager.h"
33 #include "base/task/sequence_manager/task_queue.h"
34 #include "base/task/sequence_manager/task_queue_impl.h"
35 #include "base/task/sequence_manager/task_queue_selector.h"
36 #include "base/task/sequence_manager/tasks.h"
37 #include "base/task/sequence_manager/test/mock_time_domain.h"
38 #include "base/task/sequence_manager/test/mock_time_message_pump.h"
39 #include "base/task/sequence_manager/test/sequence_manager_for_test.h"
40 #include "base/task/sequence_manager/test/test_task_queue.h"
41 #include "base/task/sequence_manager/test/test_task_time_observer.h"
42 #include "base/task/sequence_manager/thread_controller_with_message_pump_impl.h"
43 #include "base/task/sequence_manager/work_queue.h"
44 #include "base/task/sequence_manager/work_queue_sets.h"
45 #include "base/test/bind.h"
46 #include "base/test/mock_callback.h"
47 #include "base/test/null_task_runner.h"
48 #include "base/test/simple_test_tick_clock.h"
49 #include "base/test/task_environment.h"
50 #include "base/test/test_mock_time_task_runner.h"
51 #include "base/test/test_simple_task_runner.h"
52 #include "base/threading/thread.h"
53 #include "base/threading/thread_task_runner_handle.h"
54 #include "base/time/time.h"
55 #include "base/trace_event/base_tracing.h"
56 #include "base/tracing_buildflags.h"
57 #include "build/build_config.h"
58 #include "testing/gmock/include/gmock/gmock.h"
59
60 #if BUILDFLAG(ENABLE_BASE_TRACING)
61 #include "base/test/trace_event_analyzer.h"
62 #endif // BUILDFLAG(ENABLE_BASE_TRACING)
63
64 using base::sequence_manager::EnqueueOrder;
65 using testing::_;
66 using testing::AnyNumber;
67 using testing::Contains;
68 using testing::ElementsAre;
69 using testing::ElementsAreArray;
70 using testing::HasSubstr;
71 using testing::Mock;
72 using testing::Not;
73 using testing::Return;
74 using testing::StrictMock;
75 using testing::UnorderedElementsAre;
76
77 namespace base {
78 namespace sequence_manager {
79 namespace internal {
80 // To avoid symbol collisions in jumbo builds.
81 namespace sequence_manager_impl_unittest {
82
83 enum class TestType {
84 kMockTaskRunner,
85 kMessagePump,
86 };
87
ToString(TestType type)88 std::string ToString(TestType type) {
89 switch (type) {
90 case TestType::kMockTaskRunner:
91 return "kMockTaskRunner";
92 case TestType::kMessagePump:
93 return "kMessagePump";
94 }
95 }
96
GetTestNameSuffix(const testing::TestParamInfo<TestType> & info)97 std::string GetTestNameSuffix(const testing::TestParamInfo<TestType>& info) {
98 return StrCat({"With", ToString(info.param).substr(1)});
99 }
100
PrintTo(const TestType type,std::ostream * os)101 void PrintTo(const TestType type, std::ostream* os) {
102 *os << ToString(type);
103 }
104
105 using MockTask = MockCallback<base::RepeatingCallback<void()>>;
106
107 // This class abstracts the details of how the SequenceManager runs tasks.
108 // Subclasses will use a MockTaskRunner, a MessageLoop or a MockMessagePump. We
109 // can then have common tests for all the scenarios by just using this
110 // interface.
111 class Fixture {
112 public:
113 virtual ~Fixture() = default;
114 virtual void AdvanceMockTickClock(TimeDelta delta) = 0;
115 virtual const TickClock* mock_tick_clock() const = 0;
116 virtual TimeDelta NextPendingTaskDelay() const = 0;
117 // Keeps advancing time as needed to run tasks up to the specified limit.
118 virtual void FastForwardBy(TimeDelta delta) = 0;
119 // Keeps advancing time as needed to run tasks until no more tasks are
120 // available.
121 virtual void FastForwardUntilNoTasksRemain() = 0;
122 virtual void RunDoWorkOnce() = 0;
123 virtual SequenceManagerForTest* sequence_manager() const = 0;
124 virtual void DestroySequenceManager() = 0;
125 virtual int GetNowTicksCallCount() = 0;
126 };
127
128 class CallCountingTickClock : public TickClock {
129 public:
CallCountingTickClock(RepeatingCallback<TimeTicks ()> now_callback)130 explicit CallCountingTickClock(RepeatingCallback<TimeTicks()> now_callback)
131 : now_callback_(std::move(now_callback)) {}
CallCountingTickClock(TickClock * clock)132 explicit CallCountingTickClock(TickClock* clock)
133 : CallCountingTickClock(
134 BindLambdaForTesting([clock]() { return clock->NowTicks(); })) {}
135
136 ~CallCountingTickClock() override = default;
137
NowTicks() const138 TimeTicks NowTicks() const override {
139 ++now_call_count_;
140 return now_callback_.Run();
141 }
142
Reset()143 void Reset() { now_call_count_.store(0); }
144
now_call_count() const145 int now_call_count() const { return now_call_count_; }
146
147 private:
148 const RepeatingCallback<TimeTicks()> now_callback_;
149 mutable std::atomic<int> now_call_count_{0};
150 };
151
152 class FixtureWithMockTaskRunner final : public Fixture {
153 public:
FixtureWithMockTaskRunner()154 FixtureWithMockTaskRunner()
155 : test_task_runner_(MakeRefCounted<TestMockTimeTaskRunner>(
156 TestMockTimeTaskRunner::Type::kBoundToThread)),
157 call_counting_clock_(BindRepeating(&TestMockTimeTaskRunner::NowTicks,
158 test_task_runner_)),
159 sequence_manager_(SequenceManagerForTest::Create(
160 nullptr,
161 ThreadTaskRunnerHandle::Get(),
162 mock_tick_clock(),
163 SequenceManager::Settings::Builder()
164 .SetMessagePumpType(MessagePumpType::DEFAULT)
165 .SetRandomisedSamplingEnabled(false)
166 .SetTickClock(mock_tick_clock())
167 .Build())) {
168 // A null clock triggers some assertions.
169 AdvanceMockTickClock(TimeDelta::FromMilliseconds(1));
170
171 // The SequenceManager constructor calls Now() once for setting up
172 // housekeeping.
173 EXPECT_EQ(1, GetNowTicksCallCount());
174 call_counting_clock_.Reset();
175 }
176
AdvanceMockTickClock(TimeDelta delta)177 void AdvanceMockTickClock(TimeDelta delta) override {
178 test_task_runner_->AdvanceMockTickClock(delta);
179 }
180
mock_tick_clock() const181 const TickClock* mock_tick_clock() const override {
182 return &call_counting_clock_;
183 }
184
NextPendingTaskDelay() const185 TimeDelta NextPendingTaskDelay() const override {
186 return test_task_runner_->NextPendingTaskDelay();
187 }
188
FastForwardBy(TimeDelta delta)189 void FastForwardBy(TimeDelta delta) override {
190 test_task_runner_->FastForwardBy(delta);
191 }
192
FastForwardUntilNoTasksRemain()193 void FastForwardUntilNoTasksRemain() override {
194 test_task_runner_->FastForwardUntilNoTasksRemain();
195 }
196
RunDoWorkOnce()197 void RunDoWorkOnce() override {
198 EXPECT_EQ(test_task_runner_->GetPendingTaskCount(), 1u);
199 // We should only run tasks already posted by that moment.
200 RunLoop run_loop;
201 test_task_runner_->PostTask(FROM_HERE, run_loop.QuitClosure());
202 // TestMockTimeTaskRunner will fast-forward mock clock if necessary.
203 run_loop.Run();
204 }
205
test_task_runner() const206 scoped_refptr<TestMockTimeTaskRunner> test_task_runner() const {
207 return test_task_runner_;
208 }
209
sequence_manager() const210 SequenceManagerForTest* sequence_manager() const override {
211 return sequence_manager_.get();
212 }
213
DestroySequenceManager()214 void DestroySequenceManager() override { sequence_manager_.reset(); }
215
GetNowTicksCallCount()216 int GetNowTicksCallCount() override {
217 return call_counting_clock_.now_call_count();
218 }
219
220 private:
221 scoped_refptr<TestMockTimeTaskRunner> test_task_runner_;
222 CallCountingTickClock call_counting_clock_;
223 std::unique_ptr<SequenceManagerForTest> sequence_manager_;
224 };
225
226 class FixtureWithMockMessagePump : public Fixture {
227 public:
FixtureWithMockMessagePump()228 FixtureWithMockMessagePump() : call_counting_clock_(&mock_clock_) {
229 // A null clock triggers some assertions.
230 mock_clock_.Advance(TimeDelta::FromMilliseconds(1));
231
232 auto pump = std::make_unique<MockTimeMessagePump>(&mock_clock_);
233 pump_ = pump.get();
234 auto settings = SequenceManager::Settings::Builder()
235 .SetMessagePumpType(MessagePumpType::DEFAULT)
236 .SetRandomisedSamplingEnabled(false)
237 .SetTickClock(mock_tick_clock())
238 .Build();
239 sequence_manager_ = SequenceManagerForTest::Create(
240 std::make_unique<ThreadControllerWithMessagePumpImpl>(std::move(pump),
241 settings),
242 std::move(settings));
243 sequence_manager_->SetDefaultTaskRunner(MakeRefCounted<NullTaskRunner>());
244
245 // The SequenceManager constructor calls Now() once for setting up
246 // housekeeping.
247 EXPECT_EQ(1, GetNowTicksCallCount());
248 call_counting_clock_.Reset();
249 }
250
AdvanceMockTickClock(TimeDelta delta)251 void AdvanceMockTickClock(TimeDelta delta) override {
252 mock_clock_.Advance(delta);
253 }
254
mock_tick_clock() const255 const TickClock* mock_tick_clock() const override {
256 return &call_counting_clock_;
257 }
258
NextPendingTaskDelay() const259 TimeDelta NextPendingTaskDelay() const override {
260 return pump_->next_wake_up_time() - mock_tick_clock()->NowTicks();
261 }
262
FastForwardBy(TimeDelta delta)263 void FastForwardBy(TimeDelta delta) override {
264 pump_->SetAllowTimeToAutoAdvanceUntil(mock_tick_clock()->NowTicks() +
265 delta);
266 pump_->SetStopWhenMessagePumpIsIdle(true);
267 RunLoop().Run();
268 pump_->SetStopWhenMessagePumpIsIdle(false);
269 }
270
FastForwardUntilNoTasksRemain()271 void FastForwardUntilNoTasksRemain() override {
272 pump_->SetAllowTimeToAutoAdvanceUntil(TimeTicks::Max());
273 pump_->SetStopWhenMessagePumpIsIdle(true);
274 RunLoop().Run();
275 pump_->SetStopWhenMessagePumpIsIdle(false);
276 pump_->SetAllowTimeToAutoAdvanceUntil(mock_tick_clock()->NowTicks());
277 }
278
RunDoWorkOnce()279 void RunDoWorkOnce() override {
280 pump_->SetQuitAfterDoWork(true);
281 RunLoop().Run();
282 pump_->SetQuitAfterDoWork(false);
283 }
284
sequence_manager() const285 SequenceManagerForTest* sequence_manager() const override {
286 return sequence_manager_.get();
287 }
288
DestroySequenceManager()289 void DestroySequenceManager() override {
290 pump_ = nullptr;
291 sequence_manager_.reset();
292 }
293
GetNowTicksCallCount()294 int GetNowTicksCallCount() override {
295 return call_counting_clock_.now_call_count();
296 }
297
298 private:
299 MockTimeMessagePump* pump_ = nullptr;
300 SimpleTestTickClock mock_clock_;
301 CallCountingTickClock call_counting_clock_;
302 std::unique_ptr<SequenceManagerForTest> sequence_manager_;
303 };
304
305 // Convenience wrapper around the fixtures so that we can use parametrized tests
306 // instead of templated ones. The latter would be more verbose as all method
307 // calls to the fixture would need to be like this->method()
308 class SequenceManagerTest : public testing::TestWithParam<TestType>,
309 public Fixture {
310 public:
SequenceManagerTest()311 SequenceManagerTest() {
312 switch (GetUnderlyingRunnerType()) {
313 case TestType::kMockTaskRunner:
314 fixture_ = std::make_unique<FixtureWithMockTaskRunner>();
315 break;
316 case TestType::kMessagePump:
317 fixture_ = std::make_unique<FixtureWithMockMessagePump>();
318 break;
319 default:
320 NOTREACHED();
321 }
322 }
323
CreateTaskQueue(TaskQueue::Spec spec=TaskQueue::Spec ("test"))324 scoped_refptr<TestTaskQueue> CreateTaskQueue(
325 TaskQueue::Spec spec = TaskQueue::Spec("test")) {
326 return sequence_manager()->CreateTaskQueueWithType<TestTaskQueue>(spec);
327 }
328
CreateTaskQueues(size_t num_queues)329 std::vector<scoped_refptr<TestTaskQueue>> CreateTaskQueues(
330 size_t num_queues) {
331 std::vector<scoped_refptr<TestTaskQueue>> queues;
332 for (size_t i = 0; i < num_queues; i++)
333 queues.push_back(CreateTaskQueue());
334 return queues;
335 }
336
RunUntilManagerIsIdle(RepeatingClosure per_run_time_callback)337 void RunUntilManagerIsIdle(RepeatingClosure per_run_time_callback) {
338 for (;;) {
339 // Advance time if we've run out of immediate work to do.
340 if (!sequence_manager()->HasImmediateWork()) {
341 LazyNow lazy_now(mock_tick_clock());
342 Optional<TimeDelta> delay =
343 sequence_manager()->GetRealTimeDomain()->DelayTillNextTask(
344 &lazy_now);
345 if (delay) {
346 AdvanceMockTickClock(*delay);
347 per_run_time_callback.Run();
348 } else {
349 break;
350 }
351 }
352 RunLoop().RunUntilIdle();
353 }
354 }
355
AdvanceMockTickClock(TimeDelta delta)356 void AdvanceMockTickClock(TimeDelta delta) override {
357 fixture_->AdvanceMockTickClock(delta);
358 }
359
mock_tick_clock() const360 const TickClock* mock_tick_clock() const override {
361 return fixture_->mock_tick_clock();
362 }
363
NextPendingTaskDelay() const364 TimeDelta NextPendingTaskDelay() const override {
365 return fixture_->NextPendingTaskDelay();
366 }
367
FastForwardBy(TimeDelta delta)368 void FastForwardBy(TimeDelta delta) override {
369 fixture_->FastForwardBy(delta);
370 }
371
FastForwardUntilNoTasksRemain()372 void FastForwardUntilNoTasksRemain() override {
373 fixture_->FastForwardUntilNoTasksRemain();
374 }
375
RunDoWorkOnce()376 void RunDoWorkOnce() override { fixture_->RunDoWorkOnce(); }
377
sequence_manager() const378 SequenceManagerForTest* sequence_manager() const override {
379 return fixture_->sequence_manager();
380 }
381
DestroySequenceManager()382 void DestroySequenceManager() override { fixture_->DestroySequenceManager(); }
383
GetNowTicksCallCount()384 int GetNowTicksCallCount() override {
385 return fixture_->GetNowTicksCallCount();
386 }
387
GetUnderlyingRunnerType()388 TestType GetUnderlyingRunnerType() { return GetParam(); }
389
390 private:
391 std::unique_ptr<Fixture> fixture_;
392 };
393
394 INSTANTIATE_TEST_SUITE_P(All,
395 SequenceManagerTest,
396 testing::Values(TestType::kMockTaskRunner,
397 TestType::kMessagePump),
398 GetTestNameSuffix);
399
PostFromNestedRunloop(scoped_refptr<TestTaskQueue> runner,std::vector<std::pair<OnceClosure,bool>> * tasks)400 void PostFromNestedRunloop(scoped_refptr<TestTaskQueue> runner,
401 std::vector<std::pair<OnceClosure, bool>>* tasks) {
402 for (std::pair<OnceClosure, bool>& pair : *tasks) {
403 if (pair.second) {
404 runner->task_runner()->PostTask(FROM_HERE, std::move(pair.first));
405 } else {
406 runner->task_runner()->PostNonNestableTask(FROM_HERE,
407 std::move(pair.first));
408 }
409 }
410 RunLoop(RunLoop::Type::kNestableTasksAllowed).RunUntilIdle();
411 }
412
NopTask()413 void NopTask() {}
414
415 class TestCountUsesTimeSource : public TickClock {
416 public:
417 TestCountUsesTimeSource() = default;
418 TestCountUsesTimeSource(const TestCountUsesTimeSource&) = delete;
419 TestCountUsesTimeSource& operator=(const TestCountUsesTimeSource&) = delete;
420 ~TestCountUsesTimeSource() override = default;
421
NowTicks() const422 TimeTicks NowTicks() const override {
423 now_calls_count_++;
424 // Don't return 0, as it triggers some assertions.
425 return TimeTicks() + TimeDelta::FromSeconds(1);
426 }
427
now_calls_count() const428 int now_calls_count() const { return now_calls_count_; }
429
430 private:
431 mutable int now_calls_count_ = 0;
432 };
433
TEST_P(SequenceManagerTest,GetCorrectTaskRunnerForCurrentTask)434 TEST_P(SequenceManagerTest, GetCorrectTaskRunnerForCurrentTask) {
435 auto queue = CreateTaskQueue();
436
437 queue->task_runner()->PostTask(
438 FROM_HERE, BindLambdaForTesting([&]() {
439 EXPECT_EQ(queue->task_runner(),
440 sequence_manager()->GetTaskRunnerForCurrentTask());
441 }));
442
443 RunLoop().RunUntilIdle();
444 }
445
TEST_P(SequenceManagerTest,NowNotCalledIfUnneeded)446 TEST_P(SequenceManagerTest, NowNotCalledIfUnneeded) {
447 sequence_manager()->SetWorkBatchSize(6);
448
449 auto queues = CreateTaskQueues(3u);
450
451 queues[0]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
452 queues[0]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
453 queues[1]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
454 queues[1]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
455 queues[2]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
456 queues[2]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
457
458 RunLoop().RunUntilIdle();
459
460 EXPECT_EQ(0, GetNowTicksCallCount());
461 }
462
TEST_P(SequenceManagerTest,NowCalledMinimumNumberOfTimesToComputeTaskDurations)463 TEST_P(SequenceManagerTest,
464 NowCalledMinimumNumberOfTimesToComputeTaskDurations) {
465 TestTaskTimeObserver time_observer;
466 sequence_manager()->SetWorkBatchSize(6);
467 sequence_manager()->AddTaskTimeObserver(&time_observer);
468
469 auto queues = CreateTaskQueues(3u);
470
471 queues[0]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
472 queues[0]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
473 queues[1]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
474 queues[1]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
475 queues[2]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
476 queues[2]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
477
478 RunLoop().RunUntilIdle();
479 // Now is called when each task starts running and when its completed.
480 // 6 * 2 = 12 calls.
481 EXPECT_EQ(12, GetNowTicksCallCount());
482 }
483
TEST_P(SequenceManagerTest,NowCalledMinimumNumberOfTimesToComputeTaskDurationsDelayedFenceAllowed)484 TEST_P(SequenceManagerTest,
485 NowCalledMinimumNumberOfTimesToComputeTaskDurationsDelayedFenceAllowed) {
486 TestTaskTimeObserver time_observer;
487 sequence_manager()->SetWorkBatchSize(6);
488 sequence_manager()->AddTaskTimeObserver(&time_observer);
489
490 std::vector<scoped_refptr<TestTaskQueue>> queues;
491 for (size_t i = 0; i < 3; i++) {
492 queues.push_back(
493 CreateTaskQueue(TaskQueue::Spec("test").SetDelayedFencesAllowed(true)));
494 }
495
496 queues[0]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
497 queues[0]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
498 queues[1]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
499 queues[1]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
500 queues[2]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
501 queues[2]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
502
503 RunLoop().RunUntilIdle();
504 // Now is called each time a task is queued, when first task is started
505 // running, and when a task is completed. 6 * 3 = 18 calls.
506 EXPECT_EQ(18, GetNowTicksCallCount());
507 }
508
NullTask()509 void NullTask() {}
510
TestTask(uint64_t value,std::vector<EnqueueOrder> * out_result)511 void TestTask(uint64_t value, std::vector<EnqueueOrder>* out_result) {
512 out_result->push_back(EnqueueOrder::FromIntForTesting(value));
513 }
514
DisableQueueTestTask(uint64_t value,std::vector<EnqueueOrder> * out_result,TaskQueue::QueueEnabledVoter * voter)515 void DisableQueueTestTask(uint64_t value,
516 std::vector<EnqueueOrder>* out_result,
517 TaskQueue::QueueEnabledVoter* voter) {
518 out_result->push_back(EnqueueOrder::FromIntForTesting(value));
519 voter->SetVoteToEnable(false);
520 }
521
TEST_P(SequenceManagerTest,SingleQueuePosting)522 TEST_P(SequenceManagerTest, SingleQueuePosting) {
523 auto queue = CreateTaskQueue();
524
525 std::vector<EnqueueOrder> run_order;
526 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order));
527 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 2, &run_order));
528 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 3, &run_order));
529
530 RunLoop().RunUntilIdle();
531 EXPECT_THAT(run_order, ElementsAre(1u, 2u, 3u));
532 }
533
TEST_P(SequenceManagerTest,MultiQueuePosting)534 TEST_P(SequenceManagerTest, MultiQueuePosting) {
535 auto queues = CreateTaskQueues(3u);
536
537 std::vector<EnqueueOrder> run_order;
538 queues[0]->task_runner()->PostTask(FROM_HERE,
539 BindOnce(&TestTask, 1, &run_order));
540 queues[0]->task_runner()->PostTask(FROM_HERE,
541 BindOnce(&TestTask, 2, &run_order));
542 queues[1]->task_runner()->PostTask(FROM_HERE,
543 BindOnce(&TestTask, 3, &run_order));
544 queues[1]->task_runner()->PostTask(FROM_HERE,
545 BindOnce(&TestTask, 4, &run_order));
546 queues[2]->task_runner()->PostTask(FROM_HERE,
547 BindOnce(&TestTask, 5, &run_order));
548 queues[2]->task_runner()->PostTask(FROM_HERE,
549 BindOnce(&TestTask, 6, &run_order));
550
551 RunLoop().RunUntilIdle();
552 EXPECT_THAT(run_order, ElementsAre(1u, 2u, 3u, 4u, 5u, 6u));
553 }
554
TEST_P(SequenceManagerTest,NonNestableTaskPosting)555 TEST_P(SequenceManagerTest, NonNestableTaskPosting) {
556 auto queue = CreateTaskQueue();
557
558 std::vector<EnqueueOrder> run_order;
559 queue->task_runner()->PostNonNestableTask(FROM_HERE,
560 BindOnce(&TestTask, 1, &run_order));
561
562 RunLoop().RunUntilIdle();
563 EXPECT_THAT(run_order, ElementsAre(1u));
564 }
565
TEST_P(SequenceManagerTest,NonNestableTaskExecutesInExpectedOrder)566 TEST_P(SequenceManagerTest, NonNestableTaskExecutesInExpectedOrder) {
567 auto queue = CreateTaskQueue();
568
569 std::vector<EnqueueOrder> run_order;
570 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order));
571 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 2, &run_order));
572 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 3, &run_order));
573 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 4, &run_order));
574 queue->task_runner()->PostNonNestableTask(FROM_HERE,
575 BindOnce(&TestTask, 5, &run_order));
576
577 RunLoop().RunUntilIdle();
578 EXPECT_THAT(run_order, ElementsAre(1u, 2u, 3u, 4u, 5u));
579 }
580
TEST_P(SequenceManagerTest,NonNestableTasksDoesntExecuteInNestedLoop)581 TEST_P(SequenceManagerTest, NonNestableTasksDoesntExecuteInNestedLoop) {
582 if (GetUnderlyingRunnerType() == TestType::kMockTaskRunner)
583 return;
584 auto queue = CreateTaskQueue();
585
586 std::vector<EnqueueOrder> run_order;
587 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order));
588 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 2, &run_order));
589
590 std::vector<std::pair<OnceClosure, bool>> tasks_to_post_from_nested_loop;
591 tasks_to_post_from_nested_loop.push_back(
592 std::make_pair(BindOnce(&TestTask, 3, &run_order), false));
593 tasks_to_post_from_nested_loop.push_back(
594 std::make_pair(BindOnce(&TestTask, 4, &run_order), false));
595 tasks_to_post_from_nested_loop.push_back(
596 std::make_pair(BindOnce(&TestTask, 5, &run_order), true));
597 tasks_to_post_from_nested_loop.push_back(
598 std::make_pair(BindOnce(&TestTask, 6, &run_order), true));
599
600 queue->task_runner()->PostTask(
601 FROM_HERE, BindOnce(&PostFromNestedRunloop, queue,
602 Unretained(&tasks_to_post_from_nested_loop)));
603
604 RunLoop().RunUntilIdle();
605 // Note we expect tasks 3 & 4 to run last because they're non-nestable.
606 EXPECT_THAT(run_order, ElementsAre(1u, 2u, 5u, 6u, 3u, 4u));
607 }
608
609 namespace {
610
InsertFenceAndPostTestTask(int id,std::vector<EnqueueOrder> * run_order,scoped_refptr<TestTaskQueue> task_queue,SequenceManagerForTest * manager)611 void InsertFenceAndPostTestTask(int id,
612 std::vector<EnqueueOrder>* run_order,
613 scoped_refptr<TestTaskQueue> task_queue,
614 SequenceManagerForTest* manager) {
615 run_order->push_back(EnqueueOrder::FromIntForTesting(id));
616 task_queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
617 task_queue->task_runner()->PostTask(FROM_HERE,
618 BindOnce(&TestTask, id + 1, run_order));
619
620 // Force reload of immediate work queue. In real life the same effect can be
621 // achieved with cross-thread posting.
622 manager->ReloadEmptyWorkQueues();
623 }
624
625 } // namespace
626
TEST_P(SequenceManagerTest,TaskQueueDisabledFromNestedLoop)627 TEST_P(SequenceManagerTest, TaskQueueDisabledFromNestedLoop) {
628 if (GetUnderlyingRunnerType() == TestType::kMockTaskRunner)
629 return;
630 auto queue = CreateTaskQueue();
631 std::vector<EnqueueOrder> run_order;
632
633 std::vector<std::pair<OnceClosure, bool>> tasks_to_post_from_nested_loop;
634
635 tasks_to_post_from_nested_loop.push_back(
636 std::make_pair(BindOnce(&TestTask, 1, &run_order), false));
637 tasks_to_post_from_nested_loop.push_back(
638 std::make_pair(BindOnce(&InsertFenceAndPostTestTask, 2, &run_order, queue,
639 sequence_manager()),
640 true));
641
642 queue->task_runner()->PostTask(
643 FROM_HERE, BindOnce(&PostFromNestedRunloop, queue,
644 Unretained(&tasks_to_post_from_nested_loop)));
645 RunLoop().RunUntilIdle();
646
647 // Task 1 shouldn't run first due to it being non-nestable and queue gets
648 // blocked after task 2. Task 1 runs after existing nested message loop
649 // due to being posted before inserting a fence.
650 // This test checks that breaks when nestable task is pushed into a redo
651 // queue.
652 EXPECT_THAT(run_order, ElementsAre(2u, 1u));
653
654 queue->RemoveFence();
655 RunLoop().RunUntilIdle();
656 EXPECT_THAT(run_order, ElementsAre(2u, 1u, 3u));
657 }
658
TEST_P(SequenceManagerTest,HasPendingImmediateWork_ImmediateTask)659 TEST_P(SequenceManagerTest, HasPendingImmediateWork_ImmediateTask) {
660 auto queue = CreateTaskQueue();
661
662 std::vector<EnqueueOrder> run_order;
663 EXPECT_FALSE(queue->HasTaskToRunImmediately());
664 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order));
665 EXPECT_TRUE(queue->HasTaskToRunImmediately());
666
667 // Move the task into the |immediate_work_queue|.
668 EXPECT_TRUE(queue->GetTaskQueueImpl()->immediate_work_queue()->Empty());
669 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
670 queue->CreateQueueEnabledVoter();
671 voter->SetVoteToEnable(false);
672 RunLoop().RunUntilIdle();
673 EXPECT_FALSE(queue->GetTaskQueueImpl()->immediate_work_queue()->Empty());
674 EXPECT_TRUE(queue->HasTaskToRunImmediately());
675
676 // Run the task, making the queue empty.
677 voter->SetVoteToEnable(true);
678 RunLoop().RunUntilIdle();
679 EXPECT_FALSE(queue->HasTaskToRunImmediately());
680 }
681
TEST_P(SequenceManagerTest,HasPendingImmediateWork_DelayedTask)682 TEST_P(SequenceManagerTest, HasPendingImmediateWork_DelayedTask) {
683 auto queue = CreateTaskQueue();
684
685 std::vector<EnqueueOrder> run_order;
686 TimeDelta delay(TimeDelta::FromMilliseconds(10));
687 queue->task_runner()->PostDelayedTask(
688 FROM_HERE, BindOnce(&TestTask, 1, &run_order), delay);
689 EXPECT_FALSE(queue->HasTaskToRunImmediately());
690 AdvanceMockTickClock(delay);
691 EXPECT_TRUE(queue->HasTaskToRunImmediately());
692
693 // Move the task into the |delayed_work_queue|.
694 LazyNow lazy_now(mock_tick_clock());
695 sequence_manager()->MoveReadyDelayedTasksToWorkQueues(&lazy_now);
696 sequence_manager()->ScheduleWork();
697 EXPECT_FALSE(queue->GetTaskQueueImpl()->delayed_work_queue()->Empty());
698 EXPECT_TRUE(queue->HasTaskToRunImmediately());
699
700 // Run the task, making the queue empty.
701 RunLoop().RunUntilIdle();
702 EXPECT_TRUE(queue->GetTaskQueueImpl()->delayed_work_queue()->Empty());
703 }
704
TEST_P(SequenceManagerTest,DelayedTaskPosting)705 TEST_P(SequenceManagerTest, DelayedTaskPosting) {
706 auto queue = CreateTaskQueue();
707
708 std::vector<EnqueueOrder> run_order;
709 TimeDelta delay(TimeDelta::FromMilliseconds(10));
710 queue->task_runner()->PostDelayedTask(
711 FROM_HERE, BindOnce(&TestTask, 1, &run_order), delay);
712 EXPECT_EQ(TimeDelta::FromMilliseconds(10), NextPendingTaskDelay());
713 EXPECT_FALSE(queue->HasTaskToRunImmediately());
714 EXPECT_TRUE(run_order.empty());
715
716 // The task doesn't run before the delay has completed.
717 FastForwardBy(TimeDelta::FromMilliseconds(9));
718 EXPECT_TRUE(run_order.empty());
719
720 // After the delay has completed, the task runs normally.
721 FastForwardBy(TimeDelta::FromMilliseconds(1));
722 EXPECT_THAT(run_order, ElementsAre(1u));
723 EXPECT_FALSE(queue->HasTaskToRunImmediately());
724 }
725
TEST(SequenceManagerTestWithMockTaskRunner,DelayedTaskExecutedInOneMessageLoopTask)726 TEST(SequenceManagerTestWithMockTaskRunner,
727 DelayedTaskExecutedInOneMessageLoopTask) {
728 FixtureWithMockTaskRunner fixture;
729 auto queue =
730 fixture.sequence_manager()->CreateTaskQueue(TaskQueue::Spec("test"));
731
732 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
733 TimeDelta::FromMilliseconds(10));
734 RunLoop().RunUntilIdle();
735 EXPECT_EQ(1u, fixture.test_task_runner()->GetPendingTaskCount());
736 fixture.FastForwardUntilNoTasksRemain();
737 EXPECT_EQ(0u, fixture.test_task_runner()->GetPendingTaskCount());
738 }
739
TEST_P(SequenceManagerTest,DelayedTaskPosting_MultipleTasks_DecendingOrder)740 TEST_P(SequenceManagerTest, DelayedTaskPosting_MultipleTasks_DecendingOrder) {
741 auto queue = CreateTaskQueue();
742
743 std::vector<EnqueueOrder> run_order;
744 queue->task_runner()->PostDelayedTask(FROM_HERE,
745 BindOnce(&TestTask, 1, &run_order),
746 TimeDelta::FromMilliseconds(10));
747
748 queue->task_runner()->PostDelayedTask(FROM_HERE,
749 BindOnce(&TestTask, 2, &run_order),
750 TimeDelta::FromMilliseconds(8));
751
752 queue->task_runner()->PostDelayedTask(FROM_HERE,
753 BindOnce(&TestTask, 3, &run_order),
754 TimeDelta::FromMilliseconds(5));
755
756 EXPECT_EQ(TimeDelta::FromMilliseconds(5), NextPendingTaskDelay());
757
758 FastForwardBy(TimeDelta::FromMilliseconds(5));
759 EXPECT_THAT(run_order, ElementsAre(3u));
760 EXPECT_EQ(TimeDelta::FromMilliseconds(3), NextPendingTaskDelay());
761
762 FastForwardBy(TimeDelta::FromMilliseconds(3));
763 EXPECT_THAT(run_order, ElementsAre(3u, 2u));
764 EXPECT_EQ(TimeDelta::FromMilliseconds(2), NextPendingTaskDelay());
765
766 FastForwardBy(TimeDelta::FromMilliseconds(2));
767 EXPECT_THAT(run_order, ElementsAre(3u, 2u, 1u));
768 }
769
TEST_P(SequenceManagerTest,DelayedTaskPosting_MultipleTasks_AscendingOrder)770 TEST_P(SequenceManagerTest, DelayedTaskPosting_MultipleTasks_AscendingOrder) {
771 auto queue = CreateTaskQueue();
772
773 std::vector<EnqueueOrder> run_order;
774 queue->task_runner()->PostDelayedTask(FROM_HERE,
775 BindOnce(&TestTask, 1, &run_order),
776 TimeDelta::FromMilliseconds(1));
777
778 queue->task_runner()->PostDelayedTask(FROM_HERE,
779 BindOnce(&TestTask, 2, &run_order),
780 TimeDelta::FromMilliseconds(5));
781
782 queue->task_runner()->PostDelayedTask(FROM_HERE,
783 BindOnce(&TestTask, 3, &run_order),
784 TimeDelta::FromMilliseconds(10));
785
786 EXPECT_EQ(TimeDelta::FromMilliseconds(1), NextPendingTaskDelay());
787
788 FastForwardBy(TimeDelta::FromMilliseconds(1));
789 EXPECT_THAT(run_order, ElementsAre(1u));
790 EXPECT_EQ(TimeDelta::FromMilliseconds(4), NextPendingTaskDelay());
791
792 FastForwardBy(TimeDelta::FromMilliseconds(4));
793 EXPECT_THAT(run_order, ElementsAre(1u, 2u));
794 EXPECT_EQ(TimeDelta::FromMilliseconds(5), NextPendingTaskDelay());
795
796 FastForwardBy(TimeDelta::FromMilliseconds(5));
797 EXPECT_THAT(run_order, ElementsAre(1u, 2u, 3u));
798 }
799
TEST(SequenceManagerTestWithMockTaskRunner,PostDelayedTask_SharesUnderlyingDelayedTasks)800 TEST(SequenceManagerTestWithMockTaskRunner,
801 PostDelayedTask_SharesUnderlyingDelayedTasks) {
802 FixtureWithMockTaskRunner fixture;
803 auto queue =
804 fixture.sequence_manager()->CreateTaskQueue(TaskQueue::Spec("test"));
805
806 std::vector<EnqueueOrder> run_order;
807 TimeDelta delay(TimeDelta::FromMilliseconds(10));
808 queue->task_runner()->PostDelayedTask(
809 FROM_HERE, BindOnce(&TestTask, 1, &run_order), delay);
810 queue->task_runner()->PostDelayedTask(
811 FROM_HERE, BindOnce(&TestTask, 2, &run_order), delay);
812 queue->task_runner()->PostDelayedTask(
813 FROM_HERE, BindOnce(&TestTask, 3, &run_order), delay);
814
815 EXPECT_EQ(1u, fixture.test_task_runner()->GetPendingTaskCount());
816 }
817
TEST(SequenceManagerTestWithMockTaskRunner,CrossThreadTaskPostingToDisabledQueueDoesntScheduleWork)818 TEST(SequenceManagerTestWithMockTaskRunner,
819 CrossThreadTaskPostingToDisabledQueueDoesntScheduleWork) {
820 FixtureWithMockTaskRunner fixture;
821 auto queue =
822 fixture.sequence_manager()->CreateTaskQueue(TaskQueue::Spec("test"));
823 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
824 queue->CreateQueueEnabledVoter();
825 voter->SetVoteToEnable(false);
826
827 WaitableEvent done_event;
828 Thread thread("TestThread");
829 thread.Start();
830 thread.task_runner()->PostTask(FROM_HERE, BindLambdaForTesting([&]() {
831 // Should not schedule a DoWork.
832 queue->task_runner()->PostTask(
833 FROM_HERE, BindOnce(&NopTask));
834 done_event.Signal();
835 }));
836 done_event.Wait();
837 thread.Stop();
838
839 EXPECT_EQ(0u, fixture.test_task_runner()->GetPendingTaskCount());
840
841 // But if the queue becomes re-enabled it does schedule work.
842 voter->SetVoteToEnable(true);
843 EXPECT_EQ(1u, fixture.test_task_runner()->GetPendingTaskCount());
844 }
845
TEST(SequenceManagerTestWithMockTaskRunner,CrossThreadTaskPostingToBlockedQueueDoesntScheduleWork)846 TEST(SequenceManagerTestWithMockTaskRunner,
847 CrossThreadTaskPostingToBlockedQueueDoesntScheduleWork) {
848 FixtureWithMockTaskRunner fixture;
849 auto queue =
850 fixture.sequence_manager()->CreateTaskQueue(TaskQueue::Spec("test"));
851 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
852
853 WaitableEvent done_event;
854 Thread thread("TestThread");
855 thread.Start();
856 thread.task_runner()->PostTask(FROM_HERE, BindLambdaForTesting([&]() {
857 // Should not schedule a DoWork.
858 queue->task_runner()->PostTask(
859 FROM_HERE, BindOnce(&NopTask));
860 done_event.Signal();
861 }));
862 done_event.Wait();
863 thread.Stop();
864
865 EXPECT_EQ(0u, fixture.test_task_runner()->GetPendingTaskCount());
866
867 // But if the queue becomes unblocked it does schedule work.
868 queue->RemoveFence();
869 EXPECT_EQ(1u, fixture.test_task_runner()->GetPendingTaskCount());
870 }
871
872 class TestObject {
873 public:
~TestObject()874 ~TestObject() { destructor_count__++; }
875
Run()876 void Run() { FAIL() << "TestObject::Run should not be called"; }
877
878 static int destructor_count__;
879 };
880
881 int TestObject::destructor_count__ = 0;
882
TEST_P(SequenceManagerTest,PendingDelayedTasksRemovedOnShutdown)883 TEST_P(SequenceManagerTest, PendingDelayedTasksRemovedOnShutdown) {
884 auto queue = CreateTaskQueue();
885
886 TestObject::destructor_count__ = 0;
887
888 TimeDelta delay(TimeDelta::FromMilliseconds(10));
889 queue->task_runner()->PostDelayedTask(
890 FROM_HERE, BindOnce(&TestObject::Run, Owned(new TestObject())), delay);
891 queue->task_runner()->PostTask(
892 FROM_HERE, BindOnce(&TestObject::Run, Owned(new TestObject())));
893
894 DestroySequenceManager();
895
896 EXPECT_EQ(2, TestObject::destructor_count__);
897 }
898
TEST_P(SequenceManagerTest,InsertAndRemoveFence)899 TEST_P(SequenceManagerTest, InsertAndRemoveFence) {
900 auto queue = CreateTaskQueue();
901 StrictMock<MockTask> task;
902
903 // Posting a task when pumping is disabled doesn't result in work getting
904 // posted.
905 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
906 queue->task_runner()->PostTask(FROM_HERE, task.Get());
907 EXPECT_CALL(task, Run).Times(0);
908 RunLoop().RunUntilIdle();
909
910 // However polling still works.
911 EXPECT_TRUE(queue->HasTaskToRunImmediately());
912
913 // After removing the fence the task runs normally.
914 queue->RemoveFence();
915 EXPECT_CALL(task, Run);
916 RunLoop().RunUntilIdle();
917 }
918
TEST_P(SequenceManagerTest,RemovingFenceForDisabledQueueDoesNotPostDoWork)919 TEST_P(SequenceManagerTest, RemovingFenceForDisabledQueueDoesNotPostDoWork) {
920 auto queue = CreateTaskQueue();
921 StrictMock<MockTask> task;
922
923 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
924 queue->CreateQueueEnabledVoter();
925 voter->SetVoteToEnable(false);
926 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
927 queue->task_runner()->PostTask(FROM_HERE, task.Get());
928
929 queue->RemoveFence();
930 EXPECT_CALL(task, Run).Times(0);
931 RunLoop().RunUntilIdle();
932 }
933
TEST_P(SequenceManagerTest,EnablingFencedQueueDoesNotPostDoWork)934 TEST_P(SequenceManagerTest, EnablingFencedQueueDoesNotPostDoWork) {
935 auto queue = CreateTaskQueue();
936 StrictMock<MockTask> task;
937
938 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
939 queue->CreateQueueEnabledVoter();
940 voter->SetVoteToEnable(false);
941 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
942 queue->task_runner()->PostTask(FROM_HERE, task.Get());
943 voter->SetVoteToEnable(true);
944
945 EXPECT_CALL(task, Run).Times(0);
946 RunLoop().RunUntilIdle();
947 }
948
TEST_P(SequenceManagerTest,DenyRunning_BeforePosting)949 TEST_P(SequenceManagerTest, DenyRunning_BeforePosting) {
950 auto queue = CreateTaskQueue();
951 StrictMock<MockTask> task;
952
953 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
954 queue->CreateQueueEnabledVoter();
955 voter->SetVoteToEnable(false);
956 queue->task_runner()->PostTask(FROM_HERE, task.Get());
957
958 EXPECT_CALL(task, Run).Times(0);
959 RunLoop().RunUntilIdle();
960
961 voter->SetVoteToEnable(true);
962 EXPECT_CALL(task, Run);
963 RunLoop().RunUntilIdle();
964 }
965
TEST_P(SequenceManagerTest,DenyRunning_AfterPosting)966 TEST_P(SequenceManagerTest, DenyRunning_AfterPosting) {
967 auto queue = CreateTaskQueue();
968 StrictMock<MockTask> task;
969
970 queue->task_runner()->PostTask(FROM_HERE, task.Get());
971 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
972 queue->CreateQueueEnabledVoter();
973 voter->SetVoteToEnable(false);
974
975 EXPECT_CALL(task, Run).Times(0);
976 RunLoop().RunUntilIdle();
977
978 voter->SetVoteToEnable(true);
979 EXPECT_CALL(task, Run);
980 RunLoop().RunUntilIdle();
981 }
982
TEST_P(SequenceManagerTest,DenyRunning_AfterRemovingFence)983 TEST_P(SequenceManagerTest, DenyRunning_AfterRemovingFence) {
984 auto queue = CreateTaskQueue();
985
986 std::vector<EnqueueOrder> run_order;
987 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
988 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
989 queue->CreateQueueEnabledVoter();
990 voter->SetVoteToEnable(false);
991 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order));
992
993 RunLoop().RunUntilIdle();
994 EXPECT_TRUE(run_order.empty());
995
996 queue->RemoveFence();
997 voter->SetVoteToEnable(true);
998 RunLoop().RunUntilIdle();
999 EXPECT_THAT(run_order, ElementsAre(1u));
1000 }
1001
TEST_P(SequenceManagerTest,RemovingFenceWithDelayedTask)1002 TEST_P(SequenceManagerTest, RemovingFenceWithDelayedTask) {
1003 TimeDelta kDelay = TimeDelta::FromMilliseconds(10);
1004 auto queue = CreateTaskQueue();
1005 StrictMock<MockTask> task;
1006
1007 // Posting a delayed task when fenced will apply the delay, but won't cause
1008 // work to executed afterwards.
1009 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
1010
1011 queue->task_runner()->PostDelayedTask(FROM_HERE, task.Get(), kDelay);
1012
1013 // The task does not run even though it's delay is up.
1014 EXPECT_CALL(task, Run).Times(0);
1015 FastForwardBy(kDelay);
1016
1017 // Removing the fence causes the task to run.
1018 queue->RemoveFence();
1019 EXPECT_CALL(task, Run);
1020 RunLoop().RunUntilIdle();
1021 }
1022
TEST_P(SequenceManagerTest,RemovingFenceWithMultipleDelayedTasks)1023 TEST_P(SequenceManagerTest, RemovingFenceWithMultipleDelayedTasks) {
1024 auto queue = CreateTaskQueue();
1025 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
1026
1027 std::vector<EnqueueOrder> run_order;
1028 // Posting a delayed task when fenced will apply the delay, but won't cause
1029 // work to executed afterwards.
1030 TimeDelta delay1(TimeDelta::FromMilliseconds(1));
1031 TimeDelta delay2(TimeDelta::FromMilliseconds(10));
1032 TimeDelta delay3(TimeDelta::FromMilliseconds(20));
1033 queue->task_runner()->PostDelayedTask(
1034 FROM_HERE, BindOnce(&TestTask, 1, &run_order), delay1);
1035 queue->task_runner()->PostDelayedTask(
1036 FROM_HERE, BindOnce(&TestTask, 2, &run_order), delay2);
1037 queue->task_runner()->PostDelayedTask(
1038 FROM_HERE, BindOnce(&TestTask, 3, &run_order), delay3);
1039
1040 AdvanceMockTickClock(TimeDelta::FromMilliseconds(15));
1041 RunLoop().RunUntilIdle();
1042 EXPECT_TRUE(run_order.empty());
1043
1044 // Removing the fence causes the ready tasks to run.
1045 queue->RemoveFence();
1046 RunLoop().RunUntilIdle();
1047 EXPECT_THAT(run_order, ElementsAre(1u, 2u));
1048 }
1049
TEST_P(SequenceManagerTest,InsertFencePreventsDelayedTasksFromRunning)1050 TEST_P(SequenceManagerTest, InsertFencePreventsDelayedTasksFromRunning) {
1051 auto queue = CreateTaskQueue();
1052 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
1053
1054 std::vector<EnqueueOrder> run_order;
1055 TimeDelta delay(TimeDelta::FromMilliseconds(10));
1056 queue->task_runner()->PostDelayedTask(
1057 FROM_HERE, BindOnce(&TestTask, 1, &run_order), delay);
1058
1059 FastForwardBy(TimeDelta::FromMilliseconds(10));
1060 EXPECT_TRUE(run_order.empty());
1061 }
1062
TEST_P(SequenceManagerTest,MultipleFences)1063 TEST_P(SequenceManagerTest, MultipleFences) {
1064 auto queue = CreateTaskQueue();
1065
1066 std::vector<EnqueueOrder> run_order;
1067 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order));
1068 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 2, &run_order));
1069 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
1070
1071 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 3, &run_order));
1072 RunLoop().RunUntilIdle();
1073 EXPECT_THAT(run_order, ElementsAre(1u, 2u));
1074
1075 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
1076 // Subsequent tasks should be blocked.
1077 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 4, &run_order));
1078 RunLoop().RunUntilIdle();
1079 EXPECT_THAT(run_order, ElementsAre(1u, 2u, 3u));
1080 }
1081
TEST_P(SequenceManagerTest,InsertFenceThenImmediatlyRemoveDoesNotBlock)1082 TEST_P(SequenceManagerTest, InsertFenceThenImmediatlyRemoveDoesNotBlock) {
1083 auto queue = CreateTaskQueue();
1084 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
1085 queue->RemoveFence();
1086
1087 std::vector<EnqueueOrder> run_order;
1088 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order));
1089 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 2, &run_order));
1090
1091 RunLoop().RunUntilIdle();
1092 EXPECT_THAT(run_order, ElementsAre(1u, 2u));
1093 }
1094
TEST_P(SequenceManagerTest,InsertFencePostThenRemoveDoesNotBlock)1095 TEST_P(SequenceManagerTest, InsertFencePostThenRemoveDoesNotBlock) {
1096 auto queue = CreateTaskQueue();
1097 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
1098
1099 std::vector<EnqueueOrder> run_order;
1100 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order));
1101 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 2, &run_order));
1102 queue->RemoveFence();
1103
1104 RunLoop().RunUntilIdle();
1105 EXPECT_THAT(run_order, ElementsAre(1u, 2u));
1106 }
1107
TEST_P(SequenceManagerTest,MultipleFencesWithInitiallyEmptyQueue)1108 TEST_P(SequenceManagerTest, MultipleFencesWithInitiallyEmptyQueue) {
1109 auto queue = CreateTaskQueue();
1110 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
1111
1112 std::vector<EnqueueOrder> run_order;
1113 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order));
1114 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
1115 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 2, &run_order));
1116
1117 RunLoop().RunUntilIdle();
1118 EXPECT_THAT(run_order, ElementsAre(1u));
1119 }
1120
TEST_P(SequenceManagerTest,BlockedByFence)1121 TEST_P(SequenceManagerTest, BlockedByFence) {
1122 auto queue = CreateTaskQueue();
1123 EXPECT_FALSE(queue->BlockedByFence());
1124
1125 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
1126 EXPECT_TRUE(queue->BlockedByFence());
1127
1128 queue->RemoveFence();
1129 EXPECT_FALSE(queue->BlockedByFence());
1130
1131 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
1132 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
1133 EXPECT_FALSE(queue->BlockedByFence());
1134
1135 RunLoop().RunUntilIdle();
1136 EXPECT_TRUE(queue->BlockedByFence());
1137
1138 queue->RemoveFence();
1139 EXPECT_FALSE(queue->BlockedByFence());
1140 }
1141
TEST_P(SequenceManagerTest,BlockedByFence_BothTypesOfFence)1142 TEST_P(SequenceManagerTest, BlockedByFence_BothTypesOfFence) {
1143 auto queue = CreateTaskQueue();
1144
1145 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
1146
1147 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
1148 EXPECT_FALSE(queue->BlockedByFence());
1149
1150 queue->InsertFence(TaskQueue::InsertFencePosition::kBeginningOfTime);
1151 EXPECT_TRUE(queue->BlockedByFence());
1152 }
1153
1154 namespace {
1155
RecordTimeTask(std::vector<TimeTicks> * run_times,const TickClock * clock)1156 void RecordTimeTask(std::vector<TimeTicks>* run_times, const TickClock* clock) {
1157 run_times->push_back(clock->NowTicks());
1158 }
1159
RecordTimeAndQueueTask(std::vector<std::pair<scoped_refptr<TestTaskQueue>,TimeTicks>> * run_times,scoped_refptr<TestTaskQueue> task_queue,const TickClock * clock)1160 void RecordTimeAndQueueTask(
1161 std::vector<std::pair<scoped_refptr<TestTaskQueue>, TimeTicks>>* run_times,
1162 scoped_refptr<TestTaskQueue> task_queue,
1163 const TickClock* clock) {
1164 run_times->emplace_back(task_queue, clock->NowTicks());
1165 }
1166
1167 } // namespace
1168
TEST_P(SequenceManagerTest,DelayedFence_DelayedTasks)1169 TEST_P(SequenceManagerTest, DelayedFence_DelayedTasks) {
1170 const auto kStartTime = mock_tick_clock()->NowTicks();
1171 scoped_refptr<TestTaskQueue> queue =
1172 CreateTaskQueue(TaskQueue::Spec("test").SetDelayedFencesAllowed(true));
1173
1174 std::vector<TimeTicks> run_times;
1175 queue->task_runner()->PostDelayedTask(
1176 FROM_HERE, BindOnce(&RecordTimeTask, &run_times, mock_tick_clock()),
1177 TimeDelta::FromMilliseconds(100));
1178 queue->task_runner()->PostDelayedTask(
1179 FROM_HERE, BindOnce(&RecordTimeTask, &run_times, mock_tick_clock()),
1180 TimeDelta::FromMilliseconds(200));
1181 queue->task_runner()->PostDelayedTask(
1182 FROM_HERE, BindOnce(&RecordTimeTask, &run_times, mock_tick_clock()),
1183 TimeDelta::FromMilliseconds(300));
1184
1185 queue->InsertFenceAt(mock_tick_clock()->NowTicks() +
1186 TimeDelta::FromMilliseconds(250));
1187 EXPECT_FALSE(queue->HasActiveFence());
1188
1189 FastForwardUntilNoTasksRemain();
1190
1191 EXPECT_TRUE(queue->HasActiveFence());
1192 EXPECT_THAT(run_times,
1193 ElementsAre(kStartTime + TimeDelta::FromMilliseconds(100),
1194 kStartTime + TimeDelta::FromMilliseconds(200)));
1195 run_times.clear();
1196
1197 queue->RemoveFence();
1198
1199 FastForwardUntilNoTasksRemain();
1200
1201 EXPECT_FALSE(queue->HasActiveFence());
1202 EXPECT_THAT(run_times,
1203 ElementsAre(kStartTime + TimeDelta::FromMilliseconds(300)));
1204 }
1205
TEST_P(SequenceManagerTest,DelayedFence_ImmediateTasks)1206 TEST_P(SequenceManagerTest, DelayedFence_ImmediateTasks) {
1207 const auto kStartTime = mock_tick_clock()->NowTicks();
1208 scoped_refptr<TestTaskQueue> queue =
1209 CreateTaskQueue(TaskQueue::Spec("test").SetDelayedFencesAllowed(true));
1210
1211 std::vector<TimeTicks> run_times;
1212 queue->InsertFenceAt(mock_tick_clock()->NowTicks() +
1213 TimeDelta::FromMilliseconds(250));
1214
1215 for (int i = 0; i < 5; ++i) {
1216 queue->task_runner()->PostTask(
1217 FROM_HERE, BindOnce(&RecordTimeTask, &run_times, mock_tick_clock()));
1218 FastForwardBy(TimeDelta::FromMilliseconds(100));
1219 if (i < 2) {
1220 EXPECT_FALSE(queue->HasActiveFence());
1221 } else {
1222 EXPECT_TRUE(queue->HasActiveFence());
1223 }
1224 }
1225
1226 EXPECT_THAT(
1227 run_times,
1228 ElementsAre(kStartTime, kStartTime + TimeDelta::FromMilliseconds(100),
1229 kStartTime + TimeDelta::FromMilliseconds(200)));
1230 run_times.clear();
1231
1232 queue->RemoveFence();
1233 FastForwardUntilNoTasksRemain();
1234
1235 EXPECT_THAT(run_times,
1236 ElementsAre(kStartTime + TimeDelta::FromMilliseconds(500),
1237 kStartTime + TimeDelta::FromMilliseconds(500)));
1238 }
1239
TEST_P(SequenceManagerTest,DelayedFence_RemovedFenceDoesNotActivate)1240 TEST_P(SequenceManagerTest, DelayedFence_RemovedFenceDoesNotActivate) {
1241 const auto kStartTime = mock_tick_clock()->NowTicks();
1242 scoped_refptr<TestTaskQueue> queue =
1243 CreateTaskQueue(TaskQueue::Spec("test").SetDelayedFencesAllowed(true));
1244
1245 std::vector<TimeTicks> run_times;
1246 queue->InsertFenceAt(mock_tick_clock()->NowTicks() +
1247 TimeDelta::FromMilliseconds(250));
1248
1249 for (int i = 0; i < 3; ++i) {
1250 queue->task_runner()->PostTask(
1251 FROM_HERE, BindOnce(&RecordTimeTask, &run_times, mock_tick_clock()));
1252 EXPECT_FALSE(queue->HasActiveFence());
1253 FastForwardBy(TimeDelta::FromMilliseconds(100));
1254 }
1255
1256 EXPECT_TRUE(queue->HasActiveFence());
1257 queue->RemoveFence();
1258
1259 for (int i = 0; i < 2; ++i) {
1260 queue->task_runner()->PostTask(
1261 FROM_HERE, BindOnce(&RecordTimeTask, &run_times, mock_tick_clock()));
1262 FastForwardBy(TimeDelta::FromMilliseconds(100));
1263 EXPECT_FALSE(queue->HasActiveFence());
1264 }
1265
1266 EXPECT_THAT(
1267 run_times,
1268 ElementsAre(kStartTime, kStartTime + TimeDelta::FromMilliseconds(100),
1269 kStartTime + TimeDelta::FromMilliseconds(200),
1270 kStartTime + TimeDelta::FromMilliseconds(300),
1271 kStartTime + TimeDelta::FromMilliseconds(400)));
1272 }
1273
TEST_P(SequenceManagerTest,DelayedFence_TakeIncomingImmediateQueue)1274 TEST_P(SequenceManagerTest, DelayedFence_TakeIncomingImmediateQueue) {
1275 // This test checks that everything works correctly when a work queue
1276 // is swapped with an immediate incoming queue and a delayed fence
1277 // is activated, forcing a different queue to become active.
1278 const auto kStartTime = mock_tick_clock()->NowTicks();
1279 scoped_refptr<TestTaskQueue> queue1 =
1280 CreateTaskQueue(TaskQueue::Spec("test").SetDelayedFencesAllowed(true));
1281 scoped_refptr<TestTaskQueue> queue2 =
1282 CreateTaskQueue(TaskQueue::Spec("test").SetDelayedFencesAllowed(true));
1283
1284 std::vector<std::pair<scoped_refptr<TestTaskQueue>, TimeTicks>> run_times;
1285
1286 // Fence ensures that the task posted after advancing time is blocked.
1287 queue1->InsertFenceAt(mock_tick_clock()->NowTicks() +
1288 TimeDelta::FromMilliseconds(250));
1289
1290 // This task should not be blocked and should run immediately after
1291 // advancing time at 301ms.
1292 queue1->task_runner()->PostTask(
1293 FROM_HERE,
1294 BindOnce(&RecordTimeAndQueueTask, &run_times, queue1, mock_tick_clock()));
1295 // Force reload of immediate work queue. In real life the same effect can be
1296 // achieved with cross-thread posting.
1297 sequence_manager()->ReloadEmptyWorkQueues();
1298
1299 AdvanceMockTickClock(TimeDelta::FromMilliseconds(300));
1300
1301 // This task should be blocked.
1302 queue1->task_runner()->PostTask(
1303 FROM_HERE,
1304 BindOnce(&RecordTimeAndQueueTask, &run_times, queue1, mock_tick_clock()));
1305 // This task on a different runner should run as expected.
1306 queue2->task_runner()->PostTask(
1307 FROM_HERE,
1308 BindOnce(&RecordTimeAndQueueTask, &run_times, queue2, mock_tick_clock()));
1309
1310 FastForwardUntilNoTasksRemain();
1311
1312 EXPECT_THAT(
1313 run_times,
1314 ElementsAre(
1315 std::make_pair(queue1, kStartTime + TimeDelta::FromMilliseconds(300)),
1316 std::make_pair(queue2,
1317 kStartTime + TimeDelta::FromMilliseconds(300))));
1318 }
1319
1320 namespace {
1321
ReentrantTestTask(scoped_refptr<TestTaskQueue> runner,int countdown,std::vector<EnqueueOrder> * out_result)1322 void ReentrantTestTask(scoped_refptr<TestTaskQueue> runner,
1323 int countdown,
1324 std::vector<EnqueueOrder>* out_result) {
1325 out_result->push_back(EnqueueOrder::FromIntForTesting(countdown));
1326 if (--countdown) {
1327 runner->task_runner()->PostTask(
1328 FROM_HERE, BindOnce(&ReentrantTestTask, runner, countdown, out_result));
1329 }
1330 }
1331
1332 } // namespace
1333
TEST_P(SequenceManagerTest,ReentrantPosting)1334 TEST_P(SequenceManagerTest, ReentrantPosting) {
1335 auto queue = CreateTaskQueue();
1336
1337 std::vector<EnqueueOrder> run_order;
1338 queue->task_runner()->PostTask(
1339 FROM_HERE, BindOnce(&ReentrantTestTask, queue, 3, &run_order));
1340
1341 RunLoop().RunUntilIdle();
1342 EXPECT_THAT(run_order, ElementsAre(3u, 2u, 1u));
1343 }
1344
1345 namespace {
1346 class RefCountedCallbackFactory {
1347 public:
WrapCallback(OnceCallback<void ()> cb)1348 OnceCallback<void()> WrapCallback(OnceCallback<void()> cb) {
1349 return BindOnce(
1350 [](OnceCallback<void()> cb, WeakPtr<bool>) { std::move(cb).Run(); },
1351 std::move(cb), task_references_.GetWeakPtr());
1352 }
1353
HasReferences() const1354 bool HasReferences() const { return task_references_.HasWeakPtrs(); }
1355
1356 private:
1357 bool dummy_;
1358 WeakPtrFactory<bool> task_references_{&dummy_};
1359 };
1360 } // namespace
1361
TEST_P(SequenceManagerTest,NoTasksAfterShutdown)1362 TEST_P(SequenceManagerTest, NoTasksAfterShutdown) {
1363 auto queue = CreateTaskQueue();
1364 StrictMock<MockTask> task;
1365 RefCountedCallbackFactory counter;
1366
1367 EXPECT_CALL(task, Run).Times(0);
1368 queue->task_runner()->PostTask(FROM_HERE, counter.WrapCallback(task.Get()));
1369 DestroySequenceManager();
1370 queue->task_runner()->PostTask(FROM_HERE, counter.WrapCallback(task.Get()));
1371
1372 if (GetUnderlyingRunnerType() != TestType::kMessagePump) {
1373 RunLoop().RunUntilIdle();
1374 }
1375
1376 EXPECT_FALSE(counter.HasReferences());
1377 }
1378
PostTaskToRunner(scoped_refptr<TestTaskQueue> runner,std::vector<EnqueueOrder> * run_order)1379 void PostTaskToRunner(scoped_refptr<TestTaskQueue> runner,
1380 std::vector<EnqueueOrder>* run_order) {
1381 runner->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, run_order));
1382 }
1383
TEST_P(SequenceManagerTest,PostFromThread)1384 TEST_P(SequenceManagerTest, PostFromThread) {
1385 auto queue = CreateTaskQueue();
1386
1387 std::vector<EnqueueOrder> run_order;
1388 Thread thread("TestThread");
1389 thread.Start();
1390 thread.task_runner()->PostTask(
1391 FROM_HERE, BindOnce(&PostTaskToRunner, queue, &run_order));
1392 thread.Stop();
1393
1394 RunLoop().RunUntilIdle();
1395 EXPECT_THAT(run_order, ElementsAre(1u));
1396 }
1397
RePostingTestTask(scoped_refptr<TestTaskQueue> runner,int * run_count)1398 void RePostingTestTask(scoped_refptr<TestTaskQueue> runner, int* run_count) {
1399 (*run_count)++;
1400 runner->task_runner()->PostTask(
1401 FROM_HERE,
1402 BindOnce(&RePostingTestTask, Unretained(runner.get()), run_count));
1403 }
1404
TEST_P(SequenceManagerTest,DoWorkCantPostItselfMultipleTimes)1405 TEST_P(SequenceManagerTest, DoWorkCantPostItselfMultipleTimes) {
1406 auto queue = CreateTaskQueue();
1407
1408 int run_count = 0;
1409 queue->task_runner()->PostTask(
1410 FROM_HERE, BindOnce(&RePostingTestTask, queue, &run_count));
1411
1412 RunDoWorkOnce();
1413 EXPECT_EQ(1u, sequence_manager()->GetPendingTaskCountForTesting());
1414 EXPECT_EQ(1, run_count);
1415 }
1416
TEST_P(SequenceManagerTest,PostFromNestedRunloop)1417 TEST_P(SequenceManagerTest, PostFromNestedRunloop) {
1418 auto queue = CreateTaskQueue();
1419
1420 std::vector<EnqueueOrder> run_order;
1421 std::vector<std::pair<OnceClosure, bool>> tasks_to_post_from_nested_loop;
1422 tasks_to_post_from_nested_loop.push_back(
1423 std::make_pair(BindOnce(&TestTask, 1, &run_order), true));
1424
1425 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 0, &run_order));
1426 queue->task_runner()->PostTask(
1427 FROM_HERE, BindOnce(&PostFromNestedRunloop, queue,
1428 Unretained(&tasks_to_post_from_nested_loop)));
1429 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 2, &run_order));
1430
1431 RunLoop().RunUntilIdle();
1432
1433 EXPECT_THAT(run_order, ElementsAre(0u, 2u, 1u));
1434 }
1435
TEST_P(SequenceManagerTest,WorkBatching)1436 TEST_P(SequenceManagerTest, WorkBatching) {
1437 auto queue = CreateTaskQueue();
1438 sequence_manager()->SetWorkBatchSize(2);
1439
1440 std::vector<EnqueueOrder> run_order;
1441 for (int i = 0; i < 4; ++i) {
1442 queue->task_runner()->PostTask(FROM_HERE,
1443 BindOnce(&TestTask, i, &run_order));
1444 }
1445
1446 // Running one task in the host message loop should cause two posted tasks
1447 // to get executed.
1448 RunDoWorkOnce();
1449 EXPECT_THAT(run_order, ElementsAre(0u, 1u));
1450
1451 // The second task runs the remaining two posted tasks.
1452 RunDoWorkOnce();
1453 EXPECT_THAT(run_order, ElementsAre(0u, 1u, 2u, 3u));
1454 }
1455
1456 class MockTaskObserver : public TaskObserver {
1457 public:
1458 MOCK_METHOD1(DidProcessTask, void(const PendingTask& task));
1459 MOCK_METHOD2(WillProcessTask,
1460 void(const PendingTask& task, bool was_blocked_or_low_priority));
1461 };
1462
TEST_P(SequenceManagerTest,TaskObserverAdding)1463 TEST_P(SequenceManagerTest, TaskObserverAdding) {
1464 auto queue = CreateTaskQueue();
1465 MockTaskObserver observer;
1466
1467 sequence_manager()->SetWorkBatchSize(2);
1468 sequence_manager()->AddTaskObserver(&observer);
1469
1470 std::vector<EnqueueOrder> run_order;
1471 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order));
1472 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 2, &run_order));
1473
1474 EXPECT_CALL(observer,
1475 WillProcessTask(_, /*was_blocked_or_low_priority=*/false))
1476 .Times(2);
1477 EXPECT_CALL(observer, DidProcessTask(_)).Times(2);
1478 RunLoop().RunUntilIdle();
1479 }
1480
TEST_P(SequenceManagerTest,TaskObserverRemoving)1481 TEST_P(SequenceManagerTest, TaskObserverRemoving) {
1482 auto queue = CreateTaskQueue();
1483 MockTaskObserver observer;
1484 sequence_manager()->SetWorkBatchSize(2);
1485 sequence_manager()->AddTaskObserver(&observer);
1486 sequence_manager()->RemoveTaskObserver(&observer);
1487
1488 std::vector<EnqueueOrder> run_order;
1489 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order));
1490
1491 EXPECT_CALL(observer, WillProcessTask(_, _)).Times(0);
1492 EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
1493 RunLoop().RunUntilIdle();
1494 }
1495
RemoveObserverTask(SequenceManagerImpl * manager,TaskObserver * observer)1496 void RemoveObserverTask(SequenceManagerImpl* manager, TaskObserver* observer) {
1497 manager->RemoveTaskObserver(observer);
1498 }
1499
TEST_P(SequenceManagerTest,TaskObserverRemovingInsideTask)1500 TEST_P(SequenceManagerTest, TaskObserverRemovingInsideTask) {
1501 auto queue = CreateTaskQueue();
1502 MockTaskObserver observer;
1503 sequence_manager()->SetWorkBatchSize(3);
1504 sequence_manager()->AddTaskObserver(&observer);
1505
1506 queue->task_runner()->PostTask(
1507 FROM_HERE, BindOnce(&RemoveObserverTask, sequence_manager(), &observer));
1508
1509 EXPECT_CALL(observer,
1510 WillProcessTask(_, /*was_blocked_or_low_priority=*/false))
1511 .Times(1);
1512 EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
1513 RunLoop().RunUntilIdle();
1514 }
1515
TEST_P(SequenceManagerTest,QueueTaskObserverAdding)1516 TEST_P(SequenceManagerTest, QueueTaskObserverAdding) {
1517 auto queues = CreateTaskQueues(2);
1518 MockTaskObserver observer;
1519
1520 sequence_manager()->SetWorkBatchSize(2);
1521 queues[0]->AddTaskObserver(&observer);
1522
1523 std::vector<EnqueueOrder> run_order;
1524 queues[0]->task_runner()->PostTask(FROM_HERE,
1525 BindOnce(&TestTask, 1, &run_order));
1526 queues[1]->task_runner()->PostTask(FROM_HERE,
1527 BindOnce(&TestTask, 2, &run_order));
1528
1529 EXPECT_CALL(observer,
1530 WillProcessTask(_, /*was_blocked_or_low_priority=*/false))
1531 .Times(1);
1532 EXPECT_CALL(observer, DidProcessTask(_)).Times(1);
1533 RunLoop().RunUntilIdle();
1534 }
1535
TEST_P(SequenceManagerTest,QueueTaskObserverRemoving)1536 TEST_P(SequenceManagerTest, QueueTaskObserverRemoving) {
1537 auto queue = CreateTaskQueue();
1538 MockTaskObserver observer;
1539 sequence_manager()->SetWorkBatchSize(2);
1540 queue->AddTaskObserver(&observer);
1541 queue->RemoveTaskObserver(&observer);
1542
1543 std::vector<EnqueueOrder> run_order;
1544 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order));
1545
1546 EXPECT_CALL(observer,
1547 WillProcessTask(_, /*was_blocked_or_low_priority=*/false))
1548 .Times(0);
1549 EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
1550
1551 RunLoop().RunUntilIdle();
1552 }
1553
RemoveQueueObserverTask(scoped_refptr<TestTaskQueue> queue,TaskObserver * observer)1554 void RemoveQueueObserverTask(scoped_refptr<TestTaskQueue> queue,
1555 TaskObserver* observer) {
1556 queue->RemoveTaskObserver(observer);
1557 }
1558
TEST_P(SequenceManagerTest,QueueTaskObserverRemovingInsideTask)1559 TEST_P(SequenceManagerTest, QueueTaskObserverRemovingInsideTask) {
1560 auto queue = CreateTaskQueue();
1561 MockTaskObserver observer;
1562 queue->AddTaskObserver(&observer);
1563
1564 queue->task_runner()->PostTask(
1565 FROM_HERE, BindOnce(&RemoveQueueObserverTask, queue, &observer));
1566
1567 EXPECT_CALL(observer,
1568 WillProcessTask(_, /*was_blocked_or_low_priority=*/false))
1569 .Times(1);
1570 EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
1571 RunLoop().RunUntilIdle();
1572 }
1573
TEST_P(SequenceManagerTest,ThreadCheckAfterTermination)1574 TEST_P(SequenceManagerTest, ThreadCheckAfterTermination) {
1575 auto queue = CreateTaskQueue();
1576 EXPECT_TRUE(queue->task_runner()->RunsTasksInCurrentSequence());
1577 DestroySequenceManager();
1578 EXPECT_TRUE(queue->task_runner()->RunsTasksInCurrentSequence());
1579 }
1580
TEST_P(SequenceManagerTest,TimeDomain_NextScheduledRunTime)1581 TEST_P(SequenceManagerTest, TimeDomain_NextScheduledRunTime) {
1582 auto queues = CreateTaskQueues(2u);
1583 AdvanceMockTickClock(TimeDelta::FromMicroseconds(10000));
1584 LazyNow lazy_now_1(mock_tick_clock());
1585
1586 // With no delayed tasks.
1587 EXPECT_FALSE(
1588 sequence_manager()->GetRealTimeDomain()->DelayTillNextTask(&lazy_now_1));
1589
1590 // With a non-delayed task.
1591 queues[0]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
1592 EXPECT_FALSE(
1593 sequence_manager()->GetRealTimeDomain()->DelayTillNextTask(&lazy_now_1));
1594
1595 // With a delayed task.
1596 TimeDelta expected_delay = TimeDelta::FromMilliseconds(50);
1597 queues[0]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
1598 expected_delay);
1599 EXPECT_EQ(
1600 expected_delay,
1601 sequence_manager()->GetRealTimeDomain()->DelayTillNextTask(&lazy_now_1));
1602
1603 // With another delayed task in the same queue with a longer delay.
1604 queues[0]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
1605 TimeDelta::FromMilliseconds(100));
1606 EXPECT_EQ(
1607 expected_delay,
1608 sequence_manager()->GetRealTimeDomain()->DelayTillNextTask(&lazy_now_1));
1609
1610 // With another delayed task in the same queue with a shorter delay.
1611 expected_delay = TimeDelta::FromMilliseconds(20);
1612 queues[0]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
1613 expected_delay);
1614 EXPECT_EQ(
1615 expected_delay,
1616 sequence_manager()->GetRealTimeDomain()->DelayTillNextTask(&lazy_now_1));
1617
1618 // With another delayed task in a different queue with a shorter delay.
1619 expected_delay = TimeDelta::FromMilliseconds(10);
1620 queues[1]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
1621 expected_delay);
1622 EXPECT_EQ(
1623 expected_delay,
1624 sequence_manager()->GetRealTimeDomain()->DelayTillNextTask(&lazy_now_1));
1625
1626 // Test it updates as time progresses
1627 AdvanceMockTickClock(expected_delay);
1628 LazyNow lazy_now_2(mock_tick_clock());
1629 EXPECT_EQ(
1630 TimeDelta(),
1631 sequence_manager()->GetRealTimeDomain()->DelayTillNextTask(&lazy_now_2));
1632 }
1633
TEST_P(SequenceManagerTest,TimeDomain_NextScheduledRunTime_MultipleQueues)1634 TEST_P(SequenceManagerTest, TimeDomain_NextScheduledRunTime_MultipleQueues) {
1635 auto queues = CreateTaskQueues(3u);
1636
1637 TimeDelta delay1 = TimeDelta::FromMilliseconds(50);
1638 TimeDelta delay2 = TimeDelta::FromMilliseconds(5);
1639 TimeDelta delay3 = TimeDelta::FromMilliseconds(10);
1640 queues[0]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
1641 delay1);
1642 queues[1]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
1643 delay2);
1644 queues[2]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
1645 delay3);
1646 queues[0]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
1647
1648 LazyNow lazy_now(mock_tick_clock());
1649 EXPECT_EQ(delay2, sequence_manager()->GetRealTimeDomain()->DelayTillNextTask(
1650 &lazy_now));
1651 }
1652
TEST(SequenceManagerWithTaskRunnerTest,DeleteSequenceManagerInsideATask)1653 TEST(SequenceManagerWithTaskRunnerTest, DeleteSequenceManagerInsideATask) {
1654 FixtureWithMockTaskRunner fixture;
1655 auto queue =
1656 fixture.sequence_manager()->CreateTaskQueue(TaskQueue::Spec("test"));
1657
1658 queue->task_runner()->PostTask(FROM_HERE, BindLambdaForTesting([&]() {
1659 fixture.DestroySequenceManager();
1660 }));
1661
1662 // This should not crash, assuming DoWork detects the SequenceManager has
1663 // been deleted.
1664 RunLoop().RunUntilIdle();
1665 }
1666
TEST_P(SequenceManagerTest,GetAndClearSystemIsQuiescentBit)1667 TEST_P(SequenceManagerTest, GetAndClearSystemIsQuiescentBit) {
1668 auto queues = CreateTaskQueues(3u);
1669
1670 scoped_refptr<TestTaskQueue> queue0 =
1671 CreateTaskQueue(TaskQueue::Spec("test").SetShouldMonitorQuiescence(true));
1672 scoped_refptr<TestTaskQueue> queue1 =
1673 CreateTaskQueue(TaskQueue::Spec("test").SetShouldMonitorQuiescence(true));
1674 scoped_refptr<TestTaskQueue> queue2 = CreateTaskQueue();
1675
1676 EXPECT_TRUE(sequence_manager()->GetAndClearSystemIsQuiescentBit());
1677
1678 queue0->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
1679 RunLoop().RunUntilIdle();
1680 EXPECT_FALSE(sequence_manager()->GetAndClearSystemIsQuiescentBit());
1681 EXPECT_TRUE(sequence_manager()->GetAndClearSystemIsQuiescentBit());
1682
1683 queue1->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
1684 RunLoop().RunUntilIdle();
1685 EXPECT_FALSE(sequence_manager()->GetAndClearSystemIsQuiescentBit());
1686 EXPECT_TRUE(sequence_manager()->GetAndClearSystemIsQuiescentBit());
1687
1688 queue2->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
1689 RunLoop().RunUntilIdle();
1690 EXPECT_TRUE(sequence_manager()->GetAndClearSystemIsQuiescentBit());
1691
1692 queue0->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
1693 queue1->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
1694 RunLoop().RunUntilIdle();
1695 EXPECT_FALSE(sequence_manager()->GetAndClearSystemIsQuiescentBit());
1696 EXPECT_TRUE(sequence_manager()->GetAndClearSystemIsQuiescentBit());
1697 }
1698
TEST_P(SequenceManagerTest,HasPendingImmediateWork)1699 TEST_P(SequenceManagerTest, HasPendingImmediateWork) {
1700 auto queue = CreateTaskQueue();
1701
1702 EXPECT_FALSE(queue->HasTaskToRunImmediately());
1703 queue->task_runner()->PostTask(FROM_HERE, BindOnce(NullTask));
1704 EXPECT_TRUE(queue->HasTaskToRunImmediately());
1705
1706 RunLoop().RunUntilIdle();
1707 EXPECT_FALSE(queue->HasTaskToRunImmediately());
1708 }
1709
TEST_P(SequenceManagerTest,HasPendingImmediateWork_DelayedTasks)1710 TEST_P(SequenceManagerTest, HasPendingImmediateWork_DelayedTasks) {
1711 auto queue = CreateTaskQueue();
1712
1713 EXPECT_FALSE(queue->HasTaskToRunImmediately());
1714 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(NullTask),
1715 TimeDelta::FromMilliseconds(12));
1716 EXPECT_FALSE(queue->HasTaskToRunImmediately());
1717
1718 // Move time forwards until just before the delayed task should run.
1719 AdvanceMockTickClock(TimeDelta::FromMilliseconds(10));
1720 LazyNow lazy_now_1(mock_tick_clock());
1721 sequence_manager()->MoveReadyDelayedTasksToWorkQueues(&lazy_now_1);
1722 EXPECT_FALSE(queue->HasTaskToRunImmediately());
1723
1724 // Force the delayed task onto the work queue.
1725 AdvanceMockTickClock(TimeDelta::FromMilliseconds(2));
1726 LazyNow lazy_now_2(mock_tick_clock());
1727 sequence_manager()->MoveReadyDelayedTasksToWorkQueues(&lazy_now_2);
1728 EXPECT_TRUE(queue->HasTaskToRunImmediately());
1729
1730 sequence_manager()->ScheduleWork();
1731 RunLoop().RunUntilIdle();
1732 EXPECT_FALSE(queue->HasTaskToRunImmediately());
1733 }
1734
TEST_P(SequenceManagerTest,ImmediateTasksAreNotStarvedByDelayedTasks)1735 TEST_P(SequenceManagerTest, ImmediateTasksAreNotStarvedByDelayedTasks) {
1736 auto queue = CreateTaskQueue();
1737 std::vector<EnqueueOrder> run_order;
1738 constexpr auto kDelay = TimeDelta::FromMilliseconds(10);
1739
1740 // By posting the immediate tasks from a delayed one we make sure that the
1741 // delayed tasks we post afterwards have a lower enqueue_order than the
1742 // immediate ones. Thus all the delayed ones would run before the immediate
1743 // ones if it weren't for the anti-starvation feature we are testing here.
1744 queue->task_runner()->PostDelayedTask(
1745 FROM_HERE, BindLambdaForTesting([&]() {
1746 for (int i = 0; i < 9; i++) {
1747 queue->task_runner()->PostTask(FROM_HERE,
1748 BindOnce(&TestTask, i, &run_order));
1749 }
1750 }),
1751 kDelay);
1752
1753 for (int i = 10; i < 19; i++) {
1754 queue->task_runner()->PostDelayedTask(
1755 FROM_HERE, BindOnce(&TestTask, i, &run_order), kDelay);
1756 }
1757
1758 FastForwardBy(TimeDelta::FromMilliseconds(10));
1759
1760 // Delayed tasks are not allowed to starve out immediate work which is why
1761 // some of the immediate tasks run out of order.
1762 uint64_t expected_run_order[] = {10, 11, 12, 0, 13, 14, 15, 1, 16,
1763 17, 18, 2, 3, 4, 5, 6, 7, 8};
1764 EXPECT_THAT(run_order, ElementsAreArray(expected_run_order));
1765 }
1766
TEST_P(SequenceManagerTest,DelayedTaskDoesNotSkipAHeadOfNonDelayedTask_SameQueue)1767 TEST_P(SequenceManagerTest,
1768 DelayedTaskDoesNotSkipAHeadOfNonDelayedTask_SameQueue) {
1769 auto queue = CreateTaskQueue();
1770
1771 std::vector<EnqueueOrder> run_order;
1772 TimeDelta delay = TimeDelta::FromMilliseconds(10);
1773 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 2, &run_order));
1774 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 3, &run_order));
1775 queue->task_runner()->PostDelayedTask(
1776 FROM_HERE, BindOnce(&TestTask, 1, &run_order), delay);
1777
1778 AdvanceMockTickClock(delay * 2);
1779 RunLoop().RunUntilIdle();
1780
1781 EXPECT_THAT(run_order, ElementsAre(2u, 3u, 1u));
1782 }
1783
TEST_P(SequenceManagerTest,DelayedTaskDoesNotSkipAHeadOfNonDelayedTask_DifferentQueues)1784 TEST_P(SequenceManagerTest,
1785 DelayedTaskDoesNotSkipAHeadOfNonDelayedTask_DifferentQueues) {
1786 auto queues = CreateTaskQueues(2u);
1787
1788 std::vector<EnqueueOrder> run_order;
1789 TimeDelta delay = TimeDelta::FromMilliseconds(10);
1790 queues[1]->task_runner()->PostTask(FROM_HERE,
1791 BindOnce(&TestTask, 2, &run_order));
1792 queues[1]->task_runner()->PostTask(FROM_HERE,
1793 BindOnce(&TestTask, 3, &run_order));
1794 queues[0]->task_runner()->PostDelayedTask(
1795 FROM_HERE, BindOnce(&TestTask, 1, &run_order), delay);
1796
1797 AdvanceMockTickClock(delay * 2);
1798 RunLoop().RunUntilIdle();
1799
1800 EXPECT_THAT(run_order, ElementsAre(2u, 3u, 1u));
1801 }
1802
TEST_P(SequenceManagerTest,DelayedTaskDoesNotSkipAHeadOfShorterDelayedTask)1803 TEST_P(SequenceManagerTest, DelayedTaskDoesNotSkipAHeadOfShorterDelayedTask) {
1804 auto queues = CreateTaskQueues(2u);
1805
1806 std::vector<EnqueueOrder> run_order;
1807 TimeDelta delay1 = TimeDelta::FromMilliseconds(10);
1808 TimeDelta delay2 = TimeDelta::FromMilliseconds(5);
1809 queues[0]->task_runner()->PostDelayedTask(
1810 FROM_HERE, BindOnce(&TestTask, 1, &run_order), delay1);
1811 queues[1]->task_runner()->PostDelayedTask(
1812 FROM_HERE, BindOnce(&TestTask, 2, &run_order), delay2);
1813
1814 AdvanceMockTickClock(delay1 * 2);
1815 RunLoop().RunUntilIdle();
1816
1817 EXPECT_THAT(run_order, ElementsAre(2u, 1u));
1818 }
1819
CheckIsNested(bool * is_nested)1820 void CheckIsNested(bool* is_nested) {
1821 *is_nested = RunLoop::IsNestedOnCurrentThread();
1822 }
1823
PostAndQuitFromNestedRunloop(RunLoop * run_loop,scoped_refptr<TestTaskQueue> runner,bool * was_nested)1824 void PostAndQuitFromNestedRunloop(RunLoop* run_loop,
1825 scoped_refptr<TestTaskQueue> runner,
1826 bool* was_nested) {
1827 runner->task_runner()->PostTask(FROM_HERE, run_loop->QuitClosure());
1828 runner->task_runner()->PostTask(FROM_HERE,
1829 BindOnce(&CheckIsNested, was_nested));
1830 run_loop->Run();
1831 }
1832
TEST_P(SequenceManagerTest,QuitWhileNested)1833 TEST_P(SequenceManagerTest, QuitWhileNested) {
1834 if (GetUnderlyingRunnerType() == TestType::kMockTaskRunner)
1835 return;
1836 // This test makes sure we don't continue running a work batch after a nested
1837 // run loop has been exited in the middle of the batch.
1838 auto queue = CreateTaskQueue();
1839 sequence_manager()->SetWorkBatchSize(2);
1840
1841 bool was_nested = true;
1842 RunLoop run_loop(RunLoop::Type::kNestableTasksAllowed);
1843 queue->task_runner()->PostTask(
1844 FROM_HERE, BindOnce(&PostAndQuitFromNestedRunloop, Unretained(&run_loop),
1845 queue, Unretained(&was_nested)));
1846
1847 RunLoop().RunUntilIdle();
1848 EXPECT_FALSE(was_nested);
1849 }
1850
1851 class SequenceNumberCapturingTaskObserver : public TaskObserver {
1852 public:
1853 // TaskObserver overrides.
WillProcessTask(const PendingTask & pending_task,bool was_blocked_or_low_priority)1854 void WillProcessTask(const PendingTask& pending_task,
1855 bool was_blocked_or_low_priority) override {}
DidProcessTask(const PendingTask & pending_task)1856 void DidProcessTask(const PendingTask& pending_task) override {
1857 sequence_numbers_.push_back(pending_task.sequence_num);
1858 }
1859
sequence_numbers() const1860 const std::vector<int>& sequence_numbers() const { return sequence_numbers_; }
1861
1862 private:
1863 std::vector<int> sequence_numbers_;
1864 };
1865
TEST_P(SequenceManagerTest,SequenceNumSetWhenTaskIsPosted)1866 TEST_P(SequenceManagerTest, SequenceNumSetWhenTaskIsPosted) {
1867 auto queue = CreateTaskQueue();
1868
1869 SequenceNumberCapturingTaskObserver observer;
1870 sequence_manager()->AddTaskObserver(&observer);
1871
1872 // Register four tasks that will run in reverse order.
1873 std::vector<EnqueueOrder> run_order;
1874 queue->task_runner()->PostDelayedTask(FROM_HERE,
1875 BindOnce(&TestTask, 1, &run_order),
1876 TimeDelta::FromMilliseconds(30));
1877 queue->task_runner()->PostDelayedTask(FROM_HERE,
1878 BindOnce(&TestTask, 2, &run_order),
1879 TimeDelta::FromMilliseconds(20));
1880 queue->task_runner()->PostDelayedTask(FROM_HERE,
1881 BindOnce(&TestTask, 3, &run_order),
1882 TimeDelta::FromMilliseconds(10));
1883 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 4, &run_order));
1884
1885 FastForwardBy(TimeDelta::FromMilliseconds(40));
1886 ASSERT_THAT(run_order, ElementsAre(4u, 3u, 2u, 1u));
1887
1888 // The sequence numbers are a one-based monotonically incrememting counter
1889 // which should be set when the task is posted rather than when it's enqueued
1890 // onto the Incoming queue. This counter starts with 2.
1891 EXPECT_THAT(observer.sequence_numbers(), ElementsAre(5, 4, 3, 2));
1892
1893 sequence_manager()->RemoveTaskObserver(&observer);
1894 }
1895
TEST_P(SequenceManagerTest,NewTaskQueues)1896 TEST_P(SequenceManagerTest, NewTaskQueues) {
1897 auto queue = CreateTaskQueue();
1898
1899 scoped_refptr<TestTaskQueue> queue1 = CreateTaskQueue();
1900 scoped_refptr<TestTaskQueue> queue2 = CreateTaskQueue();
1901 scoped_refptr<TestTaskQueue> queue3 = CreateTaskQueue();
1902
1903 ASSERT_NE(queue1, queue2);
1904 ASSERT_NE(queue1, queue3);
1905 ASSERT_NE(queue2, queue3);
1906
1907 std::vector<EnqueueOrder> run_order;
1908 queue1->task_runner()->PostTask(FROM_HERE,
1909 BindOnce(&TestTask, 1, &run_order));
1910 queue2->task_runner()->PostTask(FROM_HERE,
1911 BindOnce(&TestTask, 2, &run_order));
1912 queue3->task_runner()->PostTask(FROM_HERE,
1913 BindOnce(&TestTask, 3, &run_order));
1914 RunLoop().RunUntilIdle();
1915
1916 EXPECT_THAT(run_order, ElementsAre(1u, 2u, 3u));
1917 }
1918
TEST_P(SequenceManagerTest,ShutdownTaskQueue_TaskRunnersDetaching)1919 TEST_P(SequenceManagerTest, ShutdownTaskQueue_TaskRunnersDetaching) {
1920 scoped_refptr<TestTaskQueue> queue = CreateTaskQueue();
1921
1922 scoped_refptr<SingleThreadTaskRunner> runner1 = queue->task_runner();
1923 scoped_refptr<SingleThreadTaskRunner> runner2 = queue->CreateTaskRunner(1);
1924
1925 std::vector<EnqueueOrder> run_order;
1926 EXPECT_TRUE(runner1->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order)));
1927 EXPECT_TRUE(runner2->PostTask(FROM_HERE, BindOnce(&TestTask, 2, &run_order)));
1928 queue->ShutdownTaskQueue();
1929 EXPECT_FALSE(
1930 runner1->PostTask(FROM_HERE, BindOnce(&TestTask, 3, &run_order)));
1931 EXPECT_FALSE(
1932 runner2->PostTask(FROM_HERE, BindOnce(&TestTask, 4, &run_order)));
1933
1934 RunLoop().RunUntilIdle();
1935 EXPECT_THAT(run_order, ElementsAre());
1936 }
1937
TEST_P(SequenceManagerTest,ShutdownTaskQueue)1938 TEST_P(SequenceManagerTest, ShutdownTaskQueue) {
1939 auto queue = CreateTaskQueue();
1940
1941 scoped_refptr<TestTaskQueue> queue1 = CreateTaskQueue();
1942 scoped_refptr<TestTaskQueue> queue2 = CreateTaskQueue();
1943 scoped_refptr<TestTaskQueue> queue3 = CreateTaskQueue();
1944
1945 ASSERT_NE(queue1, queue2);
1946 ASSERT_NE(queue1, queue3);
1947 ASSERT_NE(queue2, queue3);
1948
1949 std::vector<EnqueueOrder> run_order;
1950 queue1->task_runner()->PostTask(FROM_HERE,
1951 BindOnce(&TestTask, 1, &run_order));
1952 queue2->task_runner()->PostTask(FROM_HERE,
1953 BindOnce(&TestTask, 2, &run_order));
1954 queue3->task_runner()->PostTask(FROM_HERE,
1955 BindOnce(&TestTask, 3, &run_order));
1956 queue2->ShutdownTaskQueue();
1957 RunLoop().RunUntilIdle();
1958
1959 EXPECT_THAT(run_order, ElementsAre(1u, 3u));
1960 }
1961
TEST_P(SequenceManagerTest,ShutdownTaskQueue_WithDelayedTasks)1962 TEST_P(SequenceManagerTest, ShutdownTaskQueue_WithDelayedTasks) {
1963 auto queues = CreateTaskQueues(2u);
1964
1965 // Register three delayed tasks
1966 std::vector<EnqueueOrder> run_order;
1967 queues[0]->task_runner()->PostDelayedTask(FROM_HERE,
1968 BindOnce(&TestTask, 1, &run_order),
1969 TimeDelta::FromMilliseconds(10));
1970 queues[1]->task_runner()->PostDelayedTask(FROM_HERE,
1971 BindOnce(&TestTask, 2, &run_order),
1972 TimeDelta::FromMilliseconds(20));
1973 queues[0]->task_runner()->PostDelayedTask(FROM_HERE,
1974 BindOnce(&TestTask, 3, &run_order),
1975 TimeDelta::FromMilliseconds(30));
1976
1977 queues[1]->ShutdownTaskQueue();
1978 RunLoop().RunUntilIdle();
1979
1980 FastForwardBy(TimeDelta::FromMilliseconds(40));
1981 ASSERT_THAT(run_order, ElementsAre(1u, 3u));
1982 }
1983
1984 namespace {
ShutdownQueue(scoped_refptr<TestTaskQueue> queue)1985 void ShutdownQueue(scoped_refptr<TestTaskQueue> queue) {
1986 queue->ShutdownTaskQueue();
1987 }
1988 } // namespace
1989
TEST_P(SequenceManagerTest,ShutdownTaskQueue_InTasks)1990 TEST_P(SequenceManagerTest, ShutdownTaskQueue_InTasks) {
1991 auto queues = CreateTaskQueues(3u);
1992
1993 std::vector<EnqueueOrder> run_order;
1994 queues[0]->task_runner()->PostTask(FROM_HERE,
1995 BindOnce(&TestTask, 1, &run_order));
1996 queues[0]->task_runner()->PostTask(FROM_HERE,
1997 BindOnce(&ShutdownQueue, queues[1]));
1998 queues[0]->task_runner()->PostTask(FROM_HERE,
1999 BindOnce(&ShutdownQueue, queues[2]));
2000 queues[1]->task_runner()->PostTask(FROM_HERE,
2001 BindOnce(&TestTask, 2, &run_order));
2002 queues[2]->task_runner()->PostTask(FROM_HERE,
2003 BindOnce(&TestTask, 3, &run_order));
2004
2005 RunLoop().RunUntilIdle();
2006 ASSERT_THAT(run_order, ElementsAre(1u));
2007 }
2008
2009 namespace {
2010
2011 class MockObserver : public SequenceManager::Observer {
2012 public:
2013 MOCK_METHOD0(OnTriedToExecuteBlockedTask, void());
2014 MOCK_METHOD0(OnBeginNestedRunLoop, void());
2015 MOCK_METHOD0(OnExitNestedRunLoop, void());
2016 };
2017
2018 } // namespace
2019
TEST_P(SequenceManagerTest,ShutdownTaskQueueInNestedLoop)2020 TEST_P(SequenceManagerTest, ShutdownTaskQueueInNestedLoop) {
2021 auto queue = CreateTaskQueue();
2022
2023 // We retain a reference to the task queue even when the manager has deleted
2024 // its reference.
2025 scoped_refptr<TestTaskQueue> task_queue = CreateTaskQueue();
2026
2027 std::vector<bool> log;
2028 std::vector<std::pair<OnceClosure, bool>> tasks_to_post_from_nested_loop;
2029
2030 // Inside a nested run loop, call task_queue->ShutdownTaskQueue, bookended
2031 // by calls to HasOneRefTask to make sure the manager doesn't release its
2032 // reference until the nested run loop exits.
2033 // NB: This first HasOneRefTask is a sanity check.
2034 tasks_to_post_from_nested_loop.push_back(
2035 std::make_pair(BindOnce(&NopTask), true));
2036 tasks_to_post_from_nested_loop.push_back(std::make_pair(
2037 BindOnce(&TaskQueue::ShutdownTaskQueue, Unretained(task_queue.get())),
2038 true));
2039 tasks_to_post_from_nested_loop.push_back(
2040 std::make_pair(BindOnce(&NopTask), true));
2041 queue->task_runner()->PostTask(
2042 FROM_HERE, BindOnce(&PostFromNestedRunloop, queue,
2043 Unretained(&tasks_to_post_from_nested_loop)));
2044 RunLoop().RunUntilIdle();
2045
2046 // Just make sure that we don't crash.
2047 }
2048
TEST_P(SequenceManagerTest,TimeDomainsAreIndependant)2049 TEST_P(SequenceManagerTest, TimeDomainsAreIndependant) {
2050 auto queues = CreateTaskQueues(2u);
2051
2052 TimeTicks start_time_ticks = sequence_manager()->NowTicks();
2053 std::unique_ptr<MockTimeDomain> domain_a =
2054 std::make_unique<MockTimeDomain>(start_time_ticks);
2055 std::unique_ptr<MockTimeDomain> domain_b =
2056 std::make_unique<MockTimeDomain>(start_time_ticks);
2057 sequence_manager()->RegisterTimeDomain(domain_a.get());
2058 sequence_manager()->RegisterTimeDomain(domain_b.get());
2059 queues[0]->SetTimeDomain(domain_a.get());
2060 queues[1]->SetTimeDomain(domain_b.get());
2061
2062 std::vector<EnqueueOrder> run_order;
2063 queues[0]->task_runner()->PostDelayedTask(FROM_HERE,
2064 BindOnce(&TestTask, 1, &run_order),
2065 TimeDelta::FromMilliseconds(10));
2066 queues[0]->task_runner()->PostDelayedTask(FROM_HERE,
2067 BindOnce(&TestTask, 2, &run_order),
2068 TimeDelta::FromMilliseconds(20));
2069 queues[0]->task_runner()->PostDelayedTask(FROM_HERE,
2070 BindOnce(&TestTask, 3, &run_order),
2071 TimeDelta::FromMilliseconds(30));
2072
2073 queues[1]->task_runner()->PostDelayedTask(FROM_HERE,
2074 BindOnce(&TestTask, 4, &run_order),
2075 TimeDelta::FromMilliseconds(10));
2076 queues[1]->task_runner()->PostDelayedTask(FROM_HERE,
2077 BindOnce(&TestTask, 5, &run_order),
2078 TimeDelta::FromMilliseconds(20));
2079 queues[1]->task_runner()->PostDelayedTask(FROM_HERE,
2080 BindOnce(&TestTask, 6, &run_order),
2081 TimeDelta::FromMilliseconds(30));
2082
2083 domain_b->SetNowTicks(start_time_ticks + TimeDelta::FromMilliseconds(50));
2084 sequence_manager()->ScheduleWork();
2085
2086 RunLoop().RunUntilIdle();
2087 EXPECT_THAT(run_order, ElementsAre(4u, 5u, 6u));
2088
2089 domain_a->SetNowTicks(start_time_ticks + TimeDelta::FromMilliseconds(50));
2090 sequence_manager()->ScheduleWork();
2091
2092 RunLoop().RunUntilIdle();
2093 EXPECT_THAT(run_order, ElementsAre(4u, 5u, 6u, 1u, 2u, 3u));
2094
2095 queues[0]->ShutdownTaskQueue();
2096 queues[1]->ShutdownTaskQueue();
2097
2098 sequence_manager()->UnregisterTimeDomain(domain_a.get());
2099 sequence_manager()->UnregisterTimeDomain(domain_b.get());
2100 }
2101
TEST_P(SequenceManagerTest,TimeDomainMigration)2102 TEST_P(SequenceManagerTest, TimeDomainMigration) {
2103 auto queue = CreateTaskQueue();
2104
2105 TimeTicks start_time_ticks = sequence_manager()->NowTicks();
2106 std::unique_ptr<MockTimeDomain> domain_a =
2107 std::make_unique<MockTimeDomain>(start_time_ticks);
2108 sequence_manager()->RegisterTimeDomain(domain_a.get());
2109 queue->SetTimeDomain(domain_a.get());
2110
2111 std::vector<EnqueueOrder> run_order;
2112 queue->task_runner()->PostDelayedTask(FROM_HERE,
2113 BindOnce(&TestTask, 1, &run_order),
2114 TimeDelta::FromMilliseconds(10));
2115 queue->task_runner()->PostDelayedTask(FROM_HERE,
2116 BindOnce(&TestTask, 2, &run_order),
2117 TimeDelta::FromMilliseconds(20));
2118 queue->task_runner()->PostDelayedTask(FROM_HERE,
2119 BindOnce(&TestTask, 3, &run_order),
2120 TimeDelta::FromMilliseconds(30));
2121 queue->task_runner()->PostDelayedTask(FROM_HERE,
2122 BindOnce(&TestTask, 4, &run_order),
2123 TimeDelta::FromMilliseconds(40));
2124
2125 domain_a->SetNowTicks(start_time_ticks + TimeDelta::FromMilliseconds(20));
2126 sequence_manager()->ScheduleWork();
2127 RunLoop().RunUntilIdle();
2128 EXPECT_THAT(run_order, ElementsAre(1u, 2u));
2129
2130 std::unique_ptr<MockTimeDomain> domain_b =
2131 std::make_unique<MockTimeDomain>(start_time_ticks);
2132 sequence_manager()->RegisterTimeDomain(domain_b.get());
2133 queue->SetTimeDomain(domain_b.get());
2134
2135 domain_b->SetNowTicks(start_time_ticks + TimeDelta::FromMilliseconds(50));
2136 sequence_manager()->ScheduleWork();
2137
2138 RunLoop().RunUntilIdle();
2139 EXPECT_THAT(run_order, ElementsAre(1u, 2u, 3u, 4u));
2140
2141 queue->ShutdownTaskQueue();
2142
2143 sequence_manager()->UnregisterTimeDomain(domain_a.get());
2144 sequence_manager()->UnregisterTimeDomain(domain_b.get());
2145 }
2146
TEST_P(SequenceManagerTest,TimeDomainMigrationWithIncomingImmediateTasks)2147 TEST_P(SequenceManagerTest, TimeDomainMigrationWithIncomingImmediateTasks) {
2148 auto queue = CreateTaskQueue();
2149
2150 TimeTicks start_time_ticks = sequence_manager()->NowTicks();
2151 std::unique_ptr<MockTimeDomain> domain_a =
2152 std::make_unique<MockTimeDomain>(start_time_ticks);
2153 std::unique_ptr<MockTimeDomain> domain_b =
2154 std::make_unique<MockTimeDomain>(start_time_ticks);
2155 sequence_manager()->RegisterTimeDomain(domain_a.get());
2156 sequence_manager()->RegisterTimeDomain(domain_b.get());
2157
2158 queue->SetTimeDomain(domain_a.get());
2159 std::vector<EnqueueOrder> run_order;
2160 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order));
2161 queue->SetTimeDomain(domain_b.get());
2162
2163 RunLoop().RunUntilIdle();
2164 EXPECT_THAT(run_order, ElementsAre(1u));
2165
2166 queue->ShutdownTaskQueue();
2167
2168 sequence_manager()->UnregisterTimeDomain(domain_a.get());
2169 sequence_manager()->UnregisterTimeDomain(domain_b.get());
2170 }
2171
TEST_P(SequenceManagerTest,PostDelayedTasksReverseOrderAlternatingTimeDomains)2172 TEST_P(SequenceManagerTest,
2173 PostDelayedTasksReverseOrderAlternatingTimeDomains) {
2174 auto queue = CreateTaskQueue();
2175
2176 std::vector<EnqueueOrder> run_order;
2177
2178 std::unique_ptr<internal::RealTimeDomain> domain_a =
2179 std::make_unique<internal::RealTimeDomain>();
2180 std::unique_ptr<internal::RealTimeDomain> domain_b =
2181 std::make_unique<internal::RealTimeDomain>();
2182 sequence_manager()->RegisterTimeDomain(domain_a.get());
2183 sequence_manager()->RegisterTimeDomain(domain_b.get());
2184
2185 queue->SetTimeDomain(domain_a.get());
2186 queue->task_runner()->PostDelayedTask(FROM_HERE,
2187 BindOnce(&TestTask, 1, &run_order),
2188 TimeDelta::FromMilliseconds(40));
2189
2190 queue->SetTimeDomain(domain_b.get());
2191 queue->task_runner()->PostDelayedTask(FROM_HERE,
2192 BindOnce(&TestTask, 2, &run_order),
2193 TimeDelta::FromMilliseconds(30));
2194
2195 queue->SetTimeDomain(domain_a.get());
2196 queue->task_runner()->PostDelayedTask(FROM_HERE,
2197 BindOnce(&TestTask, 3, &run_order),
2198 TimeDelta::FromMilliseconds(20));
2199
2200 queue->SetTimeDomain(domain_b.get());
2201 queue->task_runner()->PostDelayedTask(FROM_HERE,
2202 BindOnce(&TestTask, 4, &run_order),
2203 TimeDelta::FromMilliseconds(10));
2204
2205 FastForwardBy(TimeDelta::FromMilliseconds(40));
2206 EXPECT_THAT(run_order, ElementsAre(4u, 3u, 2u, 1u));
2207
2208 queue->ShutdownTaskQueue();
2209
2210 sequence_manager()->UnregisterTimeDomain(domain_a.get());
2211 sequence_manager()->UnregisterTimeDomain(domain_b.get());
2212 }
2213
2214 namespace {
2215
2216 class MockTaskQueueObserver : public TaskQueue::Observer {
2217 public:
2218 ~MockTaskQueueObserver() override = default;
2219
2220 MOCK_METHOD1(OnQueueNextWakeUpChanged, void(TimeTicks));
2221 };
2222
2223 } // namespace
2224
TEST_P(SequenceManagerTest,TaskQueueObserver_ImmediateTask)2225 TEST_P(SequenceManagerTest, TaskQueueObserver_ImmediateTask) {
2226 auto queue = CreateTaskQueue();
2227
2228 MockTaskQueueObserver observer;
2229 queue->SetObserver(&observer);
2230
2231 // We should get a OnQueueNextWakeUpChanged notification when a task is posted
2232 // on an empty queue.
2233 EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_));
2234 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
2235 sequence_manager()->ReloadEmptyWorkQueues();
2236 Mock::VerifyAndClearExpectations(&observer);
2237
2238 // But not subsequently.
2239 EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_)).Times(0);
2240 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
2241 sequence_manager()->ReloadEmptyWorkQueues();
2242 Mock::VerifyAndClearExpectations(&observer);
2243
2244 // Unless the immediate work queue is emptied.
2245 sequence_manager()->SelectNextTask();
2246 sequence_manager()->DidRunTask();
2247 sequence_manager()->SelectNextTask();
2248 sequence_manager()->DidRunTask();
2249 EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_));
2250 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
2251 sequence_manager()->ReloadEmptyWorkQueues();
2252 Mock::VerifyAndClearExpectations(&observer);
2253
2254 // Tidy up.
2255 queue->ShutdownTaskQueue();
2256 }
2257
TEST_P(SequenceManagerTest,TaskQueueObserver_DelayedTask)2258 TEST_P(SequenceManagerTest, TaskQueueObserver_DelayedTask) {
2259 auto queue = CreateTaskQueue();
2260
2261 TimeTicks start_time = sequence_manager()->NowTicks();
2262 TimeDelta delay10s(TimeDelta::FromSeconds(10));
2263 TimeDelta delay100s(TimeDelta::FromSeconds(100));
2264 TimeDelta delay1s(TimeDelta::FromSeconds(1));
2265
2266 MockTaskQueueObserver observer;
2267 queue->SetObserver(&observer);
2268
2269 // We should get OnQueueNextWakeUpChanged notification when a delayed task is
2270 // is posted on an empty queue.
2271 EXPECT_CALL(observer, OnQueueNextWakeUpChanged(start_time + delay10s));
2272 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
2273 delay10s);
2274 Mock::VerifyAndClearExpectations(&observer);
2275
2276 // We should not get an OnQueueNextWakeUpChanged notification for a longer
2277 // delay.
2278 EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_)).Times(0);
2279 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
2280 delay100s);
2281 Mock::VerifyAndClearExpectations(&observer);
2282
2283 // We should get an OnQueueNextWakeUpChanged notification for a shorter delay.
2284 EXPECT_CALL(observer, OnQueueNextWakeUpChanged(start_time + delay1s));
2285 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask), delay1s);
2286 Mock::VerifyAndClearExpectations(&observer);
2287
2288 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
2289 queue->CreateQueueEnabledVoter();
2290 voter->SetVoteToEnable(false);
2291 Mock::VerifyAndClearExpectations(&observer);
2292
2293 // When a queue has been enabled, we may get a notification if the
2294 // TimeDomain's next scheduled wake-up has changed.
2295 EXPECT_CALL(observer, OnQueueNextWakeUpChanged(start_time + delay1s));
2296 voter->SetVoteToEnable(true);
2297 Mock::VerifyAndClearExpectations(&observer);
2298
2299 // Tidy up.
2300 queue->ShutdownTaskQueue();
2301 }
2302
TEST_P(SequenceManagerTest,TaskQueueObserver_DelayedTaskMultipleQueues)2303 TEST_P(SequenceManagerTest, TaskQueueObserver_DelayedTaskMultipleQueues) {
2304 auto queues = CreateTaskQueues(2u);
2305
2306 MockTaskQueueObserver observer0;
2307 MockTaskQueueObserver observer1;
2308 queues[0]->SetObserver(&observer0);
2309 queues[1]->SetObserver(&observer1);
2310
2311 TimeTicks start_time = sequence_manager()->NowTicks();
2312 TimeDelta delay1s(TimeDelta::FromSeconds(1));
2313 TimeDelta delay10s(TimeDelta::FromSeconds(10));
2314
2315 EXPECT_CALL(observer0, OnQueueNextWakeUpChanged(start_time + delay1s))
2316 .Times(1);
2317 EXPECT_CALL(observer1, OnQueueNextWakeUpChanged(start_time + delay10s))
2318 .Times(1);
2319 queues[0]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
2320 delay1s);
2321 queues[1]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
2322 delay10s);
2323 testing::Mock::VerifyAndClearExpectations(&observer0);
2324 testing::Mock::VerifyAndClearExpectations(&observer1);
2325
2326 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter0 =
2327 queues[0]->CreateQueueEnabledVoter();
2328 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter1 =
2329 queues[1]->CreateQueueEnabledVoter();
2330
2331 // Disabling a queue should not trigger a notification.
2332 EXPECT_CALL(observer0, OnQueueNextWakeUpChanged(_)).Times(0);
2333 voter0->SetVoteToEnable(false);
2334 Mock::VerifyAndClearExpectations(&observer0);
2335
2336 // But re-enabling it should should trigger an OnQueueNextWakeUpChanged
2337 // notification.
2338 EXPECT_CALL(observer0, OnQueueNextWakeUpChanged(start_time + delay1s));
2339 voter0->SetVoteToEnable(true);
2340 Mock::VerifyAndClearExpectations(&observer0);
2341
2342 // Disabling a queue should not trigger a notification.
2343 EXPECT_CALL(observer1, OnQueueNextWakeUpChanged(_)).Times(0);
2344 voter1->SetVoteToEnable(false);
2345 Mock::VerifyAndClearExpectations(&observer0);
2346
2347 // But re-enabling it should should trigger a notification.
2348 EXPECT_CALL(observer1, OnQueueNextWakeUpChanged(start_time + delay10s));
2349 voter1->SetVoteToEnable(true);
2350 Mock::VerifyAndClearExpectations(&observer1);
2351
2352 // Tidy up.
2353 EXPECT_CALL(observer0, OnQueueNextWakeUpChanged(_)).Times(AnyNumber());
2354 EXPECT_CALL(observer1, OnQueueNextWakeUpChanged(_)).Times(AnyNumber());
2355 queues[0]->ShutdownTaskQueue();
2356 queues[1]->ShutdownTaskQueue();
2357 }
2358
TEST_P(SequenceManagerTest,TaskQueueObserver_DelayedWorkWhichCanRunNow)2359 TEST_P(SequenceManagerTest, TaskQueueObserver_DelayedWorkWhichCanRunNow) {
2360 // This test checks that when delayed work becomes available
2361 // the notification still fires. This usually happens when time advances
2362 // and task becomes available in the middle of the scheduling code.
2363 // For this test we rely on the fact that notification dispatching code
2364 // is the same in all conditions and just change a time domain to
2365 // trigger notification.
2366
2367 auto queue = CreateTaskQueue();
2368
2369 TimeDelta delay1s(TimeDelta::FromSeconds(1));
2370 TimeDelta delay10s(TimeDelta::FromSeconds(10));
2371
2372 MockTaskQueueObserver observer;
2373 queue->SetObserver(&observer);
2374
2375 // We should get a notification when a delayed task is posted on an empty
2376 // queue.
2377 EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_));
2378 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask), delay1s);
2379 Mock::VerifyAndClearExpectations(&observer);
2380
2381 std::unique_ptr<TimeDomain> mock_time_domain =
2382 std::make_unique<internal::RealTimeDomain>();
2383 sequence_manager()->RegisterTimeDomain(mock_time_domain.get());
2384
2385 AdvanceMockTickClock(delay10s);
2386
2387 EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_));
2388 queue->SetTimeDomain(mock_time_domain.get());
2389 Mock::VerifyAndClearExpectations(&observer);
2390
2391 // Tidy up.
2392 queue->ShutdownTaskQueue();
2393 }
2394
2395 class CancelableTask {
2396 public:
CancelableTask(const TickClock * clock)2397 explicit CancelableTask(const TickClock* clock) : clock_(clock) {}
2398
RecordTimeTask(std::vector<TimeTicks> * run_times)2399 void RecordTimeTask(std::vector<TimeTicks>* run_times) {
2400 run_times->push_back(clock_->NowTicks());
2401 }
2402
2403 const TickClock* clock_;
2404 WeakPtrFactory<CancelableTask> weak_factory_{this};
2405 };
2406
TEST_P(SequenceManagerTest,TaskQueueObserver_SweepCanceledDelayedTasks)2407 TEST_P(SequenceManagerTest, TaskQueueObserver_SweepCanceledDelayedTasks) {
2408 auto queue = CreateTaskQueue();
2409
2410 MockTaskQueueObserver observer;
2411 queue->SetObserver(&observer);
2412
2413 TimeTicks start_time = sequence_manager()->NowTicks();
2414 TimeDelta delay1(TimeDelta::FromSeconds(5));
2415 TimeDelta delay2(TimeDelta::FromSeconds(10));
2416
2417 EXPECT_CALL(observer, OnQueueNextWakeUpChanged(start_time + delay1)).Times(1);
2418
2419 CancelableTask task1(mock_tick_clock());
2420 CancelableTask task2(mock_tick_clock());
2421 std::vector<TimeTicks> run_times;
2422 queue->task_runner()->PostDelayedTask(
2423 FROM_HERE,
2424 BindOnce(&CancelableTask::RecordTimeTask,
2425 task1.weak_factory_.GetWeakPtr(), &run_times),
2426 delay1);
2427 queue->task_runner()->PostDelayedTask(
2428 FROM_HERE,
2429 BindOnce(&CancelableTask::RecordTimeTask,
2430 task2.weak_factory_.GetWeakPtr(), &run_times),
2431 delay2);
2432
2433 task1.weak_factory_.InvalidateWeakPtrs();
2434
2435 // Sweeping away canceled delayed tasks should trigger a notification.
2436 EXPECT_CALL(observer, OnQueueNextWakeUpChanged(start_time + delay2)).Times(1);
2437 sequence_manager()->ReclaimMemory();
2438 }
2439
2440 namespace {
ChromiumRunloopInspectionTask(scoped_refptr<TestMockTimeTaskRunner> test_task_runner)2441 void ChromiumRunloopInspectionTask(
2442 scoped_refptr<TestMockTimeTaskRunner> test_task_runner) {
2443 // We don't expect more than 1 pending task at any time.
2444 EXPECT_GE(1u, test_task_runner->GetPendingTaskCount());
2445 }
2446 } // namespace
2447
TEST(SequenceManagerTestWithMockTaskRunner,NumberOfPendingTasksOnChromiumRunLoop)2448 TEST(SequenceManagerTestWithMockTaskRunner,
2449 NumberOfPendingTasksOnChromiumRunLoop) {
2450 FixtureWithMockTaskRunner fixture;
2451 auto queue =
2452 fixture.sequence_manager()->CreateTaskQueue(TaskQueue::Spec("test"));
2453
2454 // NOTE because tasks posted to the chromiumrun loop are not cancellable, we
2455 // will end up with a lot more tasks posted if the delayed tasks were posted
2456 // in the reverse order.
2457 // TODO(alexclarke): Consider talking to the message pump directly.
2458 for (int i = 1; i < 100; i++) {
2459 queue->task_runner()->PostDelayedTask(
2460 FROM_HERE,
2461 BindOnce(&ChromiumRunloopInspectionTask, fixture.test_task_runner()),
2462 TimeDelta::FromMilliseconds(i));
2463 }
2464 fixture.FastForwardUntilNoTasksRemain();
2465 }
2466
2467 namespace {
2468
2469 class QuadraticTask {
2470 public:
QuadraticTask(scoped_refptr<TaskRunner> task_runner,TimeDelta delay,Fixture * fixture)2471 QuadraticTask(scoped_refptr<TaskRunner> task_runner,
2472 TimeDelta delay,
2473 Fixture* fixture)
2474 : count_(0),
2475 task_runner_(task_runner),
2476 delay_(delay),
2477 fixture_(fixture) {}
2478
SetShouldExit(RepeatingCallback<bool ()> should_exit)2479 void SetShouldExit(RepeatingCallback<bool()> should_exit) {
2480 should_exit_ = should_exit;
2481 }
2482
Run()2483 void Run() {
2484 if (should_exit_.Run())
2485 return;
2486 count_++;
2487 task_runner_->PostDelayedTask(
2488 FROM_HERE, BindOnce(&QuadraticTask::Run, Unretained(this)), delay_);
2489 task_runner_->PostDelayedTask(
2490 FROM_HERE, BindOnce(&QuadraticTask::Run, Unretained(this)), delay_);
2491 fixture_->AdvanceMockTickClock(TimeDelta::FromMilliseconds(5));
2492 }
2493
Count() const2494 int Count() const { return count_; }
2495
2496 private:
2497 int count_;
2498 scoped_refptr<TaskRunner> task_runner_;
2499 TimeDelta delay_;
2500 Fixture* fixture_;
2501 RepeatingCallback<bool()> should_exit_;
2502 };
2503
2504 class LinearTask {
2505 public:
LinearTask(scoped_refptr<TaskRunner> task_runner,TimeDelta delay,Fixture * fixture)2506 LinearTask(scoped_refptr<TaskRunner> task_runner,
2507 TimeDelta delay,
2508 Fixture* fixture)
2509 : count_(0),
2510 task_runner_(task_runner),
2511 delay_(delay),
2512 fixture_(fixture) {}
2513
SetShouldExit(RepeatingCallback<bool ()> should_exit)2514 void SetShouldExit(RepeatingCallback<bool()> should_exit) {
2515 should_exit_ = should_exit;
2516 }
2517
Run()2518 void Run() {
2519 if (should_exit_.Run())
2520 return;
2521 count_++;
2522 task_runner_->PostDelayedTask(
2523 FROM_HERE, BindOnce(&LinearTask::Run, Unretained(this)), delay_);
2524 fixture_->AdvanceMockTickClock(TimeDelta::FromMilliseconds(5));
2525 }
2526
Count() const2527 int Count() const { return count_; }
2528
2529 private:
2530 int count_;
2531 scoped_refptr<TaskRunner> task_runner_;
2532 TimeDelta delay_;
2533 Fixture* fixture_;
2534 RepeatingCallback<bool()> should_exit_;
2535 };
2536
ShouldExit(QuadraticTask * quadratic_task,LinearTask * linear_task)2537 bool ShouldExit(QuadraticTask* quadratic_task, LinearTask* linear_task) {
2538 return quadratic_task->Count() == 1000 || linear_task->Count() == 1000;
2539 }
2540
2541 } // namespace
2542
TEST_P(SequenceManagerTest,DelayedTasksDontBadlyStarveNonDelayedWork_SameQueue)2543 TEST_P(SequenceManagerTest,
2544 DelayedTasksDontBadlyStarveNonDelayedWork_SameQueue) {
2545 auto queue = CreateTaskQueue();
2546
2547 QuadraticTask quadratic_delayed_task(queue->task_runner(),
2548 TimeDelta::FromMilliseconds(10), this);
2549 LinearTask linear_immediate_task(queue->task_runner(), TimeDelta(), this);
2550 RepeatingCallback<bool()> should_exit = BindRepeating(
2551 ShouldExit, &quadratic_delayed_task, &linear_immediate_task);
2552 quadratic_delayed_task.SetShouldExit(should_exit);
2553 linear_immediate_task.SetShouldExit(should_exit);
2554
2555 quadratic_delayed_task.Run();
2556 linear_immediate_task.Run();
2557
2558 FastForwardUntilNoTasksRemain();
2559
2560 double ratio = static_cast<double>(linear_immediate_task.Count()) /
2561 static_cast<double>(quadratic_delayed_task.Count());
2562
2563 EXPECT_GT(ratio, 0.333);
2564 EXPECT_LT(ratio, 1.1);
2565 }
2566
TEST_P(SequenceManagerTest,ImmediateWorkCanStarveDelayedTasks_SameQueue)2567 TEST_P(SequenceManagerTest, ImmediateWorkCanStarveDelayedTasks_SameQueue) {
2568 auto queue = CreateTaskQueue();
2569
2570 QuadraticTask quadratic_immediate_task(queue->task_runner(), TimeDelta(),
2571 this);
2572 LinearTask linear_delayed_task(queue->task_runner(),
2573 TimeDelta::FromMilliseconds(10), this);
2574 RepeatingCallback<bool()> should_exit = BindRepeating(
2575 &ShouldExit, &quadratic_immediate_task, &linear_delayed_task);
2576
2577 quadratic_immediate_task.SetShouldExit(should_exit);
2578 linear_delayed_task.SetShouldExit(should_exit);
2579
2580 quadratic_immediate_task.Run();
2581 linear_delayed_task.Run();
2582
2583 FastForwardUntilNoTasksRemain();
2584
2585 double ratio = static_cast<double>(linear_delayed_task.Count()) /
2586 static_cast<double>(quadratic_immediate_task.Count());
2587
2588 // This is by design, we want to enforce a strict ordering in task execution
2589 // where by delayed tasks can not skip ahead of non-delayed work.
2590 EXPECT_GT(ratio, 0.0);
2591 EXPECT_LT(ratio, 0.1);
2592 }
2593
TEST_P(SequenceManagerTest,DelayedTasksDontBadlyStarveNonDelayedWork_DifferentQueue)2594 TEST_P(SequenceManagerTest,
2595 DelayedTasksDontBadlyStarveNonDelayedWork_DifferentQueue) {
2596 auto queues = CreateTaskQueues(2u);
2597
2598 QuadraticTask quadratic_delayed_task(queues[0]->task_runner(),
2599 TimeDelta::FromMilliseconds(10), this);
2600 LinearTask linear_immediate_task(queues[1]->task_runner(), TimeDelta(), this);
2601 RepeatingCallback<bool()> should_exit = BindRepeating(
2602 ShouldExit, &quadratic_delayed_task, &linear_immediate_task);
2603 quadratic_delayed_task.SetShouldExit(should_exit);
2604 linear_immediate_task.SetShouldExit(should_exit);
2605
2606 quadratic_delayed_task.Run();
2607 linear_immediate_task.Run();
2608
2609 FastForwardUntilNoTasksRemain();
2610
2611 double ratio = static_cast<double>(linear_immediate_task.Count()) /
2612 static_cast<double>(quadratic_delayed_task.Count());
2613
2614 EXPECT_GT(ratio, 0.333);
2615 EXPECT_LT(ratio, 1.1);
2616 }
2617
TEST_P(SequenceManagerTest,ImmediateWorkCanStarveDelayedTasks_DifferentQueue)2618 TEST_P(SequenceManagerTest, ImmediateWorkCanStarveDelayedTasks_DifferentQueue) {
2619 auto queues = CreateTaskQueues(2u);
2620
2621 QuadraticTask quadratic_immediate_task(queues[0]->task_runner(), TimeDelta(),
2622 this);
2623 LinearTask linear_delayed_task(queues[1]->task_runner(),
2624 TimeDelta::FromMilliseconds(10), this);
2625 RepeatingCallback<bool()> should_exit = BindRepeating(
2626 &ShouldExit, &quadratic_immediate_task, &linear_delayed_task);
2627
2628 quadratic_immediate_task.SetShouldExit(should_exit);
2629 linear_delayed_task.SetShouldExit(should_exit);
2630
2631 quadratic_immediate_task.Run();
2632 linear_delayed_task.Run();
2633
2634 FastForwardUntilNoTasksRemain();
2635
2636 double ratio = static_cast<double>(linear_delayed_task.Count()) /
2637 static_cast<double>(quadratic_immediate_task.Count());
2638
2639 // This is by design, we want to enforce a strict ordering in task execution
2640 // where by delayed tasks can not skip ahead of non-delayed work.
2641 EXPECT_GT(ratio, 0.0);
2642 EXPECT_LT(ratio, 0.1);
2643 }
2644
TEST_P(SequenceManagerTest,CurrentlyExecutingTaskQueue_NoTaskRunning)2645 TEST_P(SequenceManagerTest, CurrentlyExecutingTaskQueue_NoTaskRunning) {
2646 auto queue = CreateTaskQueue();
2647
2648 EXPECT_EQ(nullptr, sequence_manager()->currently_executing_task_queue());
2649 }
2650
2651 namespace {
CurrentlyExecutingTaskQueueTestTask(SequenceManagerImpl * sequence_manager,std::vector<internal::TaskQueueImpl * > * task_sources)2652 void CurrentlyExecutingTaskQueueTestTask(
2653 SequenceManagerImpl* sequence_manager,
2654 std::vector<internal::TaskQueueImpl*>* task_sources) {
2655 task_sources->push_back(sequence_manager->currently_executing_task_queue());
2656 }
2657 } // namespace
2658
TEST_P(SequenceManagerTest,CurrentlyExecutingTaskQueue_TaskRunning)2659 TEST_P(SequenceManagerTest, CurrentlyExecutingTaskQueue_TaskRunning) {
2660 auto queues = CreateTaskQueues(2u);
2661
2662 TestTaskQueue* queue0 = queues[0].get();
2663 TestTaskQueue* queue1 = queues[1].get();
2664
2665 std::vector<internal::TaskQueueImpl*> task_sources;
2666 queue0->task_runner()->PostTask(FROM_HERE,
2667 BindOnce(&CurrentlyExecutingTaskQueueTestTask,
2668 sequence_manager(), &task_sources));
2669 queue1->task_runner()->PostTask(FROM_HERE,
2670 BindOnce(&CurrentlyExecutingTaskQueueTestTask,
2671 sequence_manager(), &task_sources));
2672 RunLoop().RunUntilIdle();
2673
2674 EXPECT_THAT(task_sources, ElementsAre(queue0->GetTaskQueueImpl(),
2675 queue1->GetTaskQueueImpl()));
2676 EXPECT_EQ(nullptr, sequence_manager()->currently_executing_task_queue());
2677 }
2678
2679 namespace {
RunloopCurrentlyExecutingTaskQueueTestTask(SequenceManagerImpl * sequence_manager,std::vector<internal::TaskQueueImpl * > * task_sources,std::vector<std::pair<OnceClosure,TestTaskQueue * >> * tasks)2680 void RunloopCurrentlyExecutingTaskQueueTestTask(
2681 SequenceManagerImpl* sequence_manager,
2682 std::vector<internal::TaskQueueImpl*>* task_sources,
2683 std::vector<std::pair<OnceClosure, TestTaskQueue*>>* tasks) {
2684 task_sources->push_back(sequence_manager->currently_executing_task_queue());
2685
2686 for (std::pair<OnceClosure, TestTaskQueue*>& pair : *tasks) {
2687 pair.second->task_runner()->PostTask(FROM_HERE, std::move(pair.first));
2688 }
2689
2690 RunLoop(RunLoop::Type::kNestableTasksAllowed).RunUntilIdle();
2691 task_sources->push_back(sequence_manager->currently_executing_task_queue());
2692 }
2693 } // namespace
2694
TEST_P(SequenceManagerTest,CurrentlyExecutingTaskQueue_NestedLoop)2695 TEST_P(SequenceManagerTest, CurrentlyExecutingTaskQueue_NestedLoop) {
2696 auto queues = CreateTaskQueues(3u);
2697
2698 TestTaskQueue* queue0 = queues[0].get();
2699 TestTaskQueue* queue1 = queues[1].get();
2700 TestTaskQueue* queue2 = queues[2].get();
2701
2702 std::vector<internal::TaskQueueImpl*> task_sources;
2703 std::vector<std::pair<OnceClosure, TestTaskQueue*>>
2704 tasks_to_post_from_nested_loop;
2705 tasks_to_post_from_nested_loop.push_back(
2706 std::make_pair(BindOnce(&CurrentlyExecutingTaskQueueTestTask,
2707 sequence_manager(), &task_sources),
2708 queue1));
2709 tasks_to_post_from_nested_loop.push_back(
2710 std::make_pair(BindOnce(&CurrentlyExecutingTaskQueueTestTask,
2711 sequence_manager(), &task_sources),
2712 queue2));
2713
2714 queue0->task_runner()->PostTask(
2715 FROM_HERE,
2716 BindOnce(&RunloopCurrentlyExecutingTaskQueueTestTask, sequence_manager(),
2717 &task_sources, &tasks_to_post_from_nested_loop));
2718
2719 RunLoop().RunUntilIdle();
2720 EXPECT_THAT(task_sources, UnorderedElementsAre(queue0->GetTaskQueueImpl(),
2721 queue1->GetTaskQueueImpl(),
2722 queue2->GetTaskQueueImpl(),
2723 queue0->GetTaskQueueImpl()));
2724 EXPECT_EQ(nullptr, sequence_manager()->currently_executing_task_queue());
2725 }
2726
2727 #if BUILDFLAG(ENABLE_BASE_TRACING)
TEST_P(SequenceManagerTest,BlameContextAttribution)2728 TEST_P(SequenceManagerTest, BlameContextAttribution) {
2729 if (GetUnderlyingRunnerType() == TestType::kMessagePump)
2730 return;
2731 using trace_analyzer::Query;
2732
2733 auto queue = CreateTaskQueue();
2734
2735 trace_analyzer::Start("*");
2736 {
2737 trace_event::BlameContext blame_context("cat", "name", "type", "scope", 0,
2738 nullptr);
2739 blame_context.Initialize();
2740 queue->SetBlameContext(&blame_context);
2741 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
2742 RunLoop().RunUntilIdle();
2743 }
2744 auto analyzer = trace_analyzer::Stop();
2745
2746 trace_analyzer::TraceEventVector events;
2747 Query q = Query::EventPhaseIs(TRACE_EVENT_PHASE_ENTER_CONTEXT) ||
2748 Query::EventPhaseIs(TRACE_EVENT_PHASE_LEAVE_CONTEXT);
2749 analyzer->FindEvents(q, &events);
2750
2751 EXPECT_EQ(2u, events.size());
2752 }
2753 #endif // BUILDFLAG(ENABLE_BASE_TRACING)
2754
TEST_P(SequenceManagerTest,NoWakeUpsForCanceledDelayedTasks)2755 TEST_P(SequenceManagerTest, NoWakeUpsForCanceledDelayedTasks) {
2756 auto queue = CreateTaskQueue();
2757
2758 TimeTicks start_time = sequence_manager()->NowTicks();
2759
2760 CancelableTask task1(mock_tick_clock());
2761 CancelableTask task2(mock_tick_clock());
2762 CancelableTask task3(mock_tick_clock());
2763 CancelableTask task4(mock_tick_clock());
2764 TimeDelta delay1(TimeDelta::FromSeconds(5));
2765 TimeDelta delay2(TimeDelta::FromSeconds(10));
2766 TimeDelta delay3(TimeDelta::FromSeconds(15));
2767 TimeDelta delay4(TimeDelta::FromSeconds(30));
2768 std::vector<TimeTicks> run_times;
2769 queue->task_runner()->PostDelayedTask(
2770 FROM_HERE,
2771 BindOnce(&CancelableTask::RecordTimeTask,
2772 task1.weak_factory_.GetWeakPtr(), &run_times),
2773 delay1);
2774 queue->task_runner()->PostDelayedTask(
2775 FROM_HERE,
2776 BindOnce(&CancelableTask::RecordTimeTask,
2777 task2.weak_factory_.GetWeakPtr(), &run_times),
2778 delay2);
2779 queue->task_runner()->PostDelayedTask(
2780 FROM_HERE,
2781 BindOnce(&CancelableTask::RecordTimeTask,
2782 task3.weak_factory_.GetWeakPtr(), &run_times),
2783 delay3);
2784 queue->task_runner()->PostDelayedTask(
2785 FROM_HERE,
2786 BindOnce(&CancelableTask::RecordTimeTask,
2787 task4.weak_factory_.GetWeakPtr(), &run_times),
2788 delay4);
2789
2790 task2.weak_factory_.InvalidateWeakPtrs();
2791 task3.weak_factory_.InvalidateWeakPtrs();
2792
2793 std::set<TimeTicks> wake_up_times;
2794
2795 RunUntilManagerIsIdle(BindRepeating(
2796 [](std::set<TimeTicks>* wake_up_times, const TickClock* clock) {
2797 wake_up_times->insert(clock->NowTicks());
2798 },
2799 &wake_up_times, mock_tick_clock()));
2800
2801 EXPECT_THAT(wake_up_times,
2802 ElementsAre(start_time + delay1, start_time + delay4));
2803 EXPECT_THAT(run_times, ElementsAre(start_time + delay1, start_time + delay4));
2804 }
2805
TEST_P(SequenceManagerTest,NoWakeUpsForCanceledDelayedTasksReversePostOrder)2806 TEST_P(SequenceManagerTest, NoWakeUpsForCanceledDelayedTasksReversePostOrder) {
2807 auto queue = CreateTaskQueue();
2808
2809 TimeTicks start_time = sequence_manager()->NowTicks();
2810
2811 CancelableTask task1(mock_tick_clock());
2812 CancelableTask task2(mock_tick_clock());
2813 CancelableTask task3(mock_tick_clock());
2814 CancelableTask task4(mock_tick_clock());
2815 TimeDelta delay1(TimeDelta::FromSeconds(5));
2816 TimeDelta delay2(TimeDelta::FromSeconds(10));
2817 TimeDelta delay3(TimeDelta::FromSeconds(15));
2818 TimeDelta delay4(TimeDelta::FromSeconds(30));
2819 std::vector<TimeTicks> run_times;
2820 queue->task_runner()->PostDelayedTask(
2821 FROM_HERE,
2822 BindOnce(&CancelableTask::RecordTimeTask,
2823 task4.weak_factory_.GetWeakPtr(), &run_times),
2824 delay4);
2825 queue->task_runner()->PostDelayedTask(
2826 FROM_HERE,
2827 BindOnce(&CancelableTask::RecordTimeTask,
2828 task3.weak_factory_.GetWeakPtr(), &run_times),
2829 delay3);
2830 queue->task_runner()->PostDelayedTask(
2831 FROM_HERE,
2832 BindOnce(&CancelableTask::RecordTimeTask,
2833 task2.weak_factory_.GetWeakPtr(), &run_times),
2834 delay2);
2835 queue->task_runner()->PostDelayedTask(
2836 FROM_HERE,
2837 BindOnce(&CancelableTask::RecordTimeTask,
2838 task1.weak_factory_.GetWeakPtr(), &run_times),
2839 delay1);
2840
2841 task2.weak_factory_.InvalidateWeakPtrs();
2842 task3.weak_factory_.InvalidateWeakPtrs();
2843
2844 std::set<TimeTicks> wake_up_times;
2845
2846 RunUntilManagerIsIdle(BindRepeating(
2847 [](std::set<TimeTicks>* wake_up_times, const TickClock* clock) {
2848 wake_up_times->insert(clock->NowTicks());
2849 },
2850 &wake_up_times, mock_tick_clock()));
2851
2852 EXPECT_THAT(wake_up_times,
2853 ElementsAre(start_time + delay1, start_time + delay4));
2854 EXPECT_THAT(run_times, ElementsAre(start_time + delay1, start_time + delay4));
2855 }
2856
TEST_P(SequenceManagerTest,TimeDomainWakeUpOnlyCancelledIfAllUsesCancelled)2857 TEST_P(SequenceManagerTest, TimeDomainWakeUpOnlyCancelledIfAllUsesCancelled) {
2858 auto queue = CreateTaskQueue();
2859
2860 TimeTicks start_time = sequence_manager()->NowTicks();
2861
2862 CancelableTask task1(mock_tick_clock());
2863 CancelableTask task2(mock_tick_clock());
2864 CancelableTask task3(mock_tick_clock());
2865 CancelableTask task4(mock_tick_clock());
2866 TimeDelta delay1(TimeDelta::FromSeconds(5));
2867 TimeDelta delay2(TimeDelta::FromSeconds(10));
2868 TimeDelta delay3(TimeDelta::FromSeconds(15));
2869 TimeDelta delay4(TimeDelta::FromSeconds(30));
2870 std::vector<TimeTicks> run_times;
2871 queue->task_runner()->PostDelayedTask(
2872 FROM_HERE,
2873 BindOnce(&CancelableTask::RecordTimeTask,
2874 task1.weak_factory_.GetWeakPtr(), &run_times),
2875 delay1);
2876 queue->task_runner()->PostDelayedTask(
2877 FROM_HERE,
2878 BindOnce(&CancelableTask::RecordTimeTask,
2879 task2.weak_factory_.GetWeakPtr(), &run_times),
2880 delay2);
2881 queue->task_runner()->PostDelayedTask(
2882 FROM_HERE,
2883 BindOnce(&CancelableTask::RecordTimeTask,
2884 task3.weak_factory_.GetWeakPtr(), &run_times),
2885 delay3);
2886 queue->task_runner()->PostDelayedTask(
2887 FROM_HERE,
2888 BindOnce(&CancelableTask::RecordTimeTask,
2889 task4.weak_factory_.GetWeakPtr(), &run_times),
2890 delay4);
2891
2892 // Post a non-canceled task with |delay3|. So we should still get a wake-up at
2893 // |delay3| even though we cancel |task3|.
2894 queue->task_runner()->PostDelayedTask(
2895 FROM_HERE,
2896 BindOnce(&CancelableTask::RecordTimeTask, Unretained(&task3), &run_times),
2897 delay3);
2898
2899 task2.weak_factory_.InvalidateWeakPtrs();
2900 task3.weak_factory_.InvalidateWeakPtrs();
2901 task1.weak_factory_.InvalidateWeakPtrs();
2902
2903 std::set<TimeTicks> wake_up_times;
2904
2905 RunUntilManagerIsIdle(BindRepeating(
2906 [](std::set<TimeTicks>* wake_up_times, const TickClock* clock) {
2907 wake_up_times->insert(clock->NowTicks());
2908 },
2909 &wake_up_times, mock_tick_clock()));
2910
2911 EXPECT_THAT(wake_up_times,
2912 ElementsAre(start_time + delay1, start_time + delay3,
2913 start_time + delay4));
2914
2915 EXPECT_THAT(run_times, ElementsAre(start_time + delay3, start_time + delay4));
2916 }
2917
TEST_P(SequenceManagerTest,SweepCanceledDelayedTasks)2918 TEST_P(SequenceManagerTest, SweepCanceledDelayedTasks) {
2919 auto queue = CreateTaskQueue();
2920
2921 CancelableTask task1(mock_tick_clock());
2922 CancelableTask task2(mock_tick_clock());
2923 CancelableTask task3(mock_tick_clock());
2924 CancelableTask task4(mock_tick_clock());
2925 TimeDelta delay1(TimeDelta::FromSeconds(5));
2926 TimeDelta delay2(TimeDelta::FromSeconds(10));
2927 TimeDelta delay3(TimeDelta::FromSeconds(15));
2928 TimeDelta delay4(TimeDelta::FromSeconds(30));
2929 std::vector<TimeTicks> run_times;
2930 queue->task_runner()->PostDelayedTask(
2931 FROM_HERE,
2932 BindOnce(&CancelableTask::RecordTimeTask,
2933 task1.weak_factory_.GetWeakPtr(), &run_times),
2934 delay1);
2935 queue->task_runner()->PostDelayedTask(
2936 FROM_HERE,
2937 BindOnce(&CancelableTask::RecordTimeTask,
2938 task2.weak_factory_.GetWeakPtr(), &run_times),
2939 delay2);
2940 queue->task_runner()->PostDelayedTask(
2941 FROM_HERE,
2942 BindOnce(&CancelableTask::RecordTimeTask,
2943 task3.weak_factory_.GetWeakPtr(), &run_times),
2944 delay3);
2945 queue->task_runner()->PostDelayedTask(
2946 FROM_HERE,
2947 BindOnce(&CancelableTask::RecordTimeTask,
2948 task4.weak_factory_.GetWeakPtr(), &run_times),
2949 delay4);
2950
2951 EXPECT_EQ(4u, queue->GetNumberOfPendingTasks());
2952 task2.weak_factory_.InvalidateWeakPtrs();
2953 task3.weak_factory_.InvalidateWeakPtrs();
2954 EXPECT_EQ(4u, queue->GetNumberOfPendingTasks());
2955
2956 sequence_manager()->ReclaimMemory();
2957 EXPECT_EQ(2u, queue->GetNumberOfPendingTasks());
2958
2959 task1.weak_factory_.InvalidateWeakPtrs();
2960 task4.weak_factory_.InvalidateWeakPtrs();
2961
2962 sequence_manager()->ReclaimMemory();
2963 EXPECT_EQ(0u, queue->GetNumberOfPendingTasks());
2964 }
2965
TEST_P(SequenceManagerTest,SweepCanceledDelayedTasks_ManyTasks)2966 TEST_P(SequenceManagerTest, SweepCanceledDelayedTasks_ManyTasks) {
2967 auto queue = CreateTaskQueue();
2968
2969 TimeTicks start_time = sequence_manager()->NowTicks();
2970
2971 constexpr const int kNumTasks = 100;
2972
2973 std::vector<std::unique_ptr<CancelableTask>> tasks(100);
2974 std::vector<TimeTicks> run_times;
2975 for (int i = 0; i < kNumTasks; i++) {
2976 tasks[i] = std::make_unique<CancelableTask>(mock_tick_clock());
2977 queue->task_runner()->PostDelayedTask(
2978 FROM_HERE,
2979 BindOnce(&CancelableTask::RecordTimeTask,
2980 tasks[i]->weak_factory_.GetWeakPtr(), &run_times),
2981 TimeDelta::FromSeconds(i + 1));
2982 }
2983
2984 // Invalidate ever other timer.
2985 for (int i = 0; i < kNumTasks; i++) {
2986 if (i % 2)
2987 tasks[i]->weak_factory_.InvalidateWeakPtrs();
2988 }
2989
2990 sequence_manager()->ReclaimMemory();
2991 EXPECT_EQ(50u, queue->GetNumberOfPendingTasks());
2992
2993 // Make sure the priority queue still operates as expected.
2994 FastForwardUntilNoTasksRemain();
2995 ASSERT_EQ(50u, run_times.size());
2996 for (int i = 0; i < 50; i++) {
2997 TimeTicks expected_run_time =
2998 start_time + TimeDelta::FromSeconds(2 * i + 1);
2999 EXPECT_EQ(run_times[i], expected_run_time);
3000 }
3001 }
3002
TEST_P(SequenceManagerTest,DelayedTasksNotSelected)3003 TEST_P(SequenceManagerTest, DelayedTasksNotSelected) {
3004 auto queue = CreateTaskQueue();
3005 constexpr TimeDelta kDelay(TimeDelta::FromMilliseconds(10));
3006 LazyNow lazy_now(mock_tick_clock());
3007 EXPECT_EQ(TimeDelta::Max(), sequence_manager()->DelayTillNextTask(&lazy_now));
3008 EXPECT_EQ(
3009 TimeDelta::Max(),
3010 sequence_manager()->DelayTillNextTask(
3011 &lazy_now, SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3012
3013 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask), kDelay);
3014
3015 // No task should be ready to execute.
3016 EXPECT_FALSE(sequence_manager()->SelectNextTask(
3017 SequencedTaskSource::SelectTaskOption::kDefault));
3018 EXPECT_FALSE(sequence_manager()->SelectNextTask(
3019 SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3020
3021 EXPECT_EQ(kDelay, sequence_manager()->DelayTillNextTask(&lazy_now));
3022 EXPECT_EQ(
3023 TimeDelta::Max(),
3024 sequence_manager()->DelayTillNextTask(
3025 &lazy_now, SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3026
3027 AdvanceMockTickClock(kDelay);
3028 LazyNow lazy_now2(mock_tick_clock());
3029
3030 // Delayed task is ready to be executed. Consider it only if not in power
3031 // suspend state.
3032 EXPECT_FALSE(sequence_manager()->SelectNextTask(
3033 SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3034 EXPECT_EQ(
3035 TimeDelta::Max(),
3036 sequence_manager()->DelayTillNextTask(
3037 &lazy_now2, SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3038
3039 // Execute the delayed task.
3040 EXPECT_TRUE(sequence_manager()->SelectNextTask(
3041 SequencedTaskSource::SelectTaskOption::kDefault));
3042 sequence_manager()->DidRunTask();
3043 EXPECT_EQ(TimeDelta::Max(),
3044 sequence_manager()->DelayTillNextTask(&lazy_now2));
3045
3046 // Tidy up.
3047 queue->ShutdownTaskQueue();
3048 }
3049
TEST_P(SequenceManagerTest,DelayedTasksNotSelectedWithImmediateTask)3050 TEST_P(SequenceManagerTest, DelayedTasksNotSelectedWithImmediateTask) {
3051 auto queue = CreateTaskQueue();
3052 constexpr TimeDelta kDelay(TimeDelta::FromMilliseconds(10));
3053 LazyNow lazy_now(mock_tick_clock());
3054
3055 EXPECT_EQ(TimeDelta::Max(), sequence_manager()->DelayTillNextTask(&lazy_now));
3056 EXPECT_EQ(
3057 TimeDelta::Max(),
3058 sequence_manager()->DelayTillNextTask(
3059 &lazy_now, SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3060
3061 // Post an immediate task.
3062 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
3063 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask), kDelay);
3064
3065 EXPECT_EQ(TimeDelta(), sequence_manager()->DelayTillNextTask(&lazy_now));
3066 EXPECT_EQ(
3067 TimeDelta(),
3068 sequence_manager()->DelayTillNextTask(
3069 &lazy_now, SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3070
3071 AdvanceMockTickClock(kDelay);
3072 LazyNow lazy_now2(mock_tick_clock());
3073
3074 // An immediate task is present, even if we skip the delayed tasks.
3075 EXPECT_EQ(
3076 TimeDelta(),
3077 sequence_manager()->DelayTillNextTask(
3078 &lazy_now2, SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3079
3080 // Immediate task should be ready to execute, execute it.
3081 EXPECT_TRUE(sequence_manager()->SelectNextTask(
3082 SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3083 sequence_manager()->DidRunTask();
3084
3085 // Delayed task is ready to be executed. Consider it only if not in power
3086 // suspend state. This test differs from
3087 // SequenceManagerTest.DelayedTasksNotSelected as it confirms that delayed
3088 // tasks are ignored even if they're already in the ready queue (per having
3089 // performed task selection already before running the immediate task above).
3090 EXPECT_FALSE(sequence_manager()->SelectNextTask(
3091 SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3092 EXPECT_EQ(
3093 TimeDelta::Max(),
3094 sequence_manager()->DelayTillNextTask(
3095 &lazy_now2, SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3096
3097 // Execute the delayed task.
3098 EXPECT_TRUE(sequence_manager()->SelectNextTask(
3099 SequencedTaskSource::SelectTaskOption::kDefault));
3100 EXPECT_EQ(
3101 TimeDelta::Max(),
3102 sequence_manager()->DelayTillNextTask(
3103 &lazy_now2, SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3104 sequence_manager()->DidRunTask();
3105
3106 // Tidy up.
3107 queue->ShutdownTaskQueue();
3108 }
3109
TEST_P(SequenceManagerTest,DelayedTasksNotSelectedWithImmediateTaskWithPriority)3110 TEST_P(SequenceManagerTest,
3111 DelayedTasksNotSelectedWithImmediateTaskWithPriority) {
3112 auto queues = CreateTaskQueues(4u);
3113 queues[0]->SetQueuePriority(TaskQueue::QueuePriority::kLowPriority);
3114 queues[1]->SetQueuePriority(TaskQueue::QueuePriority::kNormalPriority);
3115 queues[2]->SetQueuePriority(TaskQueue::QueuePriority::kHighPriority);
3116 queues[3]->SetQueuePriority(TaskQueue::QueuePriority::kVeryHighPriority);
3117
3118 // Post immediate tasks.
3119 queues[0]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
3120 queues[2]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
3121
3122 // Post delayed tasks.
3123 constexpr TimeDelta kDelay(TimeDelta::FromMilliseconds(10));
3124 queues[1]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
3125 kDelay);
3126 queues[3]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
3127 kDelay);
3128
3129 LazyNow lazy_now(mock_tick_clock());
3130
3131 EXPECT_EQ(
3132 TimeDelta(),
3133 sequence_manager()->DelayTillNextTask(
3134 &lazy_now, SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3135
3136 AdvanceMockTickClock(kDelay);
3137 LazyNow lazy_now2(mock_tick_clock());
3138
3139 EXPECT_EQ(
3140 TimeDelta(),
3141 sequence_manager()->DelayTillNextTask(
3142 &lazy_now2, SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3143
3144 // Immediate tasks should be ready to execute, execute them.
3145 EXPECT_TRUE(sequence_manager()->SelectNextTask(
3146 SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3147 sequence_manager()->DidRunTask();
3148 EXPECT_TRUE(sequence_manager()->SelectNextTask(
3149 SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3150 sequence_manager()->DidRunTask();
3151
3152 // No immediate tasks can be executed anymore.
3153 EXPECT_FALSE(sequence_manager()->SelectNextTask(
3154 SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3155 EXPECT_EQ(
3156 TimeDelta::Max(),
3157 sequence_manager()->DelayTillNextTask(
3158 &lazy_now2, SequencedTaskSource::SelectTaskOption::kSkipDelayedTask));
3159
3160 // Execute delayed tasks.
3161 EXPECT_TRUE(sequence_manager()->SelectNextTask());
3162 sequence_manager()->DidRunTask();
3163 EXPECT_TRUE(sequence_manager()->SelectNextTask());
3164 sequence_manager()->DidRunTask();
3165
3166 // No delayed tasks can be executed anymore.
3167 EXPECT_FALSE(sequence_manager()->SelectNextTask());
3168 EXPECT_EQ(TimeDelta::Max(),
3169 sequence_manager()->DelayTillNextTask(&lazy_now2));
3170
3171 // Tidy up.
3172 queues[0]->ShutdownTaskQueue();
3173 queues[1]->ShutdownTaskQueue();
3174 queues[2]->ShutdownTaskQueue();
3175 queues[3]->ShutdownTaskQueue();
3176 }
3177
TEST_P(SequenceManagerTest,DelayTillNextTask)3178 TEST_P(SequenceManagerTest, DelayTillNextTask) {
3179 auto queues = CreateTaskQueues(2u);
3180
3181 LazyNow lazy_now(mock_tick_clock());
3182 EXPECT_EQ(TimeDelta::Max(), sequence_manager()->DelayTillNextTask(&lazy_now));
3183
3184 queues[0]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
3185 TimeDelta::FromSeconds(10));
3186
3187 EXPECT_EQ(TimeDelta::FromSeconds(10),
3188 sequence_manager()->DelayTillNextTask(&lazy_now));
3189
3190 queues[1]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
3191 TimeDelta::FromSeconds(15));
3192
3193 EXPECT_EQ(TimeDelta::FromSeconds(10),
3194 sequence_manager()->DelayTillNextTask(&lazy_now));
3195
3196 queues[1]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
3197 TimeDelta::FromSeconds(5));
3198
3199 EXPECT_EQ(TimeDelta::FromSeconds(5),
3200 sequence_manager()->DelayTillNextTask(&lazy_now));
3201
3202 queues[0]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
3203
3204 EXPECT_EQ(TimeDelta(), sequence_manager()->DelayTillNextTask(&lazy_now));
3205 }
3206
TEST_P(SequenceManagerTest,DelayTillNextTask_Disabled)3207 TEST_P(SequenceManagerTest, DelayTillNextTask_Disabled) {
3208 auto queue = CreateTaskQueue();
3209
3210 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
3211 queue->CreateQueueEnabledVoter();
3212 voter->SetVoteToEnable(false);
3213 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
3214
3215 LazyNow lazy_now(mock_tick_clock());
3216 EXPECT_EQ(TimeDelta::Max(), sequence_manager()->DelayTillNextTask(&lazy_now));
3217 }
3218
TEST_P(SequenceManagerTest,DelayTillNextTask_Fence)3219 TEST_P(SequenceManagerTest, DelayTillNextTask_Fence) {
3220 auto queue = CreateTaskQueue();
3221
3222 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
3223 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
3224
3225 LazyNow lazy_now(mock_tick_clock());
3226 EXPECT_EQ(TimeDelta::Max(), sequence_manager()->DelayTillNextTask(&lazy_now));
3227 }
3228
TEST_P(SequenceManagerTest,DelayTillNextTask_FenceUnblocking)3229 TEST_P(SequenceManagerTest, DelayTillNextTask_FenceUnblocking) {
3230 auto queue = CreateTaskQueue();
3231
3232 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
3233 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
3234 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
3235
3236 LazyNow lazy_now(mock_tick_clock());
3237 EXPECT_EQ(TimeDelta(), sequence_manager()->DelayTillNextTask(&lazy_now));
3238 }
3239
TEST_P(SequenceManagerTest,DelayTillNextTask_DelayedTaskReady)3240 TEST_P(SequenceManagerTest, DelayTillNextTask_DelayedTaskReady) {
3241 auto queue = CreateTaskQueue();
3242
3243 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
3244 TimeDelta::FromSeconds(1));
3245
3246 AdvanceMockTickClock(TimeDelta::FromSeconds(10));
3247
3248 LazyNow lazy_now(mock_tick_clock());
3249 EXPECT_EQ(TimeDelta(), sequence_manager()->DelayTillNextTask(&lazy_now));
3250 }
3251
3252 namespace {
MessageLoopTaskWithDelayedQuit(Fixture * fixture,scoped_refptr<TestTaskQueue> task_queue)3253 void MessageLoopTaskWithDelayedQuit(Fixture* fixture,
3254 scoped_refptr<TestTaskQueue> task_queue) {
3255 RunLoop run_loop(RunLoop::Type::kNestableTasksAllowed);
3256 task_queue->task_runner()->PostDelayedTask(FROM_HERE, run_loop.QuitClosure(),
3257 TimeDelta::FromMilliseconds(100));
3258 fixture->AdvanceMockTickClock(TimeDelta::FromMilliseconds(200));
3259 run_loop.Run();
3260 }
3261 } // namespace
3262
TEST_P(SequenceManagerTest,DelayedTaskRunsInNestedMessageLoop)3263 TEST_P(SequenceManagerTest, DelayedTaskRunsInNestedMessageLoop) {
3264 if (GetUnderlyingRunnerType() == TestType::kMockTaskRunner)
3265 return;
3266 auto queue = CreateTaskQueue();
3267 RunLoop run_loop;
3268 queue->task_runner()->PostTask(
3269 FROM_HERE,
3270 BindOnce(&MessageLoopTaskWithDelayedQuit, this, RetainedRef(queue)));
3271 run_loop.RunUntilIdle();
3272 }
3273
3274 namespace {
MessageLoopTaskWithImmediateQuit(OnceClosure non_nested_quit_closure,scoped_refptr<TestTaskQueue> task_queue)3275 void MessageLoopTaskWithImmediateQuit(OnceClosure non_nested_quit_closure,
3276 scoped_refptr<TestTaskQueue> task_queue) {
3277 RunLoop run_loop(RunLoop::Type::kNestableTasksAllowed);
3278 // Needed because entering the nested run loop causes a DoWork to get
3279 // posted.
3280 task_queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
3281 task_queue->task_runner()->PostTask(FROM_HERE, run_loop.QuitClosure());
3282 run_loop.Run();
3283 std::move(non_nested_quit_closure).Run();
3284 }
3285 } // namespace
3286
TEST_P(SequenceManagerTest,DelayedNestedMessageLoopDoesntPreventTasksRunning)3287 TEST_P(SequenceManagerTest, DelayedNestedMessageLoopDoesntPreventTasksRunning) {
3288 if (GetUnderlyingRunnerType() == TestType::kMockTaskRunner)
3289 return;
3290 auto queue = CreateTaskQueue();
3291 RunLoop run_loop;
3292 queue->task_runner()->PostDelayedTask(
3293 FROM_HERE,
3294 BindOnce(&MessageLoopTaskWithImmediateQuit, run_loop.QuitClosure(),
3295 RetainedRef(queue)),
3296 TimeDelta::FromMilliseconds(100));
3297
3298 AdvanceMockTickClock(TimeDelta::FromMilliseconds(200));
3299 run_loop.Run();
3300 }
3301
TEST_P(SequenceManagerTest,CouldTaskRun_DisableAndReenable)3302 TEST_P(SequenceManagerTest, CouldTaskRun_DisableAndReenable) {
3303 auto queue = CreateTaskQueue();
3304
3305 EnqueueOrder enqueue_order = sequence_manager()->GetNextSequenceNumber();
3306 EXPECT_TRUE(queue->GetTaskQueueImpl()->CouldTaskRun(enqueue_order));
3307
3308 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
3309 queue->CreateQueueEnabledVoter();
3310 voter->SetVoteToEnable(false);
3311 EXPECT_FALSE(queue->GetTaskQueueImpl()->CouldTaskRun(enqueue_order));
3312
3313 voter->SetVoteToEnable(true);
3314 EXPECT_TRUE(queue->GetTaskQueueImpl()->CouldTaskRun(enqueue_order));
3315 }
3316
TEST_P(SequenceManagerTest,CouldTaskRun_Fence)3317 TEST_P(SequenceManagerTest, CouldTaskRun_Fence) {
3318 auto queue = CreateTaskQueue();
3319
3320 EnqueueOrder enqueue_order = sequence_manager()->GetNextSequenceNumber();
3321 EXPECT_TRUE(queue->GetTaskQueueImpl()->CouldTaskRun(enqueue_order));
3322
3323 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
3324 EXPECT_TRUE(queue->GetTaskQueueImpl()->CouldTaskRun(enqueue_order));
3325
3326 queue->InsertFence(TaskQueue::InsertFencePosition::kBeginningOfTime);
3327 EXPECT_FALSE(queue->GetTaskQueueImpl()->CouldTaskRun(enqueue_order));
3328
3329 queue->RemoveFence();
3330 EXPECT_TRUE(queue->GetTaskQueueImpl()->CouldTaskRun(enqueue_order));
3331 }
3332
TEST_P(SequenceManagerTest,CouldTaskRun_FenceBeforeThenAfter)3333 TEST_P(SequenceManagerTest, CouldTaskRun_FenceBeforeThenAfter) {
3334 auto queue = CreateTaskQueue();
3335
3336 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
3337
3338 EnqueueOrder enqueue_order = sequence_manager()->GetNextSequenceNumber();
3339 EXPECT_FALSE(queue->GetTaskQueueImpl()->CouldTaskRun(enqueue_order));
3340
3341 queue->InsertFence(TaskQueue::InsertFencePosition::kNow);
3342 EXPECT_TRUE(queue->GetTaskQueueImpl()->CouldTaskRun(enqueue_order));
3343 }
3344
TEST_P(SequenceManagerTest,DelayedDoWorkNotPostedForDisabledQueue)3345 TEST_P(SequenceManagerTest, DelayedDoWorkNotPostedForDisabledQueue) {
3346 auto queue = CreateTaskQueue();
3347
3348 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
3349 TimeDelta::FromMilliseconds(1));
3350 EXPECT_EQ(TimeDelta::FromMilliseconds(1), NextPendingTaskDelay());
3351
3352 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
3353 queue->CreateQueueEnabledVoter();
3354 voter->SetVoteToEnable(false);
3355
3356 switch (GetUnderlyingRunnerType()) {
3357 case TestType::kMessagePump:
3358 EXPECT_EQ(TimeDelta::FromDays(1), NextPendingTaskDelay());
3359 break;
3360
3361 case TestType::kMockTaskRunner:
3362 EXPECT_EQ(TimeDelta::Max(), NextPendingTaskDelay());
3363 break;
3364
3365 default:
3366 NOTREACHED();
3367 }
3368
3369 voter->SetVoteToEnable(true);
3370 EXPECT_EQ(TimeDelta::FromMilliseconds(1), NextPendingTaskDelay());
3371 }
3372
TEST_P(SequenceManagerTest,DisablingQueuesChangesDelayTillNextDoWork)3373 TEST_P(SequenceManagerTest, DisablingQueuesChangesDelayTillNextDoWork) {
3374 auto queues = CreateTaskQueues(3u);
3375 queues[0]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
3376 TimeDelta::FromMilliseconds(1));
3377 queues[1]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
3378 TimeDelta::FromMilliseconds(10));
3379 queues[2]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
3380 TimeDelta::FromMilliseconds(100));
3381
3382 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter0 =
3383 queues[0]->CreateQueueEnabledVoter();
3384 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter1 =
3385 queues[1]->CreateQueueEnabledVoter();
3386 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter2 =
3387 queues[2]->CreateQueueEnabledVoter();
3388
3389 EXPECT_EQ(TimeDelta::FromMilliseconds(1), NextPendingTaskDelay());
3390
3391 voter0->SetVoteToEnable(false);
3392 EXPECT_EQ(TimeDelta::FromMilliseconds(10), NextPendingTaskDelay());
3393
3394 voter1->SetVoteToEnable(false);
3395 EXPECT_EQ(TimeDelta::FromMilliseconds(100), NextPendingTaskDelay());
3396
3397 voter2->SetVoteToEnable(false);
3398 switch (GetUnderlyingRunnerType()) {
3399 case TestType::kMessagePump:
3400 EXPECT_EQ(TimeDelta::FromDays(1), NextPendingTaskDelay());
3401 break;
3402
3403 case TestType::kMockTaskRunner:
3404 EXPECT_EQ(TimeDelta::Max(), NextPendingTaskDelay());
3405 break;
3406
3407 default:
3408 NOTREACHED();
3409 }
3410 }
3411
TEST_P(SequenceManagerTest,GetNextScheduledWakeUp)3412 TEST_P(SequenceManagerTest, GetNextScheduledWakeUp) {
3413 auto queue = CreateTaskQueue();
3414
3415 EXPECT_EQ(nullopt, queue->GetNextScheduledWakeUp());
3416
3417 TimeTicks start_time = sequence_manager()->NowTicks();
3418 TimeDelta delay1 = TimeDelta::FromMilliseconds(10);
3419 TimeDelta delay2 = TimeDelta::FromMilliseconds(2);
3420
3421 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask), delay1);
3422 EXPECT_EQ(start_time + delay1, queue->GetNextScheduledWakeUp());
3423
3424 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask), delay2);
3425 EXPECT_EQ(start_time + delay2, queue->GetNextScheduledWakeUp());
3426
3427 // We don't have wake-ups scheduled for disabled queues.
3428 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
3429 queue->CreateQueueEnabledVoter();
3430 voter->SetVoteToEnable(false);
3431 EXPECT_EQ(nullopt, queue->GetNextScheduledWakeUp());
3432
3433 voter->SetVoteToEnable(true);
3434 EXPECT_EQ(start_time + delay2, queue->GetNextScheduledWakeUp());
3435
3436 // Immediate tasks shouldn't make any difference.
3437 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
3438 EXPECT_EQ(start_time + delay2, queue->GetNextScheduledWakeUp());
3439
3440 // Neither should fences.
3441 queue->InsertFence(TaskQueue::InsertFencePosition::kBeginningOfTime);
3442 EXPECT_EQ(start_time + delay2, queue->GetNextScheduledWakeUp());
3443 }
3444
TEST_P(SequenceManagerTest,SetTimeDomainForDisabledQueue)3445 TEST_P(SequenceManagerTest, SetTimeDomainForDisabledQueue) {
3446 auto queue = CreateTaskQueue();
3447
3448 MockTaskQueueObserver observer;
3449 queue->SetObserver(&observer);
3450
3451 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
3452 TimeDelta::FromMilliseconds(1));
3453
3454 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
3455 queue->CreateQueueEnabledVoter();
3456 voter->SetVoteToEnable(false);
3457
3458 // We should not get a notification for a disabled queue.
3459 EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_)).Times(0);
3460
3461 std::unique_ptr<MockTimeDomain> domain =
3462 std::make_unique<MockTimeDomain>(sequence_manager()->NowTicks());
3463 sequence_manager()->RegisterTimeDomain(domain.get());
3464 queue->SetTimeDomain(domain.get());
3465
3466 // Tidy up.
3467 queue->ShutdownTaskQueue();
3468 sequence_manager()->UnregisterTimeDomain(domain.get());
3469 }
3470
3471 namespace {
SetOnTaskHandlers(scoped_refptr<TestTaskQueue> task_queue,int * start_counter,int * complete_counter)3472 void SetOnTaskHandlers(scoped_refptr<TestTaskQueue> task_queue,
3473 int* start_counter,
3474 int* complete_counter) {
3475 task_queue->GetTaskQueueImpl()->SetOnTaskStartedHandler(BindRepeating(
3476 [](int* counter, const Task& task,
3477 const TaskQueue::TaskTiming& task_timing) { ++(*counter); },
3478 start_counter));
3479 task_queue->GetTaskQueueImpl()->SetOnTaskCompletedHandler(BindRepeating(
3480 [](int* counter, const Task& task, TaskQueue::TaskTiming* task_timing,
3481 LazyNow* lazy_now) { ++(*counter); },
3482 complete_counter));
3483 task_queue->GetTaskQueueImpl()->SetOnTaskPostedHandler(
3484 internal::TaskQueueImpl::OnTaskPostedHandler());
3485 }
3486
UnsetOnTaskHandlers(scoped_refptr<TestTaskQueue> task_queue)3487 void UnsetOnTaskHandlers(scoped_refptr<TestTaskQueue> task_queue) {
3488 task_queue->GetTaskQueueImpl()->SetOnTaskStartedHandler(
3489 internal::TaskQueueImpl::OnTaskStartedHandler());
3490 task_queue->GetTaskQueueImpl()->SetOnTaskCompletedHandler(
3491 internal::TaskQueueImpl::OnTaskCompletedHandler());
3492 task_queue->GetTaskQueueImpl()->SetOnTaskPostedHandler(
3493 internal::TaskQueueImpl::OnTaskPostedHandler());
3494 }
3495 } // namespace
3496
TEST_P(SequenceManagerTest,ProcessTasksWithoutTaskTimeObservers)3497 TEST_P(SequenceManagerTest, ProcessTasksWithoutTaskTimeObservers) {
3498 auto queue = CreateTaskQueue();
3499 int start_counter = 0;
3500 int complete_counter = 0;
3501 std::vector<EnqueueOrder> run_order;
3502 SetOnTaskHandlers(queue, &start_counter, &complete_counter);
3503 EXPECT_TRUE(queue->GetTaskQueueImpl()->RequiresTaskTiming());
3504 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order));
3505 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 2, &run_order));
3506 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 3, &run_order));
3507
3508 RunLoop().RunUntilIdle();
3509 EXPECT_EQ(start_counter, 3);
3510 EXPECT_EQ(complete_counter, 3);
3511 EXPECT_THAT(run_order, ElementsAre(1u, 2u, 3u));
3512
3513 UnsetOnTaskHandlers(queue);
3514 EXPECT_FALSE(queue->GetTaskQueueImpl()->RequiresTaskTiming());
3515 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 4, &run_order));
3516 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 5, &run_order));
3517 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 6, &run_order));
3518
3519 RunLoop().RunUntilIdle();
3520 EXPECT_EQ(start_counter, 3);
3521 EXPECT_EQ(complete_counter, 3);
3522 EXPECT_THAT(run_order, ElementsAre(1u, 2u, 3u, 4u, 5u, 6u));
3523 }
3524
TEST_P(SequenceManagerTest,ProcessTasksWithTaskTimeObservers)3525 TEST_P(SequenceManagerTest, ProcessTasksWithTaskTimeObservers) {
3526 TestTaskTimeObserver test_task_time_observer;
3527 auto queue = CreateTaskQueue();
3528 int start_counter = 0;
3529 int complete_counter = 0;
3530
3531 sequence_manager()->AddTaskTimeObserver(&test_task_time_observer);
3532 SetOnTaskHandlers(queue, &start_counter, &complete_counter);
3533 EXPECT_TRUE(queue->GetTaskQueueImpl()->RequiresTaskTiming());
3534 std::vector<EnqueueOrder> run_order;
3535 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 1, &run_order));
3536 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 2, &run_order));
3537
3538 RunLoop().RunUntilIdle();
3539 EXPECT_EQ(start_counter, 2);
3540 EXPECT_EQ(complete_counter, 2);
3541 EXPECT_THAT(run_order, ElementsAre(1u, 2u));
3542
3543 UnsetOnTaskHandlers(queue);
3544 EXPECT_FALSE(queue->GetTaskQueueImpl()->RequiresTaskTiming());
3545 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 3, &run_order));
3546 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 4, &run_order));
3547
3548 RunLoop().RunUntilIdle();
3549 EXPECT_EQ(start_counter, 2);
3550 EXPECT_EQ(complete_counter, 2);
3551 EXPECT_THAT(run_order, ElementsAre(1u, 2u, 3u, 4u));
3552
3553 sequence_manager()->RemoveTaskTimeObserver(&test_task_time_observer);
3554 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 5, &run_order));
3555 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 6, &run_order));
3556
3557 RunLoop().RunUntilIdle();
3558 EXPECT_EQ(start_counter, 2);
3559 EXPECT_EQ(complete_counter, 2);
3560 EXPECT_FALSE(queue->GetTaskQueueImpl()->RequiresTaskTiming());
3561 EXPECT_THAT(run_order, ElementsAre(1u, 2u, 3u, 4u, 5u, 6u));
3562
3563 SetOnTaskHandlers(queue, &start_counter, &complete_counter);
3564 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 7, &run_order));
3565 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&TestTask, 8, &run_order));
3566
3567 RunLoop().RunUntilIdle();
3568 EXPECT_EQ(start_counter, 4);
3569 EXPECT_EQ(complete_counter, 4);
3570 EXPECT_TRUE(queue->GetTaskQueueImpl()->RequiresTaskTiming());
3571 EXPECT_THAT(run_order, ElementsAre(1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u));
3572 UnsetOnTaskHandlers(queue);
3573 }
3574
TEST_P(SequenceManagerTest,ObserverNotFiredAfterTaskQueueDestructed)3575 TEST_P(SequenceManagerTest, ObserverNotFiredAfterTaskQueueDestructed) {
3576 scoped_refptr<TestTaskQueue> main_tq = CreateTaskQueue();
3577
3578 MockTaskQueueObserver observer;
3579 main_tq->SetObserver(&observer);
3580
3581 // We don't expect the observer to fire if the TaskQueue gets destructed.
3582 EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_)).Times(0);
3583 auto task_runner = main_tq->task_runner();
3584 main_tq = nullptr;
3585 task_runner->PostTask(FROM_HERE, BindOnce(&NopTask));
3586
3587 FastForwardUntilNoTasksRemain();
3588 }
3589
TEST_P(SequenceManagerTest,OnQueueNextWakeUpChangedNotFiredForDisabledQueuePostTask)3590 TEST_P(SequenceManagerTest,
3591 OnQueueNextWakeUpChangedNotFiredForDisabledQueuePostTask) {
3592 scoped_refptr<TestTaskQueue> main_tq = CreateTaskQueue();
3593 auto task_runner = main_tq->task_runner();
3594
3595 MockTaskQueueObserver observer;
3596 main_tq->SetObserver(&observer);
3597
3598 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
3599 main_tq->CreateQueueEnabledVoter();
3600 voter->SetVoteToEnable(false);
3601
3602 // We don't expect the OnQueueNextWakeUpChanged to fire if the TaskQueue gets
3603 // disabled.
3604 EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_)).Times(0);
3605
3606 // Should not fire the observer.
3607 task_runner->PostTask(FROM_HERE, BindOnce(&NopTask));
3608
3609 FastForwardUntilNoTasksRemain();
3610 // When |voter| goes out of scope the queue will become enabled and the
3611 // observer will fire. We're not interested in testing that however.
3612 Mock::VerifyAndClearExpectations(&observer);
3613 }
3614
TEST_P(SequenceManagerTest,OnQueueNextWakeUpChangedNotFiredForCrossThreadDisabledQueuePostTask)3615 TEST_P(SequenceManagerTest,
3616 OnQueueNextWakeUpChangedNotFiredForCrossThreadDisabledQueuePostTask) {
3617 scoped_refptr<TestTaskQueue> main_tq = CreateTaskQueue();
3618 auto task_runner = main_tq->task_runner();
3619
3620 MockTaskQueueObserver observer;
3621 main_tq->SetObserver(&observer);
3622
3623 std::unique_ptr<TaskQueue::QueueEnabledVoter> voter =
3624 main_tq->CreateQueueEnabledVoter();
3625 voter->SetVoteToEnable(false);
3626
3627 // We don't expect the observer to fire if the TaskQueue gets blocked.
3628 EXPECT_CALL(observer, OnQueueNextWakeUpChanged(_)).Times(0);
3629
3630 WaitableEvent done_event;
3631 Thread thread("TestThread");
3632 thread.Start();
3633 thread.task_runner()->PostTask(FROM_HERE, BindLambdaForTesting([&]() {
3634 // Should not fire the observer.
3635 task_runner->PostTask(FROM_HERE,
3636 BindOnce(&NopTask));
3637 done_event.Signal();
3638 }));
3639 done_event.Wait();
3640 thread.Stop();
3641
3642 FastForwardUntilNoTasksRemain();
3643 // When |voter| goes out of scope the queue will become enabled and the
3644 // observer will fire. We're not interested in testing that however.
3645 Mock::VerifyAndClearExpectations(&observer);
3646 }
3647
TEST_P(SequenceManagerTest,GracefulShutdown)3648 TEST_P(SequenceManagerTest, GracefulShutdown) {
3649 const auto kStartTime = mock_tick_clock()->NowTicks();
3650 std::vector<TimeTicks> run_times;
3651 scoped_refptr<TestTaskQueue> main_tq = CreateTaskQueue();
3652 WeakPtr<TestTaskQueue> main_tq_weak_ptr = main_tq->GetWeakPtr();
3653
3654 EXPECT_EQ(1u, sequence_manager()->ActiveQueuesCount());
3655 EXPECT_EQ(0u, sequence_manager()->QueuesToShutdownCount());
3656 EXPECT_EQ(0u, sequence_manager()->QueuesToDeleteCount());
3657
3658 for (int i = 1; i <= 5; ++i) {
3659 main_tq->task_runner()->PostDelayedTask(
3660 FROM_HERE, BindOnce(&RecordTimeTask, &run_times, mock_tick_clock()),
3661 TimeDelta::FromMilliseconds(i * 100));
3662 }
3663 FastForwardBy(TimeDelta::FromMilliseconds(250));
3664
3665 main_tq = nullptr;
3666 // Ensure that task queue went away.
3667 EXPECT_FALSE(main_tq_weak_ptr.get());
3668
3669 FastForwardBy(TimeDelta::FromMilliseconds(1));
3670
3671 EXPECT_EQ(1u, sequence_manager()->ActiveQueuesCount());
3672 EXPECT_EQ(1u, sequence_manager()->QueuesToShutdownCount());
3673 EXPECT_EQ(0u, sequence_manager()->QueuesToDeleteCount());
3674
3675 FastForwardUntilNoTasksRemain();
3676
3677 // Even with TaskQueue gone, tasks are executed.
3678 EXPECT_THAT(run_times,
3679 ElementsAre(kStartTime + TimeDelta::FromMilliseconds(100),
3680 kStartTime + TimeDelta::FromMilliseconds(200),
3681 kStartTime + TimeDelta::FromMilliseconds(300),
3682 kStartTime + TimeDelta::FromMilliseconds(400),
3683 kStartTime + TimeDelta::FromMilliseconds(500)));
3684
3685 EXPECT_EQ(0u, sequence_manager()->ActiveQueuesCount());
3686 EXPECT_EQ(0u, sequence_manager()->QueuesToShutdownCount());
3687 EXPECT_EQ(0u, sequence_manager()->QueuesToDeleteCount());
3688 }
3689
TEST_P(SequenceManagerTest,GracefulShutdown_ManagerDeletedInFlight)3690 TEST_P(SequenceManagerTest, GracefulShutdown_ManagerDeletedInFlight) {
3691 const auto kStartTime = mock_tick_clock()->NowTicks();
3692 std::vector<TimeTicks> run_times;
3693 scoped_refptr<TestTaskQueue> control_tq = CreateTaskQueue();
3694 std::vector<scoped_refptr<TestTaskQueue>> main_tqs;
3695 std::vector<WeakPtr<TestTaskQueue>> main_tq_weak_ptrs;
3696
3697 // There might be a race condition - async task queues should be unregistered
3698 // first. Increase the number of task queues to surely detect that.
3699 // The problem is that pointers are compared in a set and generally for
3700 // a small number of allocations value of the pointers increases
3701 // monotonically. 100 is large enough to force allocations from different
3702 // pages.
3703 const int N = 100;
3704 for (int i = 0; i < N; ++i) {
3705 scoped_refptr<TestTaskQueue> tq = CreateTaskQueue();
3706 main_tq_weak_ptrs.push_back(tq->GetWeakPtr());
3707 main_tqs.push_back(std::move(tq));
3708 }
3709
3710 for (int i = 1; i <= 5; ++i) {
3711 main_tqs[0]->task_runner()->PostDelayedTask(
3712 FROM_HERE, BindOnce(&RecordTimeTask, &run_times, mock_tick_clock()),
3713 TimeDelta::FromMilliseconds(i * 100));
3714 }
3715 FastForwardBy(TimeDelta::FromMilliseconds(250));
3716
3717 main_tqs.clear();
3718 // Ensure that task queues went away.
3719 for (int i = 0; i < N; ++i) {
3720 EXPECT_FALSE(main_tq_weak_ptrs[i].get());
3721 }
3722
3723 // No leaks should occur when TQM was destroyed before processing
3724 // shutdown task and TaskQueueImpl should be safely deleted on a correct
3725 // thread.
3726 DestroySequenceManager();
3727
3728 if (GetUnderlyingRunnerType() != TestType::kMessagePump) {
3729 FastForwardUntilNoTasksRemain();
3730 }
3731
3732 EXPECT_THAT(run_times,
3733 ElementsAre(kStartTime + TimeDelta::FromMilliseconds(100),
3734 kStartTime + TimeDelta::FromMilliseconds(200)));
3735 }
3736
TEST_P(SequenceManagerTest,GracefulShutdown_ManagerDeletedWithQueuesToShutdown)3737 TEST_P(SequenceManagerTest,
3738 GracefulShutdown_ManagerDeletedWithQueuesToShutdown) {
3739 const auto kStartTime = mock_tick_clock()->NowTicks();
3740 std::vector<TimeTicks> run_times;
3741 scoped_refptr<TestTaskQueue> main_tq = CreateTaskQueue();
3742 WeakPtr<TestTaskQueue> main_tq_weak_ptr = main_tq->GetWeakPtr();
3743 RefCountedCallbackFactory counter;
3744
3745 EXPECT_EQ(1u, sequence_manager()->ActiveQueuesCount());
3746 EXPECT_EQ(0u, sequence_manager()->QueuesToShutdownCount());
3747 EXPECT_EQ(0u, sequence_manager()->QueuesToDeleteCount());
3748
3749 for (int i = 1; i <= 5; ++i) {
3750 main_tq->task_runner()->PostDelayedTask(
3751 FROM_HERE,
3752 counter.WrapCallback(
3753 BindOnce(&RecordTimeTask, &run_times, mock_tick_clock())),
3754 TimeDelta::FromMilliseconds(i * 100));
3755 }
3756 FastForwardBy(TimeDelta::FromMilliseconds(250));
3757
3758 main_tq = nullptr;
3759 // Ensure that task queue went away.
3760 EXPECT_FALSE(main_tq_weak_ptr.get());
3761
3762 FastForwardBy(TimeDelta::FromMilliseconds(1));
3763
3764 EXPECT_EQ(1u, sequence_manager()->ActiveQueuesCount());
3765 EXPECT_EQ(1u, sequence_manager()->QueuesToShutdownCount());
3766 EXPECT_EQ(0u, sequence_manager()->QueuesToDeleteCount());
3767
3768 // Ensure that all queues-to-gracefully-shutdown are properly unregistered.
3769 DestroySequenceManager();
3770
3771 if (GetUnderlyingRunnerType() != TestType::kMessagePump) {
3772 FastForwardUntilNoTasksRemain();
3773 }
3774
3775 EXPECT_THAT(run_times,
3776 ElementsAre(kStartTime + TimeDelta::FromMilliseconds(100),
3777 kStartTime + TimeDelta::FromMilliseconds(200)));
3778 EXPECT_FALSE(counter.HasReferences());
3779 }
3780
TEST(SequenceManagerBasicTest,DefaultTaskRunnerSupport)3781 TEST(SequenceManagerBasicTest, DefaultTaskRunnerSupport) {
3782 auto base_sequence_manager =
3783 sequence_manager::CreateSequenceManagerOnCurrentThreadWithPump(
3784 MessagePump::Create(MessagePumpType::DEFAULT));
3785 auto queue = base_sequence_manager->CreateTaskQueue(
3786 sequence_manager::TaskQueue::Spec("default_tq"));
3787 base_sequence_manager->SetDefaultTaskRunner(queue->task_runner());
3788
3789 scoped_refptr<SingleThreadTaskRunner> original_task_runner =
3790 ThreadTaskRunnerHandle::Get();
3791 scoped_refptr<SingleThreadTaskRunner> custom_task_runner =
3792 MakeRefCounted<TestSimpleTaskRunner>();
3793 {
3794 std::unique_ptr<SequenceManager> manager =
3795 CreateSequenceManagerOnCurrentThread(SequenceManager::Settings());
3796
3797 manager->SetDefaultTaskRunner(custom_task_runner);
3798 DCHECK_EQ(custom_task_runner, ThreadTaskRunnerHandle::Get());
3799 }
3800 DCHECK_EQ(original_task_runner, ThreadTaskRunnerHandle::Get());
3801 }
3802
TEST_P(SequenceManagerTest,CanceledTasksInQueueCantMakeOtherTasksSkipAhead)3803 TEST_P(SequenceManagerTest, CanceledTasksInQueueCantMakeOtherTasksSkipAhead) {
3804 auto queues = CreateTaskQueues(2u);
3805
3806 CancelableTask task1(mock_tick_clock());
3807 CancelableTask task2(mock_tick_clock());
3808 std::vector<TimeTicks> run_times;
3809
3810 queues[0]->task_runner()->PostTask(
3811 FROM_HERE, BindOnce(&CancelableTask::RecordTimeTask,
3812 task1.weak_factory_.GetWeakPtr(), &run_times));
3813 queues[0]->task_runner()->PostTask(
3814 FROM_HERE, BindOnce(&CancelableTask::RecordTimeTask,
3815 task2.weak_factory_.GetWeakPtr(), &run_times));
3816
3817 std::vector<EnqueueOrder> run_order;
3818 queues[1]->task_runner()->PostTask(FROM_HERE,
3819 BindOnce(&TestTask, 1, &run_order));
3820
3821 queues[0]->task_runner()->PostTask(FROM_HERE,
3822 BindOnce(&TestTask, 2, &run_order));
3823
3824 task1.weak_factory_.InvalidateWeakPtrs();
3825 task2.weak_factory_.InvalidateWeakPtrs();
3826 RunLoop().RunUntilIdle();
3827
3828 EXPECT_THAT(run_order, ElementsAre(1u, 2u));
3829 }
3830
TEST_P(SequenceManagerTest,TaskRunnerDeletedOnAnotherThread)3831 TEST_P(SequenceManagerTest, TaskRunnerDeletedOnAnotherThread) {
3832 const auto kStartTime = mock_tick_clock()->NowTicks();
3833 std::vector<TimeTicks> run_times;
3834 scoped_refptr<TestTaskQueue> main_tq = CreateTaskQueue();
3835 scoped_refptr<TaskRunner> task_runner =
3836 main_tq->CreateTaskRunner(kTaskTypeNone);
3837
3838 int start_counter = 0;
3839 int complete_counter = 0;
3840 SetOnTaskHandlers(main_tq, &start_counter, &complete_counter);
3841
3842 EXPECT_EQ(1u, sequence_manager()->ActiveQueuesCount());
3843 EXPECT_EQ(0u, sequence_manager()->QueuesToShutdownCount());
3844 EXPECT_EQ(0u, sequence_manager()->QueuesToDeleteCount());
3845
3846 for (int i = 1; i <= 5; ++i) {
3847 task_runner->PostDelayedTask(
3848 FROM_HERE, BindOnce(&RecordTimeTask, &run_times, mock_tick_clock()),
3849 TimeDelta::FromMilliseconds(i * 100));
3850 }
3851
3852 // TODO(altimin): do not do this after switching to weak pointer-based
3853 // task handlers.
3854 UnsetOnTaskHandlers(main_tq);
3855
3856 // Make |task_runner| the only reference to |main_tq|.
3857 main_tq = nullptr;
3858
3859 WaitableEvent task_queue_deleted(WaitableEvent::ResetPolicy::MANUAL,
3860 WaitableEvent::InitialState::NOT_SIGNALED);
3861 std::unique_ptr<Thread> thread = std::make_unique<Thread>("test thread");
3862 thread->StartAndWaitForTesting();
3863
3864 thread->task_runner()->PostTask(
3865 FROM_HERE, BindOnce(
3866 [](scoped_refptr<TaskRunner> task_runner,
3867 WaitableEvent* task_queue_deleted) {
3868 task_runner = nullptr;
3869 task_queue_deleted->Signal();
3870 },
3871 std::move(task_runner), &task_queue_deleted));
3872 task_queue_deleted.Wait();
3873
3874 EXPECT_EQ(1u, sequence_manager()->ActiveQueuesCount());
3875 EXPECT_EQ(1u, sequence_manager()->QueuesToShutdownCount());
3876 EXPECT_EQ(0u, sequence_manager()->QueuesToDeleteCount());
3877
3878 FastForwardUntilNoTasksRemain();
3879
3880 // Even with TaskQueue gone, tasks are executed.
3881 EXPECT_THAT(run_times,
3882 ElementsAre(kStartTime + TimeDelta::FromMilliseconds(100),
3883 kStartTime + TimeDelta::FromMilliseconds(200),
3884 kStartTime + TimeDelta::FromMilliseconds(300),
3885 kStartTime + TimeDelta::FromMilliseconds(400),
3886 kStartTime + TimeDelta::FromMilliseconds(500)));
3887
3888 EXPECT_EQ(0u, sequence_manager()->ActiveQueuesCount());
3889 EXPECT_EQ(0u, sequence_manager()->QueuesToShutdownCount());
3890 EXPECT_EQ(0u, sequence_manager()->QueuesToDeleteCount());
3891
3892 thread->Stop();
3893 }
3894
3895 namespace {
3896
3897 class RunOnDestructionHelper {
3898 public:
RunOnDestructionHelper(base::OnceClosure task)3899 explicit RunOnDestructionHelper(base::OnceClosure task)
3900 : task_(std::move(task)) {}
3901
~RunOnDestructionHelper()3902 ~RunOnDestructionHelper() { std::move(task_).Run(); }
3903
3904 private:
3905 base::OnceClosure task_;
3906 };
3907
RunOnDestruction(base::OnceClosure task)3908 base::OnceClosure RunOnDestruction(base::OnceClosure task) {
3909 return base::BindOnce(
3910 [](std::unique_ptr<RunOnDestructionHelper>) {},
3911 std::make_unique<RunOnDestructionHelper>(std::move(task)));
3912 }
3913
PostOnDestruction(scoped_refptr<TestTaskQueue> task_queue,base::OnceClosure task)3914 base::OnceClosure PostOnDestruction(scoped_refptr<TestTaskQueue> task_queue,
3915 base::OnceClosure task) {
3916 return RunOnDestruction(base::BindOnce(
3917 [](base::OnceClosure task, scoped_refptr<TestTaskQueue> task_queue) {
3918 task_queue->task_runner()->PostTask(FROM_HERE, std::move(task));
3919 },
3920 std::move(task), task_queue));
3921 }
3922
3923 } // namespace
3924
TEST_P(SequenceManagerTest,TaskQueueUsedInTaskDestructorAfterShutdown)3925 TEST_P(SequenceManagerTest, TaskQueueUsedInTaskDestructorAfterShutdown) {
3926 // This test checks that when a task is posted to a shutdown queue and
3927 // destroyed, it can try to post a task to the same queue without deadlocks.
3928 scoped_refptr<TestTaskQueue> main_tq = CreateTaskQueue();
3929
3930 WaitableEvent test_executed(WaitableEvent::ResetPolicy::MANUAL,
3931 WaitableEvent::InitialState::NOT_SIGNALED);
3932 std::unique_ptr<Thread> thread = std::make_unique<Thread>("test thread");
3933 thread->StartAndWaitForTesting();
3934
3935 DestroySequenceManager();
3936
3937 thread->task_runner()->PostTask(
3938 FROM_HERE, BindOnce(
3939 [](scoped_refptr<TestTaskQueue> task_queue,
3940 WaitableEvent* test_executed) {
3941 task_queue->task_runner()->PostTask(
3942 FROM_HERE, PostOnDestruction(
3943 task_queue, base::BindOnce([]() {})));
3944 test_executed->Signal();
3945 },
3946 main_tq, &test_executed));
3947 test_executed.Wait();
3948 }
3949
TEST_P(SequenceManagerTest,TaskQueueTaskRunnerDetach)3950 TEST_P(SequenceManagerTest, TaskQueueTaskRunnerDetach) {
3951 scoped_refptr<TestTaskQueue> queue1 = CreateTaskQueue();
3952 EXPECT_TRUE(queue1->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask)));
3953 queue1->ShutdownTaskQueue();
3954 EXPECT_FALSE(queue1->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask)));
3955
3956 // Create without a sequence manager.
3957 std::unique_ptr<TimeDomain> time_domain =
3958 std::make_unique<MockTimeDomain>(TimeTicks());
3959 std::unique_ptr<TaskQueueImpl> queue2 = std::make_unique<TaskQueueImpl>(
3960 nullptr, time_domain.get(), TaskQueue::Spec("stub"));
3961 scoped_refptr<SingleThreadTaskRunner> task_runner2 =
3962 queue2->CreateTaskRunner(0);
3963 EXPECT_FALSE(task_runner2->PostTask(FROM_HERE, BindOnce(&NopTask)));
3964
3965 // Tidy up.
3966 queue2->UnregisterTaskQueue();
3967 }
3968
TEST_P(SequenceManagerTest,DestructorPostChainDuringShutdown)3969 TEST_P(SequenceManagerTest, DestructorPostChainDuringShutdown) {
3970 // Checks that a chain of closures which post other closures on destruction do
3971 // thing on shutdown.
3972 scoped_refptr<TestTaskQueue> task_queue = CreateTaskQueue();
3973 bool run = false;
3974 task_queue->task_runner()->PostTask(
3975 FROM_HERE,
3976 PostOnDestruction(
3977 task_queue,
3978 PostOnDestruction(task_queue,
3979 RunOnDestruction(base::BindOnce(
3980 [](bool* run) { *run = true; }, &run)))));
3981
3982 DestroySequenceManager();
3983
3984 EXPECT_TRUE(run);
3985 }
3986
TEST_P(SequenceManagerTest,DestructorPostsViaTaskRunnerHandleDuringShutdown)3987 TEST_P(SequenceManagerTest, DestructorPostsViaTaskRunnerHandleDuringShutdown) {
3988 scoped_refptr<TestTaskQueue> task_queue = CreateTaskQueue();
3989 bool run = false;
3990 task_queue->task_runner()->PostTask(
3991 FROM_HERE, RunOnDestruction(BindLambdaForTesting([&]() {
3992 ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
3993 base::BindOnce(&NopTask));
3994 run = true;
3995 })));
3996
3997 // Should not DCHECK when ThreadTaskRunnerHandle::Get() is invoked.
3998 DestroySequenceManager();
3999 EXPECT_TRUE(run);
4000 }
4001
TEST_P(SequenceManagerTest,CreateUnboundSequenceManagerWhichIsNeverBound)4002 TEST_P(SequenceManagerTest, CreateUnboundSequenceManagerWhichIsNeverBound) {
4003 // This should not crash.
4004 CreateUnboundSequenceManager();
4005 }
4006
TEST_P(SequenceManagerTest,HasPendingHighResolutionTasks)4007 TEST_P(SequenceManagerTest, HasPendingHighResolutionTasks) {
4008 auto queue = CreateTaskQueue();
4009 bool supports_high_res = false;
4010 #if defined(OS_WIN)
4011 supports_high_res = true;
4012 #endif
4013
4014 // Only the third task needs high resolution timing.
4015 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4016 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
4017 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4018 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
4019 TimeDelta::FromMilliseconds(100));
4020 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4021 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
4022 TimeDelta::FromMilliseconds(10));
4023 EXPECT_EQ(sequence_manager()->HasPendingHighResolutionTasks(),
4024 supports_high_res);
4025
4026 // Running immediate tasks doesn't affect pending high resolution tasks.
4027 RunLoop().RunUntilIdle();
4028 EXPECT_EQ(sequence_manager()->HasPendingHighResolutionTasks(),
4029 supports_high_res);
4030
4031 // Advancing to just before a pending low resolution task doesn't mean that we
4032 // have pending high resolution work.
4033 AdvanceMockTickClock(TimeDelta::FromMilliseconds(99));
4034 RunLoop().RunUntilIdle();
4035 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4036
4037 AdvanceMockTickClock(TimeDelta::FromMilliseconds(100));
4038 RunLoop().RunUntilIdle();
4039 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4040 }
4041
TEST_P(SequenceManagerTest,HasPendingHighResolutionTasksLowPriority)4042 TEST_P(SequenceManagerTest, HasPendingHighResolutionTasksLowPriority) {
4043 auto queue = CreateTaskQueue();
4044 queue->SetQueuePriority(TaskQueue::QueuePriority::kLowPriority);
4045 bool supports_high_res = false;
4046 #if defined(OS_WIN)
4047 supports_high_res = true;
4048 #endif
4049
4050 // No task should be considered high resolution in a low priority queue.
4051 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4052 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
4053 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4054 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
4055 TimeDelta::FromMilliseconds(100));
4056 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4057 queue->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
4058 TimeDelta::FromMilliseconds(10));
4059 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4060
4061 // Increasing queue priority should enable high resolution timer.
4062 queue->SetQueuePriority(TaskQueue::QueuePriority::kNormalPriority);
4063 EXPECT_EQ(sequence_manager()->HasPendingHighResolutionTasks(),
4064 supports_high_res);
4065 queue->SetQueuePriority(TaskQueue::QueuePriority::kLowPriority);
4066 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4067
4068 // Running immediate tasks doesn't affect pending high resolution tasks.
4069 RunLoop().RunUntilIdle();
4070 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4071
4072 // Advancing to just before a pending low resolution task doesn't mean that we
4073 // have pending high resolution work.
4074 AdvanceMockTickClock(TimeDelta::FromMilliseconds(99));
4075 RunLoop().RunUntilIdle();
4076 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4077
4078 AdvanceMockTickClock(TimeDelta::FromMilliseconds(100));
4079 RunLoop().RunUntilIdle();
4080 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4081 }
4082
TEST_P(SequenceManagerTest,HasPendingHighResolutionTasksLowAndNormalPriorityQueues)4083 TEST_P(SequenceManagerTest,
4084 HasPendingHighResolutionTasksLowAndNormalPriorityQueues) {
4085 auto queueLow = CreateTaskQueue();
4086 queueLow->SetQueuePriority(TaskQueue::QueuePriority::kLowPriority);
4087 auto queueNormal = CreateTaskQueue();
4088 queueNormal->SetQueuePriority(TaskQueue::QueuePriority::kNormalPriority);
4089 bool supports_high_res = false;
4090 #if defined(OS_WIN)
4091 supports_high_res = true;
4092 #endif
4093
4094 // No task should be considered high resolution in a low priority queue.
4095 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4096 queueLow->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
4097 TimeDelta::FromMilliseconds(10));
4098 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4099 queueNormal->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
4100 TimeDelta::FromMilliseconds(100));
4101 EXPECT_FALSE(sequence_manager()->HasPendingHighResolutionTasks());
4102
4103 // Increasing queue priority should enable high resolution timer.
4104 queueLow->SetQueuePriority(TaskQueue::QueuePriority::kNormalPriority);
4105 EXPECT_EQ(sequence_manager()->HasPendingHighResolutionTasks(),
4106 supports_high_res);
4107 }
4108
4109 namespace {
4110
4111 class PostTaskWhenDeleted;
4112 void CallbackWithDestructor(std::unique_ptr<PostTaskWhenDeleted>);
4113
4114 class PostTaskWhenDeleted {
4115 public:
PostTaskWhenDeleted(std::string name,scoped_refptr<SingleThreadTaskRunner> task_runner,size_t depth,std::set<std::string> * tasks_alive,std::vector<std::string> * tasks_deleted)4116 PostTaskWhenDeleted(std::string name,
4117 scoped_refptr<SingleThreadTaskRunner> task_runner,
4118 size_t depth,
4119 std::set<std::string>* tasks_alive,
4120 std::vector<std::string>* tasks_deleted)
4121 : name_(name),
4122 task_runner_(std::move(task_runner)),
4123 depth_(depth),
4124 tasks_alive_(tasks_alive),
4125 tasks_deleted_(tasks_deleted) {
4126 tasks_alive_->insert(full_name());
4127 }
4128
~PostTaskWhenDeleted()4129 ~PostTaskWhenDeleted() {
4130 DCHECK(tasks_alive_->find(full_name()) != tasks_alive_->end());
4131 tasks_alive_->erase(full_name());
4132 tasks_deleted_->push_back(full_name());
4133
4134 if (depth_ > 0) {
4135 task_runner_->PostTask(
4136 FROM_HERE, base::BindOnce(&CallbackWithDestructor,
4137 std::make_unique<PostTaskWhenDeleted>(
4138 name_, task_runner_, depth_ - 1,
4139 tasks_alive_, tasks_deleted_)));
4140 }
4141 }
4142
4143 private:
full_name()4144 std::string full_name() { return name_ + " " + NumberToString(depth_); }
4145
4146 std::string name_;
4147 scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
4148 int depth_;
4149 std::set<std::string>* tasks_alive_;
4150 std::vector<std::string>* tasks_deleted_;
4151 };
4152
CallbackWithDestructor(std::unique_ptr<PostTaskWhenDeleted> object)4153 void CallbackWithDestructor(std::unique_ptr<PostTaskWhenDeleted> object) {}
4154
4155 } // namespace
4156
TEST_P(SequenceManagerTest,DeletePendingTasks_Simple)4157 TEST_P(SequenceManagerTest, DeletePendingTasks_Simple) {
4158 auto queue = CreateTaskQueue();
4159
4160 std::set<std::string> tasks_alive;
4161 std::vector<std::string> tasks_deleted;
4162
4163 queue->task_runner()->PostTask(
4164 FROM_HERE,
4165 BindOnce(&CallbackWithDestructor, std::make_unique<PostTaskWhenDeleted>(
4166 "task", queue->task_runner(), 0,
4167 &tasks_alive, &tasks_deleted)));
4168
4169 EXPECT_THAT(tasks_alive, ElementsAre("task 0"));
4170 EXPECT_TRUE(sequence_manager()->HasTasks());
4171
4172 sequence_manager()->DeletePendingTasks();
4173
4174 EXPECT_THAT(tasks_alive, ElementsAre());
4175 EXPECT_THAT(tasks_deleted, ElementsAre("task 0"));
4176 EXPECT_FALSE(sequence_manager()->HasTasks());
4177
4178 // Ensure that |tasks_alive| and |tasks_deleted| outlive |manager_|
4179 // and we get a test failure instead of a test crash.
4180 DestroySequenceManager();
4181 }
4182
TEST_P(SequenceManagerTest,DeletePendingTasks_Complex)4183 TEST_P(SequenceManagerTest, DeletePendingTasks_Complex) {
4184 auto queues = CreateTaskQueues(4u);
4185
4186 std::set<std::string> tasks_alive;
4187 std::vector<std::string> tasks_deleted;
4188
4189 // Post immediate and delayed to the same task queue.
4190 queues[0]->task_runner()->PostTask(
4191 FROM_HERE,
4192 BindOnce(&CallbackWithDestructor, std::make_unique<PostTaskWhenDeleted>(
4193 "Q1 I1", queues[0]->task_runner(),
4194 1, &tasks_alive, &tasks_deleted)));
4195 queues[0]->task_runner()->PostDelayedTask(
4196 FROM_HERE,
4197 BindOnce(&CallbackWithDestructor, std::make_unique<PostTaskWhenDeleted>(
4198 "Q1 D1", queues[0]->task_runner(),
4199 0, &tasks_alive, &tasks_deleted)),
4200 base::TimeDelta::FromSeconds(1));
4201
4202 // Post one delayed task to the second queue.
4203 queues[1]->task_runner()->PostDelayedTask(
4204 FROM_HERE,
4205 BindOnce(&CallbackWithDestructor, std::make_unique<PostTaskWhenDeleted>(
4206 "Q2 D1", queues[1]->task_runner(),
4207 1, &tasks_alive, &tasks_deleted)),
4208 base::TimeDelta::FromSeconds(1));
4209
4210 // Post two immediate tasks and force a queue reload between them.
4211 queues[2]->task_runner()->PostTask(
4212 FROM_HERE,
4213 BindOnce(&CallbackWithDestructor, std::make_unique<PostTaskWhenDeleted>(
4214 "Q3 I1", queues[2]->task_runner(),
4215 0, &tasks_alive, &tasks_deleted)));
4216 queues[2]->GetTaskQueueImpl()->ReloadEmptyImmediateWorkQueue();
4217 queues[2]->task_runner()->PostTask(
4218 FROM_HERE,
4219 BindOnce(&CallbackWithDestructor, std::make_unique<PostTaskWhenDeleted>(
4220 "Q3 I2", queues[2]->task_runner(),
4221 1, &tasks_alive, &tasks_deleted)));
4222
4223 // Post a delayed task and force a delay to expire.
4224 queues[3]->task_runner()->PostDelayedTask(
4225 FROM_HERE,
4226 BindOnce(&CallbackWithDestructor, std::make_unique<PostTaskWhenDeleted>(
4227 "Q4 D1", queues[1]->task_runner(),
4228 0, &tasks_alive, &tasks_deleted)),
4229 TimeDelta::FromMilliseconds(10));
4230 AdvanceMockTickClock(TimeDelta::FromMilliseconds(100));
4231 LazyNow lazy_now(mock_tick_clock());
4232 sequence_manager()->MoveReadyDelayedTasksToWorkQueues(&lazy_now);
4233
4234 EXPECT_THAT(tasks_alive,
4235 UnorderedElementsAre("Q1 I1 1", "Q1 D1 0", "Q2 D1 1", "Q3 I1 0",
4236 "Q3 I2 1", "Q4 D1 0"));
4237 EXPECT_TRUE(sequence_manager()->HasTasks());
4238
4239 sequence_manager()->DeletePendingTasks();
4240
4241 // Note that the tasks reposting themselves are still alive.
4242 EXPECT_THAT(tasks_alive,
4243 UnorderedElementsAre("Q1 I1 0", "Q2 D1 0", "Q3 I2 0"));
4244 EXPECT_THAT(tasks_deleted,
4245 UnorderedElementsAre("Q1 I1 1", "Q1 D1 0", "Q2 D1 1", "Q3 I1 0",
4246 "Q3 I2 1", "Q4 D1 0"));
4247 EXPECT_TRUE(sequence_manager()->HasTasks());
4248 tasks_deleted.clear();
4249
4250 // Second call should remove the rest.
4251 sequence_manager()->DeletePendingTasks();
4252 EXPECT_THAT(tasks_alive, UnorderedElementsAre());
4253 EXPECT_THAT(tasks_deleted,
4254 UnorderedElementsAre("Q1 I1 0", "Q2 D1 0", "Q3 I2 0"));
4255 EXPECT_FALSE(sequence_manager()->HasTasks());
4256
4257 // Ensure that |tasks_alive| and |tasks_deleted| outlive |manager_|
4258 // and we get a test failure instead of a test crash.
4259 DestroySequenceManager();
4260 }
4261
4262 // TODO(altimin): Add a test that posts an infinite number of other tasks
4263 // from its destructor.
4264
4265 class QueueTimeTaskObserver : public TaskObserver {
4266 public:
WillProcessTask(const PendingTask & pending_task,bool was_blocked_or_low_priority)4267 void WillProcessTask(const PendingTask& pending_task,
4268 bool was_blocked_or_low_priority) override {
4269 queue_time_ = pending_task.queue_time;
4270 }
DidProcessTask(const PendingTask & pending_task)4271 void DidProcessTask(const PendingTask& pending_task) override {}
queue_time()4272 TimeTicks queue_time() { return queue_time_; }
4273
4274 private:
4275 TimeTicks queue_time_;
4276 };
4277
TEST_P(SequenceManagerTest,DoesNotRecordQueueTimeIfSettingFalse)4278 TEST_P(SequenceManagerTest, DoesNotRecordQueueTimeIfSettingFalse) {
4279 auto queue = CreateTaskQueue();
4280
4281 QueueTimeTaskObserver observer;
4282 sequence_manager()->AddTaskObserver(&observer);
4283
4284 // We do not record task queue time when the setting is false.
4285 sequence_manager()->SetAddQueueTimeToTasks(false);
4286 AdvanceMockTickClock(TimeDelta::FromMilliseconds(99));
4287 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
4288 RunLoop().RunUntilIdle();
4289 EXPECT_TRUE(observer.queue_time().is_null());
4290
4291 sequence_manager()->RemoveTaskObserver(&observer);
4292 }
4293
TEST_P(SequenceManagerTest,RecordsQueueTimeIfSettingTrue)4294 TEST_P(SequenceManagerTest, RecordsQueueTimeIfSettingTrue) {
4295 const auto kStartTime = mock_tick_clock()->NowTicks();
4296 auto queue = CreateTaskQueue();
4297
4298 QueueTimeTaskObserver observer;
4299 sequence_manager()->AddTaskObserver(&observer);
4300
4301 // We correctly record task queue time when the setting is true.
4302 sequence_manager()->SetAddQueueTimeToTasks(true);
4303 AdvanceMockTickClock(TimeDelta::FromMilliseconds(99));
4304 queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
4305 RunLoop().RunUntilIdle();
4306 EXPECT_EQ(observer.queue_time(),
4307 kStartTime + TimeDelta::FromMilliseconds(99));
4308
4309 sequence_manager()->RemoveTaskObserver(&observer);
4310 }
4311
4312 namespace {
4313 // Inject a test point for recording the destructor calls for OnceClosure
4314 // objects sent to PostTask(). It is awkward usage since we are trying to hook
4315 // the actual destruction, which is not a common operation.
4316 class DestructionObserverProbe : public RefCounted<DestructionObserverProbe> {
4317 public:
DestructionObserverProbe(bool * task_destroyed,bool * destruction_observer_called)4318 DestructionObserverProbe(bool* task_destroyed,
4319 bool* destruction_observer_called)
4320 : task_destroyed_(task_destroyed),
4321 destruction_observer_called_(destruction_observer_called) {}
Run()4322 virtual void Run() {
4323 // This task should never run.
4324 ADD_FAILURE();
4325 }
4326
4327 private:
4328 friend class RefCounted<DestructionObserverProbe>;
4329
~DestructionObserverProbe()4330 virtual ~DestructionObserverProbe() {
4331 EXPECT_FALSE(*destruction_observer_called_);
4332 *task_destroyed_ = true;
4333 }
4334
4335 bool* task_destroyed_;
4336 bool* destruction_observer_called_;
4337 };
4338
4339 class SMDestructionObserver : public CurrentThread::DestructionObserver {
4340 public:
SMDestructionObserver(bool * task_destroyed,bool * destruction_observer_called)4341 SMDestructionObserver(bool* task_destroyed, bool* destruction_observer_called)
4342 : task_destroyed_(task_destroyed),
4343 destruction_observer_called_(destruction_observer_called),
4344 task_destroyed_before_message_loop_(false) {}
WillDestroyCurrentMessageLoop()4345 void WillDestroyCurrentMessageLoop() override {
4346 task_destroyed_before_message_loop_ = *task_destroyed_;
4347 *destruction_observer_called_ = true;
4348 }
task_destroyed_before_message_loop() const4349 bool task_destroyed_before_message_loop() const {
4350 return task_destroyed_before_message_loop_;
4351 }
4352
4353 private:
4354 bool* task_destroyed_;
4355 bool* destruction_observer_called_;
4356 bool task_destroyed_before_message_loop_;
4357 };
4358
4359 } // namespace
4360
TEST_P(SequenceManagerTest,DestructionObserverTest)4361 TEST_P(SequenceManagerTest, DestructionObserverTest) {
4362 auto queue = CreateTaskQueue();
4363
4364 // Verify that the destruction observer gets called at the very end (after
4365 // all the pending tasks have been destroyed).
4366 const TimeDelta kDelay = TimeDelta::FromMilliseconds(100);
4367
4368 bool task_destroyed = false;
4369 bool destruction_observer_called = false;
4370
4371 SMDestructionObserver observer(&task_destroyed, &destruction_observer_called);
4372 sequence_manager()->AddDestructionObserver(&observer);
4373 queue->task_runner()->PostDelayedTask(
4374 FROM_HERE,
4375 BindOnce(&DestructionObserverProbe::Run,
4376 base::MakeRefCounted<DestructionObserverProbe>(
4377 &task_destroyed, &destruction_observer_called)),
4378 kDelay);
4379
4380 DestroySequenceManager();
4381
4382 EXPECT_TRUE(observer.task_destroyed_before_message_loop());
4383 // The task should have been destroyed when we deleted the loop.
4384 EXPECT_TRUE(task_destroyed);
4385 EXPECT_TRUE(destruction_observer_called);
4386 }
4387
TEST_P(SequenceManagerTest,GetMessagePump)4388 TEST_P(SequenceManagerTest, GetMessagePump) {
4389 switch (GetUnderlyingRunnerType()) {
4390 default:
4391 EXPECT_THAT(sequence_manager()->GetMessagePump(), testing::IsNull());
4392 break;
4393 case TestType::kMessagePump:
4394 EXPECT_THAT(sequence_manager()->GetMessagePump(), testing::NotNull());
4395 break;
4396 }
4397 }
4398
4399 namespace {
4400
4401 class MockTimeDomain : public TimeDomain {
4402 public:
4403 MockTimeDomain() = default;
4404 MockTimeDomain(const MockTimeDomain&) = delete;
4405 MockTimeDomain& operator=(const MockTimeDomain&) = delete;
4406 ~MockTimeDomain() override = default;
4407
CreateLazyNow() const4408 LazyNow CreateLazyNow() const override { return LazyNow(now_); }
Now() const4409 TimeTicks Now() const override { return now_; }
4410
DelayTillNextTask(LazyNow * lazy_now)4411 Optional<TimeDelta> DelayTillNextTask(LazyNow* lazy_now) override {
4412 return Optional<TimeDelta>();
4413 }
4414
4415 MOCK_METHOD1(MaybeFastForwardToNextTask, bool(bool quit_when_idle_requested));
4416
GetName() const4417 const char* GetName() const override { return "Test"; }
4418
SetNextDelayedDoWork(LazyNow * lazy_now,TimeTicks run_time)4419 void SetNextDelayedDoWork(LazyNow* lazy_now, TimeTicks run_time) override {}
4420
4421 private:
4422 TimeTicks now_;
4423 };
4424
4425 } // namespace
4426
TEST_P(SequenceManagerTest,OnSystemIdleTimeDomainNotification)4427 TEST_P(SequenceManagerTest, OnSystemIdleTimeDomainNotification) {
4428 if (GetUnderlyingRunnerType() != TestType::kMessagePump)
4429 return;
4430
4431 auto queue = CreateTaskQueue();
4432
4433 // If we call OnSystemIdle, we expect registered TimeDomains to receive a call
4434 // to MaybeFastForwardToNextTask. If no run loop has requested quit on idle,
4435 // the parameter passed in should be false.
4436 StrictMock<MockTimeDomain> mock_time_domain;
4437 sequence_manager()->RegisterTimeDomain(&mock_time_domain);
4438 EXPECT_CALL(mock_time_domain, MaybeFastForwardToNextTask(false))
4439 .WillOnce(Return(false));
4440 sequence_manager()->OnSystemIdle();
4441 sequence_manager()->UnregisterTimeDomain(&mock_time_domain);
4442 Mock::VerifyAndClearExpectations(&mock_time_domain);
4443
4444 // However if RunUntilIdle is called it should be true.
4445 queue->task_runner()->PostTask(
4446 FROM_HERE, BindLambdaForTesting([&]() {
4447 StrictMock<MockTimeDomain> mock_time_domain;
4448 EXPECT_CALL(mock_time_domain, MaybeFastForwardToNextTask(true))
4449 .WillOnce(Return(false));
4450 sequence_manager()->RegisterTimeDomain(&mock_time_domain);
4451 sequence_manager()->OnSystemIdle();
4452 sequence_manager()->UnregisterTimeDomain(&mock_time_domain);
4453 }));
4454
4455 RunLoop().RunUntilIdle();
4456 }
4457
TEST_P(SequenceManagerTest,CreateTaskQueue)4458 TEST_P(SequenceManagerTest, CreateTaskQueue) {
4459 scoped_refptr<TaskQueue> task_queue =
4460 sequence_manager()->CreateTaskQueue(TaskQueue::Spec("test"));
4461 EXPECT_THAT(task_queue.get(), testing::NotNull());
4462
4463 task_queue->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
4464 EXPECT_EQ(1u, sequence_manager()->GetPendingTaskCountForTesting());
4465 }
4466
TEST_P(SequenceManagerTest,GetPendingTaskCountForTesting)4467 TEST_P(SequenceManagerTest, GetPendingTaskCountForTesting) {
4468 auto queues = CreateTaskQueues(3u);
4469
4470 EXPECT_EQ(0u, sequence_manager()->GetPendingTaskCountForTesting());
4471
4472 queues[0]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
4473 EXPECT_EQ(1u, sequence_manager()->GetPendingTaskCountForTesting());
4474
4475 queues[0]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
4476 EXPECT_EQ(2u, sequence_manager()->GetPendingTaskCountForTesting());
4477
4478 queues[0]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
4479 EXPECT_EQ(3u, sequence_manager()->GetPendingTaskCountForTesting());
4480
4481 queues[1]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
4482 EXPECT_EQ(4u, sequence_manager()->GetPendingTaskCountForTesting());
4483
4484 queues[2]->task_runner()->PostTask(FROM_HERE, BindOnce(&NopTask));
4485 EXPECT_EQ(5u, sequence_manager()->GetPendingTaskCountForTesting());
4486
4487 queues[1]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
4488 TimeDelta::FromMilliseconds(10));
4489 EXPECT_EQ(6u, sequence_manager()->GetPendingTaskCountForTesting());
4490
4491 queues[2]->task_runner()->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
4492 TimeDelta::FromMilliseconds(20));
4493 EXPECT_EQ(7u, sequence_manager()->GetPendingTaskCountForTesting());
4494
4495 RunLoop().RunUntilIdle();
4496 EXPECT_EQ(2u, sequence_manager()->GetPendingTaskCountForTesting());
4497
4498 AdvanceMockTickClock(TimeDelta::FromMilliseconds(10));
4499 RunLoop().RunUntilIdle();
4500 EXPECT_EQ(1u, sequence_manager()->GetPendingTaskCountForTesting());
4501
4502 AdvanceMockTickClock(TimeDelta::FromMilliseconds(10));
4503 RunLoop().RunUntilIdle();
4504 EXPECT_EQ(0u, sequence_manager()->GetPendingTaskCountForTesting());
4505 }
4506
TEST_P(SequenceManagerTest,PostDelayedTaskFromOtherThread)4507 TEST_P(SequenceManagerTest, PostDelayedTaskFromOtherThread) {
4508 scoped_refptr<TestTaskQueue> main_tq = CreateTaskQueue();
4509 scoped_refptr<TaskRunner> task_runner =
4510 main_tq->CreateTaskRunner(kTaskTypeNone);
4511 sequence_manager()->SetAddQueueTimeToTasks(true);
4512
4513 Thread thread("test thread");
4514 thread.StartAndWaitForTesting();
4515
4516 WaitableEvent task_posted(WaitableEvent::ResetPolicy::MANUAL,
4517 WaitableEvent::InitialState::NOT_SIGNALED);
4518 thread.task_runner()->PostTask(
4519 FROM_HERE, BindOnce(
4520 [](scoped_refptr<TaskRunner> task_runner,
4521 WaitableEvent* task_posted) {
4522 task_runner->PostDelayedTask(
4523 FROM_HERE, BindOnce(&NopTask),
4524 base::TimeDelta::FromMilliseconds(10));
4525 task_posted->Signal();
4526 },
4527 std::move(task_runner), &task_posted));
4528 task_posted.Wait();
4529 FastForwardUntilNoTasksRemain();
4530 RunLoop().RunUntilIdle();
4531 thread.Stop();
4532 }
4533
PostTaskA(scoped_refptr<TaskRunner> task_runner)4534 void PostTaskA(scoped_refptr<TaskRunner> task_runner) {
4535 task_runner->PostTask(FROM_HERE, BindOnce(&NopTask));
4536 task_runner->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
4537 base::TimeDelta::FromMilliseconds(10));
4538 }
4539
PostTaskB(scoped_refptr<TaskRunner> task_runner)4540 void PostTaskB(scoped_refptr<TaskRunner> task_runner) {
4541 task_runner->PostTask(FROM_HERE, BindOnce(&NopTask));
4542 task_runner->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
4543 base::TimeDelta::FromMilliseconds(20));
4544 }
4545
PostTaskC(scoped_refptr<TaskRunner> task_runner)4546 void PostTaskC(scoped_refptr<TaskRunner> task_runner) {
4547 task_runner->PostTask(FROM_HERE, BindOnce(&NopTask));
4548 task_runner->PostDelayedTask(FROM_HERE, BindOnce(&NopTask),
4549 base::TimeDelta::FromMilliseconds(30));
4550 }
4551
TEST_P(SequenceManagerTest,DescribeAllPendingTasks)4552 TEST_P(SequenceManagerTest, DescribeAllPendingTasks) {
4553 auto queues = CreateTaskQueues(3u);
4554
4555 PostTaskA(queues[0]->task_runner());
4556 PostTaskB(queues[1]->task_runner());
4557 PostTaskC(queues[2]->task_runner());
4558
4559 std::string description = sequence_manager()->DescribeAllPendingTasks();
4560 EXPECT_THAT(description, HasSubstr("PostTaskA@"));
4561 EXPECT_THAT(description, HasSubstr("PostTaskB@"));
4562 EXPECT_THAT(description, HasSubstr("PostTaskC@"));
4563 }
4564
TEST_P(SequenceManagerTest,TaskPriortyInterleaving)4565 TEST_P(SequenceManagerTest, TaskPriortyInterleaving) {
4566 auto queues = CreateTaskQueues(TaskQueue::QueuePriority::kQueuePriorityCount);
4567
4568 for (uint8_t priority = 0;
4569 priority < TaskQueue::QueuePriority::kQueuePriorityCount; priority++) {
4570 if (priority != TaskQueue::QueuePriority::kNormalPriority) {
4571 queues[priority]->SetQueuePriority(
4572 static_cast<TaskQueue::QueuePriority>(priority));
4573 }
4574 }
4575
4576 std::string order;
4577 for (int i = 0; i < 60; i++) {
4578 for (uint8_t priority = 0;
4579 priority < TaskQueue::QueuePriority::kQueuePriorityCount; priority++) {
4580 queues[priority]->task_runner()->PostTask(
4581 FROM_HERE,
4582 base::BindOnce([](std::string* str, char c) { str->push_back(c); },
4583 &order, '0' + priority));
4584 }
4585 }
4586
4587 RunLoop().RunUntilIdle();
4588
4589 EXPECT_EQ(order,
4590 "000000000000000000000000000000000000000000000000000000000000"
4591 "111111111111111111111111111111111111111111111111111111111111"
4592 "222222222222222222222222222222222222222222222222222222222222"
4593 "333333333333333333333333333333333333333333333333333333333333"
4594 "444444444444444444444444444444444444444444444444444444444444"
4595 "555555555555555555555555555555555555555555555555555555555555"
4596 "666666666666666666666666666666666666666666666666666666666666");
4597 }
4598
4599 class CancelableTaskWithDestructionObserver {
4600 public:
CancelableTaskWithDestructionObserver()4601 CancelableTaskWithDestructionObserver() {}
4602
Task(std::unique_ptr<ScopedClosureRunner> destruction_observer)4603 void Task(std::unique_ptr<ScopedClosureRunner> destruction_observer) {
4604 destruction_observer_ = std::move(destruction_observer);
4605 }
4606
4607 std::unique_ptr<ScopedClosureRunner> destruction_observer_;
4608 WeakPtrFactory<CancelableTaskWithDestructionObserver> weak_factory_{this};
4609 };
4610
TEST_P(SequenceManagerTest,PeriodicHousekeeping)4611 TEST_P(SequenceManagerTest, PeriodicHousekeeping) {
4612 auto queue = CreateTaskQueue();
4613
4614 // Post a task that will trigger housekeeping.
4615 queue->task_runner()->PostDelayedTask(
4616 FROM_HERE, BindOnce(&NopTask),
4617 SequenceManagerImpl::kReclaimMemoryInterval);
4618
4619 // Posts some tasks set to run long in the future and then cancel some of
4620 // them.
4621 bool task1_deleted = false;
4622 bool task2_deleted = false;
4623 bool task3_deleted = false;
4624 CancelableTaskWithDestructionObserver task1;
4625 CancelableTaskWithDestructionObserver task2;
4626 CancelableTaskWithDestructionObserver task3;
4627
4628 queue->task_runner()->PostDelayedTask(
4629 FROM_HERE,
4630 BindOnce(&CancelableTaskWithDestructionObserver::Task,
4631 task1.weak_factory_.GetWeakPtr(),
4632 std::make_unique<ScopedClosureRunner>(
4633 BindLambdaForTesting([&]() { task1_deleted = true; }))),
4634 TimeDelta::FromHours(1));
4635
4636 queue->task_runner()->PostDelayedTask(
4637 FROM_HERE,
4638 BindOnce(&CancelableTaskWithDestructionObserver::Task,
4639 task2.weak_factory_.GetWeakPtr(),
4640 std::make_unique<ScopedClosureRunner>(
4641 BindLambdaForTesting([&]() { task2_deleted = true; }))),
4642 TimeDelta::FromHours(2));
4643
4644 queue->task_runner()->PostDelayedTask(
4645 FROM_HERE,
4646 BindOnce(&CancelableTaskWithDestructionObserver::Task,
4647 task3.weak_factory_.GetWeakPtr(),
4648 std::make_unique<ScopedClosureRunner>(
4649 BindLambdaForTesting([&]() { task3_deleted = true; }))),
4650 TimeDelta::FromHours(3));
4651
4652 task2.weak_factory_.InvalidateWeakPtrs();
4653 task3.weak_factory_.InvalidateWeakPtrs();
4654
4655 EXPECT_FALSE(task1_deleted);
4656 EXPECT_FALSE(task2_deleted);
4657 EXPECT_FALSE(task3_deleted);
4658
4659 // This should trigger housekeeping which will sweep away the canceled tasks.
4660 FastForwardBy(SequenceManagerImpl::kReclaimMemoryInterval);
4661
4662 EXPECT_FALSE(task1_deleted);
4663 EXPECT_TRUE(task2_deleted);
4664 EXPECT_TRUE(task3_deleted);
4665
4666 // Tidy up.
4667 FastForwardUntilNoTasksRemain();
4668 }
4669
4670 class MockCrashKeyImplementation : public debug::CrashKeyImplementation {
4671 public:
4672 MOCK_METHOD2(Allocate,
4673 debug::CrashKeyString*(const char name[], debug::CrashKeySize));
4674 MOCK_METHOD2(Set, void(debug::CrashKeyString*, StringPiece));
4675 MOCK_METHOD1(Clear, void(debug::CrashKeyString*));
4676 };
4677
TEST_P(SequenceManagerTest,CrashKeys)4678 TEST_P(SequenceManagerTest, CrashKeys) {
4679 testing::InSequence sequence;
4680 auto queue = CreateTaskQueue();
4681 auto runner = queue->CreateTaskRunner(kTaskTypeNone);
4682 auto crash_key_impl = std::make_unique<MockCrashKeyImplementation>();
4683 RunLoop run_loop;
4684
4685 MockCrashKeyImplementation* mock_impl = crash_key_impl.get();
4686 debug::SetCrashKeyImplementation(std::move(crash_key_impl));
4687 debug::CrashKeyString dummy_key("dummy", debug::CrashKeySize::Size64);
4688
4689 // Parent task.
4690 auto parent_location = FROM_HERE;
4691 auto expected_stack1 = StringPrintf(
4692 "0x%zX 0x0",
4693 reinterpret_cast<uintptr_t>(parent_location.program_counter()));
4694 EXPECT_CALL(*mock_impl, Allocate(_, _)).WillRepeatedly(Return(&dummy_key));
4695 EXPECT_CALL(*mock_impl, Set(_, testing::Eq(expected_stack1)));
4696
4697 // Child task.
4698 auto location = FROM_HERE;
4699 auto expected_stack2 = StringPrintf(
4700 "0x%zX 0x%zX", reinterpret_cast<uintptr_t>(location.program_counter()),
4701 reinterpret_cast<uintptr_t>(parent_location.program_counter()));
4702 EXPECT_CALL(*mock_impl, Set(_, testing::Eq(expected_stack2)));
4703
4704 sequence_manager()->EnableCrashKeys("test-async-stack");
4705
4706 // Run a task that posts another task to establish an asynchronous call stack.
4707 runner->PostTask(parent_location, BindLambdaForTesting([&]() {
4708 runner->PostTask(location, run_loop.QuitClosure());
4709 }));
4710 run_loop.Run();
4711
4712 debug::SetCrashKeyImplementation(nullptr);
4713 }
4714
TEST_P(SequenceManagerTest,CrossQueueTaskPostingWhenQueueDeleted)4715 TEST_P(SequenceManagerTest, CrossQueueTaskPostingWhenQueueDeleted) {
4716 MockTask task;
4717 auto queue_1 = CreateTaskQueue();
4718 auto queue_2 = CreateTaskQueue();
4719
4720 EXPECT_CALL(task, Run).Times(1);
4721
4722 queue_1->task_runner()->PostDelayedTask(
4723 FROM_HERE, PostOnDestruction(queue_2, task.Get()),
4724 TimeDelta::FromMinutes(1));
4725
4726 queue_1->ShutdownTaskQueue();
4727
4728 FastForwardUntilNoTasksRemain();
4729 }
4730
TEST_P(SequenceManagerTest,UnregisterTaskQueueTriggersScheduleWork)4731 TEST_P(SequenceManagerTest, UnregisterTaskQueueTriggersScheduleWork) {
4732 constexpr auto kDelay = TimeDelta::FromMinutes(1);
4733 auto queue_1 = CreateTaskQueue();
4734 auto queue_2 = CreateTaskQueue();
4735
4736 MockTask task;
4737 EXPECT_CALL(task, Run).Times(1);
4738
4739 queue_1->task_runner()->PostDelayedTask(FROM_HERE, task.Get(), kDelay);
4740 queue_2->task_runner()->PostDelayedTask(FROM_HERE, task.Get(), kDelay * 2);
4741
4742 AdvanceMockTickClock(kDelay * 2);
4743
4744 // Wakeup time needs to be adjusted to kDelay * 2 when the queue is
4745 // unregistered from the TimeDomain
4746 queue_1->ShutdownTaskQueue();
4747
4748 RunLoop().RunUntilIdle();
4749 }
4750
TEST_P(SequenceManagerTest,ReclaimMemoryRemovesCorrectQueueFromSet)4751 TEST_P(SequenceManagerTest, ReclaimMemoryRemovesCorrectQueueFromSet) {
4752 auto queue1 = CreateTaskQueue();
4753 auto queue2 = CreateTaskQueue();
4754 auto queue3 = CreateTaskQueue();
4755 auto queue4 = CreateTaskQueue();
4756
4757 std::vector<int> order;
4758
4759 CancelableClosure cancelable_closure1(
4760 BindLambdaForTesting([&]() { order.push_back(10); }));
4761 CancelableClosure cancelable_closure2(
4762 BindLambdaForTesting([&]() { order.push_back(11); }));
4763 queue1->task_runner()->PostTask(FROM_HERE, BindLambdaForTesting([&]() {
4764 order.push_back(1);
4765 cancelable_closure1.Cancel();
4766 cancelable_closure2.Cancel();
4767 // This should remove |queue4| from the work
4768 // queue set,
4769 sequence_manager()->ReclaimMemory();
4770 }));
4771 queue2->task_runner()->PostTask(
4772 FROM_HERE, BindLambdaForTesting([&]() { order.push_back(2); }));
4773 queue3->task_runner()->PostTask(
4774 FROM_HERE, BindLambdaForTesting([&]() { order.push_back(3); }));
4775 queue4->task_runner()->PostTask(FROM_HERE, cancelable_closure1.callback());
4776 queue4->task_runner()->PostTask(FROM_HERE, cancelable_closure2.callback());
4777
4778 RunLoop().RunUntilIdle();
4779
4780 // Make sure ReclaimMemory didn't prevent the task from |queue2| from running.
4781 EXPECT_THAT(order, ElementsAre(1, 2, 3));
4782 }
4783
TEST_P(SequenceManagerTest,OnNativeWorkPending)4784 TEST_P(SequenceManagerTest, OnNativeWorkPending) {
4785 MockTask task;
4786 auto queue = CreateTaskQueue();
4787 queue->SetQueuePriority(TaskQueue::QueuePriority::kNormalPriority);
4788
4789 auto CheckPostedTaskRan = [&](bool should_have_run) {
4790 EXPECT_CALL(task, Run).Times(should_have_run ? 1 : 0);
4791 RunLoop().RunUntilIdle();
4792 Mock::VerifyAndClearExpectations(&task);
4793 };
4794
4795 // Scheduling native work with higher priority causes the posted task to be
4796 // deferred.
4797 auto native_work = sequence_manager()->OnNativeWorkPending(
4798 TaskQueue::QueuePriority::kHighPriority);
4799 queue->task_runner()->PostTask(FROM_HERE, task.Get());
4800 CheckPostedTaskRan(false);
4801
4802 // Once the native work completes, the posted task is free to execute.
4803 native_work.reset();
4804 CheckPostedTaskRan(true);
4805
4806 // Lower priority native work doesn't preempt posted tasks.
4807 native_work = sequence_manager()->OnNativeWorkPending(
4808 TaskQueue::QueuePriority::kLowPriority);
4809 queue->task_runner()->PostTask(FROM_HERE, task.Get());
4810 CheckPostedTaskRan(true);
4811
4812 // Equal priority native work doesn't preempt posted tasks.
4813 native_work = sequence_manager()->OnNativeWorkPending(
4814 TaskQueue::QueuePriority::kNormalPriority);
4815 queue->task_runner()->PostTask(FROM_HERE, task.Get());
4816 CheckPostedTaskRan(true);
4817
4818 // When there are multiple priorities of native work, only the highest
4819 // priority matters.
4820 native_work = sequence_manager()->OnNativeWorkPending(
4821 TaskQueue::QueuePriority::kNormalPriority);
4822 auto native_work_high = sequence_manager()->OnNativeWorkPending(
4823 TaskQueue::QueuePriority::kHighPriority);
4824 auto native_work_low = sequence_manager()->OnNativeWorkPending(
4825 TaskQueue::QueuePriority::kLowPriority);
4826 queue->task_runner()->PostTask(FROM_HERE, task.Get());
4827 CheckPostedTaskRan(false);
4828 native_work.reset();
4829 CheckPostedTaskRan(false);
4830 native_work_high.reset();
4831 CheckPostedTaskRan(true);
4832 }
4833
4834 namespace {
4835
4836 class TaskObserverExpectingNoDelayedRunTime : public TaskObserver {
4837 public:
4838 TaskObserverExpectingNoDelayedRunTime() = default;
4839 ~TaskObserverExpectingNoDelayedRunTime() override = default;
4840
num_will_process_task() const4841 int num_will_process_task() const { return num_will_process_task_; }
num_did_process_task() const4842 int num_did_process_task() const { return num_did_process_task_; }
4843
4844 private:
WillProcessTask(const base::PendingTask & pending_task,bool was_blocked_or_low_priority)4845 void WillProcessTask(const base::PendingTask& pending_task,
4846 bool was_blocked_or_low_priority) override {
4847 EXPECT_TRUE(pending_task.delayed_run_time.is_null());
4848 ++num_will_process_task_;
4849 }
DidProcessTask(const base::PendingTask & pending_task)4850 void DidProcessTask(const base::PendingTask& pending_task) override {
4851 EXPECT_TRUE(pending_task.delayed_run_time.is_null());
4852 ++num_did_process_task_;
4853 }
4854
4855 int num_will_process_task_ = 0;
4856 int num_did_process_task_ = 0;
4857 };
4858
4859 } // namespace
4860
4861 // The |delayed_run_time| must not be set for immediate tasks as that prevents
4862 // external observers from correctly identifying delayed tasks.
4863 // https://crbug.com/1029137
TEST_P(SequenceManagerTest,NoDelayedRunTimeForImmediateTask)4864 TEST_P(SequenceManagerTest, NoDelayedRunTimeForImmediateTask) {
4865 TaskObserverExpectingNoDelayedRunTime task_observer;
4866 sequence_manager()->SetAddQueueTimeToTasks(true);
4867 sequence_manager()->AddTaskObserver(&task_observer);
4868 auto queue = CreateTaskQueue();
4869
4870 base::RunLoop run_loop;
4871 queue->task_runner()->PostTask(
4872 FROM_HERE, BindLambdaForTesting([&]() { run_loop.Quit(); }));
4873 run_loop.Run();
4874
4875 EXPECT_EQ(1, task_observer.num_will_process_task());
4876 EXPECT_EQ(1, task_observer.num_did_process_task());
4877
4878 sequence_manager()->RemoveTaskObserver(&task_observer);
4879 }
4880
TEST_P(SequenceManagerTest,TaskObserverBlockedOrLowPriority_QueueDisabled)4881 TEST_P(SequenceManagerTest, TaskObserverBlockedOrLowPriority_QueueDisabled) {
4882 auto queue = CreateTaskQueue();
4883 testing::StrictMock<MockTaskObserver> observer;
4884 sequence_manager()->AddTaskObserver(&observer);
4885
4886 queue->task_runner()->PostTask(FROM_HERE, DoNothing());
4887 queue->GetTaskQueueImpl()->SetQueueEnabled(false);
4888 queue->GetTaskQueueImpl()->SetQueueEnabled(true);
4889
4890 EXPECT_CALL(observer,
4891 WillProcessTask(_, /*was_blocked_or_low_priority=*/true));
4892 EXPECT_CALL(observer, DidProcessTask(_));
4893 RunLoop().RunUntilIdle();
4894
4895 sequence_manager()->RemoveTaskObserver(&observer);
4896 }
4897
TEST_P(SequenceManagerTest,TaskObserverBlockedOrLowPriority_FenceBeginningOfTime)4898 TEST_P(SequenceManagerTest,
4899 TaskObserverBlockedOrLowPriority_FenceBeginningOfTime) {
4900 auto queue = CreateTaskQueue();
4901 testing::StrictMock<MockTaskObserver> observer;
4902 sequence_manager()->AddTaskObserver(&observer);
4903
4904 queue->task_runner()->PostTask(FROM_HERE, DoNothing());
4905 queue->GetTaskQueueImpl()->InsertFence(
4906 TaskQueue::InsertFencePosition::kBeginningOfTime);
4907 queue->GetTaskQueueImpl()->RemoveFence();
4908
4909 EXPECT_CALL(observer,
4910 WillProcessTask(_, /*was_blocked_or_low_priority=*/true));
4911 EXPECT_CALL(observer, DidProcessTask(_));
4912 RunLoop().RunUntilIdle();
4913
4914 sequence_manager()->RemoveTaskObserver(&observer);
4915 }
4916
TEST_P(SequenceManagerTest,TaskObserverBlockedOrLowPriority_PostedBeforeFenceNow)4917 TEST_P(SequenceManagerTest,
4918 TaskObserverBlockedOrLowPriority_PostedBeforeFenceNow) {
4919 auto queue = CreateTaskQueue();
4920 testing::StrictMock<MockTaskObserver> observer;
4921 sequence_manager()->AddTaskObserver(&observer);
4922
4923 queue->task_runner()->PostTask(FROM_HERE, DoNothing());
4924 queue->GetTaskQueueImpl()->InsertFence(TaskQueue::InsertFencePosition::kNow);
4925 queue->GetTaskQueueImpl()->RemoveFence();
4926
4927 EXPECT_CALL(observer,
4928 WillProcessTask(_, /*was_blocked_or_low_priority=*/false));
4929 EXPECT_CALL(observer, DidProcessTask(_));
4930 RunLoop().RunUntilIdle();
4931
4932 sequence_manager()->RemoveTaskObserver(&observer);
4933 }
4934
TEST_P(SequenceManagerTest,TaskObserverBlockedOrLowPriority_PostedAfterFenceNow)4935 TEST_P(SequenceManagerTest,
4936 TaskObserverBlockedOrLowPriority_PostedAfterFenceNow) {
4937 auto queue = CreateTaskQueue();
4938 testing::StrictMock<MockTaskObserver> observer;
4939 sequence_manager()->AddTaskObserver(&observer);
4940
4941 queue->GetTaskQueueImpl()->InsertFence(TaskQueue::InsertFencePosition::kNow);
4942 queue->task_runner()->PostTask(FROM_HERE, DoNothing());
4943 queue->GetTaskQueueImpl()->RemoveFence();
4944
4945 EXPECT_CALL(observer,
4946 WillProcessTask(_, /*was_blocked_or_low_priority=*/true));
4947 EXPECT_CALL(observer, DidProcessTask(_));
4948 RunLoop().RunUntilIdle();
4949
4950 sequence_manager()->RemoveTaskObserver(&observer);
4951 }
4952
TEST_P(SequenceManagerTest,TaskObserverBlockedOrLowPriority_LowerPriorityWhileQueued)4953 TEST_P(SequenceManagerTest,
4954 TaskObserverBlockedOrLowPriority_LowerPriorityWhileQueued) {
4955 auto queue = CreateTaskQueue();
4956 testing::StrictMock<MockTaskObserver> observer;
4957 sequence_manager()->AddTaskObserver(&observer);
4958
4959 queue->task_runner()->PostTask(FROM_HERE, DoNothing());
4960 queue->SetQueuePriority(TaskQueue::QueuePriority::kLowPriority);
4961 queue->SetQueuePriority(TaskQueue::QueuePriority::kNormalPriority);
4962
4963 EXPECT_CALL(observer,
4964 WillProcessTask(_, /*was_blocked_or_low_priority=*/true));
4965 EXPECT_CALL(observer, DidProcessTask(_));
4966 RunLoop().RunUntilIdle();
4967
4968 sequence_manager()->RemoveTaskObserver(&observer);
4969 }
4970
TEST_P(SequenceManagerTest,TaskObserverBlockedOrLowPriority_LowPriorityWhenQueueing)4971 TEST_P(SequenceManagerTest,
4972 TaskObserverBlockedOrLowPriority_LowPriorityWhenQueueing) {
4973 auto queue = CreateTaskQueue();
4974 testing::StrictMock<MockTaskObserver> observer;
4975 sequence_manager()->AddTaskObserver(&observer);
4976
4977 queue->SetQueuePriority(TaskQueue::QueuePriority::kLowPriority);
4978 queue->task_runner()->PostTask(FROM_HERE, DoNothing());
4979 queue->SetQueuePriority(TaskQueue::QueuePriority::kNormalPriority);
4980
4981 EXPECT_CALL(observer,
4982 WillProcessTask(_, /*was_blocked_or_low_priority=*/true));
4983 EXPECT_CALL(observer, DidProcessTask(_));
4984 RunLoop().RunUntilIdle();
4985
4986 sequence_manager()->RemoveTaskObserver(&observer);
4987 }
4988
TEST_P(SequenceManagerTest,TaskObserverBlockedOrLowPriority_LowPriorityWhenRunning)4989 TEST_P(SequenceManagerTest,
4990 TaskObserverBlockedOrLowPriority_LowPriorityWhenRunning) {
4991 auto queue = CreateTaskQueue();
4992 testing::StrictMock<MockTaskObserver> observer;
4993 sequence_manager()->AddTaskObserver(&observer);
4994
4995 queue->task_runner()->PostTask(FROM_HERE, DoNothing());
4996 queue->SetQueuePriority(TaskQueue::QueuePriority::kLowPriority);
4997
4998 EXPECT_CALL(observer,
4999 WillProcessTask(_, /*was_blocked_or_low_priority=*/true));
5000 EXPECT_CALL(observer, DidProcessTask(_));
5001 RunLoop().RunUntilIdle();
5002
5003 sequence_manager()->RemoveTaskObserver(&observer);
5004 }
5005
TEST_P(SequenceManagerTest,TaskObserverBlockedOrLowPriority_TaskObserverUnblockedWithBacklog)5006 TEST_P(SequenceManagerTest,
5007 TaskObserverBlockedOrLowPriority_TaskObserverUnblockedWithBacklog) {
5008 auto queue = CreateTaskQueue();
5009 testing::StrictMock<MockTaskObserver> observer;
5010 sequence_manager()->AddTaskObserver(&observer);
5011
5012 queue->SetQueuePriority(TaskQueue::QueuePriority::kLowPriority);
5013 queue->task_runner()->PostTask(FROM_HERE, DoNothing());
5014 queue->GetTaskQueueImpl()->InsertFence(
5015 TaskQueue::InsertFencePosition::kBeginningOfTime);
5016 queue->task_runner()->PostTask(FROM_HERE, DoNothing());
5017 queue->GetTaskQueueImpl()->RemoveFence();
5018 queue->task_runner()->PostTask(FROM_HERE, DoNothing());
5019 queue->SetQueuePriority(TaskQueue::QueuePriority::kNormalPriority);
5020 // Post a task while the queue is kNormalPriority and unblocked, but has a
5021 // backlog of tasks that were blocked.
5022 queue->task_runner()->PostTask(FROM_HERE, DoNothing());
5023
5024 EXPECT_CALL(observer,
5025 WillProcessTask(_, /*was_blocked_or_low_priority=*/true))
5026 .Times(3);
5027 EXPECT_CALL(observer, DidProcessTask(_)).Times(4);
5028 EXPECT_CALL(observer,
5029 WillProcessTask(_, /*was_blocked_or_low_priority=*/false));
5030 RunLoop().RunUntilIdle();
5031 testing::Mock::VerifyAndClear(&observer);
5032
5033 sequence_manager()->RemoveTaskObserver(&observer);
5034 }
5035
TEST_P(SequenceManagerTest,TaskObserverBlockedOrLowPriority_Mix)5036 TEST_P(SequenceManagerTest, TaskObserverBlockedOrLowPriority_Mix) {
5037 auto queue = CreateTaskQueue();
5038 testing::StrictMock<MockTaskObserver> observer;
5039 sequence_manager()->AddTaskObserver(&observer);
5040
5041 queue->SetQueuePriority(TaskQueue::QueuePriority::kLowPriority);
5042 queue->task_runner()->PostTask(FROM_HERE, DoNothing());
5043 queue->GetTaskQueueImpl()->InsertFence(
5044 TaskQueue::InsertFencePosition::kBeginningOfTime);
5045 queue->task_runner()->PostTask(FROM_HERE, DoNothing());
5046 queue->GetTaskQueueImpl()->RemoveFence();
5047 queue->task_runner()->PostTask(FROM_HERE, DoNothing());
5048
5049 EXPECT_CALL(observer,
5050 WillProcessTask(_, /*was_blocked_or_low_priority=*/true))
5051 .Times(3);
5052 EXPECT_CALL(observer, DidProcessTask(_)).Times(3);
5053 RunLoop().RunUntilIdle();
5054 testing::Mock::VerifyAndClear(&observer);
5055
5056 queue->SetQueuePriority(TaskQueue::QueuePriority::kNormalPriority);
5057 queue->task_runner()->PostTask(FROM_HERE, DoNothing());
5058 EXPECT_CALL(observer,
5059 WillProcessTask(_, /*was_blocked_or_low_priority=*/false));
5060 EXPECT_CALL(observer, DidProcessTask(_));
5061 RunLoop().RunUntilIdle();
5062
5063 sequence_manager()->RemoveTaskObserver(&observer);
5064 }
5065
5066 } // namespace sequence_manager_impl_unittest
5067 } // namespace internal
5068 } // namespace sequence_manager
5069 } // namespace base
5070