OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/scheduler/base/time_domain.h" | 5 #include "components/scheduler/base/time_domain.h" |
6 | 6 |
7 #include "base/test/simple_test_tick_clock.h" | 7 #include "base/test/simple_test_tick_clock.h" |
8 #include "cc/test/ordered_simple_task_runner.h" | 8 #include "cc/test/ordered_simple_task_runner.h" |
9 #include "components/scheduler/base/task_queue_impl.h" | 9 #include "components/scheduler/base/task_queue_impl.h" |
10 #include "components/scheduler/base/task_queue_manager.h" | 10 #include "components/scheduler/base/task_queue_manager.h" |
11 #include "components/scheduler/base/task_queue_manager_delegate_for_test.h" | 11 #include "components/scheduler/base/task_queue_manager_delegate_for_test.h" |
12 #include "components/scheduler/base/test_time_source.h" | 12 #include "components/scheduler/base/test_time_source.h" |
13 #include "testing/gmock/include/gmock/gmock.h" | 13 #include "testing/gmock/include/gmock/gmock.h" |
14 | 14 |
15 using testing::_; | 15 using testing::_; |
| 16 using testing::Mock; |
16 | 17 |
17 namespace scheduler { | 18 namespace scheduler { |
18 | 19 |
19 class MockTimeDomain : public TimeDomain { | 20 class MockTimeDomain : public TimeDomain { |
20 public: | 21 public: |
21 MockTimeDomain() | 22 MockTimeDomain() |
22 : now_(base::TimeTicks() + base::TimeDelta::FromSeconds(1)) {} | 23 : now_(base::TimeTicks() + base::TimeDelta::FromSeconds(1)) {} |
23 | 24 |
24 using TimeDomain::NextScheduledRunTime; | 25 using TimeDomain::NextScheduledRunTime; |
25 using TimeDomain::NextScheduledTaskQueue; | 26 using TimeDomain::NextScheduledTaskQueue; |
26 using TimeDomain::ScheduleDelayedWork; | 27 using TimeDomain::ScheduleDelayedWork; |
27 using TimeDomain::UnregisterQueue; | 28 using TimeDomain::UnregisterQueue; |
28 using TimeDomain::UpdateWorkQueues; | 29 using TimeDomain::UpdateWorkQueues; |
29 | 30 |
30 // TimeSource implementation: | 31 // TimeSource implementation: |
31 LazyNow CreateLazyNow() override { return LazyNow(now_); } | 32 LazyNow CreateLazyNow() override { return LazyNow(now_); } |
32 | 33 |
33 void AsValueIntoInternal( | 34 void AsValueIntoInternal( |
34 base::trace_event::TracedValue* state) const override {} | 35 base::trace_event::TracedValue* state) const override {} |
35 | 36 |
36 bool MaybeAdvanceTime() override { return false; } | 37 bool MaybeAdvanceTime() override { return false; } |
| 38 const char* GetName() const override { return "Test"; } |
| 39 void OnRegisterWithTaskQueueManager( |
| 40 TaskQueueManagerDelegate* task_queue_manager_delegate, |
| 41 base::Closure do_work_closure) override {} |
37 | 42 |
38 const char* GetName() const override { return "Test"; } | 43 MOCK_METHOD2(RequestWakeup, void(LazyNow* lazy_now, base::TimeDelta delay)); |
39 | |
40 MOCK_METHOD1(RequestWakeup, void(base::TimeDelta delay)); | |
41 | 44 |
42 void SetNow(base::TimeTicks now) { now_ = now; } | 45 void SetNow(base::TimeTicks now) { now_ = now; } |
43 | 46 |
44 base::TimeTicks Now() const { return now_; } | 47 base::TimeTicks Now() const { return now_; } |
45 | 48 |
46 private: | 49 private: |
47 base::TimeTicks now_; | 50 base::TimeTicks now_; |
48 | 51 |
49 ~MockTimeDomain() override {} | 52 ~MockTimeDomain() override {} |
50 | 53 |
51 DISALLOW_COPY_AND_ASSIGN(MockTimeDomain); | 54 DISALLOW_COPY_AND_ASSIGN(MockTimeDomain); |
52 }; | 55 }; |
53 | 56 |
54 class TimeDomainTest : public testing::Test { | 57 class TimeDomainTest : public testing::Test { |
55 public: | 58 public: |
56 void SetUp() final { | 59 void SetUp() final { |
57 time_domain_ = make_scoped_refptr(new MockTimeDomain()); | 60 time_domain_ = make_scoped_refptr(new MockTimeDomain()); |
58 task_queue_ = make_scoped_refptr(new internal::TaskQueueImpl( | 61 task_queue_ = make_scoped_refptr(new internal::TaskQueueImpl( |
59 nullptr, time_domain_, TaskQueue::Spec("test_queue"), "test.category", | 62 nullptr, time_domain_, TaskQueue::Spec("test_queue"), "test.category", |
60 "test.category")); | 63 "test.category")); |
61 } | 64 } |
62 | 65 |
63 scoped_refptr<MockTimeDomain> time_domain_; | 66 scoped_refptr<MockTimeDomain> time_domain_; |
64 scoped_refptr<internal::TaskQueueImpl> task_queue_; | 67 scoped_refptr<internal::TaskQueueImpl> task_queue_; |
65 }; | 68 }; |
66 | 69 |
67 TEST_F(TimeDomainTest, ScheduleDelayedWork) { | 70 TEST_F(TimeDomainTest, ScheduleDelayedWork) { |
68 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10); | 71 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10); |
69 base::TimeTicks delayed_runtime = time_domain_->Now() + delay; | 72 base::TimeTicks delayed_runtime = time_domain_->Now() + delay; |
70 EXPECT_CALL(*time_domain_.get(), RequestWakeup(delay)); | 73 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, delay)); |
71 LazyNow lazy_now = time_domain_->CreateLazyNow(); | 74 LazyNow lazy_now = time_domain_->CreateLazyNow(); |
72 time_domain_->ScheduleDelayedWork(task_queue_.get(), | 75 time_domain_->ScheduleDelayedWork(task_queue_.get(), |
73 time_domain_->Now() + delay, &lazy_now); | 76 time_domain_->Now() + delay, &lazy_now); |
74 | 77 |
75 base::TimeTicks next_scheduled_runtime; | 78 base::TimeTicks next_scheduled_runtime; |
76 EXPECT_TRUE(time_domain_->NextScheduledRunTime(&next_scheduled_runtime)); | 79 EXPECT_TRUE(time_domain_->NextScheduledRunTime(&next_scheduled_runtime)); |
77 EXPECT_EQ(delayed_runtime, next_scheduled_runtime); | 80 EXPECT_EQ(delayed_runtime, next_scheduled_runtime); |
78 | 81 |
79 TaskQueue* next_task_queue; | 82 TaskQueue* next_task_queue; |
80 EXPECT_TRUE(time_domain_->NextScheduledTaskQueue(&next_task_queue)); | 83 EXPECT_TRUE(time_domain_->NextScheduledTaskQueue(&next_task_queue)); |
81 EXPECT_EQ(task_queue_.get(), next_task_queue); | 84 EXPECT_EQ(task_queue_.get(), next_task_queue); |
82 } | 85 } |
83 | 86 |
| 87 TEST_F(TimeDomainTest, RequestWakeup_OnlyCalledForEarlierTasks) { |
| 88 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(10); |
| 89 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(20); |
| 90 base::TimeDelta delay3 = base::TimeDelta::FromMilliseconds(30); |
| 91 base::TimeDelta delay4 = base::TimeDelta::FromMilliseconds(1); |
| 92 |
| 93 // RequestWakeup should always be called if there are no other wakeups. |
| 94 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, delay1)); |
| 95 LazyNow lazy_now = time_domain_->CreateLazyNow(); |
| 96 time_domain_->ScheduleDelayedWork(task_queue_.get(), |
| 97 time_domain_->Now() + delay1, &lazy_now); |
| 98 |
| 99 Mock::VerifyAndClearExpectations(time_domain_.get()); |
| 100 |
| 101 // RequestWakeup should not be called when scheduling later tasks. |
| 102 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, _)).Times(0); |
| 103 time_domain_->ScheduleDelayedWork(task_queue_.get(), |
| 104 time_domain_->Now() + delay2, &lazy_now); |
| 105 time_domain_->ScheduleDelayedWork(task_queue_.get(), |
| 106 time_domain_->Now() + delay3, &lazy_now); |
| 107 |
| 108 // RequestWakeup should be called when scheduling earlier tasks. |
| 109 Mock::VerifyAndClearExpectations(time_domain_.get()); |
| 110 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, delay4)); |
| 111 time_domain_->ScheduleDelayedWork(task_queue_.get(), |
| 112 time_domain_->Now() + delay4, &lazy_now); |
| 113 } |
| 114 |
84 TEST_F(TimeDomainTest, UnregisterQueue) { | 115 TEST_F(TimeDomainTest, UnregisterQueue) { |
85 scoped_refptr<internal::TaskQueueImpl> task_queue2_ = | 116 scoped_refptr<internal::TaskQueueImpl> task_queue2_ = |
86 make_scoped_refptr(new internal::TaskQueueImpl( | 117 make_scoped_refptr(new internal::TaskQueueImpl( |
87 nullptr, time_domain_, TaskQueue::Spec("test_queue2"), | 118 nullptr, time_domain_, TaskQueue::Spec("test_queue2"), |
88 "test.category", "test.category")); | 119 "test.category", "test.category")); |
89 | 120 |
90 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_)).Times(2); | 121 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, _)).Times(1); |
91 LazyNow lazy_now = time_domain_->CreateLazyNow(); | 122 LazyNow lazy_now = time_domain_->CreateLazyNow(); |
92 time_domain_->ScheduleDelayedWork( | 123 time_domain_->ScheduleDelayedWork( |
93 task_queue_.get(), | 124 task_queue_.get(), |
94 time_domain_->Now() + base::TimeDelta::FromMilliseconds(10), &lazy_now); | 125 time_domain_->Now() + base::TimeDelta::FromMilliseconds(10), &lazy_now); |
95 time_domain_->ScheduleDelayedWork( | 126 time_domain_->ScheduleDelayedWork( |
96 task_queue2_.get(), | 127 task_queue2_.get(), |
97 time_domain_->Now() + base::TimeDelta::FromMilliseconds(100), &lazy_now); | 128 time_domain_->Now() + base::TimeDelta::FromMilliseconds(100), &lazy_now); |
98 | 129 |
99 TaskQueue* next_task_queue; | 130 TaskQueue* next_task_queue; |
100 EXPECT_TRUE(time_domain_->NextScheduledTaskQueue(&next_task_queue)); | 131 EXPECT_TRUE(time_domain_->NextScheduledTaskQueue(&next_task_queue)); |
(...skipping 24 matching lines...) Expand all Loading... |
125 // next time MoveReadyDelayedTasksToIncomingQueue is called, the task will | 156 // next time MoveReadyDelayedTasksToIncomingQueue is called, the task will |
126 // get moved onto the incomming queue. | 157 // get moved onto the incomming queue. |
127 base::TimeDelta dummy_delay = base::TimeDelta::FromMilliseconds(10); | 158 base::TimeDelta dummy_delay = base::TimeDelta::FromMilliseconds(10); |
128 dummy_queue->PostDelayedTask(FROM_HERE, base::Closure(), dummy_delay); | 159 dummy_queue->PostDelayedTask(FROM_HERE, base::Closure(), dummy_delay); |
129 dummy_time_source.Advance(dummy_delay); | 160 dummy_time_source.Advance(dummy_delay); |
130 | 161 |
131 // Now we can test that ScheduleDelayedWork triggers calls to | 162 // Now we can test that ScheduleDelayedWork triggers calls to |
132 // MoveReadyDelayedTasksToIncomingQueue as expected. | 163 // MoveReadyDelayedTasksToIncomingQueue as expected. |
133 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(50); | 164 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(50); |
134 base::TimeTicks delayed_runtime = time_domain_->Now() + delay; | 165 base::TimeTicks delayed_runtime = time_domain_->Now() + delay; |
135 EXPECT_CALL(*time_domain_.get(), RequestWakeup(delay)); | 166 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, delay)); |
136 LazyNow lazy_now = time_domain_->CreateLazyNow(); | 167 LazyNow lazy_now = time_domain_->CreateLazyNow(); |
137 time_domain_->ScheduleDelayedWork(dummy_queue.get(), delayed_runtime, | 168 time_domain_->ScheduleDelayedWork(dummy_queue.get(), delayed_runtime, |
138 &lazy_now); | 169 &lazy_now); |
139 | 170 |
140 time_domain_->UpdateWorkQueues(false, nullptr); | 171 time_domain_->UpdateWorkQueues(false, nullptr); |
141 EXPECT_EQ(0UL, dummy_queue->IncomingQueueSizeForTest()); | 172 EXPECT_EQ(0UL, dummy_queue->IncomingQueueSizeForTest()); |
142 | 173 |
143 time_domain_->SetNow(delayed_runtime); | 174 time_domain_->SetNow(delayed_runtime); |
144 time_domain_->UpdateWorkQueues(false, nullptr); | 175 time_domain_->UpdateWorkQueues(false, nullptr); |
145 EXPECT_EQ(1UL, dummy_queue->IncomingQueueSizeForTest()); | 176 EXPECT_EQ(1UL, dummy_queue->IncomingQueueSizeForTest()); |
146 } | 177 } |
147 | 178 |
148 } // namespace scheduler | 179 } // namespace scheduler |
OLD | NEW |