cc: Split animating and drawing into separate actions

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 <limits>
 
 #include "base/basictypes.h"
@@ skipping 443 matching lines @@
     page_scale_animation_->ZoomWithAnchor(anchor,
                                           page_scale,
                                           duration.InSecondsF());
   } else {
     gfx::Vector2dF scaled_target_offset = target_offset;
     page_scale_animation_->ZoomTo(scaled_target_offset,
                                   page_scale,
                                   duration.InSecondsF());
   }
 
-  SetNeedsRedraw();
+  SetNeedsAnimate();
   client_->SetNeedsCommitOnImplThread();
   client_->RenewTreePriority();
 }
 
-void LayerTreeHostImpl::ScheduleAnimation() {
-  SetNeedsRedraw();
-}
+void LayerTreeHostImpl::ScheduleAnimation() { SetNeedsAnimate(); }

[brianderson, 2014/04/01 16:05:11]

Can we get rid of ScheduleAnimation?

[Sami, 2014/04/17 15:16:33]

Looks like we can, done.

 
 bool LayerTreeHostImpl::HaveTouchEventHandlersAt(
     const gfx::Point& viewport_point) {
   if (!settings_.touch_hit_testing)
     return true;
   if (!EnsureRenderSurfaceLayerList())
     return false;
 
   gfx::PointF device_viewport_point =
       gfx::ScalePoint(viewport_point, device_scale_factor_);
@@ skipping 1190 matching lines @@
   // draw or timer tick.
   if (!visible_)
     ManageTiles();
 
   if (!renderer_)
     return;
 
   renderer_->SetVisible(visible);
 }
 
