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 using testing::Mock; |
17 | 17 |
18 namespace scheduler { | 18 namespace scheduler { |
19 | 19 |
20 class MockTimeDomain : public TimeDomain { | 20 class MockTimeDomain : public TimeDomain { |
21 public: | 21 public: |
22 MockTimeDomain() | 22 explicit MockTimeDomain(TimeDomain::Observer* observer) |
23 : now_(base::TimeTicks() + base::TimeDelta::FromSeconds(1)) {} | 23 : TimeDomain(observer), |
| 24 now_(base::TimeTicks() + base::TimeDelta::FromSeconds(1)) {} |
| 25 |
| 26 ~MockTimeDomain() override {} |
24 | 27 |
25 using TimeDomain::NextScheduledRunTime; | 28 using TimeDomain::NextScheduledRunTime; |
26 using TimeDomain::NextScheduledTaskQueue; | 29 using TimeDomain::NextScheduledTaskQueue; |
27 using TimeDomain::ScheduleDelayedWork; | 30 using TimeDomain::ScheduleDelayedWork; |
28 using TimeDomain::UnregisterQueue; | 31 using TimeDomain::UnregisterQueue; |
29 using TimeDomain::UpdateWorkQueues; | 32 using TimeDomain::UpdateWorkQueues; |
| 33 using TimeDomain::RegisterAsUpdatableTaskQueue; |
30 | 34 |
31 // TimeSource implementation: | 35 // TimeSource implementation: |
32 LazyNow CreateLazyNow() override { return LazyNow(now_); } | 36 LazyNow CreateLazyNow() override { return LazyNow(now_); } |
33 | 37 |
34 void AsValueIntoInternal( | 38 void AsValueIntoInternal( |
35 base::trace_event::TracedValue* state) const override {} | 39 base::trace_event::TracedValue* state) const override {} |
36 | 40 |
37 bool MaybeAdvanceTime() override { return false; } | 41 bool MaybeAdvanceTime() override { return false; } |
38 const char* GetName() const override { return "Test"; } | 42 const char* GetName() const override { return "Test"; } |
39 void OnRegisterWithTaskQueueManager( | 43 void OnRegisterWithTaskQueueManager( |
40 TaskQueueManagerDelegate* task_queue_manager_delegate, | 44 TaskQueueManagerDelegate* task_queue_manager_delegate, |
41 base::Closure do_work_closure) override {} | 45 base::Closure do_work_closure) override {} |
42 | 46 |
43 MOCK_METHOD2(RequestWakeup, void(LazyNow* lazy_now, base::TimeDelta delay)); | 47 MOCK_METHOD2(RequestWakeup, void(LazyNow* lazy_now, base::TimeDelta delay)); |
44 | 48 |
45 void SetNow(base::TimeTicks now) { now_ = now; } | 49 void SetNow(base::TimeTicks now) { now_ = now; } |
46 | 50 |
47 base::TimeTicks Now() const { return now_; } | 51 base::TimeTicks Now() const { return now_; } |
48 | 52 |
49 private: | 53 private: |
50 base::TimeTicks now_; | 54 base::TimeTicks now_; |
51 | 55 |
52 ~MockTimeDomain() override {} | |
53 | |
54 DISALLOW_COPY_AND_ASSIGN(MockTimeDomain); | 56 DISALLOW_COPY_AND_ASSIGN(MockTimeDomain); |
55 }; | 57 }; |
56 | 58 |
57 class TimeDomainTest : public testing::Test { | 59 class TimeDomainTest : public testing::Test { |
58 public: | 60 public: |
59 void SetUp() final { | 61 void SetUp() final { |
60 time_domain_ = make_scoped_refptr(new MockTimeDomain()); | 62 time_domain_ = make_scoped_ptr(CreateMockTimeDomain()); |
61 task_queue_ = make_scoped_refptr(new internal::TaskQueueImpl( | 63 task_queue_ = make_scoped_refptr(new internal::TaskQueueImpl( |
62 nullptr, time_domain_, TaskQueue::Spec("test_queue"), "test.category", | 64 nullptr, time_domain_.get(), TaskQueue::Spec("test_queue"), |
63 "test.category")); | 65 "test.category", "test.category")); |
64 } | 66 } |
65 | 67 |
66 scoped_refptr<MockTimeDomain> time_domain_; | 68 virtual MockTimeDomain* CreateMockTimeDomain() { |
| 69 return new MockTimeDomain(nullptr); |
| 70 } |
| 71 |
| 72 scoped_ptr<MockTimeDomain> time_domain_; |
67 scoped_refptr<internal::TaskQueueImpl> task_queue_; | 73 scoped_refptr<internal::TaskQueueImpl> task_queue_; |
68 }; | 74 }; |
69 | 75 |
70 TEST_F(TimeDomainTest, ScheduleDelayedWork) { | 76 TEST_F(TimeDomainTest, ScheduleDelayedWork) { |
71 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10); | 77 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(10); |
72 base::TimeTicks delayed_runtime = time_domain_->Now() + delay; | 78 base::TimeTicks delayed_runtime = time_domain_->Now() + delay; |
73 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, delay)); | 79 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, delay)); |
74 LazyNow lazy_now = time_domain_->CreateLazyNow(); | 80 LazyNow lazy_now = time_domain_->CreateLazyNow(); |
75 time_domain_->ScheduleDelayedWork(task_queue_.get(), | 81 time_domain_->ScheduleDelayedWork(task_queue_.get(), |
76 time_domain_->Now() + delay, &lazy_now); | 82 time_domain_->Now() + delay, &lazy_now); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
108 // RequestWakeup should be called when scheduling earlier tasks. | 114 // RequestWakeup should be called when scheduling earlier tasks. |
109 Mock::VerifyAndClearExpectations(time_domain_.get()); | 115 Mock::VerifyAndClearExpectations(time_domain_.get()); |
110 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, delay4)); | 116 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, delay4)); |
111 time_domain_->ScheduleDelayedWork(task_queue_.get(), | 117 time_domain_->ScheduleDelayedWork(task_queue_.get(), |
112 time_domain_->Now() + delay4, &lazy_now); | 118 time_domain_->Now() + delay4, &lazy_now); |
113 } | 119 } |
114 | 120 |
115 TEST_F(TimeDomainTest, UnregisterQueue) { | 121 TEST_F(TimeDomainTest, UnregisterQueue) { |
116 scoped_refptr<internal::TaskQueueImpl> task_queue2_ = | 122 scoped_refptr<internal::TaskQueueImpl> task_queue2_ = |
117 make_scoped_refptr(new internal::TaskQueueImpl( | 123 make_scoped_refptr(new internal::TaskQueueImpl( |
118 nullptr, time_domain_, TaskQueue::Spec("test_queue2"), | 124 nullptr, time_domain_.get(), TaskQueue::Spec("test_queue2"), |
119 "test.category", "test.category")); | 125 "test.category", "test.category")); |
120 | 126 |
121 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, _)).Times(1); | 127 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, _)).Times(1); |
122 LazyNow lazy_now = time_domain_->CreateLazyNow(); | 128 LazyNow lazy_now = time_domain_->CreateLazyNow(); |
123 time_domain_->ScheduleDelayedWork( | 129 time_domain_->ScheduleDelayedWork( |
124 task_queue_.get(), | 130 task_queue_.get(), |
125 time_domain_->Now() + base::TimeDelta::FromMilliseconds(10), &lazy_now); | 131 time_domain_->Now() + base::TimeDelta::FromMilliseconds(10), &lazy_now); |
126 time_domain_->ScheduleDelayedWork( | 132 time_domain_->ScheduleDelayedWork( |
127 task_queue2_.get(), | 133 task_queue2_.get(), |
128 time_domain_->Now() + base::TimeDelta::FromMilliseconds(100), &lazy_now); | 134 time_domain_->Now() + base::TimeDelta::FromMilliseconds(100), &lazy_now); |
129 | 135 |
130 TaskQueue* next_task_queue; | 136 TaskQueue* next_task_queue; |
131 EXPECT_TRUE(time_domain_->NextScheduledTaskQueue(&next_task_queue)); | 137 EXPECT_TRUE(time_domain_->NextScheduledTaskQueue(&next_task_queue)); |
132 EXPECT_EQ(task_queue_.get(), next_task_queue); | 138 EXPECT_EQ(task_queue_.get(), next_task_queue); |
133 | 139 |
134 time_domain_->UnregisterQueue(task_queue_.get()); | 140 time_domain_->UnregisterQueue(task_queue_.get()); |
135 EXPECT_TRUE(time_domain_->NextScheduledTaskQueue(&next_task_queue)); | 141 EXPECT_TRUE(time_domain_->NextScheduledTaskQueue(&next_task_queue)); |
136 EXPECT_EQ(task_queue2_.get(), next_task_queue); | 142 EXPECT_EQ(task_queue2_.get(), next_task_queue); |
137 | 143 |
138 time_domain_->UnregisterQueue(task_queue2_.get()); | 144 time_domain_->UnregisterQueue(task_queue2_.get()); |
139 EXPECT_FALSE(time_domain_->NextScheduledTaskQueue(&next_task_queue)); | 145 EXPECT_FALSE(time_domain_->NextScheduledTaskQueue(&next_task_queue)); |
140 } | 146 } |
141 | 147 |
142 TEST_F(TimeDomainTest, UpdateWorkQueues) { | 148 TEST_F(TimeDomainTest, UpdateWorkQueues) { |
143 scoped_refptr<MockTimeDomain> dummy_delegate(new MockTimeDomain()); | 149 scoped_ptr<MockTimeDomain> dummy_delegate(new MockTimeDomain(nullptr)); |
144 base::SimpleTestTickClock dummy_time_source; | 150 base::SimpleTestTickClock dummy_time_source; |
145 scoped_refptr<cc::OrderedSimpleTaskRunner> dummy_task_runner( | 151 scoped_refptr<cc::OrderedSimpleTaskRunner> dummy_task_runner( |
146 new cc::OrderedSimpleTaskRunner(&dummy_time_source, false)); | 152 new cc::OrderedSimpleTaskRunner(&dummy_time_source, false)); |
147 TaskQueueManager task_queue_manager( | 153 TaskQueueManager task_queue_manager( |
148 TaskQueueManagerDelegateForTest::Create( | 154 TaskQueueManagerDelegateForTest::Create( |
149 dummy_task_runner, | 155 dummy_task_runner, |
150 make_scoped_ptr(new TestTimeSource(&dummy_time_source))), | 156 make_scoped_ptr(new TestTimeSource(&dummy_time_source))), |
151 "test.scheduler", "test.scheduler", "scheduler.debug"); | 157 "test.scheduler", "test.scheduler", "scheduler.debug"); |
152 scoped_refptr<internal::TaskQueueImpl> dummy_queue = | 158 scoped_refptr<internal::TaskQueueImpl> dummy_queue = |
153 task_queue_manager.NewTaskQueue(TaskQueue::Spec("test_queue")); | 159 task_queue_manager.NewTaskQueue(TaskQueue::Spec("test_queue")); |
(...skipping 15 matching lines...) Expand all Loading... |
169 &lazy_now); | 175 &lazy_now); |
170 | 176 |
171 time_domain_->UpdateWorkQueues(false, nullptr); | 177 time_domain_->UpdateWorkQueues(false, nullptr); |
172 EXPECT_EQ(0UL, dummy_queue->IncomingQueueSizeForTest()); | 178 EXPECT_EQ(0UL, dummy_queue->IncomingQueueSizeForTest()); |
173 | 179 |
174 time_domain_->SetNow(delayed_runtime); | 180 time_domain_->SetNow(delayed_runtime); |
175 time_domain_->UpdateWorkQueues(false, nullptr); | 181 time_domain_->UpdateWorkQueues(false, nullptr); |
176 EXPECT_EQ(1UL, dummy_queue->IncomingQueueSizeForTest()); | 182 EXPECT_EQ(1UL, dummy_queue->IncomingQueueSizeForTest()); |
177 } | 183 } |
178 | 184 |
| 185 namespace { |
| 186 class MockObserver : public TimeDomain::Observer { |
| 187 public: |
| 188 ~MockObserver() override {} |
| 189 |
| 190 MOCK_METHOD0(OnTimeDomainHasImmediateWork, void()); |
| 191 MOCK_METHOD0(OnTimeDomainHasDelayedWork, void()); |
| 192 }; |
| 193 } // namespace |
| 194 |
| 195 class TimeDomainWithObserverTest : public TimeDomainTest { |
| 196 public: |
| 197 MockTimeDomain* CreateMockTimeDomain() override { |
| 198 observer_.reset(new MockObserver()); |
| 199 return new MockTimeDomain(observer_.get()); |
| 200 } |
| 201 |
| 202 scoped_ptr<MockObserver> observer_; |
| 203 }; |
| 204 |
| 205 TEST_F(TimeDomainWithObserverTest, OnTimeDomainHasImmediateWork) { |
| 206 EXPECT_CALL(*observer_, OnTimeDomainHasImmediateWork()); |
| 207 time_domain_->RegisterAsUpdatableTaskQueue(task_queue_.get()); |
| 208 } |
| 209 |
| 210 TEST_F(TimeDomainWithObserverTest, OnTimeDomainHasDelayedWork) { |
| 211 EXPECT_CALL(*observer_, OnTimeDomainHasDelayedWork()); |
| 212 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, _)); |
| 213 LazyNow lazy_now = time_domain_->CreateLazyNow(); |
| 214 time_domain_->ScheduleDelayedWork( |
| 215 task_queue_.get(), |
| 216 time_domain_->Now() + base::TimeDelta::FromMilliseconds(10), &lazy_now); |
| 217 } |
| 218 |
179 } // namespace scheduler | 219 } // namespace scheduler |
OLD | NEW |