cc: Make unittests use FakePictureLayer instead of FakeContentLayer.

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/scroll_offset_animation_curve.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/time_util.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/test/animation_test_common.h"
-#include "cc/test/fake_content_layer.h"
 #include "cc/test/fake_content_layer_client.h"
+#include "cc/test/fake_picture_layer.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/trees/layer_tree_impl.h"
 
 namespace cc {
 namespace {
 
 class LayerTreeHostAnimationTest : public LayerTreeTest {
  public:
   void SetupTree() override {
     LayerTreeTest::SetupTree();
@@ skipping 197 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAnimationsGetDeleted);
 
 // Ensure that an animation's timing function is respected.
 class LayerTreeHostAnimationTestAddAnimationWithTimingFunction
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAddAnimationWithTimingFunction() {}
 
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    content_ = FakeContentLayer::Create(layer_settings(), &client_);
-    content_->SetBounds(gfx::Size(4, 4));
-    layer_tree_host()->root_layer()->AddChild(content_);
+    picture_ = FakePictureLayer::Create(layer_settings(), &client_);
+    picture_->SetBounds(gfx::Size(4, 4));
+    layer_tree_host()->root_layer()->AddChild(picture_);
   }
 
-  void BeginTest() override { PostAddAnimationToMainThread(content_.get()); }
+  void BeginTest() override { PostAddAnimationToMainThread(picture_.get()); }
 
   void AnimateLayers(LayerTreeHostImpl* host_impl,
                      base::TimeTicks monotonic_time) override {
     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();
     float start_opacity = curve->GetValue(base::TimeDelta());
     float end_opacity = curve->GetValue(curve->Duration());
     float linearly_interpolated_opacity =
         0.25f * end_opacity + 0.75f * start_opacity;
     base::TimeDelta time = TimeUtil::Scale(curve->Duration(), 0.25f);
     // If the linear timing function associated with this animation was not
     // picked up, then the linearly interpolated opacity would be different
     // because of the default ease timing function.
     EXPECT_FLOAT_EQ(linearly_interpolated_opacity, curve->GetValue(time));
 
     EndTest();
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
-  scoped_refptr<FakeContentLayer> content_;
+  scoped_refptr<FakePictureLayer> picture_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAddAnimationWithTimingFunction);
 
 // Ensures that main thread animations have their start times synchronized with
 // impl thread animations.
 class LayerTreeHostAnimationTestSynchronizeAnimationStartTimes
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestSynchronizeAnimationStartTimes() {}
 
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    content_ = FakeContentLayer::Create(layer_settings(), &client_);
-    content_->SetBounds(gfx::Size(4, 4));
-    content_->set_layer_animation_delegate(this);
-    layer_tree_host()->root_layer()->AddChild(content_);
+    picture_ = FakePictureLayer::Create(layer_settings(), &client_);
+    picture_->SetBounds(gfx::Size(4, 4));
+    picture_->set_layer_animation_delegate(this);
+    layer_tree_host()->root_layer()->AddChild(picture_);
   }
 
-  void BeginTest() override { PostAddAnimationToMainThread(content_.get()); }
+  void BeginTest() override { PostAddAnimationToMainThread(picture_.get()); }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                               Animation::TargetProperty target_property,
                               int group) override {
     LayerAnimationController* controller =
         layer_tree_host()->root_layer()->children()[0]->
         layer_animation_controller();
     Animation* animation = controller->GetAnimation(Animation::OPACITY);
     main_start_time_ = animation->start_time();
     controller->RemoveAnimation(animation->id());
@@ skipping 14 matching lines @@
 
   void AfterTest() override {
     EXPECT_EQ(impl_start_time_, main_start_time_);
     EXPECT_LT(base::TimeTicks(), impl_start_time_);
   }
 
  private:
   base::TimeTicks main_start_time_;
   base::TimeTicks impl_start_time_;
   FakeContentLayerClient client_;
-  scoped_refptr<FakeContentLayer> content_;
+  scoped_refptr<FakePictureLayer> picture_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestSynchronizeAnimationStartTimes);
 
 // Ensures that notify animation finished is called.
 class LayerTreeHostAnimationTestAnimationFinishedEvents
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAnimationFinishedEvents() {}
@@ skipping 19 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAnimationFinishedEvents);
 
 // Ensures that when opacity is being animated, this value does not cause the
 // subtree to be skipped.
 class LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity()
       : update_check_layer_(
-            FakeContentLayer::Create(layer_settings(), &client_)) {}
+            FakePictureLayer::Create(layer_settings(), &client_)) {}
 
   void SetupTree() override {
     update_check_layer_->SetOpacity(0.f);
     layer_tree_host()->SetRootLayer(update_check_layer_);
     LayerTreeHostAnimationTest::SetupTree();
   }
 
   void BeginTest() override {
     PostAddAnimationToMainThread(update_check_layer_.get());
   }
