cc: Split animating and drawing into separate actions

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/debug/trace_event.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "ui/gfx/frame_time.h"
 
 namespace cc {
 
 SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
     : settings_(settings),
       output_surface_state_(OUTPUT_SURFACE_LOST),
       begin_impl_frame_state_(BEGIN_IMPL_FRAME_STATE_IDLE),
       commit_state_(COMMIT_STATE_IDLE),
       texture_state_(LAYER_TEXTURE_STATE_UNLOCKED),
       forced_redraw_state_(FORCED_REDRAW_STATE_IDLE),
       readback_state_(READBACK_STATE_IDLE),
       commit_count_(0),
       current_frame_number_(0),
+      last_frame_number_animate_performed_(-1),
       last_frame_number_swap_performed_(-1),
       last_frame_number_begin_main_frame_sent_(-1),
       last_frame_number_update_visible_tiles_was_called_(-1),
       manage_tiles_funnel_(0),
       consecutive_checkerboard_animations_(0),
       needs_redraw_(false),
       needs_manage_tiles_(false),
       swap_used_incomplete_tile_(false),
       needs_commit_(false),
       main_thread_needs_layer_textures_(false),
@@ skipping 111 matching lines @@
       return "FORCED_REDRAW_STATE_WAITING_FOR_DRAW";
   }
   NOTREACHED();
   return "???";
 }
 
 const char* SchedulerStateMachine::ActionToString(Action action) {
   switch (action) {
     case ACTION_NONE:
       return "ACTION_NONE";
+    case ACTION_ANIMATE:
+      return "ACTION_ANIMATE";
     case ACTION_SEND_BEGIN_MAIN_FRAME:
       return "ACTION_SEND_BEGIN_MAIN_FRAME";
     case ACTION_COMMIT:
       return "ACTION_COMMIT";
     case ACTION_UPDATE_VISIBLE_TILES:
       return "ACTION_UPDATE_VISIBLE_TILES";
     case ACTION_ACTIVATE_PENDING_TREE:
       return "ACTION_ACTIVATE_PENDING_TREE";
     case ACTION_DRAW_AND_SWAP_IF_POSSIBLE:
       return "ACTION_DRAW_AND_SWAP_IF_POSSIBLE";
@@ skipping 61 matching lines @@
       "6_deadline",
       (last_begin_impl_frame_args_.deadline - base::TimeTicks())
               .InMicroseconds() /
           1000.0L);
   state->Set("major_timestamps_in_ms", timestamps_state.release());
 
   scoped_ptr<base::DictionaryValue> minor_state(new base::DictionaryValue);
   minor_state->SetInteger("commit_count", commit_count_);
   minor_state->SetInteger("current_frame_number", current_frame_number_);
 
+  minor_state->SetInteger("last_frame_number_animate_performed",
+                          last_frame_number_animate_performed_);
   minor_state->SetInteger("last_frame_number_swap_performed",
                           last_frame_number_swap_performed_);
   minor_state->SetInteger(
       "last_frame_number_begin_main_frame_sent",
       last_frame_number_begin_main_frame_sent_);
   minor_state->SetInteger(
       "last_frame_number_update_visible_tiles_was_called",
       last_frame_number_update_visible_tiles_was_called_);
 
   minor_state->SetInteger("manage_tiles_funnel", manage_tiles_funnel_);
@@ skipping 200 matching lines @@
 
   // If the last swap drew with checkerboard or missing tiles, we should
   // poll for any new visible tiles so we can be notified to draw again
   // when there are.
   if (swap_used_incomplete_tile_)
     return true;
 
   return false;
 }
 
+bool SchedulerStateMachine::ShouldAnimate() const {
+  if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING)
+    return false;
+
+  if (last_frame_number_animate_performed_ == current_frame_number_)
+    return false;
+
+  return true;
+}
+
 bool SchedulerStateMachine::ShouldSendBeginMainFrame() const {
   if (!needs_commit_)
     return false;
 
   // Only send BeginMainFrame when there isn't another commit pending already.
   if (commit_state_ != COMMIT_STATE_IDLE)
     return false;
 
   // Don't send BeginMainFrame early if we are prioritizing the active tree
   // because of smoothness_takes_priority.
@@ skipping 93 matching lines @@
       return ACTION_DRAW_AND_READBACK;
     else if (PendingDrawsShouldBeAborted())
       return ACTION_DRAW_AND_SWAP_ABORT;
     else if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)
       return ACTION_DRAW_AND_SWAP_FORCED;
     else
       return ACTION_DRAW_AND_SWAP_IF_POSSIBLE;
   }
   if (ShouldManageTiles())
     return ACTION_MANAGE_TILES;
+  if (ShouldAnimate())
+    return ACTION_ANIMATE;
   if (ShouldSendBeginMainFrame())
     return ACTION_SEND_BEGIN_MAIN_FRAME;
   if (ShouldBeginOutputSurfaceCreation())
     return ACTION_BEGIN_OUTPUT_SURFACE_CREATION;
   return ACTION_NONE;
 }
 
 void SchedulerStateMachine::CheckInvariants() {
   // We should never try to perform a draw for readback and forced draw due to
   // timeout simultaneously.
@@ skipping 13 matching lines @@
 
     case ACTION_UPDATE_VISIBLE_TILES:
       last_frame_number_update_visible_tiles_was_called_ =
           current_frame_number_;
       return;
 
     case ACTION_ACTIVATE_PENDING_TREE:
       UpdateStateOnActivation();
       return;
 
+    case ACTION_ANIMATE:
+      last_frame_number_animate_performed_ = current_frame_number_;
+      return;
+
     case ACTION_SEND_BEGIN_MAIN_FRAME:
       DCHECK(!has_pending_tree_ ||
              settings_.main_frame_before_activation_enabled);
       DCHECK(!active_tree_needs_first_draw_ ||
              settings_.main_frame_before_draw_enabled);
       DCHECK(visible_ ||
              readback_state_ == READBACK_STATE_NEEDS_BEGIN_MAIN_FRAME);
       commit_state_ = COMMIT_STATE_BEGIN_MAIN_FRAME_SENT;
       needs_commit_ = false;
       if (readback_state_ == READBACK_STATE_NEEDS_BEGIN_MAIN_FRAME)
@@ skipping 572 matching lines @@
     case OUTPUT_SURFACE_ACTIVE:
     case OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT:
     case OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION:
       return true;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace cc