cc: Use BeginFrameArgs

cc/trees/layer_tree_host_unittest_animation.cc

 // Copyright 2012 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.h"
 
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/timing_function.h"
 #include "cc/layers/layer.h"
@@ skipping 252 matching lines @@
   virtual void BeginTest() OVERRIDE {
     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   // Use WillAnimateLayers to set visible false before the animation runs and
   // causes a commit, so we block the second visible animate in single-thread
   // mode.
   virtual void WillAnimateLayers(
       LayerTreeHostImpl* host_impl,
       base::TimeTicks monotonic_time) OVERRIDE {
+    if (!host_impl->active_tree()->root_layer())

[enne (OOO), 2013/08/15 19:47:59]

I'm a little confused why animation is happening with this patch.  It looks like
in LTHI that animation happens right before drawing or during a background tick.
 Is drawing happening without a root layer for this test?

That said, what do you think about moving this early out (and other similar
ones) to LayerTreeHostImplForTesting::AnimateLayers or even up to the callers of
LayerTreeHostImpl::Animate?

The real LayerTreeHostImpl bails when there's not an active tree and I don't see
a reason to call animate without an active tree.  Also, all the unit tests still
pass with that change.

[brianderson, 2013/08/15 23:05:10]

I would be fine with moving the early out up to the callers of
LayerTreeHostImpl::Animate. Is it okay that we do not animate the pending tree
when there's no active tree?

[brianderson, 2013/08/15 23:45:12]

Animation used to be coupled with drawing, but this patch moves drawing to the
deadline and keeps animation in the impl thread's BeginFrame when using
ThreadProxy.

This should allow us to better prioritize tiles and make more informed
activation decisions before the deadline.

[enne (OOO), 2013/08/16 00:53:22]

Yeah.  LayerTreeHostImpl::Animate does this check.  The only way there can be no
active tree is if there has never been a commit.  Animations aren't started
until they get to the active tree so that the full animation gets displayed to
the user.  Therefore, the only reason you need to animate the pending tree is if
there's an animation happening on the active tree that also affects the same
layer in the pending tree.

+      return;
+
     // Verify that the host can draw, it's just not visible.
     EXPECT_TRUE(host_impl->CanDraw());
     if (num_animates_ < 2) {
       if (!num_animates_) {
         // We have a long animation running. It should continue to tick even
         // if we are not visible.
         PostSetVisibleToMainThread(false);
       }
       num_animates_++;
       return;
@@ skipping 23 matching lines @@
     layer_tree_host()->root_layer()->AddChild(content_);
   }
 
   virtual void BeginTest() OVERRIDE {
     PostAddAnimationToMainThread(content_.get());
   }
 
   virtual void AnimateLayers(
       LayerTreeHostImpl* host_impl,
       base::TimeTicks monotonic_time) OVERRIDE {
+    if (!host_impl->active_tree()->root_layer())
+      return;
     LayerAnimationController* controller_impl =
         host_impl->active_tree()->root_layer()->children()[0]->
         layer_animation_controller();
     Animation* animation =
         controller_impl->GetAnimation(Animation::Opacity);
     if (!animation)
       return;
 
     const FloatAnimationCurve* curve =
         animation->curve()->ToFloatAnimationCurve();
@@ skipping 49 matching lines @@
     main_start_time_ = animation->start_time();
     controller->RemoveAnimation(animation->id());
 
     if (impl_start_time_ > 0.0)
       EndTest();
   }
 
   virtual void UpdateAnimationState(
       LayerTreeHostImpl* impl_host,
       bool has_unfinished_animation) OVERRIDE {
+    if (!impl_host->active_tree()->root_layer())
+      return;
+
     LayerAnimationController* controller =
         impl_host->active_tree()->root_layer()->children()[0]->
         layer_animation_controller();
     Animation* animation =
         controller->GetAnimation(Animation::Opacity);
     if (!animation)
       return;
 
     impl_start_time_ = animation->start_time();
     controller->RemoveAnimation(animation->id());
@@ skipping 341 matching lines @@
   virtual void DispatchAddInstantAnimation(Layer* layer_to_receive_animation)
       OVERRIDE {
     LayerTreeHostAnimationTest::DispatchAddInstantAnimation(
         layer_to_receive_animation);
     added_animations_++;
   }
 
   virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                      LayerTreeHostImpl::FrameData* frame_data,
                                      bool result) OVERRIDE {
-    if (added_animations_ < 2)
+    if (host_impl->active_tree()->source_frame_number() < 2)
       return result;
     if (TestEnded())
       return result;
     // Act like there is checkerboard when the second animation wants to draw.
     ++prevented_draw_;
+    if (finished_times_)
+      EndTest();
     return false;
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // The animation is longer than 1 BeginFrame interval.
         AddOpacityTransitionToLayer(content_.get(), 0.1, 0.2f, 0.8f, false);
         added_animations_++;
         break;
       case 2:
         // This second animation will not be drawn so it should not start.
         AddAnimatedTransformToLayer(content_.get(), 0.1, 5, 5);
         added_animations_++;
         break;
     }
   }
 
   virtual void NotifyAnimationStarted(double wall_clock_time) OVERRIDE {
     if (TestEnded())
       return;
     started_times_++;
   }
 
   virtual void NotifyAnimationFinished(double wall_clock_time) OVERRIDE {
     // We should be checkerboarding already, but it should still finish the
     // first animation.
-    EXPECT_EQ(2, added_animations_);

[enne (OOO), 2013/08/15 19:47:59]

Just as a sanity check, move this to AfterTest rather than removing it?

[brianderson, 2013/08/15 23:05:10]

Ok.

     finished_times_++;
-    EndTest();
+    if (prevented_draw_)
+      EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {
     // Make sure we tried to draw the second animation but failed.
     EXPECT_LT(0, prevented_draw_);
     // The first animation should be started, but the second should not because
     // of checkerboard.
     EXPECT_EQ(1, started_times_);
     // The first animation should still be finished.
     EXPECT_EQ(1, finished_times_);
   }
 
   int prevented_draw_;
   int added_animations_;
   int started_times_;
   int finished_times_;
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> content_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations);
 
 }  // namespace
 }  // namespace cc