@@ skipping 11 matching lines @@
     // Update() should have been called once, proving that the layer was not
     // skipped.
     EXPECT_EQ(1u, update_check_layer_->update_count());
 
     // clear update_check_layer_ so LayerTreeHost dies.
     update_check_layer_ = NULL;
   }
 
  private:
   FakeContentLayerClient client_;
-  scoped_refptr<FakeContentLayer> update_check_layer_;
+  scoped_refptr<FakePictureLayer> update_check_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestDoNotSkipLayersWithAnimatedOpacity);
 
 // Layers added to tree with existing active animations should have the
 // animation correctly recognized.
 class LayerTreeHostAnimationTestLayerAddedWithAnimation
     : public LayerTreeHostAnimationTest {
  public:
@@ skipping 61 matching lines @@
   void AfterTest() override {
     EXPECT_EQ(2, num_begin_frames_);
     EXPECT_EQ(1, num_commit_calls_);
     EXPECT_EQ(1, num_draw_calls_);
   }
 
  private:
   int num_begin_frames_;
   int num_commit_calls_;
   int num_draw_calls_;
-  FakeContentLayerClient client_;
-  scoped_refptr<FakeContentLayer> content_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestCancelAnimateCommit);
 
 class LayerTreeHostAnimationTestForceRedraw
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestForceRedraw()
       : num_animate_(0), num_draw_layers_(0) {}
 
@@ skipping 61 matching lines @@
 
 // Make sure the main thread can still execute animations when CanDraw() is not
 // true.
 class LayerTreeHostAnimationTestRunAnimationWhenNotCanDraw
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestRunAnimationWhenNotCanDraw() : started_times_(0) {}
 
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    content_ = FakeContentLayer::Create(layer_settings(), &client_);
-    content_->SetBounds(gfx::Size(4, 4));
-    content_->set_layer_animation_delegate(this);
-    layer_tree_host()->root_layer()->AddChild(content_);
+    picture_ = FakePictureLayer::Create(layer_settings(), &client_);
+    picture_->SetBounds(gfx::Size(4, 4));
+    picture_->set_layer_animation_delegate(this);
+    layer_tree_host()->root_layer()->AddChild(picture_);
   }
 
   void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size());
-    PostAddAnimationToMainThread(content_.get());
+    PostAddAnimationToMainThread(picture_.get());
   }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                               Animation::TargetProperty target_property,
                               int group) override {
     started_times_++;
   }
 
   void NotifyAnimationFinished(base::TimeTicks monotonic_time,
                                Animation::TargetProperty target_property,
                                int group) override {
     EndTest();
   }
 
   void AfterTest() override { EXPECT_EQ(1, started_times_); }
 
  private:
   int started_times_;
   FakeContentLayerClient client_;
