cc: Make animations tick regardless of drawing.

cc/trees/layer_tree_host_impl.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/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 94 matching lines @@
     // correct. In fact, setting fake thread id's interferes with the real
     // thread id's and causes breakage.
     scoped_ptr<DebugScopedSetImplThread> set_impl_thread;
     if (!layer_tree_host_impl_->proxy()->HasImplThread()) {
       set_impl_thread.reset(
           new DebugScopedSetImplThread(layer_tree_host_impl_->proxy()));
     }
 
     layer_tree_host_impl_->ActivatePendingTreeIfNeeded();
     layer_tree_host_impl_->Animate(base::TimeTicks::Now(), base::Time::Now());
+    layer_tree_host_impl_->UpdateBackgroundAnimateTicking();
+    bool start_ready_animations = true;
+    layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
     layer_tree_host_impl_->BeginNextFrame();
   }
 
   void SetActive(bool active) {
     if (active != time_source_->Active())
       time_source_->SetActive(active);
   }
 
  private:
   LayerTreeHostImplTimeSourceAdapter(
@@ skipping 543 matching lines @@
     occlusion_tracker.overdraw_metrics()->RecordMetrics(this);
 
   RemoveRenderPasses(CullRenderPassesWithNoQuads(), frame);
   renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
   RemoveRenderPasses(CullRenderPassesWithCachedTextures(renderer_.get()),
                      frame);
 
   return draw_frame;
 }
 
-void LayerTreeHostImpl::SetBackgroundTickingEnabled(bool enabled) {
+void LayerTreeHostImpl::UpdateBackgroundAnimateTicking() {
+  bool able_to_draw = visible_ && CanDraw();

[enne (OOO), 2013/04/05 16:01:12]

These two lines of code bake in a bunch assumptions from code elsewhere about
when animations are actually updated and when they won't.

I think it'd be a little bit more elegant if it were possible to just call the
original SetBackgroundTickingEnabled(true) from the same bit of code
(ScheduledActionDrawAndSwapInternal or DoComposite) when it doesn't
UpdateAnimationState.

[danakj, 2013/04/05 16:38:58]

Ok, PTAL.

+  bool enabled = !able_to_draw &&
+                 !animation_registrar_->active_animation_controllers().empty();
+
   // Lazily create the time_source adapter so that we can vary the interval for
   // testing.
   if (!time_source_client_adapter_) {
     time_source_client_adapter_ = LayerTreeHostImplTimeSourceAdapter::Create(
         this,
         DelayBasedTimeSource::Create(LowFrequencyAnimationInterval(),
                                      proxy_->CurrentThread()));
   }
 
   time_source_client_adapter_->SetActive(enabled);
@@ skipping 346 matching lines @@
   DCHECK(frame->render_passes.empty());
   frame->render_passes_by_id.clear();
 
   // The next frame should start by assuming nothing has changed, and changes
   // are noted as they occur.
   for (size_t i = 0; i < frame->render_surface_layer_list->size(); i++) {
     (*frame->render_surface_layer_list)[i]->render_surface()->damage_tracker()->
         DidDrawDamagedArea();
   }
   active_tree_->root_layer()->ResetAllChangeTrackingForSubtree();
-  UpdateAnimationState();
 }
 
 void LayerTreeHostImpl::DidDrawAllLayers(const FrameData& frame) {
   for (size_t i = 0; i < frame.will_draw_layers.size(); ++i)
     frame.will_draw_layers[i]->DidDraw(resource_provider_.get());
 
   // Once all layers have been drawn, pending texture uploads should no
   // longer block future uploads.
   resource_provider_->MarkPendingUploadsAsNonBlocking();
 }
@@ skipping 184 matching lines @@
   if (visible_ == visible)
     return;
   visible_ = visible;
   DidVisibilityChange(this, visible_);
   EnforceManagedMemoryPolicy(managed_memory_policy_);
 
   if (!renderer_)
     return;
 
   renderer_->SetVisible(visible);
-
-  SetBackgroundTickingEnabled(
-      !visible_ &&
-      !animation_registrar_->active_animation_controllers().empty());
 }
 
 bool LayerTreeHostImpl::InitializeRenderer(
     scoped_ptr<OutputSurface> output_surface) {
   // Since we will create a new resource provider, we cannot continue to use
   // the old resources (i.e. render_surfaces and texture IDs). Clear them
   // before we destroy the old resource provider.
   if (active_tree_->root_layer())
     ClearRenderSurfaces();
   if (active_tree_->root_layer())
@@ skipping 551 matching lines @@
   double monotonic_seconds = (monotonic_time - base::TimeTicks()).InSecondsF();
 
   AnimationRegistrar::AnimationControllerMap copy =
       animation_registrar_->active_animation_controllers();
   for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
        iter != copy.end();
        ++iter)
     (*iter).second->Animate(monotonic_seconds);
 
   client_->SetNeedsRedrawOnImplThread();
-  SetBackgroundTickingEnabled(
-      !visible_ &&
-      !animation_registrar_->active_animation_controllers().empty());
 }
 
-void LayerTreeHostImpl::UpdateAnimationState() {
+void LayerTreeHostImpl::UpdateAnimationState(bool start_ready_animations) {
   if (!settings_.accelerated_animation_enabled ||
       animation_registrar_->active_animation_controllers().empty() ||
       !active_tree_->root_layer())
     return;
 
   TRACE_EVENT0("cc", "LayerTreeHostImpl::UpdateAnimationState");
   scoped_ptr<AnimationEventsVector> events =
       make_scoped_ptr(new AnimationEventsVector);
   AnimationRegistrar::AnimationControllerMap copy =
       animation_registrar_->active_animation_controllers();
   for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
        iter != copy.end();
        ++iter)
-    (*iter).second->UpdateState(events.get());
+    (*iter).second->UpdateState(start_ready_animations, events.get());
 
   if (!events->empty()) {
     client_->PostAnimationEventsToMainThreadOnImplThread(events.Pass(),
                                                          last_animation_time_);
   }
 }
 
 base::TimeDelta LayerTreeHostImpl::LowFrequencyAnimationInterval() const {
   return base::TimeDelta::FromSeconds(1);
 }
@@ skipping 200 matching lines @@
 }
 
 void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
   if (debug_state_.continuous_painting != debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = debug_state;
 }
 
 }  // namespace cc