CC Animation: Erase cc::LayerSettings everywhere.

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 <stdint.h>
 
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/animation_host.h"
@@ skipping 25 matching lines @@
       : timeline_id_(AnimationIdProvider::NextTimelineId()),
         player_id_(AnimationIdProvider::NextPlayerId()),
         player_child_id_(AnimationIdProvider::NextPlayerId()) {
     timeline_ = AnimationTimeline::Create(timeline_id_);
     player_ = AnimationPlayer::Create(player_id_);
     player_child_ = AnimationPlayer::Create(player_child_id_);
 
     player_->set_layer_animation_delegate(this);
   }
 
-  void InitializeSettings(LayerTreeSettings* settings) override {
-    settings->use_compositor_animation_timelines = true;
-  }
-
-  void InitializeLayerSettings(LayerSettings* layer_settings) override {
-    layer_settings->use_compositor_animation_timelines = true;
-  }
-
   void AttachPlayersToTimeline() {
     layer_tree_host()->animation_host()->AddAnimationTimeline(timeline_.get());
     timeline_->AttachPlayer(player_.get());
     timeline_->AttachPlayer(player_child_.get());
   }
 
  protected:
   scoped_refptr<AnimationTimeline> timeline_;
   scoped_refptr<AnimationPlayer> player_;
   scoped_refptr<AnimationPlayer> player_child_;
@@ skipping 204 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAnimationsGetDeleted);
 
 // Ensure that an animation's timing function is respected.
 class LayerTreeHostAnimationTestAddAnimationWithTimingFunction
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    picture_ = FakePictureLayer::Create(layer_settings(), &client_);
+    picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(picture_->bounds());
     layer_tree_host()->root_layer()->AddChild(picture_);
 
     AttachPlayersToTimeline();
     player_child_->AttachLayer(picture_->id());
   }
 
   void BeginTest() override {
     PostAddAnimationToMainThreadPlayer(player_child_.get());
@@ skipping 44 matching lines @@
 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:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    picture_ = FakePictureLayer::Create(layer_settings(), &client_);
+    picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(picture_->bounds());
 
     layer_tree_host()->root_layer()->AddChild(picture_);
 
     AttachPlayersToTimeline();
     player_child_->set_layer_animation_delegate(this);
     player_child_->AttachLayer(picture_->id());
   }
 
@@ skipping 72 matching lines @@
 
 // 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_() {}
 
   void SetupTree() override {
-    update_check_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    update_check_layer_ = FakePictureLayer::Create(&client_);
     update_check_layer_->SetOpacity(0.f);
     layer_tree_host()->SetRootLayer(update_check_layer_);
     client_.set_bounds(update_check_layer_->bounds());
     LayerTreeHostAnimationTest::SetupTree();
 
     AttachPlayersToTimeline();
     player_->AttachLayer(update_check_layer_->id());
   }
 
   void BeginTest() override {
@@ skipping 35 matching lines @@
 // animation correctly recognized.
 class LayerTreeHostAnimationTestLayerAddedWithAnimation
     : public LayerTreeHostAnimationTest {
  public:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1) {
       AttachPlayersToTimeline();
 
-      scoped_refptr<Layer> layer = Layer::Create(layer_settings());
+      scoped_refptr<Layer> layer = Layer::Create();
       player_->AttachLayer(layer->id());
       player_->set_layer_animation_delegate(this);
 
       // Any valid AnimationCurve will do here.
       scoped_ptr<AnimationCurve> curve(new FakeFloatAnimationCurve());
       scoped_ptr<Animation> animation(
           Animation::Create(std::move(curve), 1, 1, TargetProperty::OPACITY));
       player_->AddAnimation(std::move(animation));
 
       // We add the animation *before* attaching the layer to the tree.
@@ skipping 125 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAnimateAfterSetNeedsCommit);
 
 // Animations should not be started when frames are being skipped due to
 // checkerboard.
 class LayerTreeHostAnimationTestCheckerboardDoesntStartAnimations
     : public LayerTreeHostAnimationTest {
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    picture_ = FakePictureLayer::Create(layer_settings(), &client_);
+    picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(picture_->bounds());
     layer_tree_host()->root_layer()->AddChild(picture_);
 
     AttachPlayersToTimeline();
     player_child_->AttachLayer(picture_->id());
     player_child_->set_layer_animation_delegate(this);
   }
 
   void InitializeSettings(LayerTreeSettings* settings) override {
@@ skipping 66 matching lines @@
 
 // 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:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
 
-    scroll_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    scroll_layer_ = FakePictureLayer::Create(&client_);
     scroll_layer_->SetScrollClipLayerId(layer_tree_host()->root_layer()->id());
     scroll_layer_->SetBounds(gfx::Size(1000, 1000));
     client_.set_bounds(scroll_layer_->bounds());
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset(10, 20));
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
 
     AttachPlayersToTimeline();
     player_child_->AttachLayer(scroll_layer_->id());
   }
 