-  scoped_refptr<FakeContentLayer> content_;
+  scoped_refptr<FakePictureLayer> picture_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestRunAnimationWhenNotCanDraw);
 
 // Animations should not be started when frames are being skipped due to
 // checkerboard.
 class LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations
     : public LayerTreeHostAnimationTest {
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    content_ = FakeContentLayer::Create(layer_settings(), &client_);
-    content_->SetBounds(gfx::Size(4, 4));
-    content_->set_layer_animation_delegate(this);
-    layer_tree_host()->root_layer()->AddChild(content_);
+    picture_ = FakePictureLayer::Create(layer_settings(), &client_);
+    picture_->SetBounds(gfx::Size(4, 4));
+    picture_->set_layer_animation_delegate(this);
+    layer_tree_host()->root_layer()->AddChild(picture_);
   }
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     // Make sure that drawing many times doesn't cause a checkerboarded
     // animation to start so we avoid flake in this test.
     settings->timeout_and_draw_when_animation_checkerboards = false;
   }
 
   void BeginTest() override {
     prevented_draw_ = 0;
@@ skipping 14 matching lines @@
     ++prevented_draw_;
     if (prevented_draw_ > 2)
       EndTest();
     return DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
   }
 
   void DidCommitAndDrawFrame() 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);
+        AddOpacityTransitionToLayer(picture_.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);
+        AddAnimatedTransformToLayer(picture_.get(), 0.1, 5, 5);
         added_animations_++;
         break;
     }
   }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
                               Animation::TargetProperty target_property,
                               int group) override {
     if (TestEnded())
       return;
     started_times_++;
   }
 
   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_);
   }
 
   int prevented_draw_;
   int added_animations_;
   int started_times_;
   FakeContentLayerClient client_;
-  scoped_refptr<FakeContentLayer> content_;
+  scoped_refptr<FakePictureLayer> picture_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations);
 
 // Verifies that scroll offset animations are only accepted when impl-scrolling
 // is supported, and that when scroll offset animations are accepted,
 // scroll offset updates are sent back to the main thread.
 class LayerTreeHostAnimationTestScrollOffsetChangesArePropagated
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestScrollOffsetChangesArePropagated() {}
 
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
 
-    scroll_layer_ = FakeContentLayer::Create(layer_settings(), &client_);
+    scroll_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     scroll_layer_->SetScrollClipLayerId(layer_tree_host()->root_layer()->id());
     scroll_layer_->SetBounds(gfx::Size(1000, 1000));
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset(10, 20));
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
@@ skipping 17 matching lines @@
         if (scroll_layer_->scroll_offset().x() > 10 &&
             scroll_layer_->scroll_offset().y() > 20)
           EndTest();
     }
   }
 
   void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
-  scoped_refptr<FakeContentLayer> scroll_layer_;
+  scoped_refptr<FakePictureLayer> scroll_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestScrollOffsetChangesArePropagated);
 
 // Verifies that when the main thread removes a scroll animation and sets a new
 // scroll position, the active tree takes on exactly this new scroll position
 // after activation, and the main thread doesn't receive a spurious scroll
 // delta.
 class LayerTreeHostAnimationTestScrollOffsetAnimationRemoval
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestScrollOffsetAnimationRemoval()
       : final_postion_(50.0, 100.0) {}
 
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
 
-    scroll_layer_ = FakeContentLayer::Create(layer_settings(), &client_);
+    scroll_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     scroll_layer_->SetScrollClipLayerId(layer_tree_host()->root_layer()->id());
     scroll_layer_->SetBounds(gfx::Size(10000, 10000));
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset(100.0, 200.0));
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
 
     scoped_ptr<ScrollOffsetAnimationCurve> curve(
         ScrollOffsetAnimationCurve::Create(gfx::ScrollOffset(6500.f, 7500.f),
                                            EaseInOutTimingFunction::Create()));
     scoped_ptr<Animation> animation(
         Animation::Create(curve.Pass(), 1, 0, Animation::SCROLL_OFFSET));
@@ skipping 74 matching lines @@
     EXPECT_EQ(final_postion_, scroll_layer_impl->CurrentScrollOffset());
     EndTest();
   }
 
   void AfterTest() override {
     EXPECT_EQ(final_postion_, scroll_layer_->scroll_offset());
   }
 
  private:
   FakeContentLayerClient client_;
