De-activate LayerAnimationControllers when all animations are WaitingForDeletion

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 236 matching lines @@
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   bool started_animating_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAnimationsGetDeleted);
 
 // Ensures that animations continue to be ticked when we are backgrounded.
 class LayerTreeHostAnimationTestTickAnimationWhileBackgrounded

[ajuma, 2013/11/15 18:32:50]

This test was flaking on the Windows trybots. Since the animation we were adding
was really short (0.000001 seconds), I suspect we were getting the following
sequence of events:
-animation added to main thread
-animation committed to impl thread
-animation ticked on the impl thread (num_animates_ is now 1)
-animation ticked again on the impl thread, finishing and moving into
WaitingForDeletion (num_animates_ is now 2)
-ThreadProxy::SetVisibleOnImplThread makes us non-visible, and we don't trigger
background ticking since there are no active animation controllers
-the test hangs since WillAnimateLayers is never called again

To fix this, I've increased the duration of the animation to 1 second (but note
that this shouldn't actually make the test take 1 second, since the test
finishes once we've ticked animations 3 times).

     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestTickAnimationWhileBackgrounded()
       : num_animates_(0) {}
 
   virtual void BeginTest() OVERRIDE {
-    PostAddAnimationToMainThread(layer_tree_host()->root_layer());
+    PostAddLongAnimationToMainThread(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 {
     // Verify that the host can draw, it's just not visible.
     EXPECT_TRUE(host_impl->CanDraw());
@@ skipping 584 matching lines @@
 
   virtual void BeginTest() OVERRIDE {
     prevented_draw_ = 0;
     added_animations_ = 0;
     started_times_ = 0;
     finished_times_ = 0;
 
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DispatchAddInstantAnimation(Layer* layer_to_receive_animation)
-      OVERRIDE {

[ajuma, 2013/11/15 18:32:50]

This needed to be changed, since this CL removes DispatchAddInstantAnimation in
LayerTreeTest. But there doesn't seem to be any way for this code to get reached
in this test, since we never call PostAddInstantAnimationToMainThread. So I've
removed this method altogether.

-    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)
       return result;
     if (TestEnded())
       return result;
     // Act like there is checkerboard when the second animation wants to draw.
     ++prevented_draw_;
     return false;
@@ skipping 44 matching lines @@
   int finished_times_;
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> content_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations);
 
 }  // namespace
 }  // namespace cc