UI Compositor: Fix threaded animation survival if layer removed and added.

ui/compositor/layer_animator_unittest.cc

 // Copyright (c) 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 "ui/compositor/layer_animator.h"
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
@@ skipping 2514 matching lines @@
 
   Layer layer;
   root_1.Add(&layer);
   LayerAnimator* animator = layer.GetAnimator();
   double target_opacity = 1.0;
   base::TimeDelta time_delta = base::TimeDelta::FromSeconds(1);
   animator->ScheduleAnimation(new LayerAnimationSequence(
       LayerAnimationElement::CreateOpacityElement(target_opacity, time_delta)));
   EXPECT_TRUE(compositor_1->layer_animator_collection()->HasActiveAnimators());
   EXPECT_FALSE(compositor_2->layer_animator_collection()->HasActiveAnimators());
+  EXPECT_TRUE(layer.cc_layer_for_testing()->HasActiveAnimation());
 
   root_2.Add(&layer);
   EXPECT_FALSE(compositor_1->layer_animator_collection()->HasActiveAnimators());
   EXPECT_TRUE(compositor_2->layer_animator_collection()->HasActiveAnimators());
+  EXPECT_TRUE(layer.cc_layer_for_testing()->HasActiveAnimation());
+
   host_2.reset();
   host_1.reset();
   TerminateContextFactoryForTests();
 }
 
+TEST(LayerAnimatorTest, ThreadedAnimationSurvivesIfLayerRemovedAdded) {
+  bool enable_pixel_output = false;
+  ui::ContextFactory* context_factory =
+      InitializeContextFactoryForTests(enable_pixel_output);
+  const gfx::Rect bounds(10, 10, 100, 100);
+  scoped_ptr<TestCompositorHost> host(
+      TestCompositorHost::Create(bounds, context_factory));
+  host->Show();
+
+  Compositor* compositor = host->GetCompositor();
+
+  Layer root;
+  compositor->SetRootLayer(&root);
+
+  Layer layer;
+  root.Add(&layer);
+
+  LayerAnimator* animator = layer.GetAnimator();
+  double target_opacity = 1.0;
+  base::TimeDelta time_delta = base::TimeDelta::FromSeconds(1);
+  animator->ScheduleAnimation(new LayerAnimationSequence(
+      LayerAnimationElement::CreateOpacityElement(target_opacity, time_delta)));
+
+  EXPECT_TRUE(layer.cc_layer_for_testing()->HasActiveAnimation());
+  root.Remove(&layer);
+  root.Add(&layer);
+  EXPECT_TRUE(layer.cc_layer_for_testing()->HasActiveAnimation());
+
+  host.reset();
+  TerminateContextFactoryForTests();
+}
+
 class LayerOwnerAnimationObserver : public LayerAnimationObserver {
  public:
   LayerOwnerAnimationObserver(LayerAnimator* animator)
       : animator_layer_(new Layer(LAYER_TEXTURED)) {
     animator_layer_->SetAnimator(animator);
   }
 
   ~LayerOwnerAnimationObserver() override {}
 
   void OnLayerAnimationEnded(LayerAnimationSequence* sequence) override {
@@ skipping 244 matching lines @@
   EXPECT_EQ(observer.last_ended_sequence(), nullptr);
   EXPECT_EQ(observer.last_detached_sequence(), first_sequence);
 
   EXPECT_TRUE(observer.AbortedEpochIsBeforeDetachedEpoch());
   EXPECT_TRUE(observer.AbortedEpochIsBeforeStartedEpoch());
   EXPECT_TRUE(observer.AttachedEpochIsBeforeScheduledEpoch());
   EXPECT_TRUE(observer.ScheduledEpochIsBeforeStartedEpoch());
 }
 
 }  // namespace ui