Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(24)

Side by Side Diff: third_party/WebKit/Source/platform/scheduler/base/time_domain_unittest.cc

Issue 2258713004: Make tasks cancellable inside the blink scheduler. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Various comment nits addressed 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
OLDNEW
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 "platform/scheduler/base/time_domain.h" 5 #include "platform/scheduler/base/time_domain.h"
6 6
7 #include "base/macros.h" 7 #include "base/macros.h"
8 #include "base/memory/ptr_util.h" 8 #include "base/memory/ptr_util.h"
9 #include "base/test/simple_test_tick_clock.h" 9 #include "base/test/simple_test_tick_clock.h"
10 #include "cc/test/ordered_simple_task_runner.h" 10 #include "cc/test/ordered_simple_task_runner.h"
(...skipping 12 matching lines...) Expand all
23 namespace scheduler { 23 namespace scheduler {
24 24
25 class MockTimeDomain : public TimeDomain { 25 class MockTimeDomain : public TimeDomain {
26 public: 26 public:
27 explicit MockTimeDomain(TimeDomain::Observer* observer) 27 explicit MockTimeDomain(TimeDomain::Observer* observer)
28 : TimeDomain(observer), 28 : TimeDomain(observer),
29 now_(base::TimeTicks() + base::TimeDelta::FromSeconds(1)) {} 29 now_(base::TimeTicks() + base::TimeDelta::FromSeconds(1)) {}
30 30
31 ~MockTimeDomain() override {} 31 ~MockTimeDomain() override {}
32 32
33 using TimeDomain::CancelDelayedWork;
33 using TimeDomain::ClearExpiredWakeups; 34 using TimeDomain::ClearExpiredWakeups;
34 using TimeDomain::NextScheduledRunTime; 35 using TimeDomain::NextScheduledRunTime;
35 using TimeDomain::NextScheduledTaskQueue; 36 using TimeDomain::NextScheduledTaskQueue;
36 using TimeDomain::ScheduleDelayedWork; 37 using TimeDomain::ScheduleDelayedWork;
37 using TimeDomain::UnregisterQueue; 38 using TimeDomain::UnregisterQueue;
38 using TimeDomain::UpdateWorkQueues; 39 using TimeDomain::UpdateWorkQueues;
39 using TimeDomain::RegisterAsUpdatableTaskQueue; 40 using TimeDomain::RegisterAsUpdatableTaskQueue;
40 41
41 // TimeSource implementation: 42 // TimeSource implementation:
42 LazyNow CreateLazyNow() const override { return LazyNow(now_); } 43 LazyNow CreateLazyNow() const override { return LazyNow(now_); }
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after
189 time_domain_->ClearExpiredWakeups(); 190 time_domain_->ClearExpiredWakeups();
190 191
191 ASSERT_TRUE(time_domain_->NextScheduledRunTime(&next_run_time)); 192 ASSERT_TRUE(time_domain_->NextScheduledRunTime(&next_run_time));
192 EXPECT_EQ(run_time2, next_run_time); 193 EXPECT_EQ(run_time2, next_run_time);
193 194
194 time_domain_->SetNow(run_time2); 195 time_domain_->SetNow(run_time2);
195 time_domain_->ClearExpiredWakeups(); 196 time_domain_->ClearExpiredWakeups();
196 ASSERT_FALSE(time_domain_->NextScheduledRunTime(&next_run_time)); 197 ASSERT_FALSE(time_domain_->NextScheduledRunTime(&next_run_time));
197 } 198 }
198 199
200 TEST_F(TimeDomainTest, CancelDelayedWork) {
201 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(50);
202 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, delay));
203 base::TimeTicks now = time_domain_->Now();
204 base::TimeTicks delayed_runtime = now + delay;
205 time_domain_->ScheduleDelayedWork(task_queue_.get(), delayed_runtime, now);
206
207 base::TimeTicks next_run_time;
208 ASSERT_TRUE(time_domain_->NextScheduledRunTime(&next_run_time));
209 EXPECT_EQ(delayed_runtime, next_run_time);
210
211 time_domain_->CancelDelayedWork(task_queue_.get(), delayed_runtime);
212 EXPECT_FALSE(time_domain_->NextScheduledRunTime(&next_run_time));
213 }
214
215 TEST_F(TimeDomainTest, CancelDelayedWorkTaskQueueDoesntMatch) {
216 base::TimeDelta delay = base::TimeDelta::FromMilliseconds(50);
217 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, delay));
218 base::TimeTicks now = time_domain_->Now();
219 base::TimeTicks delayed_runtime = now + delay;
220 time_domain_->ScheduleDelayedWork(task_queue_.get(), delayed_runtime, now);
221
222 base::TimeTicks next_run_time;
223 ASSERT_TRUE(time_domain_->NextScheduledRunTime(&next_run_time));
224 EXPECT_EQ(delayed_runtime, next_run_time);
225
226 time_domain_->CancelDelayedWork(nullptr, delayed_runtime);
227 ASSERT_TRUE(time_domain_->NextScheduledRunTime(&next_run_time));
228 EXPECT_EQ(delayed_runtime, next_run_time);
229 }
230
231 TEST_F(TimeDomainTest, CancelDelayedWorkTwoWakeUpsCancelFirst) {
232 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50);
233 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(150);
234 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, delay1));
235 base::TimeTicks now = time_domain_->Now();
236 base::TimeTicks delayed_runtime1 = now + delay1;
237 base::TimeTicks delayed_runtime2 = now + delay2;
238 time_domain_->ScheduleDelayedWork(task_queue_.get(), delayed_runtime1, now);
239 time_domain_->ScheduleDelayedWork(task_queue_.get(), delayed_runtime2, now);
240
241 base::TimeTicks next_run_time;
242 ASSERT_TRUE(time_domain_->NextScheduledRunTime(&next_run_time));
243 EXPECT_EQ(delayed_runtime1, next_run_time);
244 Mock::VerifyAndClearExpectations(time_domain_.get());
245
246 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, delay2));
247 time_domain_->CancelDelayedWork(task_queue_.get(), delayed_runtime1);
248 ASSERT_TRUE(time_domain_->NextScheduledRunTime(&next_run_time));
249 EXPECT_EQ(delayed_runtime2, next_run_time);
250 }
251
252 TEST_F(TimeDomainTest, CancelDelayedWorkTwoWakeUpsCancelSecond) {
253 base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(50);
254 base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(150);
255 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, delay1));
256 base::TimeTicks now = time_domain_->Now();
257 base::TimeTicks delayed_runtime1 = now + delay1;
258 base::TimeTicks delayed_runtime2 = now + delay2;
259 time_domain_->ScheduleDelayedWork(task_queue_.get(), delayed_runtime1, now);
260 time_domain_->ScheduleDelayedWork(task_queue_.get(), delayed_runtime2, now);
261
262 base::TimeTicks next_run_time;
263 ASSERT_TRUE(time_domain_->NextScheduledRunTime(&next_run_time));
264 EXPECT_EQ(delayed_runtime1, next_run_time);
265 Mock::VerifyAndClearExpectations(time_domain_.get());
266
267 time_domain_->CancelDelayedWork(task_queue_.get(), delayed_runtime2);
268 ASSERT_TRUE(time_domain_->NextScheduledRunTime(&next_run_time));
269 EXPECT_EQ(delayed_runtime1, next_run_time);
270
271 time_domain_->SetNow(delayed_runtime1);
272 LazyNow lazy_now = time_domain_->CreateLazyNow();
273 time_domain_->UpdateWorkQueues(false, nullptr, lazy_now);
274 ASSERT_FALSE(time_domain_->NextScheduledRunTime(&next_run_time));
275 }
276
199 namespace { 277 namespace {
200 class MockObserver : public TimeDomain::Observer { 278 class MockObserver : public TimeDomain::Observer {
201 public: 279 public:
202 ~MockObserver() override {} 280 ~MockObserver() override {}
203 281
204 MOCK_METHOD0(OnTimeDomainHasImmediateWork, void()); 282 MOCK_METHOD0(OnTimeDomainHasImmediateWork, void());
205 MOCK_METHOD0(OnTimeDomainHasDelayedWork, void()); 283 MOCK_METHOD0(OnTimeDomainHasDelayedWork, void());
206 }; 284 };
207 } // namespace 285 } // namespace
208 286
(...skipping 15 matching lines...) Expand all
224 TEST_F(TimeDomainWithObserverTest, OnTimeDomainHasDelayedWork) { 302 TEST_F(TimeDomainWithObserverTest, OnTimeDomainHasDelayedWork) {
225 EXPECT_CALL(*observer_, OnTimeDomainHasDelayedWork()); 303 EXPECT_CALL(*observer_, OnTimeDomainHasDelayedWork());
226 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, _)); 304 EXPECT_CALL(*time_domain_.get(), RequestWakeup(_, _));
227 base::TimeTicks now = time_domain_->Now(); 305 base::TimeTicks now = time_domain_->Now();
228 time_domain_->ScheduleDelayedWork( 306 time_domain_->ScheduleDelayedWork(
229 task_queue_.get(), now + base::TimeDelta::FromMilliseconds(10), now); 307 task_queue_.get(), now + base::TimeDelta::FromMilliseconds(10), now);
230 } 308 }
231 309
232 } // namespace scheduler 310 } // namespace scheduler
233 } // namespace blink 311 } // namespace blink
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698