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 3 // found in the LICENSE file. 4 5 #include "cc/scheduler/scheduler_state_machine.h" 6 7 #include "base/debug/trace_event.h" 8 #include "base/format_macros.h" 9 #include "base/logging.h" 10 #include "base/strings/stringprintf.h" 11 #include "base/values.h" 12 #include "ui/gfx/frame_time.h" 13 14 namespace cc { 15 16 SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings) 17 : settings_(settings), 18 output_surface_state_(OUTPUT_SURFACE_LOST), 19 begin_impl_frame_state_(BEGIN_IMPL_FRAME_STATE_IDLE), 20 commit_state_(COMMIT_STATE_IDLE), 21 forced_redraw_state_(FORCED_REDRAW_STATE_IDLE), 22 commit_count_(0), 23 current_frame_number_(0), 24 last_frame_number_animate_performed_(-1), 25 last_frame_number_swap_performed_(-1), 26 last_frame_number_swap_requested_(-1), 27 last_frame_number_begin_main_frame_sent_(-1), 28 last_frame_number_update_visible_tiles_was_called_(-1), 29 manage_tiles_funnel_(0), 30 consecutive_checkerboard_animations_(0), 31 max_pending_swaps_(1), 32 pending_swaps_(0), 33 needs_redraw_(false), 34 needs_animate_(false), 35 needs_manage_tiles_(false), 36 swap_used_incomplete_tile_(false), 37 needs_commit_(false), 38 inside_poll_for_anticipated_draw_triggers_(false), 39 visible_(false), 40 can_start_(false), 41 can_draw_(false), 42 has_pending_tree_(false), 43 pending_tree_is_ready_for_activation_(false), 44 active_tree_needs_first_draw_(false), 45 did_create_and_initialize_first_output_surface_(false), 46 smoothness_takes_priority_(false), 47 skip_next_begin_main_frame_to_reduce_latency_(false), 48 skip_begin_main_frame_to_reduce_latency_(false), 49 continuous_painting_(false) { 50 } 51 52 const char* SchedulerStateMachine::OutputSurfaceStateToString( 53 OutputSurfaceState state) { 54 switch (state) { 55 case OUTPUT_SURFACE_ACTIVE: 56 return "OUTPUT_SURFACE_ACTIVE"; 57 case OUTPUT_SURFACE_LOST: 58 return "OUTPUT_SURFACE_LOST"; 59 case OUTPUT_SURFACE_CREATING: 60 return "OUTPUT_SURFACE_CREATING"; 61 case OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT: 62 return "OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT"; 63 case OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION: 64 return "OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION"; 65 } 66 NOTREACHED(); 67 return "???"; 68 } 69 70 const char* SchedulerStateMachine::BeginImplFrameStateToString( 71 BeginImplFrameState state) { 72 switch (state) { 73 case BEGIN_IMPL_FRAME_STATE_IDLE: 74 return "BEGIN_IMPL_FRAME_STATE_IDLE"; 75 case BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING: 76 return "BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING"; 77 case BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME: 78 return "BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME"; 79 case BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE: 80 return "BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE"; 81 } 82 NOTREACHED(); 83 return "???"; 84 } 85 86 const char* SchedulerStateMachine::CommitStateToString(CommitState state) { 87 switch (state) { 88 case COMMIT_STATE_IDLE: 89 return "COMMIT_STATE_IDLE"; 90 case COMMIT_STATE_BEGIN_MAIN_FRAME_SENT: 91 return "COMMIT_STATE_BEGIN_MAIN_FRAME_SENT"; 92 case COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED: 93 return "COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED"; 94 case COMMIT_STATE_READY_TO_COMMIT: 95 return "COMMIT_STATE_READY_TO_COMMIT"; 96 case COMMIT_STATE_WAITING_FOR_ACTIVATION: 97 return "COMMIT_STATE_WAITING_FOR_ACTIVATION"; 98 case COMMIT_STATE_WAITING_FOR_FIRST_DRAW: 99 return "COMMIT_STATE_WAITING_FOR_FIRST_DRAW"; 100 } 101 NOTREACHED(); 102 return "???"; 103 } 104 105 const char* SchedulerStateMachine::ForcedRedrawOnTimeoutStateToString( 106 ForcedRedrawOnTimeoutState state) { 107 switch (state) { 108 case FORCED_REDRAW_STATE_IDLE: 109 return "FORCED_REDRAW_STATE_IDLE"; 110 case FORCED_REDRAW_STATE_WAITING_FOR_COMMIT: 111 return "FORCED_REDRAW_STATE_WAITING_FOR_COMMIT"; 112 case FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION: 113 return "FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION"; 114 case FORCED_REDRAW_STATE_WAITING_FOR_DRAW: 115 return "FORCED_REDRAW_STATE_WAITING_FOR_DRAW"; 116 } 117 NOTREACHED(); 118 return "???"; 119 } 120 121 const char* SchedulerStateMachine::ActionToString(Action action) { 122 switch (action) { 123 case ACTION_NONE: 124 return "ACTION_NONE"; 125 case ACTION_ANIMATE: 126 return "ACTION_ANIMATE"; 127 case ACTION_SEND_BEGIN_MAIN_FRAME: 128 return "ACTION_SEND_BEGIN_MAIN_FRAME"; 129 case ACTION_COMMIT: 130 return "ACTION_COMMIT"; 131 case ACTION_UPDATE_VISIBLE_TILES: 132 return "ACTION_UPDATE_VISIBLE_TILES"; 133 case ACTION_ACTIVATE_PENDING_TREE: 134 return "ACTION_ACTIVATE_PENDING_TREE"; 135 case ACTION_DRAW_AND_SWAP_IF_POSSIBLE: 136 return "ACTION_DRAW_AND_SWAP_IF_POSSIBLE"; 137 case ACTION_DRAW_AND_SWAP_FORCED: 138 return "ACTION_DRAW_AND_SWAP_FORCED"; 139 case ACTION_DRAW_AND_SWAP_ABORT: 140 return "ACTION_DRAW_AND_SWAP_ABORT"; 141 case ACTION_BEGIN_OUTPUT_SURFACE_CREATION: 142 return "ACTION_BEGIN_OUTPUT_SURFACE_CREATION"; 143 case ACTION_MANAGE_TILES: 144 return "ACTION_MANAGE_TILES"; 145 } 146 NOTREACHED(); 147 return "???"; 148 } 149 150 scoped_ptr<base::Value> SchedulerStateMachine::AsValue() const { 151 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue); 152 153 scoped_ptr<base::DictionaryValue> major_state(new base::DictionaryValue); 154 major_state->SetString("next_action", ActionToString(NextAction())); 155 major_state->SetString("begin_impl_frame_state", 156 BeginImplFrameStateToString(begin_impl_frame_state_)); 157 major_state->SetString("commit_state", CommitStateToString(commit_state_)); 158 major_state->SetString("output_surface_state_", 159 OutputSurfaceStateToString(output_surface_state_)); 160 major_state->SetString( 161 "forced_redraw_state", 162 ForcedRedrawOnTimeoutStateToString(forced_redraw_state_)); 163 state->Set("major_state", major_state.release()); 164 165 scoped_ptr<base::DictionaryValue> timestamps_state(new base::DictionaryValue); 166 base::TimeTicks now = gfx::FrameTime::Now(); 167 timestamps_state->SetDouble( 168 "0_interval", begin_impl_frame_args_.interval.InMicroseconds() / 1000.0L); 169 timestamps_state->SetDouble( 170 "1_now_to_deadline", 171 (begin_impl_frame_args_.deadline - now).InMicroseconds() / 1000.0L); 172 timestamps_state->SetDouble( 173 "2_frame_time_to_now", 174 (now - begin_impl_frame_args_.frame_time).InMicroseconds() / 1000.0L); 175 timestamps_state->SetDouble( 176 "3_frame_time_to_deadline", 177 (begin_impl_frame_args_.deadline - begin_impl_frame_args_.frame_time) 178 .InMicroseconds() / 179 1000.0L); 180 timestamps_state->SetDouble( 181 "4_now", (now - base::TimeTicks()).InMicroseconds() / 1000.0L); 182 timestamps_state->SetDouble( 183 "5_frame_time", 184 (begin_impl_frame_args_.frame_time - base::TimeTicks()).InMicroseconds() / 185 1000.0L); 186 timestamps_state->SetDouble( 187 "6_deadline", 188 (begin_impl_frame_args_.deadline - base::TimeTicks()).InMicroseconds() / 189 1000.0L); 190 state->Set("major_timestamps_in_ms", timestamps_state.release()); 191 192 scoped_ptr<base::DictionaryValue> minor_state(new base::DictionaryValue); 193 minor_state->SetInteger("commit_count", commit_count_); 194 minor_state->SetInteger("current_frame_number", current_frame_number_); 195 196 minor_state->SetInteger("last_frame_number_animate_performed", 197 last_frame_number_animate_performed_); 198 minor_state->SetInteger("last_frame_number_swap_performed", 199 last_frame_number_swap_performed_); 200 minor_state->SetInteger("last_frame_number_swap_requested", 201 last_frame_number_swap_requested_); 202 minor_state->SetInteger( 203 "last_frame_number_begin_main_frame_sent", 204 last_frame_number_begin_main_frame_sent_); 205 minor_state->SetInteger( 206 "last_frame_number_update_visible_tiles_was_called", 207 last_frame_number_update_visible_tiles_was_called_); 208 209 minor_state->SetInteger("manage_tiles_funnel", manage_tiles_funnel_); 210 minor_state->SetInteger("consecutive_checkerboard_animations", 211 consecutive_checkerboard_animations_); 212 minor_state->SetInteger("max_pending_swaps_", max_pending_swaps_); 213 minor_state->SetInteger("pending_swaps_", pending_swaps_); 214 minor_state->SetBoolean("needs_redraw", needs_redraw_); 215 minor_state->SetBoolean("needs_animate_", needs_animate_); 216 minor_state->SetBoolean("needs_manage_tiles", needs_manage_tiles_); 217 minor_state->SetBoolean("swap_used_incomplete_tile", 218 swap_used_incomplete_tile_); 219 minor_state->SetBoolean("needs_commit", needs_commit_); 220 minor_state->SetBoolean("visible", visible_); 221 minor_state->SetBoolean("can_start", can_start_); 222 minor_state->SetBoolean("can_draw", can_draw_); 223 minor_state->SetBoolean("has_pending_tree", has_pending_tree_); 224 minor_state->SetBoolean("pending_tree_is_ready_for_activation", 225 pending_tree_is_ready_for_activation_); 226 minor_state->SetBoolean("active_tree_needs_first_draw", 227 active_tree_needs_first_draw_); 228 minor_state->SetBoolean("did_create_and_initialize_first_output_surface", 229 did_create_and_initialize_first_output_surface_); 230 minor_state->SetBoolean("smoothness_takes_priority", 231 smoothness_takes_priority_); 232 minor_state->SetBoolean("main_thread_is_in_high_latency_mode", 233 MainThreadIsInHighLatencyMode()); 234 minor_state->SetBoolean("skip_begin_main_frame_to_reduce_latency", 235 skip_begin_main_frame_to_reduce_latency_); 236 minor_state->SetBoolean("skip_next_begin_main_frame_to_reduce_latency", 237 skip_next_begin_main_frame_to_reduce_latency_); 238 minor_state->SetBoolean("continuous_painting", continuous_painting_); 239 state->Set("minor_state", minor_state.release()); 240 241 return state.PassAs<base::Value>(); 242 } 243 244 void SchedulerStateMachine::AdvanceCurrentFrameNumber() { 245 current_frame_number_++; 246 247 // "Drain" the ManageTiles funnel. 248 if (manage_tiles_funnel_ > 0) 249 manage_tiles_funnel_--; 250 251 skip_begin_main_frame_to_reduce_latency_ = 252 skip_next_begin_main_frame_to_reduce_latency_; 253 skip_next_begin_main_frame_to_reduce_latency_ = false; 254 } 255 256 bool SchedulerStateMachine::HasSentBeginMainFrameThisFrame() const { 257 return current_frame_number_ == 258 last_frame_number_begin_main_frame_sent_; 259 } 260 261 bool SchedulerStateMachine::HasUpdatedVisibleTilesThisFrame() const { 262 return current_frame_number_ == 263 last_frame_number_update_visible_tiles_was_called_; 264 } 265 266 bool SchedulerStateMachine::HasSwappedThisFrame() const { 267 return current_frame_number_ == last_frame_number_swap_performed_; 268 } 269 270 bool SchedulerStateMachine::HasRequestedSwapThisFrame() const { 271 return current_frame_number_ == last_frame_number_swap_requested_; 272 } 273 274 bool SchedulerStateMachine::PendingDrawsShouldBeAborted() const { 275 // These are all the cases where we normally cannot or do not want to draw 276 // but, if needs_redraw_ is true and we do not draw to make forward progress, 277 // we might deadlock with the main thread. 278 // This should be a superset of PendingActivationsShouldBeForced() since 279 // activation of the pending tree is blocked by drawing of the active tree and 280 // the main thread might be blocked on activation of the most recent commit. 281 if (PendingActivationsShouldBeForced()) 282 return true; 283 284 // Additional states where we should abort draws. 285 // Note: We don't force activation in these cases because doing so would 286 // result in checkerboarding on resize, becoming visible, etc. 287 if (!can_draw_) 288 return true; 289 if (!visible_) 290 return true; 291 return false; 292 } 293 294 bool SchedulerStateMachine::PendingActivationsShouldBeForced() const { 295 // These are all the cases where, if we do not force activations to make 296 // forward progress, we might deadlock with the main thread. 297 298 // There is no output surface to trigger our activations. 299 if (output_surface_state_ == OUTPUT_SURFACE_LOST) 300 return true; 301 302 return false; 303 } 304 305 bool SchedulerStateMachine::ShouldBeginOutputSurfaceCreation() const { 306 // Don't try to initialize too early. 307 if (!can_start_) 308 return false; 309 310 // We only want to start output surface initialization after the 311 // previous commit is complete. 312 if (commit_state_ != COMMIT_STATE_IDLE) 313 return false; 314 315 // Make sure the BeginImplFrame from any previous OutputSurfaces 316 // are complete before creating the new OutputSurface. 317 if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_IDLE) 318 return false; 319 320 // We want to clear the pipline of any pending draws and activations 321 // before starting output surface initialization. This allows us to avoid 322 // weird corner cases where we abort draws or force activation while we 323 // are initializing the output surface. 324 if (active_tree_needs_first_draw_ || has_pending_tree_) 325 return false; 326 327 // We need to create the output surface if we don't have one and we haven't 328 // started creating one yet. 329 return output_surface_state_ == OUTPUT_SURFACE_LOST; 330 } 331 332 bool SchedulerStateMachine::ShouldDraw() const { 333 // If we need to abort draws, we should do so ASAP since the draw could 334 // be blocking other important actions (like output surface initialization), 335 // from occuring. If we are waiting for the first draw, then perfom the 336 // aborted draw to keep things moving. If we are not waiting for the first 337 // draw however, we don't want to abort for no reason. 338 if (PendingDrawsShouldBeAborted()) 339 return active_tree_needs_first_draw_; 340 341 // After this line, we only want to send a swap request once per frame. 342 if (HasRequestedSwapThisFrame()) 343 return false; 344 345 // Do not queue too many swaps. 346 if (pending_swaps_ >= max_pending_swaps_) 347 return false; 348 349 // Except for the cases above, do not draw outside of the BeginImplFrame 350 // deadline. 351 if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) 352 return false; 353 354 // Only handle forced redraws due to timeouts on the regular deadline. 355 if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW) 356 return true; 357 358 return needs_redraw_; 359 } 360 361 bool SchedulerStateMachine::ShouldActivatePendingTree() const { 362 // There is nothing to activate. 363 if (!has_pending_tree_) 364 return false; 365 366 // We should not activate a second tree before drawing the first one. 367 // Even if we need to force activation of the pending tree, we should abort 368 // drawing the active tree first. 369 if (active_tree_needs_first_draw_) 370 return false; 371 372 // If we want to force activation, do so ASAP. 373 if (PendingActivationsShouldBeForced()) 374 return true; 375 376 // At this point, only activate if we are ready to activate. 377 return pending_tree_is_ready_for_activation_; 378 } 379 380 bool SchedulerStateMachine::ShouldUpdateVisibleTiles() const { 381 if (!settings_.impl_side_painting) 382 return false; 383 if (HasUpdatedVisibleTilesThisFrame()) 384 return false; 385 386 // We don't want to update visible tiles right after drawing. 387 if (HasRequestedSwapThisFrame()) 388 return false; 389 390 // There's no reason to check for tiles if we don't have an output surface. 391 if (!HasInitializedOutputSurface()) 392 return false; 393 394 // We should not check for visible tiles until we've entered the deadline so 395 // we check as late as possible and give the tiles more time to initialize. 396 if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) 397 return false; 398 399 // If the last swap drew with checkerboard or missing tiles, we should 400 // poll for any new visible tiles so we can be notified to draw again 401 // when there are. 402 if (swap_used_incomplete_tile_) 403 return true; 404 405 return false; 406 } 407 408 bool SchedulerStateMachine::ShouldAnimate() const { 409 if (!can_draw_) 410 return false; 411 412 if (last_frame_number_animate_performed_ == current_frame_number_) 413 return false; 414 415 if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING && 416 begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) 417 return false; 418 419 return needs_redraw_ || needs_animate_; 420 } 421 422 bool SchedulerStateMachine::ShouldSendBeginMainFrame() const { 423 if (!needs_commit_) 424 return false; 425 426 // Only send BeginMainFrame when there isn't another commit pending already. 427 if (commit_state_ != COMMIT_STATE_IDLE) 428 return false; 429 430 // Don't send BeginMainFrame early if we are prioritizing the active tree 431 // because of smoothness_takes_priority. 432 if (smoothness_takes_priority_ && 433 (has_pending_tree_ || active_tree_needs_first_draw_)) { 434 return false; 435 } 436 437 // We do not need commits if we are not visible. 438 if (!visible_) 439 return false; 440 441 // We want to start the first commit after we get a new output surface ASAP. 442 if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT) 443 return true; 444 445 // We should not send BeginMainFrame while we are in 446 // BEGIN_IMPL_FRAME_STATE_IDLE since we might have new 447 // user input arriving soon. 448 // TODO(brianderson): Allow sending BeginMainFrame while idle when the main 449 // thread isn't consuming user input. 450 if (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_IDLE && 451 BeginFrameNeeded()) 452 return false; 453 454 // We need a new commit for the forced redraw. This honors the 455 // single commit per interval because the result will be swapped to screen. 456 if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_COMMIT) 457 return true; 458 459 // After this point, we only start a commit once per frame. 460 if (HasSentBeginMainFrameThisFrame()) 461 return false; 462 463 // We shouldn't normally accept commits if there isn't an OutputSurface. 464 if (!HasInitializedOutputSurface()) 465 return false; 466 467 // SwapAck throttle the BeginMainFrames unless we just swapped. 468 // TODO(brianderson): Remove this restriction to improve throughput. 469 bool just_swapped_in_deadline = 470 begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE && 471 HasSwappedThisFrame(); 472 if (pending_swaps_ >= max_pending_swaps_ && !just_swapped_in_deadline) 473 return false; 474 475 if (skip_begin_main_frame_to_reduce_latency_) 476 return false; 477 478 return true; 479 } 480 481 bool SchedulerStateMachine::ShouldCommit() const { 482 if (commit_state_ != COMMIT_STATE_READY_TO_COMMIT) 483 return false; 484 485 // We must not finish the commit until the pending tree is free. 486 if (has_pending_tree_) { 487 DCHECK(settings_.main_frame_before_activation_enabled); 488 return false; 489 } 490 491 // Prioritize drawing the previous commit before finishing the next commit. 492 if (active_tree_needs_first_draw_) 493 return false; 494 495 return true; 496 } 497 498 bool SchedulerStateMachine::ShouldManageTiles() const { 499 // ManageTiles only really needs to be called immediately after commit 500 // and then periodically after that. Use a funnel to make sure we average 501 // one ManageTiles per BeginImplFrame in the long run. 502 if (manage_tiles_funnel_ > 0) 503 return false; 504 505 // Limiting to once per-frame is not enough, since we only want to 506 // manage tiles _after_ draws. Polling for draw triggers and 507 // begin-frame are mutually exclusive, so we limit to these two cases. 508 if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE && 509 !inside_poll_for_anticipated_draw_triggers_) 510 return false; 511 return needs_manage_tiles_; 512 } 513 514 SchedulerStateMachine::Action SchedulerStateMachine::NextAction() const { 515 if (ShouldUpdateVisibleTiles()) 516 return ACTION_UPDATE_VISIBLE_TILES; 517 if (ShouldActivatePendingTree()) 518 return ACTION_ACTIVATE_PENDING_TREE; 519 if (ShouldCommit()) 520 return ACTION_COMMIT; 521 if (ShouldAnimate()) 522 return ACTION_ANIMATE; 523 if (ShouldDraw()) { 524 if (PendingDrawsShouldBeAborted()) 525 return ACTION_DRAW_AND_SWAP_ABORT; 526 else if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW) 527 return ACTION_DRAW_AND_SWAP_FORCED; 528 else 529 return ACTION_DRAW_AND_SWAP_IF_POSSIBLE; 530 } 531 if (ShouldManageTiles()) 532 return ACTION_MANAGE_TILES; 533 if (ShouldSendBeginMainFrame()) 534 return ACTION_SEND_BEGIN_MAIN_FRAME; 535 if (ShouldBeginOutputSurfaceCreation()) 536 return ACTION_BEGIN_OUTPUT_SURFACE_CREATION; 537 return ACTION_NONE; 538 } 539 540 void SchedulerStateMachine::UpdateState(Action action) { 541 switch (action) { 542 case ACTION_NONE: 543 return; 544 545 case ACTION_UPDATE_VISIBLE_TILES: 546 last_frame_number_update_visible_tiles_was_called_ = 547 current_frame_number_; 548 return; 549 550 case ACTION_ACTIVATE_PENDING_TREE: 551 UpdateStateOnActivation(); 552 return; 553 554 case ACTION_ANIMATE: 555 last_frame_number_animate_performed_ = current_frame_number_; 556 needs_animate_ = false; 557 // TODO(skyostil): Instead of assuming this, require the client to tell 558 // us. 559 SetNeedsRedraw(); 560 return; 561 562 case ACTION_SEND_BEGIN_MAIN_FRAME: 563 DCHECK(!has_pending_tree_ || 564 settings_.main_frame_before_activation_enabled); 565 DCHECK(!active_tree_needs_first_draw_ || 566 settings_.main_frame_before_draw_enabled); 567 DCHECK(visible_); 568 commit_state_ = COMMIT_STATE_BEGIN_MAIN_FRAME_SENT; 569 needs_commit_ = false; 570 last_frame_number_begin_main_frame_sent_ = 571 current_frame_number_; 572 return; 573 574 case ACTION_COMMIT: { 575 bool commit_was_aborted = false; 576 UpdateStateOnCommit(commit_was_aborted); 577 return; 578 } 579 580 case ACTION_DRAW_AND_SWAP_FORCED: 581 case ACTION_DRAW_AND_SWAP_IF_POSSIBLE: { 582 bool did_request_swap = true; 583 UpdateStateOnDraw(did_request_swap); 584 return; 585 } 586 587 case ACTION_DRAW_AND_SWAP_ABORT: { 588 bool did_request_swap = false; 589 UpdateStateOnDraw(did_request_swap); 590 return; 591 } 592 593 case ACTION_BEGIN_OUTPUT_SURFACE_CREATION: 594 DCHECK_EQ(output_surface_state_, OUTPUT_SURFACE_LOST); 595 output_surface_state_ = OUTPUT_SURFACE_CREATING; 596 597 // The following DCHECKs make sure we are in the proper quiescent state. 598 // The pipeline should be flushed entirely before we start output 599 // surface creation to avoid complicated corner cases. 600 DCHECK_EQ(commit_state_, COMMIT_STATE_IDLE); 601 DCHECK(!has_pending_tree_); 602 DCHECK(!active_tree_needs_first_draw_); 603 return; 604 605 case ACTION_MANAGE_TILES: 606 UpdateStateOnManageTiles(); 607 return; 608 } 609 } 610 611 void SchedulerStateMachine::UpdateStateOnCommit(bool commit_was_aborted) { 612 commit_count_++; 613 614 if (commit_was_aborted || settings_.main_frame_before_activation_enabled) { 615 commit_state_ = COMMIT_STATE_IDLE; 616 } else if (settings_.main_frame_before_draw_enabled) { 617 commit_state_ = settings_.impl_side_painting 618 ? COMMIT_STATE_WAITING_FOR_ACTIVATION 619 : COMMIT_STATE_IDLE; 620 } else { 621 commit_state_ = COMMIT_STATE_WAITING_FOR_FIRST_DRAW; 622 } 623 624 // If we are impl-side-painting but the commit was aborted, then we behave 625 // mostly as if we are not impl-side-painting since there is no pending tree. 626 has_pending_tree_ = settings_.impl_side_painting && !commit_was_aborted; 627 628 // Update state related to forced draws. 629 if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_COMMIT) { 630 forced_redraw_state_ = has_pending_tree_ 631 ? FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION 632 : FORCED_REDRAW_STATE_WAITING_FOR_DRAW; 633 } 634 635 // Update the output surface state. 636 DCHECK_NE(output_surface_state_, OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION); 637 if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT) { 638 if (has_pending_tree_) { 639 output_surface_state_ = OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION; 640 } else { 641 output_surface_state_ = OUTPUT_SURFACE_ACTIVE; 642 needs_redraw_ = true; 643 } 644 } 645 646 // Update state if we have a new active tree to draw, or if the active tree 647 // was unchanged but we need to do a forced draw. 648 if (!has_pending_tree_ && 649 (!commit_was_aborted || 650 forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)) { 651 needs_redraw_ = true; 652 active_tree_needs_first_draw_ = true; 653 } 654 655 // This post-commit work is common to both completed and aborted commits. 656 pending_tree_is_ready_for_activation_ = false; 657 658 if (continuous_painting_) 659 needs_commit_ = true; 660 } 661 662 void SchedulerStateMachine::UpdateStateOnActivation() { 663 if (commit_state_ == COMMIT_STATE_WAITING_FOR_ACTIVATION) 664 commit_state_ = COMMIT_STATE_IDLE; 665 666 if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION) 667 output_surface_state_ = OUTPUT_SURFACE_ACTIVE; 668 669 if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION) 670 forced_redraw_state_ = FORCED_REDRAW_STATE_WAITING_FOR_DRAW; 671 672 has_pending_tree_ = false; 673 pending_tree_is_ready_for_activation_ = false; 674 active_tree_needs_first_draw_ = true; 675 needs_redraw_ = true; 676 } 677 678 void SchedulerStateMachine::UpdateStateOnDraw(bool did_request_swap) { 679 if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW) 680 forced_redraw_state_ = FORCED_REDRAW_STATE_IDLE; 681 682 if (!has_pending_tree_ && 683 commit_state_ == COMMIT_STATE_WAITING_FOR_FIRST_DRAW) { 684 commit_state_ = COMMIT_STATE_IDLE; 685 } 686 687 needs_redraw_ = false; 688 active_tree_needs_first_draw_ = false; 689 690 if (did_request_swap) 691 last_frame_number_swap_requested_ = current_frame_number_; 692 } 693 694 void SchedulerStateMachine::UpdateStateOnManageTiles() { 695 needs_manage_tiles_ = false; 696 } 697 698 void SchedulerStateMachine::SetSkipNextBeginMainFrameToReduceLatency() { 699 skip_next_begin_main_frame_to_reduce_latency_ = true; 700 } 701 702 bool SchedulerStateMachine::BeginFrameNeeded() const { 703 // Proactive BeginFrames are bad for the synchronous compositor because we 704 // have to draw when we get the BeginFrame and could end up drawing many 705 // duplicate frames if our new frame isn't ready in time. 706 // To poll for state with the synchronous compositor without having to draw, 707 // we rely on ShouldPollForAnticipatedDrawTriggers instead. 708 if (!SupportsProactiveBeginFrame()) 709 return BeginFrameNeededToAnimateOrDraw(); 710 711 return BeginFrameNeededToAnimateOrDraw() || ProactiveBeginFrameWanted(); 712 } 713 714 bool SchedulerStateMachine::ShouldPollForAnticipatedDrawTriggers() const { 715 // ShouldPollForAnticipatedDrawTriggers is what we use in place of 716 // ProactiveBeginFrameWanted when we are using the synchronous 717 // compositor. 718 if (!SupportsProactiveBeginFrame()) { 719 return !BeginFrameNeededToAnimateOrDraw() && ProactiveBeginFrameWanted(); 720 } 721 722 // Non synchronous compositors should rely on 723 // ProactiveBeginFrameWanted to poll for state instead. 724 return false; 725 } 726 727 // Note: If SupportsProactiveBeginFrame is false, the scheduler should poll 728 // for changes in it's draw state so it can request a BeginFrame when it's 729 // actually ready. 730 bool SchedulerStateMachine::SupportsProactiveBeginFrame() const { 731 // It is undesirable to proactively request BeginFrames if we are 732 // using a synchronous compositor because we *must* draw for every 733 // BeginFrame, which could cause duplicate draws. 734 return !settings_.using_synchronous_renderer_compositor; 735 } 736 737 // These are the cases where we definitely (or almost definitely) have a 738 // new frame to animate and/or draw and can draw. 739 bool SchedulerStateMachine::BeginFrameNeededToAnimateOrDraw() const { 740 // The output surface is the provider of BeginImplFrames, so we are not going 741 // to get them even if we ask for them. 742 if (!HasInitializedOutputSurface()) 743 return false; 744 745 // If we can't draw, don't tick until we are notified that we can draw again. 746 if (!can_draw_) 747 return false; 748 749 // The forced draw respects our normal draw scheduling, so we need to 750 // request a BeginImplFrame for it. 751 if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW) 752 return true; 753 754 // There's no need to produce frames if we are not visible. 755 if (!visible_) 756 return false; 757 758 // We need to draw a more complete frame than we did the last BeginImplFrame, 759 // so request another BeginImplFrame in anticipation that we will have 760 // additional visible tiles. 761 if (swap_used_incomplete_tile_) 762 return true; 763 764 if (needs_animate_) 765 return true; 766 767 return needs_redraw_; 768 } 769 770 // These are cases where we are very likely to draw soon, but might not 771 // actually have a new frame to draw when we receive the next BeginImplFrame. 772 // Proactively requesting the BeginImplFrame helps hide the round trip latency 773 // of the SetNeedsBeginFrame request that has to go to the Browser. 774 bool SchedulerStateMachine::ProactiveBeginFrameWanted() const { 775 // The output surface is the provider of BeginImplFrames, 776 // so we are not going to get them even if we ask for them. 777 if (!HasInitializedOutputSurface()) 778 return false; 779 780 // Do not be proactive when invisible. 781 if (!visible_) 782 return false; 783 784 // We should proactively request a BeginImplFrame if a commit is pending 785 // because we will want to draw if the commit completes quickly. 786 if (needs_commit_ || commit_state_ != COMMIT_STATE_IDLE) 787 return true; 788 789 // If the pending tree activates quickly, we'll want a BeginImplFrame soon 790 // to draw the new active tree. 791 if (has_pending_tree_) 792 return true; 793 794 // Changing priorities may allow us to activate (given the new priorities), 795 // which may result in a new frame. 796 if (needs_manage_tiles_) 797 return true; 798 799 // If we just sent a swap request, it's likely that we are going to produce 800 // another frame soon. This helps avoid negative glitches in our 801 // SetNeedsBeginFrame requests, which may propagate to the BeginImplFrame 802 // provider and get sampled at an inopportune time, delaying the next 803 // BeginImplFrame. 804 if (HasRequestedSwapThisFrame()) 805 return true; 806 807 return false; 808 } 809 810 void SchedulerStateMachine::OnBeginImplFrame(const BeginFrameArgs& args) { 811 AdvanceCurrentFrameNumber(); 812 begin_impl_frame_args_ = args; 813 DCHECK_EQ(begin_impl_frame_state_, BEGIN_IMPL_FRAME_STATE_IDLE) << *AsValue(); 814 begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING; 815 } 816 817 void SchedulerStateMachine::OnBeginImplFrameDeadlinePending() { 818 DCHECK_EQ(begin_impl_frame_state_, 819 BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING) 820 << *AsValue(); 821 begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME; 822 } 823 824 void SchedulerStateMachine::OnBeginImplFrameDeadline() { 825 DCHECK_EQ(begin_impl_frame_state_, BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME) 826 << *AsValue(); 827 begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE; 828 } 829 830 void SchedulerStateMachine::OnBeginImplFrameIdle() { 831 DCHECK_EQ(begin_impl_frame_state_, BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) 832 << *AsValue(); 833 begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_IDLE; 834 } 835 836 bool SchedulerStateMachine::ShouldTriggerBeginImplFrameDeadlineEarly() const { 837 // TODO(brianderson): This should take into account multiple commit sources. 838 839 if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME) 840 return false; 841 842 // If we've lost the output surface, end the current BeginImplFrame ASAP 843 // so we can start creating the next output surface. 844 if (output_surface_state_ == OUTPUT_SURFACE_LOST) 845 return true; 846 847 // SwapAck throttle the deadline since we wont draw and swap anyway. 848 if (pending_swaps_ >= max_pending_swaps_) 849 return false; 850 851 if (active_tree_needs_first_draw_) 852 return true; 853 854 if (!needs_redraw_) 855 return false; 856 857 // This is used to prioritize impl-thread draws when the main thread isn't 858 // producing anything, e.g., after an aborted commit. We also check that we 859 // don't have a pending tree -- otherwise we should give it a chance to 860 // activate. 861 // TODO(skyostil): Revisit this when we have more accurate deadline estimates. 862 if (commit_state_ == COMMIT_STATE_IDLE && !has_pending_tree_) 863 return true; 864 865 // Prioritize impl-thread draws in smoothness mode. 866 if (smoothness_takes_priority_) 867 return true; 868 869 return false; 870 } 871 872 bool SchedulerStateMachine::MainThreadIsInHighLatencyMode() const { 873 // If a commit is pending before the previous commit has been drawn, we 874 // are definitely in a high latency mode. 875 if (CommitPending() && (active_tree_needs_first_draw_ || has_pending_tree_)) 876 return true; 877 878 // If we just sent a BeginMainFrame and haven't hit the deadline yet, the main 879 // thread is in a low latency mode. 880 if (HasSentBeginMainFrameThisFrame() && 881 (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING || 882 begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME)) 883 return false; 884 885 // If there's a commit in progress it must either be from the previous frame 886 // or it started after the impl thread's deadline. In either case the main 887 // thread is in high latency mode. 888 if (CommitPending()) 889 return true; 890 891 // Similarly, if there's a pending tree the main thread is in high latency 892 // mode, because either 893 // it's from the previous frame 894 // or 895 // we're currently drawing the active tree and the pending tree will thus 896 // only be drawn in the next frame. 897 if (has_pending_tree_) 898 return true; 899 900 if (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) { 901 // Even if there's a new active tree to draw at the deadline or we've just 902 // swapped it, it may have been triggered by a previous BeginImplFrame, in 903 // which case the main thread is in a high latency mode. 904 return (active_tree_needs_first_draw_ || HasSwappedThisFrame()) && 905 !HasSentBeginMainFrameThisFrame(); 906 } 907 908 // If the active tree needs its first draw in any other state, we know the 909 // main thread is in a high latency mode. 910 return active_tree_needs_first_draw_; 911 } 912 913 void SchedulerStateMachine::DidEnterPollForAnticipatedDrawTriggers() { 914 AdvanceCurrentFrameNumber(); 915 inside_poll_for_anticipated_draw_triggers_ = true; 916 } 917 918 void SchedulerStateMachine::DidLeavePollForAnticipatedDrawTriggers() { 919 inside_poll_for_anticipated_draw_triggers_ = false; 920 } 921 922 void SchedulerStateMachine::SetVisible(bool visible) { visible_ = visible; } 923 924 void SchedulerStateMachine::SetCanDraw(bool can_draw) { can_draw_ = can_draw; } 925 926 void SchedulerStateMachine::SetNeedsRedraw() { needs_redraw_ = true; } 927 928 void SchedulerStateMachine::SetNeedsAnimate() { 929 needs_animate_ = true; 930 } 931 932 void SchedulerStateMachine::SetNeedsManageTiles() { 933 if (!needs_manage_tiles_) { 934 TRACE_EVENT0("cc", 935 "SchedulerStateMachine::SetNeedsManageTiles"); 936 needs_manage_tiles_ = true; 937 } 938 } 939 940 void SchedulerStateMachine::SetMaxSwapsPending(int max) { 941 max_pending_swaps_ = max; 942 } 943 944 void SchedulerStateMachine::DidSwapBuffers() { 945 pending_swaps_++; 946 DCHECK_LE(pending_swaps_, max_pending_swaps_); 947 948 last_frame_number_swap_performed_ = current_frame_number_; 949 } 950 951 void SchedulerStateMachine::SetSwapUsedIncompleteTile( 952 bool used_incomplete_tile) { 953 swap_used_incomplete_tile_ = used_incomplete_tile; 954 } 955 956 void SchedulerStateMachine::DidSwapBuffersComplete() { 957 DCHECK_GT(pending_swaps_, 0); 958 pending_swaps_--; 959 } 960 961 void SchedulerStateMachine::SetSmoothnessTakesPriority( 962 bool smoothness_takes_priority) { 963 smoothness_takes_priority_ = smoothness_takes_priority; 964 } 965 966 void SchedulerStateMachine::DidDrawIfPossibleCompleted(DrawResult result) { 967 switch (result) { 968 case INVALID_RESULT: 969 NOTREACHED() << "Uninitialized DrawResult."; 970 break; 971 case DRAW_ABORTED_CANT_DRAW: 972 case DRAW_ABORTED_CONTEXT_LOST: 973 NOTREACHED() << "Invalid return value from DrawAndSwapIfPossible:" 974 << result; 975 break; 976 case DRAW_SUCCESS: 977 consecutive_checkerboard_animations_ = 0; 978 forced_redraw_state_ = FORCED_REDRAW_STATE_IDLE; 979 break; 980 case DRAW_ABORTED_CHECKERBOARD_ANIMATIONS: 981 needs_redraw_ = true; 982 983 // If we're already in the middle of a redraw, we don't need to 984 // restart it. 985 if (forced_redraw_state_ != FORCED_REDRAW_STATE_IDLE) 986 return; 987 988 needs_commit_ = true; 989 consecutive_checkerboard_animations_++; 990 if (settings_.timeout_and_draw_when_animation_checkerboards && 991 consecutive_checkerboard_animations_ >= 992 settings_.maximum_number_of_failed_draws_before_draw_is_forced_) { 993 consecutive_checkerboard_animations_ = 0; 994 // We need to force a draw, but it doesn't make sense to do this until 995 // we've committed and have new textures. 996 forced_redraw_state_ = FORCED_REDRAW_STATE_WAITING_FOR_COMMIT; 997 } 998 break; 999 case DRAW_ABORTED_MISSING_HIGH_RES_CONTENT: 1000 // It's not clear whether this missing content is because of missing 1001 // pictures (which requires a commit) or because of memory pressure 1002 // removing textures (which might not). To be safe, request a commit 1003 // anyway. 1004 needs_commit_ = true; 1005 break; 1006 } 1007 } 1008 1009 void SchedulerStateMachine::SetNeedsCommit() { needs_commit_ = true; } 1010 1011 void SchedulerStateMachine::NotifyReadyToCommit() { 1012 DCHECK(commit_state_ == COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED) << *AsValue(); 1013 commit_state_ = COMMIT_STATE_READY_TO_COMMIT; 1014 } 1015 1016 void SchedulerStateMachine::BeginMainFrameAborted(bool did_handle) { 1017 DCHECK_EQ(commit_state_, COMMIT_STATE_BEGIN_MAIN_FRAME_SENT); 1018 if (did_handle) { 1019 bool commit_was_aborted = true; 1020 UpdateStateOnCommit(commit_was_aborted); 1021 } else { 1022 commit_state_ = COMMIT_STATE_IDLE; 1023 SetNeedsCommit(); 1024 } 1025 } 1026 1027 void SchedulerStateMachine::DidManageTiles() { 1028 needs_manage_tiles_ = false; 1029 // "Fill" the ManageTiles funnel. 1030 manage_tiles_funnel_++; 1031 } 1032 1033 void SchedulerStateMachine::DidLoseOutputSurface() { 1034 if (output_surface_state_ == OUTPUT_SURFACE_LOST || 1035 output_surface_state_ == OUTPUT_SURFACE_CREATING) 1036 return; 1037 output_surface_state_ = OUTPUT_SURFACE_LOST; 1038 needs_redraw_ = false; 1039 } 1040 1041 void SchedulerStateMachine::NotifyReadyToActivate() { 1042 if (has_pending_tree_) 1043 pending_tree_is_ready_for_activation_ = true; 1044 } 1045 1046 void SchedulerStateMachine::DidCreateAndInitializeOutputSurface() { 1047 DCHECK_EQ(output_surface_state_, OUTPUT_SURFACE_CREATING); 1048 output_surface_state_ = OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT; 1049 1050 if (did_create_and_initialize_first_output_surface_) { 1051 // TODO(boliu): See if we can remove this when impl-side painting is always 1052 // on. Does anything on the main thread need to update after recreate? 1053 needs_commit_ = true; 1054 } 1055 did_create_and_initialize_first_output_surface_ = true; 1056 pending_swaps_ = 0; 1057 } 1058 1059 void SchedulerStateMachine::NotifyBeginMainFrameStarted() { 1060 DCHECK_EQ(commit_state_, COMMIT_STATE_BEGIN_MAIN_FRAME_SENT); 1061 commit_state_ = COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED; 1062 } 1063 1064 bool SchedulerStateMachine::HasInitializedOutputSurface() const { 1065 switch (output_surface_state_) { 1066 case OUTPUT_SURFACE_LOST: 1067 case OUTPUT_SURFACE_CREATING: 1068 return false; 1069 1070 case OUTPUT_SURFACE_ACTIVE: 1071 case OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT: 1072 case OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION: 1073 return true; 1074 } 1075 NOTREACHED(); 1076 return false; 1077 } 1078 1079 } // namespace cc 1080
