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

Side by Side Diff: cc/scheduler/scheduler_state_machine.cc

Issue 22926024: cc: Control activation from the Scheduler (Closed) Base URL: http://git.chromium.org/chromium/src.git@schedOutputSurface4
Patch Set: Created 7 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 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_state_machine.h" 5 #include "cc/scheduler/scheduler_state_machine.h"
6 6
7 #include "base/format_macros.h" 7 #include "base/format_macros.h"
8 #include "base/logging.h" 8 #include "base/logging.h"
9 #include "base/strings/stringprintf.h" 9 #include "base/strings/stringprintf.h"
10 #include "base/values.h" 10 #include "base/values.h"
11 11
12 namespace cc { 12 namespace cc {
13 13
14 SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings) 14 SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
15 : settings_(settings), 15 : settings_(settings),
16 output_surface_state_(OUTPUT_SURFACE_LOST), 16 output_surface_state_(OUTPUT_SURFACE_LOST),
17 commit_state_(COMMIT_STATE_IDLE), 17 commit_state_(COMMIT_STATE_IDLE),
18 commit_count_(0), 18 commit_count_(0),
19 current_frame_number_(0), 19 current_frame_number_(0),
20 last_frame_number_where_begin_frame_sent_to_main_thread_(-1), 20 last_frame_number_where_begin_frame_sent_to_main_thread_(-1),
21 last_frame_number_where_draw_was_called_(-1), 21 last_frame_number_where_draw_was_called_(-1),
22 last_frame_number_where_tree_activation_attempted_(-1), 22 last_frame_number_pending_tree_activated_(-1),
23 last_frame_number_where_update_visible_tiles_was_called_(-1), 23 last_frame_number_where_update_visible_tiles_was_called_(-1),
24 consecutive_failed_draws_(0), 24 consecutive_failed_draws_(0),
25 maximum_number_of_failed_draws_before_draw_is_forced_(3), 25 maximum_number_of_failed_draws_before_draw_is_forced_(3),
26 needs_redraw_(false), 26 needs_redraw_(false),
27 swap_used_incomplete_tile_(false), 27 swap_used_incomplete_tile_(false),
28 needs_forced_redraw_(false), 28 needs_forced_redraw_(false),
29 needs_forced_redraw_after_next_commit_(false), 29 needs_forced_redraw_after_next_commit_(false),
30 needs_commit_(false), 30 needs_commit_(false),
31 needs_forced_commit_(false), 31 needs_forced_commit_(false),
32 expect_immediate_begin_frame_for_main_thread_(false), 32 expect_immediate_begin_frame_for_main_thread_(false),
33 main_thread_needs_layer_textures_(false), 33 main_thread_needs_layer_textures_(false),
34 inside_begin_frame_(false), 34 inside_begin_frame_(false),
35 active_tree_has_been_drawn_(false),
36 active_tree_is_null_(true),
35 visible_(false), 37 visible_(false),
36 can_start_(false), 38 can_start_(false),
37 can_draw_(false), 39 can_draw_(false),
38 has_pending_tree_(false), 40 has_pending_tree_(false),
41 pending_tree_is_ready_for_activation_(false),
39 draw_if_possible_failed_(false), 42 draw_if_possible_failed_(false),
40 texture_state_(LAYER_TEXTURE_STATE_UNLOCKED), 43 texture_state_(LAYER_TEXTURE_STATE_UNLOCKED),
41 did_create_and_initialize_first_output_surface_(false) {} 44 did_create_and_initialize_first_output_surface_(false) {}
42 45
43 const char* SchedulerStateMachine::OutputSurfaceStateToString( 46 const char* SchedulerStateMachine::OutputSurfaceStateToString(
44 OutputSurfaceState state) { 47 OutputSurfaceState state) {
45 switch (state) { 48 switch (state) {
46 case OUTPUT_SURFACE_ACTIVE: 49 case OUTPUT_SURFACE_ACTIVE:
47 return "OUTPUT_SURFACE_ACTIVE"; 50 return "OUTPUT_SURFACE_ACTIVE";
48 case OUTPUT_SURFACE_LOST: 51 case OUTPUT_SURFACE_LOST:
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
91 const char* SchedulerStateMachine::ActionToString(Action action) { 94 const char* SchedulerStateMachine::ActionToString(Action action) {
92 switch (action) { 95 switch (action) {
93 case ACTION_NONE: 96 case ACTION_NONE:
94 return "ACTION_NONE"; 97 return "ACTION_NONE";
95 case ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD: 98 case ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD:
96 return "ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD"; 99 return "ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD";
97 case ACTION_COMMIT: 100 case ACTION_COMMIT:
98 return "ACTION_COMMIT"; 101 return "ACTION_COMMIT";
99 case ACTION_UPDATE_VISIBLE_TILES: 102 case ACTION_UPDATE_VISIBLE_TILES:
100 return "ACTION_UPDATE_VISIBLE_TILES"; 103 return "ACTION_UPDATE_VISIBLE_TILES";
101 case ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED: 104 case ACTION_ACTIVATE_PENDING_TREE:
102 return "ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED"; 105 return "ACTION_ACTIVATE_PENDING_TREE";
103 case ACTION_DRAW_IF_POSSIBLE: 106 case ACTION_DRAW_IF_POSSIBLE:
104 return "ACTION_DRAW_IF_POSSIBLE"; 107 return "ACTION_DRAW_IF_POSSIBLE";
105 case ACTION_DRAW_FORCED: 108 case ACTION_DRAW_FORCED:
106 return "ACTION_DRAW_FORCED"; 109 return "ACTION_DRAW_FORCED";
107 case ACTION_DRAW_AND_SWAP_ABORT: 110 case ACTION_DRAW_AND_SWAP_ABORT:
108 return "ACTION_DRAW_AND_SWAP_ABORT"; 111 return "ACTION_DRAW_AND_SWAP_ABORT";
109 case ACTION_BEGIN_OUTPUT_SURFACE_CREATION: 112 case ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
110 return "ACTION_BEGIN_OUTPUT_SURFACE_CREATION"; 113 return "ACTION_BEGIN_OUTPUT_SURFACE_CREATION";
111 case ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD: 114 case ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD:
112 return "ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD"; 115 return "ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD";
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
155 state->Set("major_timestamps_in_ms", timestamps_state.release()); 158 state->Set("major_timestamps_in_ms", timestamps_state.release());
156 159
157 scoped_ptr<base::DictionaryValue> minor_state(new base::DictionaryValue); 160 scoped_ptr<base::DictionaryValue> minor_state(new base::DictionaryValue);
158 minor_state->SetInteger("commit_count", commit_count_); 161 minor_state->SetInteger("commit_count", commit_count_);
159 minor_state->SetInteger("current_frame_number", current_frame_number_); 162 minor_state->SetInteger("current_frame_number", current_frame_number_);
160 minor_state->SetInteger( 163 minor_state->SetInteger(
161 "last_frame_number_where_begin_frame_sent_to_main_thread", 164 "last_frame_number_where_begin_frame_sent_to_main_thread",
162 last_frame_number_where_begin_frame_sent_to_main_thread_); 165 last_frame_number_where_begin_frame_sent_to_main_thread_);
163 minor_state->SetInteger("last_frame_number_where_draw_was_called", 166 minor_state->SetInteger("last_frame_number_where_draw_was_called",
164 last_frame_number_where_draw_was_called_); 167 last_frame_number_where_draw_was_called_);
165 minor_state->SetInteger("last_frame_number_where_tree_activation_attempted", 168 minor_state->SetInteger("last_frame_number_pending_tree_activated_",
166 last_frame_number_where_tree_activation_attempted_); 169 last_frame_number_pending_tree_activated_);
167 minor_state->SetInteger( 170 minor_state->SetInteger(
168 "last_frame_number_where_update_visible_tiles_was_called", 171 "last_frame_number_where_update_visible_tiles_was_called",
169 last_frame_number_where_update_visible_tiles_was_called_); 172 last_frame_number_where_update_visible_tiles_was_called_);
170 minor_state->SetInteger("consecutive_failed_draws", 173 minor_state->SetInteger("consecutive_failed_draws",
171 consecutive_failed_draws_); 174 consecutive_failed_draws_);
172 minor_state->SetInteger( 175 minor_state->SetInteger(
173 "maximum_number_of_failed_draws_before_draw_is_forced", 176 "maximum_number_of_failed_draws_before_draw_is_forced",
174 maximum_number_of_failed_draws_before_draw_is_forced_); 177 maximum_number_of_failed_draws_before_draw_is_forced_);
178 minor_state->SetBoolean("active_tree_has_been_drawn_",
179 active_tree_has_been_drawn_);
180 minor_state->SetBoolean("active_tree_is_null_", active_tree_is_null_);
175 minor_state->SetBoolean("needs_redraw", needs_redraw_); 181 minor_state->SetBoolean("needs_redraw", needs_redraw_);
176 minor_state->SetBoolean("swap_used_incomplete_tile", 182 minor_state->SetBoolean("swap_used_incomplete_tile",
177 swap_used_incomplete_tile_); 183 swap_used_incomplete_tile_);
178 minor_state->SetBoolean("needs_forced_redraw", needs_forced_redraw_); 184 minor_state->SetBoolean("needs_forced_redraw", needs_forced_redraw_);
179 minor_state->SetBoolean("needs_forced_redraw_after_next_commit", 185 minor_state->SetBoolean("needs_forced_redraw_after_next_commit",
180 needs_forced_redraw_after_next_commit_); 186 needs_forced_redraw_after_next_commit_);
181 minor_state->SetBoolean("needs_commit", needs_commit_); 187 minor_state->SetBoolean("needs_commit", needs_commit_);
182 minor_state->SetBoolean("needs_forced_commit", needs_forced_commit_); 188 minor_state->SetBoolean("needs_forced_commit", needs_forced_commit_);
183 minor_state->SetBoolean("expect_immediate_begin_frame_for_main_thread", 189 minor_state->SetBoolean("expect_immediate_begin_frame_for_main_thread",
184 expect_immediate_begin_frame_for_main_thread_); 190 expect_immediate_begin_frame_for_main_thread_);
185 minor_state->SetBoolean("main_thread_needs_layer_textures", 191 minor_state->SetBoolean("main_thread_needs_layer_textures",
186 main_thread_needs_layer_textures_); 192 main_thread_needs_layer_textures_);
187 minor_state->SetBoolean("inside_begin_frame", inside_begin_frame_); 193 minor_state->SetBoolean("inside_begin_frame", inside_begin_frame_);
188 minor_state->SetBoolean("visible", visible_); 194 minor_state->SetBoolean("visible", visible_);
189 minor_state->SetBoolean("can_start", can_start_); 195 minor_state->SetBoolean("can_start", can_start_);
190 minor_state->SetBoolean("can_draw", can_draw_); 196 minor_state->SetBoolean("can_draw", can_draw_);
191 minor_state->SetBoolean("has_pending_tree", has_pending_tree_); 197 minor_state->SetBoolean("has_pending_tree", has_pending_tree_);
198 minor_state->SetBoolean("pending_tree_is_ready_for_activation_",
199 pending_tree_is_ready_for_activation_);
192 minor_state->SetBoolean("draw_if_possible_failed", draw_if_possible_failed_); 200 minor_state->SetBoolean("draw_if_possible_failed", draw_if_possible_failed_);
193 minor_state->SetBoolean("did_create_and_initialize_first_output_surface", 201 minor_state->SetBoolean("did_create_and_initialize_first_output_surface",
194 did_create_and_initialize_first_output_surface_); 202 did_create_and_initialize_first_output_surface_);
195 state->Set("minor_state", minor_state.release()); 203 state->Set("minor_state", minor_state.release());
196 204
197 return state.PassAs<base::Value>(); 205 return state.PassAs<base::Value>();
198 } 206 }
199 207
200 bool SchedulerStateMachine::HasDrawnThisFrame() const { 208 bool SchedulerStateMachine::HasDrawnThisFrame() const {
201 return current_frame_number_ == last_frame_number_where_draw_was_called_; 209 return current_frame_number_ == last_frame_number_where_draw_was_called_;
202 } 210 }
203 211
204 bool SchedulerStateMachine::HasAttemptedTreeActivationThisFrame() const { 212 bool SchedulerStateMachine::HasActivatedPendingTreeThisFrame() const {
205 return current_frame_number_ == 213 return current_frame_number_ ==
206 last_frame_number_where_tree_activation_attempted_; 214 last_frame_number_pending_tree_activated_;
207 } 215 }
208 216
209 bool SchedulerStateMachine::HasUpdatedVisibleTilesThisFrame() const { 217 bool SchedulerStateMachine::HasUpdatedVisibleTilesThisFrame() const {
210 return current_frame_number_ == 218 return current_frame_number_ ==
211 last_frame_number_where_update_visible_tiles_was_called_; 219 last_frame_number_where_update_visible_tiles_was_called_;
212 } 220 }
213 221
214 bool SchedulerStateMachine::HasSentBeginFrameToMainThreadThisFrame() const { 222 bool SchedulerStateMachine::HasSentBeginFrameToMainThreadThisFrame() const {
215 return current_frame_number_ == 223 return current_frame_number_ ==
216 last_frame_number_where_begin_frame_sent_to_main_thread_; 224 last_frame_number_where_begin_frame_sent_to_main_thread_;
(...skipping 20 matching lines...) Expand all
237 OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION); 245 OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION);
238 if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT) { 246 if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT) {
239 if (commit_results_in_pending_tree) { 247 if (commit_results_in_pending_tree) {
240 output_surface_state_ = OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION; 248 output_surface_state_ = OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION;
241 } else { 249 } else {
242 output_surface_state_ = OUTPUT_SURFACE_ACTIVE; 250 output_surface_state_ = OUTPUT_SURFACE_ACTIVE;
243 needs_redraw_ = true; 251 needs_redraw_ = true;
244 } 252 }
245 } 253 }
246 254
247 // if we don't have to wait for activation, update needs_redraw now. 255 // Update state if we have a new active tree to draw.
248 if (!commit_results_in_pending_tree) { 256 if (!commit_results_in_pending_tree &&
249 if (!commit_was_aborted) 257 (!commit_was_aborted || expect_immediate_begin_frame_for_main_thread_)) {
250 needs_redraw_ = true; 258 needs_redraw_ = true;
251 if (expect_immediate_begin_frame_for_main_thread_) 259 active_tree_has_been_drawn_ = false;
252 needs_redraw_ = true;
253 } 260 }
254 261
255 // This post-commit work is common to both completed and aborted commits. 262 // This post-commit work is common to both completed and aborted commits.
256 if (draw_if_possible_failed_) 263 if (draw_if_possible_failed_)
257 last_frame_number_where_draw_was_called_ = -1; 264 last_frame_number_where_draw_was_called_ = -1;
258 265
259 if (needs_forced_redraw_after_next_commit_) { 266 if (needs_forced_redraw_after_next_commit_) {
260 needs_forced_redraw_after_next_commit_ = false; 267 needs_forced_redraw_after_next_commit_ = false;
261 needs_forced_redraw_ = true; 268 needs_forced_redraw_ = true;
262 } 269 }
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
301 if (HasDrawnThisFrame()) 308 if (HasDrawnThisFrame())
302 return false; 309 return false;
303 310
304 // We currently only draw within the BeginFrame. 311 // We currently only draw within the BeginFrame.
305 if (!inside_begin_frame_) 312 if (!inside_begin_frame_)
306 return false; 313 return false;
307 314
308 return needs_redraw_; 315 return needs_redraw_;
309 } 316 }
310 317
311 bool SchedulerStateMachine::ShouldAttemptTreeActivation() const { 318 bool SchedulerStateMachine::ShouldActivatePendingTree() const {
312 return has_pending_tree_ && inside_begin_frame_ && 319 // Some quick early outs.
313 !HasAttemptedTreeActivationThisFrame(); 320 if (!inside_begin_frame_)
321 return false;
322 if (!has_pending_tree_)
323 return false;
324 if (HasActivatedPendingTreeThisFrame())
325 return false;
326
327 if (!pending_tree_is_ready_for_activation_)
328 return false;
329
330 // We do not want to activate a second tree before drawing the first one.
enne (OOO) 2013/08/23 17:54:09 Is this handled by the HasActivatedPendingTreeThis
brianderson 2013/08/23 20:51:59 There's some overlap, but there are cases where Ha
331 return active_tree_has_been_drawn_ || active_tree_is_null_;
314 } 332 }
315 333
316 bool SchedulerStateMachine::ShouldUpdateVisibleTiles() const { 334 bool SchedulerStateMachine::ShouldUpdateVisibleTiles() const {
317 if (!settings_.impl_side_painting) 335 if (!settings_.impl_side_painting)
318 return false; 336 return false;
319 if (HasUpdatedVisibleTilesThisFrame()) 337 if (HasUpdatedVisibleTilesThisFrame())
320 return false; 338 return false;
321 339
322 return ShouldAttemptTreeActivation() || ShouldDraw() || 340 return ShouldActivatePendingTree() || ShouldDraw() ||
323 swap_used_incomplete_tile_; 341 swap_used_incomplete_tile_;
324 } 342 }
325 343
326 bool SchedulerStateMachine::ShouldSendBeginFrameToMainThread() const { 344 bool SchedulerStateMachine::ShouldSendBeginFrameToMainThread() const {
327 if (!needs_commit_) 345 if (!needs_commit_)
328 return false; 346 return false;
329 347
330 // Only send BeginFrame to the main thread when idle. 348 // Only send BeginFrame to the main thread when idle.
331 if (commit_state_ != COMMIT_STATE_IDLE) 349 if (commit_state_ != COMMIT_STATE_IDLE)
332 return false; 350 return false;
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
381 needs_forced_commit_) 399 needs_forced_commit_)
382 // TODO(enne): Should probably drop the active tree on force commit. 400 // TODO(enne): Should probably drop the active tree on force commit.
383 return has_pending_tree_ ? ACTION_NONE 401 return has_pending_tree_ ? ACTION_NONE
384 : ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD; 402 : ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD;
385 if (output_surface_state_ == OUTPUT_SURFACE_LOST && can_start_) 403 if (output_surface_state_ == OUTPUT_SURFACE_LOST && can_start_)
386 return ACTION_BEGIN_OUTPUT_SURFACE_CREATION; 404 return ACTION_BEGIN_OUTPUT_SURFACE_CREATION;
387 if (output_surface_state_ == OUTPUT_SURFACE_CREATING) 405 if (output_surface_state_ == OUTPUT_SURFACE_CREATING)
388 return ACTION_NONE; 406 return ACTION_NONE;
389 if (ShouldUpdateVisibleTiles()) 407 if (ShouldUpdateVisibleTiles())
390 return ACTION_UPDATE_VISIBLE_TILES; 408 return ACTION_UPDATE_VISIBLE_TILES;
391 if (ShouldAttemptTreeActivation()) 409 if (ShouldActivatePendingTree())
392 return ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED; 410 return ACTION_ACTIVATE_PENDING_TREE;
393 if (ShouldDraw()) { 411 if (ShouldDraw()) {
394 return needs_forced_redraw_ ? ACTION_DRAW_FORCED 412 return needs_forced_redraw_ ? ACTION_DRAW_FORCED
395 : ACTION_DRAW_IF_POSSIBLE; 413 : ACTION_DRAW_IF_POSSIBLE;
396 } 414 }
397 if (ShouldSendBeginFrameToMainThread()) 415 if (ShouldSendBeginFrameToMainThread())
398 return ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD; 416 return ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD;
399 return ACTION_NONE; 417 return ACTION_NONE;
400 } 418 }
401 case COMMIT_STATE_FRAME_IN_PROGRESS: 419 case COMMIT_STATE_FRAME_IN_PROGRESS:
402 if (ShouldUpdateVisibleTiles()) 420 if (ShouldUpdateVisibleTiles())
403 return ACTION_UPDATE_VISIBLE_TILES; 421 return ACTION_UPDATE_VISIBLE_TILES;
404 if (ShouldAttemptTreeActivation()) 422 if (ShouldActivatePendingTree())
405 return ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED; 423 return ACTION_ACTIVATE_PENDING_TREE;
406 if (ShouldDraw()) { 424 if (ShouldDraw()) {
407 return needs_forced_redraw_ ? ACTION_DRAW_FORCED 425 return needs_forced_redraw_ ? ACTION_DRAW_FORCED
408 : ACTION_DRAW_IF_POSSIBLE; 426 : ACTION_DRAW_IF_POSSIBLE;
409 } 427 }
410 return ACTION_NONE; 428 return ACTION_NONE;
411 429
412 case COMMIT_STATE_READY_TO_COMMIT: 430 case COMMIT_STATE_READY_TO_COMMIT:
413 return ACTION_COMMIT; 431 return ACTION_COMMIT;
414 432
415 case COMMIT_STATE_WAITING_FOR_FIRST_DRAW: { 433 case COMMIT_STATE_WAITING_FOR_FIRST_DRAW: {
416 if (ShouldUpdateVisibleTiles()) 434 if (ShouldUpdateVisibleTiles())
417 return ACTION_UPDATE_VISIBLE_TILES; 435 return ACTION_UPDATE_VISIBLE_TILES;
418 if (ShouldAttemptTreeActivation()) 436 if (ShouldActivatePendingTree())
419 return ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED; 437 return ACTION_ACTIVATE_PENDING_TREE;
420 if (ShouldDraw()) { 438 if (ShouldDraw()) {
421 if (needs_forced_redraw_) 439 if (needs_forced_redraw_)
422 return ACTION_DRAW_FORCED; 440 return ACTION_DRAW_FORCED;
423 else if (PendingDrawsShouldBeAborted()) 441 else if (PendingDrawsShouldBeAborted())
424 return ACTION_DRAW_AND_SWAP_ABORT; 442 return ACTION_DRAW_AND_SWAP_ABORT;
425 else 443 else
426 return ACTION_DRAW_IF_POSSIBLE; 444 return ACTION_DRAW_IF_POSSIBLE;
427 } 445 }
428 return ACTION_NONE; 446 return ACTION_NONE;
429 } 447 }
430 448
431 case COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW: 449 case COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW:
432 if (ShouldUpdateVisibleTiles()) 450 if (ShouldUpdateVisibleTiles())
433 return ACTION_UPDATE_VISIBLE_TILES; 451 return ACTION_UPDATE_VISIBLE_TILES;
434 if (ShouldAttemptTreeActivation()) 452 if (ShouldActivatePendingTree())
435 return ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED; 453 return ACTION_ACTIVATE_PENDING_TREE;
436 if (needs_forced_redraw_) 454 if (needs_forced_redraw_)
437 return ACTION_DRAW_FORCED; 455 return ACTION_DRAW_FORCED;
438 return ACTION_NONE; 456 return ACTION_NONE;
439 } 457 }
440 NOTREACHED(); 458 NOTREACHED();
441 return ACTION_NONE; 459 return ACTION_NONE;
442 } 460 }
443 461
444 void SchedulerStateMachine::UpdateState(Action action) { 462 void SchedulerStateMachine::UpdateState(Action action) {
445 switch (action) { 463 switch (action) {
446 case ACTION_NONE: 464 case ACTION_NONE:
447 return; 465 return;
448 466
449 case ACTION_UPDATE_VISIBLE_TILES: 467 case ACTION_UPDATE_VISIBLE_TILES:
450 last_frame_number_where_update_visible_tiles_was_called_ = 468 last_frame_number_where_update_visible_tiles_was_called_ =
451 current_frame_number_; 469 current_frame_number_;
452 return; 470 return;
453 471
454 case ACTION_ACTIVATE_PENDING_TREE_IF_NEEDED: 472 case ACTION_ACTIVATE_PENDING_TREE:
455 last_frame_number_where_tree_activation_attempted_ = 473 last_frame_number_pending_tree_activated_ = current_frame_number_;
456 current_frame_number_;
457 return; 474 return;
458 475
459 case ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD: 476 case ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD:
460 DCHECK(!has_pending_tree_); 477 DCHECK(!has_pending_tree_);
461 if (!needs_forced_commit_ && 478 if (!needs_forced_commit_ &&
462 output_surface_state_ != OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT) { 479 output_surface_state_ != OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT) {
463 DCHECK(visible_); 480 DCHECK(visible_);
464 DCHECK_GT(current_frame_number_, 481 DCHECK_GT(current_frame_number_,
465 last_frame_number_where_begin_frame_sent_to_main_thread_); 482 last_frame_number_where_begin_frame_sent_to_main_thread_);
466 } 483 }
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after
512 expect_immediate_begin_frame_for_main_thread_ = false; 529 expect_immediate_begin_frame_for_main_thread_ = false;
513 } else if (commit_state_ == COMMIT_STATE_WAITING_FOR_FIRST_DRAW) { 530 } else if (commit_state_ == COMMIT_STATE_WAITING_FOR_FIRST_DRAW) {
514 commit_state_ = COMMIT_STATE_IDLE; 531 commit_state_ = COMMIT_STATE_IDLE;
515 } 532 }
516 if (texture_state_ == LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD) 533 if (texture_state_ == LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD)
517 texture_state_ = LAYER_TEXTURE_STATE_UNLOCKED; 534 texture_state_ = LAYER_TEXTURE_STATE_UNLOCKED;
518 535
519 needs_redraw_ = false; 536 needs_redraw_ = false;
520 needs_forced_redraw_ = false; 537 needs_forced_redraw_ = false;
521 draw_if_possible_failed_ = false; 538 draw_if_possible_failed_ = false;
539 active_tree_has_been_drawn_ = true;
522 540
523 if (did_swap) 541 if (did_swap)
524 swap_used_incomplete_tile_ = false; 542 swap_used_incomplete_tile_ = false;
525 } 543 }
526 544
527 void SchedulerStateMachine::SetMainThreadNeedsLayerTextures() { 545 void SchedulerStateMachine::SetMainThreadNeedsLayerTextures() {
528 DCHECK(!main_thread_needs_layer_textures_); 546 DCHECK(!main_thread_needs_layer_textures_);
529 DCHECK_NE(texture_state_, LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD); 547 DCHECK_NE(texture_state_, LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD);
530 main_thread_needs_layer_textures_ = true; 548 main_thread_needs_layer_textures_ = true;
531 } 549 }
(...skipping 97 matching lines...) Expand 10 before | Expand all | Expand 10 after
629 } 647 }
630 648
631 void SchedulerStateMachine::DidLoseOutputSurface() { 649 void SchedulerStateMachine::DidLoseOutputSurface() {
632 if (output_surface_state_ == OUTPUT_SURFACE_LOST || 650 if (output_surface_state_ == OUTPUT_SURFACE_LOST ||
633 output_surface_state_ == OUTPUT_SURFACE_CREATING) 651 output_surface_state_ == OUTPUT_SURFACE_CREATING)
634 return; 652 return;
635 output_surface_state_ = OUTPUT_SURFACE_LOST; 653 output_surface_state_ = OUTPUT_SURFACE_LOST;
636 needs_redraw_ = false; 654 needs_redraw_ = false;
637 } 655 }
638 656
639 void SchedulerStateMachine::SetHasPendingTree(bool has_pending_tree) { 657 void SchedulerStateMachine::NotifyReadyToActivate() {
658 if (has_pending_tree_)
659 pending_tree_is_ready_for_activation_ = true;
660 }
661
662 void SchedulerStateMachine::SetHasTrees(bool has_pending_tree,
663 bool active_tree_is_null) {
664 active_tree_is_null_ = active_tree_is_null;
640 if (has_pending_tree_ && !has_pending_tree) { 665 if (has_pending_tree_ && !has_pending_tree) {
641 // There is a new active tree. 666 // There is a new active tree.
667 pending_tree_is_ready_for_activation_ = false;
668 active_tree_has_been_drawn_ = false;
669 needs_redraw_ = true;
670
642 if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION) 671 if (output_surface_state_ == OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION)
643 output_surface_state_ = OUTPUT_SURFACE_ACTIVE; 672 output_surface_state_ = OUTPUT_SURFACE_ACTIVE;
644 673 } else if (!has_pending_tree_ && has_pending_tree) {
645 needs_redraw_ = true; 674 // There is a new pending tree.
675 pending_tree_is_ready_for_activation_ = false;
646 } 676 }
647 has_pending_tree_ = has_pending_tree; 677 has_pending_tree_ = has_pending_tree;
648 } 678 }
649 679
650 void SchedulerStateMachine::SetCanDraw(bool can) { can_draw_ = can; } 680 void SchedulerStateMachine::SetCanDraw(bool can) { can_draw_ = can; }
651 681
652 void SchedulerStateMachine::DidCreateAndInitializeOutputSurface() { 682 void SchedulerStateMachine::DidCreateAndInitializeOutputSurface() {
653 DCHECK_EQ(output_surface_state_, OUTPUT_SURFACE_CREATING); 683 DCHECK_EQ(output_surface_state_, OUTPUT_SURFACE_CREATING);
654 output_surface_state_ = OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT; 684 output_surface_state_ = OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT;
655 685
(...skipping 19 matching lines...) Expand all
675 NOTREACHED(); 705 NOTREACHED();
676 return false; 706 return false;
677 } 707 }
678 708
679 void SchedulerStateMachine::SetMaximumNumberOfFailedDrawsBeforeDrawIsForced( 709 void SchedulerStateMachine::SetMaximumNumberOfFailedDrawsBeforeDrawIsForced(
680 int num_draws) { 710 int num_draws) {
681 maximum_number_of_failed_draws_before_draw_is_forced_ = num_draws; 711 maximum_number_of_failed_draws_before_draw_is_forced_ = num_draws;
682 } 712 }
683 713
684 } // namespace cc 714 } // namespace cc
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698