cc: Make animations tick regardless of drawing.

cc/trees/thread_proxy.cc

Index: cc/trees/thread_proxy.cc
diff --git a/cc/trees/thread_proxy.cc b/cc/trees/thread_proxy.cc
index a09850a5ece8968e1f7868140f1c74fe0202676a..f4cd60de252eeda76116c895bde9b84a72d56670 100644
--- a/cc/trees/thread_proxy.cc
+++ b/cc/trees/thread_proxy.cc
@@ -348,6 +348,8 @@ void ThreadProxy::OnCanDrawStateChanged(bool can_draw) {
   TRACE_EVENT1(
       "cc", "ThreadProxy::OnCanDrawStateChanged", "can_draw", can_draw);
   scheduler_on_impl_thread_->SetCanDraw(can_draw);
+  layer_tree_host_impl_->UpdateBackgroundAnimateTicking(
+      !layer_tree_host_impl_->visible() || !can_draw);

[enne (OOO), 2013/04/05 17:06:53]

I think this is halfway to what I was trying to ask for.  There are parts of the
code that call UpdateAnimationState and then sometimes you don't get to those
parts.  Is it possible to call UpdateBackgroundAnimateTicking(true) in such
cases, rather than checking states here?

[danakj, 2013/04/05 17:54:49]

To be clear, background animate ticking causes us to run
Animate()+UpdateAnimateState() on a timer. It's for when we won't be drawing, so
animations will stop progressing otherwise.

So it's about more than UpadteAnimateState(). Any time we entire a state where
a) we're not drawing and b) we have an animation, then we want to enable
background animation ticking.

is this what you were thinking of when you asked for this?

 }
 
 void ThreadProxy::OnHasPendingTreeStateChanged(bool has_pending_tree) {
@@ -811,6 +813,9 @@ void ThreadProxy::ScheduledActionCommit() {
   layer_tree_host_->FinishCommitOnImplThread(layer_tree_host_impl_.get());
   layer_tree_host_impl_->CommitComplete();
 
+  layer_tree_host_impl_->UpdateBackgroundAnimateTicking(
+      !layer_tree_host_impl_->visible() || !layer_tree_host_impl_->CanDraw());
+
   next_frame_is_newly_committed_frame_on_impl_thread_ = true;
 
   if (layer_tree_host_->settings().impl_side_painting &&
@@ -876,30 +881,42 @@ ThreadProxy::ScheduledActionDrawAndSwapInternal(bool forced_draw) {
 
   layer_tree_host_impl_->ActivatePendingTreeIfNeeded();
   layer_tree_host_impl_->Animate(monotonic_time, wall_clock_time);
+  layer_tree_host_impl_->UpdateBackgroundAnimateTicking(false);
 
   // This method is called on a forced draw, regardless of whether we are able
   // to produce a frame, as the calling site on main thread is blocked until its
-  // request completes, and we signal completion here. If canDraw() is false, we
+  // request completes, and we signal completion here. If CanDraw() is false, we
   // will indicate success=false to the caller, but we must still signal
   // completion to avoid deadlock.
 
-  // We guard prepareToDraw() with canDraw() because it always returns a valid
+  // We guard PrepareToDraw() with CanDraw() because it always returns a valid
   // frame, so can only be used when such a frame is possible. Since
-  // drawLayers() depends on the result of prepareToDraw(), it is guarded on
-  // canDraw() as well.
+  // DrawLayers() depends on the result of PrepareToDraw(), it is guarded on
+  // CanDraw() as well.
 
   LayerTreeHostImpl::FrameData frame;
-  bool draw_frame =
-      layer_tree_host_impl_->CanDraw() &&
-      (layer_tree_host_impl_->PrepareToDraw(&frame) || forced_draw);
+  bool draw_frame = false;
+  bool start_ready_animations = true;
+
+  if (layer_tree_host_impl_->CanDraw()) {
+    // Do not start animations if we skip drawing the frame to avoid
+    // checkerboarding.
+    if (layer_tree_host_impl_->PrepareToDraw(&frame) || forced_draw)
+      draw_frame = true;
+    else
+      start_ready_animations = false;
+  }
+
   if (draw_frame) {
     layer_tree_host_impl_->DrawLayers(
         &frame,
         scheduler_on_impl_thread_->LastVSyncTime());
-    result.did_draw= true;
+    result.did_draw = true;
   }
   layer_tree_host_impl_->DidDrawAllLayers(frame);
 
+  layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
+
   // Check for tree activation.
   if (completion_event_for_commit_held_on_tree_activation_ &&
       !layer_tree_host_impl_->pending_tree()) {