@@ skipping 40 matching lines @@
 // delta.
 class LayerTreeHostAnimationTestScrollOffsetAnimationRemoval
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestScrollOffsetAnimationRemoval()
       : final_postion_(50.0, 100.0) {}
 
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
 
-    scroll_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    scroll_layer_ = FakePictureLayer::Create(&client_);
     scroll_layer_->SetScrollClipLayerId(layer_tree_host()->root_layer()->id());
     scroll_layer_->SetBounds(gfx::Size(10000, 10000));
     client_.set_bounds(scroll_layer_->bounds());
     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(
@@ skipping 107 matching lines @@
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1) {
       player_->AttachLayer(layer_tree_host()->root_layer()->id());
       AddAnimatedTransformToPlayer(player_.get(), 4, 1, 1);
     } else if (layer_tree_host()->source_frame_number() == 2) {
       AddOpacityTransitionToPlayer(player_.get(), 1, 0.f, 0.5f, true);
 
-      scoped_refptr<Layer> layer = Layer::Create(layer_settings());
+      scoped_refptr<Layer> layer = Layer::Create();
       layer_tree_host()->root_layer()->AddChild(layer);
       layer->SetBounds(gfx::Size(4, 4));
 
       player_child_->AttachLayer(layer->id());
       player_child_->set_layer_animation_delegate(this);
       AddOpacityTransitionToPlayer(player_child_.get(), 1, 0.f, 0.5f, true);
     }
   }
 
   void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
@@ skipping 63 matching lines @@
 // This test blocks activation which is not supported for single thread mode.
 MULTI_THREAD_BLOCKNOTIFY_TEST_F(
     LayerTreeHostAnimationTestAnimationsAddedToNewAndExistingLayers);
 
 class LayerTreeHostAnimationTestPendingTreeAnimatesFirstCommit
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
 
-    layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    layer_ = FakePictureLayer::Create(&client_);
     layer_->SetBounds(gfx::Size(2, 2));
     client_.set_bounds(layer_->bounds());
     // Transform the layer to 4,4 to start.
     gfx::Transform start_transform;
     start_transform.Translate(4.0, 4.0);
     layer_->SetTransform(start_transform);
 
     layer_tree_host()->root_layer()->AddChild(layer_);
     player_->AttachLayer(layer_->id());
 
@@ skipping 57 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestPendingTreeAnimatesFirstCommit);
 
 // When a layer with an animation is removed from the tree and later re-added,
 // the animation should resume.
 class LayerTreeHostAnimationTestAnimatedLayerRemovedAndAdded
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    layer_ = Layer::Create(layer_settings());
+    layer_ = Layer::Create();
     layer_->SetBounds(gfx::Size(4, 4));
     layer_tree_host()->root_layer()->AddChild(layer_);
 
     layer_tree_host()->animation_host()->AddAnimationTimeline(timeline_.get());
     timeline_->AttachPlayer(player_.get());
     player_->AttachLayer(layer_->id());
     DCHECK(player_->element_animations());
 
     AddOpacityTransitionToPlayer(player_.get(), 10000.0, 0.1f, 0.9f, true);
   }
