cc: Avoid updating animations in the background without an active tree

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 86 matching lines @@
     }
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int num_animates_;
 };
 
-// Temporarily suppressed per crbug.com/280706.
-//MULTI_THREAD_TEST_F(
-//    LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback);
+MULTI_THREAD_TEST_F(
+    LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback);
 
 // Add a layer animation and confirm that
 // LayerTreeHostImpl::updateAnimationState does get called and continues to
 // get called.
 class LayerTreeHostAnimationTestAddAnimation
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAddAnimation()
       : num_animates_(0),
         received_animation_started_notification_(false),
@@ skipping 167 matching lines @@
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int num_animates_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestTickAnimationWhileBackgrounded);
 
+// Ensures that animations do not tick when we are backgrounded and
+// and the active tree's root layer is null.
+class LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree
+    : public LayerTreeHostAnimationTest {
+ public:
+  virtual void BeginTest() OVERRIDE {
+    PostAddAnimationToMainThread(layer_tree_host()->root_layer());
+  }
+
+  virtual void NotifyAnimationFinished(double time) OVERRIDE {
+    // Replace animated commits with a null root layer commit.
+    layer_tree_host()->SetRootLayer(make_scoped_refptr<Layer>(NULL));
+  }
+
+  virtual void DidCommit() OVERRIDE {
+    // This alternates setting the root tree null and root tree with animation.

[danakj, 2013/08/29 17:22:17]

"setting the root tree null" - i think you mean setting an empty tree?

"and root tree with animation" - setting a non-empty tree with an animation?

+    switch (layer_tree_host()->source_frame_number()) {
+      case 1:
+        // Wait for NotifyAnimationFinished to set the root layer to null.
+        break;
+      case 2:
+        SetupTree();
+        PostAddAnimationToMainThread(layer_tree_host()->root_layer());

[danakj, 2013/08/29 17:22:17]

This is going to be racey, you're post-tasking the add animation, but the impl
thread could have already post-tasked the beginframe. You should just add the
animation directly.

You could also do the same in BeginTest() and simply PostSNC().

+        break;
+      case 3:
+        // Wait for NotifyAnimationFinished to set the root layer to null.
+        break;
+      case 4:
+        EndTest();
+        break;
+    }
+  }
+
+  virtual void BeginCommitOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+    // At the start of every commit, block activations and make sure
+    // we are backgrounded.
+    host_impl->BlockNotifyReadyToActivateForTesting(true);
+    PostSetVisibleToMainThread(false);
+  }
+
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+    if (host_impl->settings().impl_side_painting) {
+      // We block activation for several ticks to make sure that, even though
+      // there is a pending tree with animations, we still do not background
+      // tick if the active tree has a null root layer.
+      if (host_impl->pending_tree()->source_frame_number() < 4) {
+        base::MessageLoopProxy::current()->PostDelayedTask(
+            FROM_HERE,
+            base::Bind(
+                &LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree::

[danakj, 2013/08/29 17:22:17]

80 col. save the Bind() result in a callback before this PostDelayedTask to
avoid this?

Callback cb = base::Bind(
     &LayerTre...

+                     UnblockActivations,
+                base::Unretained(this),
+                host_impl),
+            4 * LowFrequencyAnimationInterval());
+      }
+    } else {
+      UnblockActivations(host_impl);

[danakj, 2013/08/29 17:22:17]

if (!impl paint) do this and early out?  maybe that solves the 80col problem too

+    }
+  }
+
+  virtual void UnblockActivations(LayerTreeHostImpl* host_impl) {
+    host_impl->BlockNotifyReadyToActivateForTesting(false);
+
+    // Initiate the next commit after a delay to give us a chance to background
+    // tick if the root layer isn't null.
+    base::MessageLoopProxy::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(
+            &LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree::
+                 InitiateNextCommit,
+            base::Unretained(this)),
+        4 * LowFrequencyAnimationInterval());
+  }
+
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+    // Verify that we are actually alternating null root layers.
+    switch (host_impl->active_tree()->source_frame_number()) {
+      case 1:
+      case 3:
+        EXPECT_FALSE(host_impl->active_tree()->root_layer());
+        break;
+      case 0:
+      case 2:
+        EXPECT_TRUE(host_impl->active_tree()->root_layer());
+        break;
+    }
+  }
+
+  virtual void InitiateNextCommit() {

[danakj, 2013/08/29 17:22:17]

not virtual?

+    // The next commit is blocked until we become visible again.
+    PostSetVisibleToMainThread(true);
+  }
+
+  virtual void WillAnimateLayers(LayerTreeHostImpl* host_impl,
+                                 base::TimeTicks monotonic_time) OVERRIDE {
+    EXPECT_TRUE(host_impl->active_tree()->root_layer());
+  }
+
+  virtual void AfterTest() OVERRIDE {}
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(
+    LayerTreeHostAnimationTestNoBackgroundTickingWithoutActiveTree);
+
 // Ensure that an animation's timing function is respected.
 class LayerTreeHostAnimationTestAddAnimationWithTimingFunction
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAddAnimationWithTimingFunction() {}
 
   virtual void SetupTree() OVERRIDE {
     LayerTreeHostAnimationTest::SetupTree();
     content_ = FakeContentLayer::Create(&client_);
     content_->SetBounds(gfx::Size(4, 4));
@@ skipping 491 matching lines @@
   int finished_times_;
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> content_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations);
 
 }  // namespace
 }  // namespace cc