Moving background animation ticking from LayerTreeHostImpl into the Scheduler.

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 <algorithm>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 158 matching lines @@
                  &completion,
                  visible));
   completion.Wait();
 }
 
 void ThreadProxy::SetVisibleOnImplThread(CompletionEvent* completion,
                                          bool visible) {
   TRACE_EVENT0("cc", "ThreadProxy::SetVisibleOnImplThread");
   impl().layer_tree_host_impl->SetVisible(visible);
   impl().scheduler->SetVisible(visible);
-  UpdateBackgroundAnimateTicking();
   completion->Signal();
 }
 
-void ThreadProxy::UpdateBackgroundAnimateTicking() {
-  bool should_background_tick =
-      !impl().scheduler->WillDrawIfNeeded() &&
-      impl().layer_tree_host_impl->active_tree()->root_layer();
-  impl().layer_tree_host_impl->UpdateBackgroundAnimateTicking(
-      should_background_tick);
-}
-
 void ThreadProxy::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "ThreadProxy::DidLoseOutputSurface");
   DCHECK(IsMainThread());
   layer_tree_host()->DidLoseOutputSurface();
 
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
     // Return lost resources to their owners immediately.
     BlockingTaskRunner::CapturePostTasks blocked(
@@ skipping 150 matching lines @@
 
 void ThreadProxy::WillBeginImplFrame(const BeginFrameArgs& args) {
   impl().layer_tree_host_impl->WillBeginImplFrame(args);
 }
 
 void ThreadProxy::OnCanDrawStateChanged(bool can_draw) {
   TRACE_EVENT1(
       "cc", "ThreadProxy::OnCanDrawStateChanged", "can_draw", can_draw);
   DCHECK(IsImplThread());
   impl().scheduler->SetCanDraw(can_draw);
-  UpdateBackgroundAnimateTicking();
 }
 
 void ThreadProxy::NotifyReadyToActivate() {
   TRACE_EVENT0("cc", "ThreadProxy::NotifyReadyToActivate");
   impl().scheduler->NotifyReadyToActivate();
 }
 
 void ThreadProxy::SetNeedsCommitOnImplThread() {
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsCommitOnImplThread");
   DCHECK(IsImplThread());
@@ skipping 548 matching lines @@
   if (did_handle)
     SetInputThrottledUntilCommitOnImplThread(false);
   impl().layer_tree_host_impl->BeginMainFrameAborted(did_handle);
   impl().scheduler->BeginMainFrameAborted(did_handle);
 }
 
 void ThreadProxy::ScheduledActionAnimate() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionAnimate");
   DCHECK(IsImplThread());
 
+  // Don't animate if there is no root layer.
+  // TODO(mithro): Both Animate and UpdateAnimationState already have a
+  // "!active_tree_->root_layer()" check?
+  if (!impl().layer_tree_host_impl->active_tree()->root_layer()) {
+    return;
+  }
+
   impl().animation_time =
       impl().layer_tree_host_impl->CurrentBeginFrameArgs().frame_time;
   impl().layer_tree_host_impl->Animate(impl().animation_time);
+
+  // If animations are not visible, update the state now as
+  // ScheduledActionDrawAndSwapIfPossible will never be called.
+  if (!impl().layer_tree_host_impl->AnimationsAreVisible()) {
+    impl().layer_tree_host_impl->UpdateAnimationState(true);
+  }
 }
 
 void ThreadProxy::ScheduledActionCommit() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionCommit");
   DCHECK(IsImplThread());
   DCHECK(IsMainThreadBlocked());
   DCHECK(impl().commit_completion_event);
   DCHECK(impl().current_resource_update_controller);
 
   // Complete all remaining texture updates.
@@ skipping 23 matching lines @@
     impl().commit_completion_event->Signal();
     impl().commit_completion_event = NULL;
   }
 
   // Delay this step until afer the main thread has been released as it's
   // often a good bit of work to update the tree and prepare the new frame.
   impl().layer_tree_host_impl->CommitComplete();
 
   SetInputThrottledUntilCommitOnImplThread(false);
 
-  UpdateBackgroundAnimateTicking();
-
   impl().next_frame_is_newly_committed_frame = true;
 
   impl().timing_history.DidCommit();
 }
 
 void ThreadProxy::ScheduledActionUpdateVisibleTiles() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionUpdateVisibleTiles");
   DCHECK(IsImplThread());
   impl().layer_tree_host_impl->UpdateVisibleTiles();
 }
@@ skipping 357 matching lines @@
   DCHECK(IsImplThread());
 
   if (impl().completion_event_for_commit_held_on_tree_activation) {
     TRACE_EVENT_INSTANT0(
         "cc", "ReleaseCommitbyActivation", TRACE_EVENT_SCOPE_THREAD);
     DCHECK(impl().layer_tree_host_impl->settings().impl_side_painting);
     impl().completion_event_for_commit_held_on_tree_activation->Signal();
     impl().completion_event_for_commit_held_on_tree_activation = NULL;
   }
 
-  UpdateBackgroundAnimateTicking();
-
   impl().timing_history.DidActivateSyncTree();
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidManageTiles();
 }
 
 }  // namespace cc