CC Animation: Erase cc::LayerSettings everywhere.

cc/layers/layer_position_constraint_unittest.cc

 // Copyright 2013 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/layers/layer_position_constraint.h"
 
 #include <vector>
 
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
-#include "cc/layers/layer_settings.h"
 #include "cc/proto/layer_position_constraint.pb.h"
 #include "cc/test/fake_layer_tree_host.h"
 #include "cc/test/fake_proxy.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 class LayerWithForcedDrawsContent : public Layer {
  public:
-  explicit LayerWithForcedDrawsContent(const LayerSettings& settings)
-      : Layer(settings) {}
+  LayerWithForcedDrawsContent() {}
 
   bool DrawsContent() const override;
 
  private:
   ~LayerWithForcedDrawsContent() override {}
 };
 
 bool LayerWithForcedDrawsContent::DrawsContent() const {
   return true;
 }
@@ skipping 44 matching lines @@
     CreateTreeForTest();
     fixed_to_top_left_.set_is_fixed_position(true);
     fixed_to_bottom_right_.set_is_fixed_position(true);
     fixed_to_bottom_right_.set_is_fixed_to_right_edge(true);
     fixed_to_bottom_right_.set_is_fixed_to_bottom_edge(true);
   }
 
   void CreateTreeForTest() {
     // scroll_layer_ is the inner viewport scroll layer and child_ is the outer
     // viewport scroll layer.
-    root_ = Layer::Create(layer_settings_);
-    inner_viewport_container_layer_ = Layer::Create(layer_settings_);
-    scroll_layer_ = Layer::Create(layer_settings_);
-    outer_viewport_container_layer_ = Layer::Create(layer_settings_);
-    child_transform_layer_ = Layer::Create(layer_settings_);
-    child_ = Layer::Create(layer_settings_);
-    grand_child_ =
-        make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings_));
-    great_grand_child_ =
-        make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings_));
+    root_ = Layer::Create();
+    inner_viewport_container_layer_ = Layer::Create();
+    scroll_layer_ = Layer::Create();
+    outer_viewport_container_layer_ = Layer::Create();
+    child_transform_layer_ = Layer::Create();
+    child_ = Layer::Create();
+    grand_child_ = make_scoped_refptr(new LayerWithForcedDrawsContent());
+    great_grand_child_ = make_scoped_refptr(new LayerWithForcedDrawsContent());
 
     gfx::Transform IdentityMatrix;
     gfx::Point3F transform_origin;
     gfx::PointF position;
     gfx::Size bounds(200, 200);
     gfx::Size clip_bounds(100, 100);
     SetLayerPropertiesForTesting(inner_viewport_container_layer_.get(),
                                  IdentityMatrix, transform_origin, position,
                                  clip_bounds, true);
     SetLayerPropertiesForTesting(scroll_layer_.get(), IdentityMatrix,
@@ skipping 57 matching lines @@
         outer_viewport_container_layer_impl_->children()[0].get();
     child_impl_ = child_transform_layer_impl_->children()[0].get();
     grand_child_impl_ = child_impl_->children()[0].get();
     great_grand_child_impl_ = grand_child_impl_->children()[0].get();
   }
 
  protected:
   FakeLayerTreeHostClient fake_client_;
   TestTaskGraphRunner task_graph_runner_;
   scoped_ptr<FakeLayerTreeHost> layer_tree_host_;
-  LayerSettings layer_settings_;
   scoped_refptr<Layer> root_;
   scoped_refptr<Layer> inner_viewport_container_layer_;
   scoped_refptr<Layer> scroll_layer_;
   scoped_refptr<Layer> outer_viewport_container_layer_;
   scoped_refptr<Layer> child_transform_layer_;
   scoped_refptr<Layer> child_;
   scoped_refptr<Layer> grand_child_;
   scoped_refptr<Layer> great_grand_child_;
   LayerImpl* root_impl_;
   LayerImpl* inner_viewport_container_layer_impl_;
