OLD | NEW |
1 // Copyright 2011 The Chromium Authors. All rights reserved. | 1 // Copyright 2011 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 "cc/scheduler/scheduler.h" | 5 #include "cc/scheduler/scheduler.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/logging.h" | 10 #include "base/logging.h" |
(...skipping 152 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
163 client.Reset(); | 163 client.Reset(); |
164 | 164 |
165 // FinishCommit should commit | 165 // FinishCommit should commit |
166 scheduler->FinishCommit(); | 166 scheduler->FinishCommit(); |
167 EXPECT_ACTION("ScheduledActionCommit", client, 0, 2); | 167 EXPECT_ACTION("ScheduledActionCommit", client, 0, 2); |
168 EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2); | 168 EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2); |
169 EXPECT_TRUE(client.needs_begin_frame()); | 169 EXPECT_TRUE(client.needs_begin_frame()); |
170 client.Reset(); | 170 client.Reset(); |
171 | 171 |
172 // BeginFrame should draw. | 172 // BeginFrame should draw. |
173 scheduler->BeginFrame(base::TimeTicks::Now()); | 173 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
174 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2); | 174 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2); |
175 EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2); | 175 EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2); |
176 EXPECT_FALSE(client.needs_begin_frame()); | 176 EXPECT_FALSE(client.needs_begin_frame()); |
177 client.Reset(); | 177 client.Reset(); |
178 } | 178 } |
179 | 179 |
180 TEST(SchedulerTest, RequestCommitAfterBeginFrameSentToMainThread) { | 180 TEST(SchedulerTest, RequestCommitAfterBeginFrameSentToMainThread) { |
181 FakeSchedulerClient client; | 181 FakeSchedulerClient client; |
182 SchedulerSettings default_scheduler_settings; | 182 SchedulerSettings default_scheduler_settings; |
183 Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings); | 183 Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings); |
(...skipping 17 matching lines...) Expand all Loading... |
201 client.Reset(); | 201 client.Reset(); |
202 | 202 |
203 // Since another commit is needed, FinishCommit should commit, | 203 // Since another commit is needed, FinishCommit should commit, |
204 // then begin another frame. | 204 // then begin another frame. |
205 scheduler->FinishCommit(); | 205 scheduler->FinishCommit(); |
206 EXPECT_ACTION("ScheduledActionCommit", client, 0, 2); | 206 EXPECT_ACTION("ScheduledActionCommit", client, 0, 2); |
207 EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2); | 207 EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2); |
208 client.Reset(); | 208 client.Reset(); |
209 | 209 |
210 // Tick should draw but then begin another frame. | 210 // Tick should draw but then begin another frame. |
211 scheduler->BeginFrame(base::TimeTicks::Now()); | 211 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
212 EXPECT_TRUE(client.needs_begin_frame()); | 212 EXPECT_TRUE(client.needs_begin_frame()); |
213 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2); | 213 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2); |
214 EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 1, 2); | 214 EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 1, 2); |
215 client.Reset(); | 215 client.Reset(); |
216 | 216 |
217 // Go back to quiescent state and verify we no longer request BeginFrames. | 217 // Go back to quiescent state and verify we no longer request BeginFrames. |
218 scheduler->FinishCommit(); | 218 scheduler->FinishCommit(); |
219 scheduler->BeginFrame(base::TimeTicks::Now()); | 219 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
220 EXPECT_FALSE(client.needs_begin_frame()); | 220 EXPECT_FALSE(client.needs_begin_frame()); |
221 } | 221 } |
222 | 222 |
223 TEST(SchedulerTest, TextureAcquisitionCausesCommitInsteadOfDraw) { | 223 TEST(SchedulerTest, TextureAcquisitionCausesCommitInsteadOfDraw) { |
224 FakeSchedulerClient client; | 224 FakeSchedulerClient client; |
225 SchedulerSettings default_scheduler_settings; | 225 SchedulerSettings default_scheduler_settings; |
226 Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings); | 226 Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings); |
227 scheduler->SetCanStart(); | 227 scheduler->SetCanStart(); |
228 scheduler->SetVisible(true); | 228 scheduler->SetVisible(true); |
229 scheduler->SetCanDraw(true); | 229 scheduler->SetCanDraw(true); |
230 EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client); | 230 EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client); |
231 | 231 |
232 client.Reset(); | 232 client.Reset(); |
233 scheduler->DidCreateAndInitializeOutputSurface(); | 233 scheduler->DidCreateAndInitializeOutputSurface(); |
234 scheduler->SetNeedsRedraw(); | 234 scheduler->SetNeedsRedraw(); |
235 EXPECT_TRUE(scheduler->RedrawPending()); | 235 EXPECT_TRUE(scheduler->RedrawPending()); |
236 EXPECT_SINGLE_ACTION("SetNeedsBeginFrameOnImplThread", client); | 236 EXPECT_SINGLE_ACTION("SetNeedsBeginFrameOnImplThread", client); |
237 EXPECT_TRUE(client.needs_begin_frame()); | 237 EXPECT_TRUE(client.needs_begin_frame()); |
238 | 238 |
239 client.Reset(); | 239 client.Reset(); |
240 scheduler->BeginFrame(base::TimeTicks::Now()); | 240 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
241 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2); | 241 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2); |
242 EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2); | 242 EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2); |
243 EXPECT_FALSE(scheduler->RedrawPending()); | 243 EXPECT_FALSE(scheduler->RedrawPending()); |
244 EXPECT_FALSE(client.needs_begin_frame()); | 244 EXPECT_FALSE(client.needs_begin_frame()); |
245 | 245 |
246 client.Reset(); | 246 client.Reset(); |
247 scheduler->SetMainThreadNeedsLayerTextures(); | 247 scheduler->SetMainThreadNeedsLayerTextures(); |
248 EXPECT_ACTION("ScheduledActionAcquireLayerTexturesForMainThread", | 248 EXPECT_ACTION("ScheduledActionAcquireLayerTexturesForMainThread", |
249 client, | 249 client, |
250 0, | 250 0, |
251 3); | 251 3); |
252 // A commit was started by SetMainThreadNeedsLayerTextures(). | 252 // A commit was started by SetMainThreadNeedsLayerTextures(). |
253 EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 1, 3); | 253 EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 1, 3); |
254 EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 2, 3); | 254 EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 2, 3); |
255 | 255 |
256 // We should request a BeginFrame in anticipation of a draw. | 256 // We should request a BeginFrame in anticipation of a draw. |
257 client.Reset(); | 257 client.Reset(); |
258 scheduler->SetNeedsRedraw(); | 258 scheduler->SetNeedsRedraw(); |
259 EXPECT_TRUE(scheduler->RedrawPending()); | 259 EXPECT_TRUE(scheduler->RedrawPending()); |
260 EXPECT_TRUE(client.needs_begin_frame()); | 260 EXPECT_TRUE(client.needs_begin_frame()); |
261 | 261 |
262 // No draw happens since the textures are acquired by the main thread. | 262 // No draw happens since the textures are acquired by the main thread. |
263 client.Reset(); | 263 client.Reset(); |
264 scheduler->BeginFrame(base::TimeTicks::Now()); | 264 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
265 EXPECT_SINGLE_ACTION("SetNeedsBeginFrameOnImplThread", client); | 265 EXPECT_SINGLE_ACTION("SetNeedsBeginFrameOnImplThread", client); |
266 EXPECT_TRUE(scheduler->RedrawPending()); | 266 EXPECT_TRUE(scheduler->RedrawPending()); |
267 EXPECT_TRUE(client.needs_begin_frame()); | 267 EXPECT_TRUE(client.needs_begin_frame()); |
268 | 268 |
269 // Commit will release the texture. | 269 // Commit will release the texture. |
270 client.Reset(); | 270 client.Reset(); |
271 scheduler->FinishCommit(); | 271 scheduler->FinishCommit(); |
272 EXPECT_SINGLE_ACTION("ScheduledActionCommit", client); | 272 EXPECT_SINGLE_ACTION("ScheduledActionCommit", client); |
273 EXPECT_TRUE(scheduler->RedrawPending()); | 273 EXPECT_TRUE(scheduler->RedrawPending()); |
274 EXPECT_TRUE(client.needs_begin_frame()); | 274 EXPECT_TRUE(client.needs_begin_frame()); |
275 | 275 |
276 // Now we can draw again after the commit happens. | 276 // Now we can draw again after the commit happens. |
277 client.Reset(); | 277 client.Reset(); |
278 scheduler->BeginFrame(base::TimeTicks::Now()); | 278 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
279 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2); | 279 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2); |
280 EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2); | 280 EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2); |
281 EXPECT_FALSE(scheduler->RedrawPending()); | 281 EXPECT_FALSE(scheduler->RedrawPending()); |
282 EXPECT_FALSE(client.needs_begin_frame()); | 282 EXPECT_FALSE(client.needs_begin_frame()); |
283 client.Reset(); | 283 client.Reset(); |
284 } | 284 } |
285 | 285 |
286 TEST(SchedulerTest, TextureAcquisitionCollision) { | 286 TEST(SchedulerTest, TextureAcquisitionCollision) { |
287 FakeSchedulerClient client; | 287 FakeSchedulerClient client; |
288 SchedulerSettings default_scheduler_settings; | 288 SchedulerSettings default_scheduler_settings; |
(...skipping 27 matching lines...) Expand all Loading... |
316 EXPECT_TRUE(client.needs_begin_frame()); | 316 EXPECT_TRUE(client.needs_begin_frame()); |
317 client.Reset(); | 317 client.Reset(); |
318 | 318 |
319 // Between commit and draw, texture acquisition for main thread delayed, | 319 // Between commit and draw, texture acquisition for main thread delayed, |
320 // and main thread blocks. | 320 // and main thread blocks. |
321 scheduler->SetMainThreadNeedsLayerTextures(); | 321 scheduler->SetMainThreadNeedsLayerTextures(); |
322 EXPECT_EQ(0, client.num_actions_()); | 322 EXPECT_EQ(0, client.num_actions_()); |
323 client.Reset(); | 323 client.Reset(); |
324 | 324 |
325 // Once compositor draw complete, the delayed texture acquisition fires. | 325 // Once compositor draw complete, the delayed texture acquisition fires. |
326 scheduler->BeginFrame(base::TimeTicks::Now()); | 326 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
327 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 3); | 327 EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 3); |
328 EXPECT_ACTION("ScheduledActionAcquireLayerTexturesForMainThread", | 328 EXPECT_ACTION("ScheduledActionAcquireLayerTexturesForMainThread", |
329 client, | 329 client, |
330 1, | 330 1, |
331 3); | 331 3); |
332 EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 2, 3); | 332 EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 2, 3); |
333 client.Reset(); | 333 client.Reset(); |
334 } | 334 } |
335 | 335 |
336 TEST(SchedulerTest, VisibilitySwitchWithTextureAcquisition) { | 336 TEST(SchedulerTest, VisibilitySwitchWithTextureAcquisition) { |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
397 scheduler->SetCanStart(); | 397 scheduler->SetCanStart(); |
398 scheduler->SetVisible(true); | 398 scheduler->SetVisible(true); |
399 scheduler->SetCanDraw(true); | 399 scheduler->SetCanDraw(true); |
400 scheduler->DidCreateAndInitializeOutputSurface(); | 400 scheduler->DidCreateAndInitializeOutputSurface(); |
401 | 401 |
402 scheduler->SetNeedsRedraw(); | 402 scheduler->SetNeedsRedraw(); |
403 EXPECT_TRUE(scheduler->RedrawPending()); | 403 EXPECT_TRUE(scheduler->RedrawPending()); |
404 EXPECT_TRUE(client.needs_begin_frame()); | 404 EXPECT_TRUE(client.needs_begin_frame()); |
405 EXPECT_EQ(0, client.num_draws()); | 405 EXPECT_EQ(0, client.num_draws()); |
406 | 406 |
407 scheduler->BeginFrame(base::TimeTicks::Now()); | 407 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
408 EXPECT_EQ(1, client.num_draws()); | 408 EXPECT_EQ(1, client.num_draws()); |
409 EXPECT_TRUE(scheduler->RedrawPending()); | 409 EXPECT_TRUE(scheduler->RedrawPending()); |
410 EXPECT_TRUE(client.needs_begin_frame()); | 410 EXPECT_TRUE(client.needs_begin_frame()); |
411 | 411 |
412 scheduler->BeginFrame(base::TimeTicks::Now()); | 412 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
413 EXPECT_EQ(2, client.num_draws()); | 413 EXPECT_EQ(2, client.num_draws()); |
414 EXPECT_FALSE(scheduler->RedrawPending()); | 414 EXPECT_FALSE(scheduler->RedrawPending()); |
415 EXPECT_FALSE(client.needs_begin_frame()); | 415 EXPECT_FALSE(client.needs_begin_frame()); |
416 } | 416 } |
417 | 417 |
418 // Test that requesting redraw inside a failed draw doesn't lose the request. | 418 // Test that requesting redraw inside a failed draw doesn't lose the request. |
419 TEST(SchedulerTest, RequestRedrawInsideFailedDraw) { | 419 TEST(SchedulerTest, RequestRedrawInsideFailedDraw) { |
420 SchedulerClientThatsetNeedsDrawInsideDraw client; | 420 SchedulerClientThatsetNeedsDrawInsideDraw client; |
421 SchedulerSettings default_scheduler_settings; | 421 SchedulerSettings default_scheduler_settings; |
422 Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings); | 422 Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings); |
423 scheduler->SetCanStart(); | 423 scheduler->SetCanStart(); |
424 scheduler->SetVisible(true); | 424 scheduler->SetVisible(true); |
425 scheduler->SetCanDraw(true); | 425 scheduler->SetCanDraw(true); |
426 scheduler->DidCreateAndInitializeOutputSurface(); | 426 scheduler->DidCreateAndInitializeOutputSurface(); |
427 | 427 |
428 client.SetDrawWillHappen(false); | 428 client.SetDrawWillHappen(false); |
429 | 429 |
430 scheduler->SetNeedsRedraw(); | 430 scheduler->SetNeedsRedraw(); |
431 EXPECT_TRUE(scheduler->RedrawPending()); | 431 EXPECT_TRUE(scheduler->RedrawPending()); |
432 EXPECT_TRUE(client.needs_begin_frame()); | 432 EXPECT_TRUE(client.needs_begin_frame()); |
433 EXPECT_EQ(0, client.num_draws()); | 433 EXPECT_EQ(0, client.num_draws()); |
434 | 434 |
435 // Fail the draw. | 435 // Fail the draw. |
436 scheduler->BeginFrame(base::TimeTicks::Now()); | 436 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
437 EXPECT_EQ(1, client.num_draws()); | 437 EXPECT_EQ(1, client.num_draws()); |
438 | 438 |
439 // We have a commit pending and the draw failed, and we didn't lose the redraw | 439 // We have a commit pending and the draw failed, and we didn't lose the redraw |
440 // request. | 440 // request. |
441 EXPECT_TRUE(scheduler->CommitPending()); | 441 EXPECT_TRUE(scheduler->CommitPending()); |
442 EXPECT_TRUE(scheduler->RedrawPending()); | 442 EXPECT_TRUE(scheduler->RedrawPending()); |
443 EXPECT_TRUE(client.needs_begin_frame()); | 443 EXPECT_TRUE(client.needs_begin_frame()); |
444 | 444 |
445 // Fail the draw again. | 445 // Fail the draw again. |
446 scheduler->BeginFrame(base::TimeTicks::Now()); | 446 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
447 EXPECT_EQ(2, client.num_draws()); | 447 EXPECT_EQ(2, client.num_draws()); |
448 EXPECT_TRUE(scheduler->CommitPending()); | 448 EXPECT_TRUE(scheduler->CommitPending()); |
449 EXPECT_TRUE(scheduler->RedrawPending()); | 449 EXPECT_TRUE(scheduler->RedrawPending()); |
450 EXPECT_TRUE(client.needs_begin_frame()); | 450 EXPECT_TRUE(client.needs_begin_frame()); |
451 | 451 |
452 // Draw successfully. | 452 // Draw successfully. |
453 client.SetDrawWillHappen(true); | 453 client.SetDrawWillHappen(true); |
454 scheduler->BeginFrame(base::TimeTicks::Now()); | 454 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
455 EXPECT_EQ(3, client.num_draws()); | 455 EXPECT_EQ(3, client.num_draws()); |
456 EXPECT_TRUE(scheduler->CommitPending()); | 456 EXPECT_TRUE(scheduler->CommitPending()); |
457 EXPECT_FALSE(scheduler->RedrawPending()); | 457 EXPECT_FALSE(scheduler->RedrawPending()); |
458 EXPECT_TRUE(client.needs_begin_frame()); | 458 EXPECT_TRUE(client.needs_begin_frame()); |
459 } | 459 } |
460 | 460 |
461 class SchedulerClientThatsetNeedsCommitInsideDraw : public FakeSchedulerClient { | 461 class SchedulerClientThatsetNeedsCommitInsideDraw : public FakeSchedulerClient { |
462 public: | 462 public: |
463 virtual void ScheduledActionSendBeginFrameToMainThread() OVERRIDE {} | 463 virtual void ScheduledActionSendBeginFrameToMainThread() OVERRIDE {} |
464 virtual ScheduledActionDrawAndSwapResult | 464 virtual ScheduledActionDrawAndSwapResult |
(...skipping 24 matching lines...) Expand all Loading... |
489 scheduler->SetCanStart(); | 489 scheduler->SetCanStart(); |
490 scheduler->SetVisible(true); | 490 scheduler->SetVisible(true); |
491 scheduler->SetCanDraw(true); | 491 scheduler->SetCanDraw(true); |
492 scheduler->DidCreateAndInitializeOutputSurface(); | 492 scheduler->DidCreateAndInitializeOutputSurface(); |
493 | 493 |
494 scheduler->SetNeedsRedraw(); | 494 scheduler->SetNeedsRedraw(); |
495 EXPECT_TRUE(scheduler->RedrawPending()); | 495 EXPECT_TRUE(scheduler->RedrawPending()); |
496 EXPECT_EQ(0, client.num_draws()); | 496 EXPECT_EQ(0, client.num_draws()); |
497 EXPECT_TRUE(client.needs_begin_frame()); | 497 EXPECT_TRUE(client.needs_begin_frame()); |
498 | 498 |
499 scheduler->BeginFrame(base::TimeTicks::Now()); | 499 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
500 EXPECT_EQ(1, client.num_draws()); | 500 EXPECT_EQ(1, client.num_draws()); |
501 EXPECT_TRUE(scheduler->CommitPending()); | 501 EXPECT_TRUE(scheduler->CommitPending()); |
502 EXPECT_TRUE(client.needs_begin_frame()); | 502 EXPECT_TRUE(client.needs_begin_frame()); |
503 scheduler->FinishCommit(); | 503 scheduler->FinishCommit(); |
504 | 504 |
505 scheduler->BeginFrame(base::TimeTicks::Now()); | 505 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
506 EXPECT_EQ(2, client.num_draws());; | 506 EXPECT_EQ(2, client.num_draws());; |
507 EXPECT_FALSE(scheduler->RedrawPending()); | 507 EXPECT_FALSE(scheduler->RedrawPending()); |
508 EXPECT_FALSE(scheduler->CommitPending()); | 508 EXPECT_FALSE(scheduler->CommitPending()); |
509 EXPECT_FALSE(client.needs_begin_frame()); | 509 EXPECT_FALSE(client.needs_begin_frame()); |
510 } | 510 } |
511 | 511 |
512 // Tests that when a draw fails then the pending commit should not be dropped. | 512 // Tests that when a draw fails then the pending commit should not be dropped. |
513 TEST(SchedulerTest, RequestCommitInsideFailedDraw) { | 513 TEST(SchedulerTest, RequestCommitInsideFailedDraw) { |
514 SchedulerClientThatsetNeedsDrawInsideDraw client; | 514 SchedulerClientThatsetNeedsDrawInsideDraw client; |
515 SchedulerSettings default_scheduler_settings; | 515 SchedulerSettings default_scheduler_settings; |
516 Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings); | 516 Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings); |
517 scheduler->SetCanStart(); | 517 scheduler->SetCanStart(); |
518 scheduler->SetVisible(true); | 518 scheduler->SetVisible(true); |
519 scheduler->SetCanDraw(true); | 519 scheduler->SetCanDraw(true); |
520 scheduler->DidCreateAndInitializeOutputSurface(); | 520 scheduler->DidCreateAndInitializeOutputSurface(); |
521 | 521 |
522 client.SetDrawWillHappen(false); | 522 client.SetDrawWillHappen(false); |
523 | 523 |
524 scheduler->SetNeedsRedraw(); | 524 scheduler->SetNeedsRedraw(); |
525 EXPECT_TRUE(scheduler->RedrawPending()); | 525 EXPECT_TRUE(scheduler->RedrawPending()); |
526 EXPECT_TRUE(client.needs_begin_frame()); | 526 EXPECT_TRUE(client.needs_begin_frame()); |
527 EXPECT_EQ(0, client.num_draws()); | 527 EXPECT_EQ(0, client.num_draws()); |
528 | 528 |
529 // Fail the draw. | 529 // Fail the draw. |
530 scheduler->BeginFrame(base::TimeTicks::Now()); | 530 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
531 EXPECT_EQ(1, client.num_draws()); | 531 EXPECT_EQ(1, client.num_draws()); |
532 | 532 |
533 // We have a commit pending and the draw failed, and we didn't lose the commit | 533 // We have a commit pending and the draw failed, and we didn't lose the commit |
534 // request. | 534 // request. |
535 EXPECT_TRUE(scheduler->CommitPending()); | 535 EXPECT_TRUE(scheduler->CommitPending()); |
536 EXPECT_TRUE(scheduler->RedrawPending()); | 536 EXPECT_TRUE(scheduler->RedrawPending()); |
537 EXPECT_TRUE(client.needs_begin_frame()); | 537 EXPECT_TRUE(client.needs_begin_frame()); |
538 | 538 |
539 // Fail the draw again. | 539 // Fail the draw again. |
540 scheduler->BeginFrame(base::TimeTicks::Now()); | 540 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
541 EXPECT_EQ(2, client.num_draws()); | 541 EXPECT_EQ(2, client.num_draws()); |
542 EXPECT_TRUE(scheduler->CommitPending()); | 542 EXPECT_TRUE(scheduler->CommitPending()); |
543 EXPECT_TRUE(scheduler->RedrawPending()); | 543 EXPECT_TRUE(scheduler->RedrawPending()); |
544 EXPECT_TRUE(client.needs_begin_frame()); | 544 EXPECT_TRUE(client.needs_begin_frame()); |
545 | 545 |
546 // Draw successfully. | 546 // Draw successfully. |
547 client.SetDrawWillHappen(true); | 547 client.SetDrawWillHappen(true); |
548 scheduler->BeginFrame(base::TimeTicks::Now()); | 548 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
549 EXPECT_EQ(3, client.num_draws()); | 549 EXPECT_EQ(3, client.num_draws()); |
550 EXPECT_TRUE(scheduler->CommitPending()); | 550 EXPECT_TRUE(scheduler->CommitPending()); |
551 EXPECT_FALSE(scheduler->RedrawPending()); | 551 EXPECT_FALSE(scheduler->RedrawPending()); |
552 EXPECT_TRUE(client.needs_begin_frame()); | 552 EXPECT_TRUE(client.needs_begin_frame()); |
553 } | 553 } |
554 | 554 |
555 TEST(SchedulerTest, NoSwapWhenDrawFails) { | 555 TEST(SchedulerTest, NoSwapWhenDrawFails) { |
556 SchedulerClientThatsetNeedsCommitInsideDraw client; | 556 SchedulerClientThatsetNeedsCommitInsideDraw client; |
557 SchedulerSettings default_scheduler_settings; | 557 SchedulerSettings default_scheduler_settings; |
558 Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings); | 558 Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings); |
559 scheduler->SetCanStart(); | 559 scheduler->SetCanStart(); |
560 scheduler->SetVisible(true); | 560 scheduler->SetVisible(true); |
561 scheduler->SetCanDraw(true); | 561 scheduler->SetCanDraw(true); |
562 scheduler->DidCreateAndInitializeOutputSurface(); | 562 scheduler->DidCreateAndInitializeOutputSurface(); |
563 | 563 |
564 scheduler->SetNeedsRedraw(); | 564 scheduler->SetNeedsRedraw(); |
565 EXPECT_TRUE(scheduler->RedrawPending()); | 565 EXPECT_TRUE(scheduler->RedrawPending()); |
566 EXPECT_TRUE(client.needs_begin_frame()); | 566 EXPECT_TRUE(client.needs_begin_frame()); |
567 EXPECT_EQ(0, client.num_draws()); | 567 EXPECT_EQ(0, client.num_draws()); |
568 | 568 |
569 // Draw successfully, this starts a new frame. | 569 // Draw successfully, this starts a new frame. |
570 scheduler->BeginFrame(base::TimeTicks::Now()); | 570 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
571 EXPECT_EQ(1, client.num_draws()); | 571 EXPECT_EQ(1, client.num_draws()); |
572 | 572 |
573 scheduler->SetNeedsRedraw(); | 573 scheduler->SetNeedsRedraw(); |
574 EXPECT_TRUE(scheduler->RedrawPending()); | 574 EXPECT_TRUE(scheduler->RedrawPending()); |
575 EXPECT_TRUE(client.needs_begin_frame()); | 575 EXPECT_TRUE(client.needs_begin_frame()); |
576 | 576 |
577 // Fail to draw, this should not start a frame. | 577 // Fail to draw, this should not start a frame. |
578 client.SetDrawWillHappen(false); | 578 client.SetDrawWillHappen(false); |
579 scheduler->BeginFrame(base::TimeTicks::Now()); | 579 scheduler->BeginFrame(BeginFrameArgs::CreateForTesting()); |
580 EXPECT_EQ(2, client.num_draws()); | 580 EXPECT_EQ(2, client.num_draws()); |
581 } | 581 } |
582 | 582 |
583 TEST(SchedulerTest, NoSwapWhenSwapFailsDuringForcedCommit) { | 583 TEST(SchedulerTest, NoSwapWhenSwapFailsDuringForcedCommit) { |
584 FakeSchedulerClient client; | 584 FakeSchedulerClient client; |
585 SchedulerSettings default_scheduler_settings; | 585 SchedulerSettings default_scheduler_settings; |
586 Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings); | 586 Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings); |
587 | 587 |
588 // Tell the client that it will fail to swap. | 588 // Tell the client that it will fail to swap. |
589 client.SetDrawWillHappen(true); | 589 client.SetDrawWillHappen(true); |
590 client.SetSwapWillHappenIfDrawHappens(false); | 590 client.SetSwapWillHappenIfDrawHappens(false); |
591 | 591 |
592 // Get the compositor to do a ScheduledActionDrawAndSwapForced. | 592 // Get the compositor to do a ScheduledActionDrawAndSwapForced. |
593 scheduler->SetCanDraw(true); | 593 scheduler->SetCanDraw(true); |
594 scheduler->SetNeedsRedraw(); | 594 scheduler->SetNeedsRedraw(); |
595 scheduler->SetNeedsForcedRedraw(); | 595 scheduler->SetNeedsForcedRedraw(); |
596 EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapForced")); | 596 EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapForced")); |
597 } | 597 } |
598 | 598 |
599 } // namespace | 599 } // namespace |
600 } // namespace cc | 600 } // namespace cc |
OLD | NEW |