-  scoped_refptr<FakeContentLayer> scroll_layer_;
+  scoped_refptr<FakePictureLayer> scroll_layer_;
   const gfx::ScrollOffset final_postion_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestScrollOffsetAnimationRemoval);
 
 // When animations are simultaneously added to an existing layer and to a new
 // layer, they should start at the same time, even when there's already a
 // running animation on the existing layer.
 class LayerTreeHostAnimationTestAnimationsAddedToNewAndExistingLayers
     : public LayerTreeHostAnimationTest {
@@ skipping 80 matching lines @@
 
 // When a layer with an animation is removed from the tree and later re-added,
 // the animation should resume.
 class LayerTreeHostAnimationTestAnimatedLayerRemovedAndAdded
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAnimatedLayerRemovedAndAdded() {}
 
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    content_ = Layer::Create(layer_settings());
-    content_->SetBounds(gfx::Size(4, 4));
-    layer_tree_host()->root_layer()->AddChild(content_);
-    AddOpacityTransitionToLayer(content_.get(), 10000.0, 0.1f, 0.9f, true);
+    layer_ = Layer::Create(layer_settings());
+    layer_->SetBounds(gfx::Size(4, 4));
+    layer_tree_host()->root_layer()->AddChild(layer_);
+    AddOpacityTransitionToLayer(layer_.get(), 10000.0, 0.1f, 0.9f, true);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
-        content_->RemoveFromParent();
+        layer_->RemoveFromParent();
         break;
       case 2:
-        layer_tree_host()->root_layer()->AddChild(content_);
+        layer_tree_host()->root_layer()->AddChild(layer_);
         break;
     }
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0:
         EXPECT_TRUE(host_impl->animation_registrar()->needs_animate_layers());
         break;
       case 1:
         EXPECT_FALSE(host_impl->animation_registrar()->needs_animate_layers());
         break;
       case 2:
         EXPECT_TRUE(host_impl->animation_registrar()->needs_animate_layers());
         EndTest();
         break;
     }
   }
 
   void AfterTest() override {}
 
  private:
-  scoped_refptr<Layer> content_;
+  scoped_refptr<Layer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAnimatedLayerRemovedAndAdded);
 
 class LayerTreeHostAnimationTestAddAnimationAfterAnimating
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAddAnimationAfterAnimating()
       : num_swap_buffers_(0) {}
 
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    content_ = Layer::Create(layer_settings());
-    content_->SetBounds(gfx::Size(4, 4));
-    layer_tree_host()->root_layer()->AddChild(content_);
+    layer_ = Layer::Create(layer_settings());
+    layer_->SetBounds(gfx::Size(4, 4));
+    layer_tree_host()->root_layer()->AddChild(layer_);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // First frame: add an animation to the root layer.
         AddAnimatedTransformToLayer(layer_tree_host()->root_layer(), 0.1, 5, 5);
         break;
       case 2:
         // Second frame: add an animation to the content layer. The root layer
         // animation has caused us to animate already during this frame.
-        AddOpacityTransitionToLayer(content_.get(), 0.1, 5, 5, false);
+        AddOpacityTransitionToLayer(layer_.get(), 0.1, 5, 5, false);
         break;
     }
   }
 
   void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
     // After both animations have started, verify that they have valid
     // start times.
     num_swap_buffers_++;
     AnimationRegistrar::AnimationControllerMap controllers_copy =
         host_impl->animation_registrar()
@@ skipping 10 matching lines @@
           Animation* anim = it.second->GetAnimation(Animation::OPACITY);
           EXPECT_GT((anim->start_time() - base::TimeTicks()).InSecondsF(), 0);
         }
       }
     }
   }
 
   void AfterTest() override {}
 
  private:
-  scoped_refptr<Layer> content_;
+  scoped_refptr<Layer> layer_;
   int num_swap_buffers_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAddAnimationAfterAnimating);
 
 }  // namespace
 }  // namespace cc