@@ skipping 358 matching lines @@
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerWithMultipleIntermediateSurfaces) {
   // This test checks for correct scroll compensation when the fixed-position
   // container contributes to a different render surface than the fixed-position
   // layer, with additional render surfaces in-between. This checks that the
   // conversion to ancestor surfaces is accumulated properly in the final matrix
   // transform.
 
   // Add one more layer to the test tree for this scenario.
   scoped_refptr<Layer> fixed_position_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings_));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   SetLayerPropertiesForTesting(fixed_position_child.get(), gfx::Transform(),
                                gfx::Point3F(), gfx::PointF(),
                                gfx::Size(100, 100), true);
   great_grand_child_->AddChild(fixed_position_child);
 
   // Actually set up the scenario here.
   child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPosition(gfx::PointF(8.f, 6.f));
   grand_child_->SetForceRenderSurface(true);
   great_grand_child_->SetPosition(gfx::PointF(40.f, 60.f));
@@ skipping 136 matching lines @@
     LayerPositionConstraintTest,
     ScrollCompensationForFixedPositionLayerWithMultipleSurfacesAndTransforms) {
   // This test checks for correct scroll compensation when the fixed-position
   // container contributes to a different render surface than the fixed-position
   // layer, with additional render surfaces in-between, and the fixed-position
   // container is transformed. This checks that the conversion to ancestor
   // surfaces is accumulated properly in the final matrix transform.
 
   // Add one more layer to the test tree for this scenario.
   scoped_refptr<Layer> fixed_position_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings_));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   SetLayerPropertiesForTesting(fixed_position_child.get(), gfx::Transform(),
                                gfx::Point3F(), gfx::PointF(),
                                gfx::Size(100, 100), true);
   great_grand_child_->AddChild(fixed_position_child);
 
   // Actually set up the scenario here.
   child_transform_layer_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPosition(gfx::PointF(8.f, 6.f));
   grand_child_->SetForceRenderSurface(true);
   great_grand_child_->SetPosition(gfx::PointF(40.f, 60.f));
@@ skipping 311 matching lines @@
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedWithinFixedWithInterveningContainer) {
   // This test checks scroll compensation for a fixed-position layer that is
   // inside of another fixed-position layer, but they have different fixed
   // position containers. In this situation, the child fixed-position element
   // would still have to compensate with respect to its container.
 
   // Add one more layer to the hierarchy for this test.
   scoped_refptr<Layer> great_great_grand_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings_));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   great_grand_child_->AddChild(great_great_grand_child);
 
   child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPositionConstraint(fixed_to_top_left_);
   great_grand_child_->SetIsContainerForFixedPositionLayers(true);
   great_grand_child_->SetScrollClipLayerId(root_->id());
   great_great_grand_child->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
@@ skipping 32 matching lines @@
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_to_container2_transform,
                                   fixed_to_container2->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
        ScrollCompensationForInnerViewportBoundsDelta) {
   // This test checks for correct scroll compensation when the fixed-position
   // container is the inner viewport scroll layer and has non-zero bounds delta.
   scoped_refptr<Layer> fixed_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings_));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   fixed_child->SetBounds(gfx::Size(300, 300));
   scroll_layer_->AddChild(fixed_child);
   fixed_child->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   LayerImpl* fixed_child_impl =
       root_impl_->layer_tree_impl()->FindActiveTreeLayerById(fixed_child->id());
 
   // Case 1: fixed-container size delta of 20, 20
@@ skipping 54 matching lines @@
   VerifySerializeAndDeserializeProto(true, false, true);
   VerifySerializeAndDeserializeProto(true, false, false);
   VerifySerializeAndDeserializeProto(false, true, true);
   VerifySerializeAndDeserializeProto(false, true, false);
   VerifySerializeAndDeserializeProto(false, false, true);
   VerifySerializeAndDeserializeProto(false, false, false);
 }
 
 }  // namespace
 }  // namespace cc