Keep vsync enabled while there is a pending requestAnimationFrame

cc/scheduler/scheduler_state_machine.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/scheduler/scheduler_state_machine.h"
 
 #include "base/logging.h"
 #include "base/stringprintf.h"
 
 namespace cc {
@@ skipping 14 matching lines @@
       needs_commit_(false),
       needs_forced_commit_(false),
       expect_immediate_begin_frame_(false),
       main_thread_needs_layer_textures_(false),
       inside_vsync_(false),
       visible_(false),
       can_begin_frame_(false),
       can_draw_(false),
       has_pending_tree_(false),
       draw_if_possible_failed_(false),
+      animate_requested_(false),
       texture_state_(LAYER_TEXTURE_STATE_UNLOCKED),
       output_surface_state_(OUTPUT_SURFACE_ACTIVE) {}
 
 std::string SchedulerStateMachine::ToString() {
   std::string str;
   base::StringAppendF(&str,
                       "settings_.impl_side_painting = %d; ",
                       settings_.impl_side_painting);
   base::StringAppendF(&str, "commit_state_ = %d; ", commit_state_);
   base::StringAppendF(
@@ skipping 212 matching lines @@
       last_frame_number_where_tree_activation_attempted_ =
           current_frame_number_;
       return;
 
     case ACTION_BEGIN_FRAME:
       DCHECK(!has_pending_tree_);
       DCHECK(visible_ || needs_forced_commit_);
       commit_state_ = COMMIT_STATE_FRAME_IN_PROGRESS;
       needs_commit_ = false;
       needs_forced_commit_ = false;
+      animate_requested_ = false;
       return;
 
     case ACTION_COMMIT:
       if (expect_immediate_begin_frame_)
         commit_state_ = COMMIT_STATE_WAITING_FOR_FIRST_FORCED_DRAW;
       else
         commit_state_ = COMMIT_STATE_WAITING_FOR_FIRST_DRAW;
       // When impl-side painting, we draw on activation instead of on commit.
       if (!settings_.impl_side_painting)
         needs_redraw_ = true;
@@ skipping 47 matching lines @@
   DCHECK_NE(texture_state_, LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD);
   main_thread_needs_layer_textures_ = true;
 }
 
 bool SchedulerStateMachine::VSyncCallbackNeeded() const {
   // If we have a pending tree, need to keep getting notifications until
   // the tree is ready to be swapped.
   if (has_pending_tree_)
     return true;
 
+  if (animate_requested_)
+    return true;
+
   // If we can't draw, don't tick until we are notified that we can draw again.
   if (!can_draw_)
     return false;
 
   if (needs_forced_redraw_)
     return true;
 
   if (visible_ && swap_used_incomplete_tile_)
     return true;
 
@@ skipping 34 matching lines @@
       // we've committed and have new textures.
       needs_forced_redraw_after_next_commit_ = true;
     }
   } else {
     consecutive_failed_draws_ = 0;
   }
 }
 
 void SchedulerStateMachine::SetNeedsCommit() { needs_commit_ = true; }
 
+void SchedulerStateMachine::SetAnimateRequested() {
+  animate_requested_ = true;
+}
+
 void SchedulerStateMachine::SetNeedsForcedCommit() {
   needs_forced_commit_ = true;
   expect_immediate_begin_frame_ = true;
 }
 
 void SchedulerStateMachine::BeginFrameComplete() {
   DCHECK(commit_state_ == COMMIT_STATE_FRAME_IN_PROGRESS ||
          (expect_immediate_begin_frame_ && commit_state_ != COMMIT_STATE_IDLE))
       << ToString();
   commit_state_ = COMMIT_STATE_READY_TO_COMMIT;
@@ skipping 27 matching lines @@
   output_surface_state_ = OUTPUT_SURFACE_ACTIVE;
   SetNeedsCommit();
 }
 
 void SchedulerStateMachine::SetMaximumNumberOfFailedDrawsBeforeDrawIsForced(
     int num_draws) {
   maximum_number_of_failed_draws_before_draw_is_forced_ = num_draws;
 }
 
 }  // namespace cc