components/scheduler/renderer/deadline_task_runner_unittest.cc - Issue 2118903002: scheduler: Move the Blink scheduler into Blink

Side by Side Diff: components/scheduler/renderer/deadline_task_runner_unittest.cc

Issue 2118903002: scheduler: Move the Blink scheduler into Blink (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Really fixed the test failure this time Created 4 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

« no previous file with comments | « components/scheduler/renderer/deadline_task_runner.cc ('k') | components/scheduler/renderer/idle_time_estimator.h » ('j') | content/child/resource_scheduling_filter.cc » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
1 // Copyright 2015 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 "components/scheduler/renderer/deadline_task_runner.h"

6

7 #include <memory>

8

9 #include "base/test/simple_test_tick_clock.h"

10 #include "cc/test/ordered_simple_task_runner.h"

11 #include "testing/gmock/include/gmock/gmock.h"

12 #include "testing/gtest/include/gtest/gtest.h"

13

14 namespace scheduler {

15

16 class DeadlineTaskRunnerTest : public testing::Test {

17 public:

18 DeadlineTaskRunnerTest() {}

19 ~DeadlineTaskRunnerTest() override {}

20

21 void SetUp() override {

22 clock_.reset(new base::SimpleTestTickClock());

23 clock_->Advance(base::TimeDelta::FromMicroseconds(5000));

24 mock_task_runner_ = new cc::OrderedSimpleTaskRunner(clock_.get(), true);

25 deadline_task_runner_.reset(new DeadlineTaskRunner(

26 base::Bind(&DeadlineTaskRunnerTest::TestTask, base::Unretained(this)),

27 mock_task_runner_));

28 run_times_.clear();

29 }

30

31 bool RunUntilIdle() { return mock_task_runner_->RunUntilIdle(); }

32

33 void TestTask() { run_times_.push_back(clock_->NowTicks()); }

34

35 std::unique_ptr<base::SimpleTestTickClock> clock_;

36 scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;

37 std::unique_ptr<DeadlineTaskRunner> deadline_task_runner_;

38 std::vector<base::TimeTicks> run_times_;

39 };

40

41 TEST_F(DeadlineTaskRunnerTest, RunOnce) {

42 base::TimeTicks start_time = clock_->NowTicks();

43 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10);

44 deadline_task_runner_->SetDeadline(FROM_HERE, delay, clock_->NowTicks());

45 RunUntilIdle();

46

47 EXPECT_THAT(run_times_, testing::ElementsAre(start_time + delay));

48 };

49

50 TEST_F(DeadlineTaskRunnerTest, RunTwice) {

51 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(10);

52 base::TimeTicks deadline1 = clock_->NowTicks() + delay1;

53 deadline_task_runner_->SetDeadline(FROM_HERE, delay1, clock_->NowTicks());

54 RunUntilIdle();

55

56 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(100);

57 base::TimeTicks deadline2 = clock_->NowTicks() + delay2;

58 deadline_task_runner_->SetDeadline(FROM_HERE, delay2, clock_->NowTicks());

59 RunUntilIdle();

60

61 EXPECT_THAT(run_times_, testing::ElementsAre(deadline1, deadline2));

62 };

63

64 TEST_F(DeadlineTaskRunnerTest, EarlierDeadlinesTakePrecidence) {

65 base::TimeTicks start_time = clock_->NowTicks();

66 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(1);

67 base::TimeDelta delay10 = base::TimeDelta::FromMilliseconds(10);

68 base::TimeDelta delay100 = base::TimeDelta::FromMilliseconds(100);

69 deadline_task_runner_->SetDeadline(FROM_HERE, delay100, clock_->NowTicks());

70 deadline_task_runner_->SetDeadline(FROM_HERE, delay10, clock_->NowTicks());

71 deadline_task_runner_->SetDeadline(FROM_HERE, delay1, clock_->NowTicks());

72

73 RunUntilIdle();

74

75 EXPECT_THAT(run_times_, testing::ElementsAre(start_time + delay1));

76 };

77

78 TEST_F(DeadlineTaskRunnerTest, LaterDeadlinesIgnored) {

79 base::TimeTicks start_time = clock_->NowTicks();

80 base::TimeDelta delay100 = base::TimeDelta::FromMilliseconds(100);

81 base::TimeDelta delay10000 = base::TimeDelta::FromMilliseconds(10000);

82 deadline_task_runner_->SetDeadline(FROM_HERE, delay100, clock_->NowTicks());

83 deadline_task_runner_->SetDeadline(FROM_HERE, delay10000, clock_->NowTicks());

84

85 RunUntilIdle();

86

87 EXPECT_THAT(run_times_, testing::ElementsAre(start_time + delay100));

88 };

89

90 TEST_F(DeadlineTaskRunnerTest, DeleteDeadlineTaskRunnerAfterPosting) {

91 deadline_task_runner_->SetDeadline(

92 FROM_HERE, base::TimeDelta::FromMilliseconds(10), clock_->NowTicks());

93

94 // Deleting the pending task should cancel it.

95 deadline_task_runner_.reset(nullptr);

96 RunUntilIdle();

97

98 EXPECT_TRUE(run_times_.empty());

99 };

100

101 } // namespace scheduler

OLD	NEW