@@ skipping 76 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAnimatedLayerRemovedAndAdded);
 
 class LayerTreeHostAnimationTestAddAnimationAfterAnimating
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    layer_ = Layer::Create(layer_settings());
+    layer_ = Layer::Create();
     layer_->SetBounds(gfx::Size(4, 4));
     layer_tree_host()->root_layer()->AddChild(layer_);
 
     AttachPlayersToTimeline();
 
     player_->AttachLayer(layer_tree_host()->root_layer()->id());
     player_child_->AttachLayer(layer_->id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
@@ skipping 42 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAddAnimationAfterAnimating);
 
 class LayerTreeHostAnimationTestRemoveAnimation
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    layer_ = FakePictureLayer::Create(&client_);
     layer_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(layer_->bounds());
     layer_tree_host()->root_layer()->AddChild(layer_);
 
     AttachPlayersToTimeline();
 
     player_->AttachLayer(layer_tree_host()->root_layer()->id());
     player_child_->AttachLayer(layer_->id());
   }
 
@@ skipping 16 matching lines @@
 
         // Do something that causes property trees to get rebuilt. This is
         // intended to simulate the conditions that caused the bug whose fix
         // this is testing (the test will pass without it but won't test what
         // we want it to). We were updating the wrong transform node at the end
         // of an animation (we were assuming the layer with the finished
         // animation still had its own transform node). But nodes can only get
         // added/deleted when something triggers a rebuild. Adding a layer
         // triggers a rebuild, and since the layer that had an animation before
         // no longer has one, it doesn't get a transform node in the rebuild.
-        layer_->AddChild(Layer::Create(layer_settings()));
+        layer_->AddChild(Layer::Create());
         break;
     }
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     LayerImpl* root = host_impl->active_tree()->root_layer();
     LayerImpl* child = root->children()[0].get();
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0:
         // No animation yet.
@@ skipping 24 matching lines @@
   FakeContentLayerClient client_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestRemoveAnimation);
 
 class LayerTreeHostAnimationTestIsAnimating
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    layer_ = FakePictureLayer::Create(&client_);
     layer_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(layer_->bounds());
     layer_tree_host()->root_layer()->AddChild(layer_);
 
     AttachPlayersToTimeline();
     player_->AttachLayer(layer_->id());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ skipping 64 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestIsAnimating);
 
 class LayerTreeHostAnimationTestAnimationFinishesDuringCommit
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAnimationFinishesDuringCommit()
       : signalled_(false) {}
 
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    layer_ = FakePictureLayer::Create(&client_);
     layer_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(layer_->bounds());
     layer_tree_host()->root_layer()->AddChild(layer_);
 
     AttachPlayersToTimeline();
 
     player_->AttachLayer(layer_tree_host()->root_layer()->id());
     player_child_->AttachLayer(layer_->id());
   }
 
@@ skipping 55 matching lines @@
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAnimationFinishesDuringCommit);
 
 class LayerTreeHostAnimationTestNotifyAnimationFinished
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestNotifyAnimationFinished()
       : called_animation_started_(false), called_animation_finished_(false) {}
 
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    picture_ = FakePictureLayer::Create(layer_settings(), &client_);
+    picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(picture_->bounds());
     layer_tree_host()->root_layer()->AddChild(picture_);
 
     AttachPlayersToTimeline();
     player_->AttachLayer(picture_->id());
     player_->set_layer_animation_delegate(this);
   }
 
   void BeginTest() override {
@@ skipping 112 matching lines @@
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestSetPotentiallyAnimatingOnLacDestruction);
 
 // Check that we invalidate property trees on AnimationPlayer::SetNeedsCommit.
 class LayerTreeHostAnimationTestRebuildPropertyTreesOnAnimationSetNeedsCommit
     : public LayerTreeHostAnimationTest {
  public:
   void SetupTree() override {
     LayerTreeHostAnimationTest::SetupTree();
-    layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    layer_ = FakePictureLayer::Create(&client_);
     layer_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(layer_->bounds());
     layer_tree_host()->root_layer()->AddChild(layer_);
 
     AttachPlayersToTimeline();
 
     player_->AttachLayer(layer_tree_host()->root_layer()->id());
     player_child_->AttachLayer(layer_->id());
   }
 
@@ skipping 24 matching lines @@
  private:
   scoped_refptr<Layer> layer_;
   FakeContentLayerClient client_;
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestRebuildPropertyTreesOnAnimationSetNeedsCommit);
 
 }  // namespace
 }  // namespace cc