cc: Make animations tick regardless of drawing.

cc/trees/thread_proxy.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/trees/thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "cc/base/thread.h"
@@ skipping 330 matching lines @@
       "cc", "ThreadProxy::RequestVSyncNotification", "enable", !!client);
   vsync_client_ = client;
   layer_tree_host_impl_->EnableVSyncNotification(!!client);
 }
 
 void ThreadProxy::OnCanDrawStateChanged(bool can_draw) {
   DCHECK(IsImplThread());
   TRACE_EVENT1(
       "cc", "ThreadProxy::OnCanDrawStateChanged", "can_draw", can_draw);
   scheduler_on_impl_thread_->SetCanDraw(can_draw);
+  layer_tree_host_impl_->UpdateBackgroundAnimateTicking();
 }
 
 void ThreadProxy::OnHasPendingTreeStateChanged(bool has_pending_tree) {
   DCHECK(IsImplThread());
   TRACE_EVENT1("cc",
                "ThreadProxy::OnHasPendingTreeStateChanged",
                "has_pending_tree",
                has_pending_tree);
   scheduler_on_impl_thread_->SetHasPendingTree(has_pending_tree);
 }
@@ skipping 443 matching lines @@
 
   // Complete all remaining texture updates.
   current_resource_update_controller_on_impl_thread_->Finalize();
   current_resource_update_controller_on_impl_thread_.reset();
 
   layer_tree_host_impl_->BeginCommit();
   layer_tree_host_->BeginCommitOnImplThread(layer_tree_host_impl_.get());
   layer_tree_host_->FinishCommitOnImplThread(layer_tree_host_impl_.get());
   layer_tree_host_impl_->CommitComplete();
 
+  layer_tree_host_impl_->UpdateBackgroundAnimateTicking();
+
   next_frame_is_newly_committed_frame_on_impl_thread_ = true;
 
   if (layer_tree_host_->settings().impl_side_painting &&
       layer_tree_host_->BlocksPendingCommit()) {
     // For some layer types in impl-side painting, the commit is held until
     // the pending tree is activated.
     TRACE_EVENT_INSTANT0("cc", "HoldCommit", TRACE_EVENT_SCOPE_THREAD);
     completion_event_for_commit_held_on_tree_activation_ =
         commit_completion_event_on_impl_thread_;
     commit_completion_event_on_impl_thread_ = NULL;
@@ skipping 45 matching lines @@
 
   // FIXME: compute the frame display time more intelligently
   base::TimeTicks monotonic_time = base::TimeTicks::Now();
   base::Time wall_clock_time = base::Time::Now();
 
   if (input_handler_on_impl_thread_)
     input_handler_on_impl_thread_->Animate(monotonic_time);
 
   layer_tree_host_impl_->ActivatePendingTreeIfNeeded();
   layer_tree_host_impl_->Animate(monotonic_time, wall_clock_time);
+  layer_tree_host_impl_->UpdateBackgroundAnimateTicking();
 
   // 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
   // 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
   // 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.
 
   LayerTreeHostImpl::FrameData frame;
   bool draw_frame =
       layer_tree_host_impl_->CanDraw() &&
       (layer_tree_host_impl_->PrepareToDraw(&frame) || forced_draw);
   if (draw_frame) {
     layer_tree_host_impl_->DrawLayers(
         &frame,
         scheduler_on_impl_thread_->LastVSyncTime());
     result.did_draw= true;
   }
   layer_tree_host_impl_->DidDrawAllLayers(frame);
 
+  layer_tree_host_impl_->UpdateAnimationState();

[ajuma, 2013/04/04 15:28:47]

If the call to PrepareToDraw (above) returned false, causing us to skip the
frame, we don't want to start animations (to avoid regressing
http://crbug.com/123593), but it makes sense to continue ticking/finishing
in-progress animations. We could add a |DoNotPromoteAnimations| argument to
UpdateAnimationState, passing it on to LayerAnimationController::UpdateState,
preventing this from calling PromoteStartedAnimations.

[danakj, 2013/04/04 18:28:25]

Ok, I've done this and added
LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations.RunMultiThread.

This test does not run in single thread mode as it does not  skip drawing due to
checkerboard.

+
   // Check for tree activation.
   if (completion_event_for_commit_held_on_tree_activation_ &&
       !layer_tree_host_impl_->pending_tree()) {
     TRACE_EVENT_INSTANT0("cc", "ReleaseCommitbyActivation",
                          TRACE_EVENT_SCOPE_THREAD);
     DCHECK(layer_tree_host_impl_->settings().impl_side_painting);
     completion_event_for_commit_held_on_tree_activation_->Signal();
     completion_event_for_commit_held_on_tree_activation_ = NULL;
   }
 
@@ skipping 400 matching lines @@
       base::Bind(&ThreadProxy::StartScrollbarAnimationOnImplThread,
                  impl_thread_weak_ptr_),
       delay);
 }
 
 void ThreadProxy::StartScrollbarAnimationOnImplThread() {
   layer_tree_host_impl_->StartScrollbarAnimation(base::TimeTicks::Now());
 }
 
 }  // namespace cc