+void LayerTreeHostImpl::SetNeedsAnimate() {
+  client_->SetNeedsAnimateOnImplThread();
+}
+
 void LayerTreeHostImpl::SetNeedsRedraw() {
   NotifySwapPromiseMonitorsOfSetNeedsRedraw();

[brianderson, 2014/04/01 16:05:11]

What does NotifySwapPromiseMonitorsOfSetNeedsRedraw do? Do we need it in
SetNeedsAnimate too?

[Sami, 2014/04/17 15:16:33]

As far as I understand it, that call tells the latency tracking system that we
are about to draw and swap soon. A call to SetNeedsAnimate() by itself isn't a
strong enough guarantee of that, because the animation may end up being a no-op,
so I don't think we need the call there.

+miletus@, could you verify my assumptions?

[danakj, 2014/04/17 15:18:09]

It is meant to tell the monitor that we might draw and swap and cause it to
insert a LatencyInfo. It can have false positives. The LatencyInfo should later
be aborted if we don't end up drawing as a result.

   client_->SetNeedsRedrawOnImplThread();
 }
 
 ManagedMemoryPolicy LayerTreeHostImpl::ActualManagedMemoryPolicy() const {
   ManagedMemoryPolicy actual = cached_managed_memory_policy_;
   // TODO(ernstm): The second condition disables pre-painting for all layers
   // when GPU rasterization is enabled. Once we selectively enable GPU
   // rasterization per layer, we also need to disable pre-painting selectively:
   // crbug.com/335387
   if (debug_state_.rasterize_only_visible_content ||
@@ skipping 960 matching lines @@
       monotonic_time_for_cc_animations);
 
   ScrollViewportBy(next_scroll - scroll_total);
   SetNeedsRedraw();
 
   if (page_scale_animation_->IsAnimationCompleteAtTime(
           monotonic_time_for_cc_animations)) {
     page_scale_animation_.reset();
     client_->SetNeedsCommitOnImplThread();
     client_->RenewTreePriority();
+  } else {
+    SetNeedsAnimate();

[brianderson, 2014/04/01 16:05:11]

Can you get rid of the SetNeedsRedraw above?

In the current patch, SetNeedsAnimate eventually implies SetNeedsRedraw in the
scheduler. In the future, it seems like you want the animation system to trigger
a redraw if something has changed. In both cases, I don't think the
SetNeedsRedraw is needed.

[Sami, 2014/04/17 15:16:33]

I think we still need the SetNeedsRedraw here because AnimatePageScale is the
"animation system" for page scale animations, and really only it knows when a
redraw is needed. I guess an alternative would be to move more of this logic to
input/page_scale_animation.cc, or better yet introduce a new
PageScaleAnimationManager.

You're right that it isn't required in the sense that things still work, but
I've made some of the animation unit tests to enforce the separation between
SetNeedsAnimate and SetNeedsRedraw.

   }
 }
 
 void LayerTreeHostImpl::AnimateTopControls(base::TimeTicks time) {
   if (!top_controls_manager_ || !top_controls_manager_->animation())
     return;
   gfx::Vector2dF scroll = top_controls_manager_->Animate(time);
   if (active_tree_->TotalScrollOffset().y() == 0.f)
     return;
   if (scroll.IsZero()) {
-    // This may happen on the first animation step. Force redraw otherwise
+    // This may happen on the first animation step. Force animate otherwise
     // the animation would stop because of no new frames.
-    SetNeedsRedraw();
+    SetNeedsAnimate();

[brianderson, 2014/04/01 16:05:11]

I guess this is the way it already is, but I wonder why this SetNeedsAnimate
isn't needed for the else block?

[Sami, 2014/04/17 15:16:33]

Good question. I think we should call SetNeedsAnimate in both cases here. It
looks the way this worked is that top_controls_manager_->Animate() ends up
calling DidChangeTopControlsPosition, which in turn calls SetNeedsRedraw. Now
that we can schedule animation without relying on that callback I think we can
just remove this special case.

   } else {
     ScrollViewportBy(gfx::ScaleVector2d(
         scroll, 1.f / active_tree_->total_page_scale_factor()));
   }
 }
 
 void LayerTreeHostImpl::AnimateLayers(base::TimeTicks monotonic_time) {
   if (!settings_.accelerated_animation_enabled ||
       !needs_animate_layers() ||
       !active_tree_->root_layer())
     return;
 
   TRACE_EVENT0("cc", "LayerTreeHostImpl::AnimateLayers");
 
   // TODO(ajuma): http://crbug.com/178171 - Animations use double for monotonic
   // time.
   double monotonic_time_for_cc_animations =
       (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_time_for_cc_animations);
 
-  SetNeedsRedraw();
+  SetNeedsAnimate();
 }
 
 void LayerTreeHostImpl::UpdateAnimationState(bool start_ready_animations) {
   if (!settings_.accelerated_animation_enabled ||
       !needs_animate_layers() ||
       !active_tree_->root_layer())
     return;
 
   TRACE_EVENT0("cc", "LayerTreeHostImpl::UpdateAnimationState");
   scoped_ptr<AnimationEventsVector> events =
@@ skipping 89 matching lines @@
 
 void LayerTreeHostImpl::AnimateScrollbarsRecursive(LayerImpl* layer,
                                                    base::TimeTicks time) {
   if (!layer)
     return;
 
   ScrollbarAnimationController* scrollbar_controller =
       layer->scrollbar_animation_controller();
   if (scrollbar_controller && scrollbar_controller->Animate(time)) {
     TRACE_EVENT_INSTANT0(
-        "cc", "LayerTreeHostImpl::SetNeedsRedraw due to AnimateScrollbars",
+        "cc",
+        "LayerTreeHostImpl::SetNeedsAnimate due to AnimateScrollbars",
         TRACE_EVENT_SCOPE_THREAD);
-    SetNeedsRedraw();
+    SetNeedsAnimate();
   }
 
   for (size_t i = 0; i < layer->children().size(); ++i)
     AnimateScrollbarsRecursive(layer->children()[i], time);
 }
 
 void LayerTreeHostImpl::StartScrollbarAnimation() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::StartScrollbarAnimation");
   StartScrollbarAnimationRecursive(RootLayer(), CurrentFrameTimeTicks());
 }
 
 void LayerTreeHostImpl::StartScrollbarAnimationRecursive(LayerImpl* layer,
                                                          base::TimeTicks time) {
   if (!layer)
     return;
 
   ScrollbarAnimationController* scrollbar_controller =
       layer->scrollbar_animation_controller();
   if (scrollbar_controller && scrollbar_controller->IsAnimating()) {
     base::TimeDelta delay = scrollbar_controller->DelayBeforeStart(time);
-    if (delay > base::TimeDelta())
+    if (delay > base::TimeDelta()) {
       client_->RequestScrollbarAnimationOnImplThread(delay);
-    else if (scrollbar_controller->Animate(time))
-      SetNeedsRedraw();
+    } else if (scrollbar_controller->Animate(time)) {
+      SetNeedsAnimate();
+    }
   }
 
   for (size_t i = 0; i < layer->children().size(); ++i)
     StartScrollbarAnimationRecursive(layer->children()[i], time);
 }
 
 void LayerTreeHostImpl::SetTreePriority(TreePriority priority) {
   if (!tile_manager_)
     return;
 
@@ skipping 170 matching lines @@
   swap_promise_monitor_.erase(monitor);
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 }  // namespace cc