CC Animation: Erase cc::LayerSettings everywhere.

cc/trees/layer_tree_host_common_unittest.cc

 // Copyright 2011 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_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 35 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 #include "ui/gfx/transform.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; }
 
 class MockContentLayerClient : public ContentLayerClient {
@@ skipping 18 matching lines @@
 
 #define EXPECT_IDEAL_SCALE_EQ(expected, layer)                 \
   do {                                                         \
     EXPECT_FLOAT_EQ(expected, layer->GetIdealContentsScale()); \
   } while (false)
 
 class LayerTreeSettingsScaleContent : public LayerTreeSettings {
  public:
   LayerTreeSettingsScaleContent() {
     layer_transforms_should_scale_layer_contents = true;
-    use_compositor_animation_timelines = true;
   }
 };
 
 class LayerTreeHostCommonScalingTest : public LayerTreeHostCommonTest {
  public:
   LayerTreeHostCommonScalingTest()
       : LayerTreeHostCommonTest(LayerTreeSettingsScaleContent()) {}
 };
 
 TEST_F(LayerTreeHostCommonTest, TransformsForNoOpLayer) {
   // Sanity check: For layers positioned at zero, with zero size,
   // and with identity transforms, then the draw transform,
   // screen space transform, and the hierarchy passed on to children
   // layers should also be identity transforms.
 
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child = Layer::Create(layer_settings());
-  scoped_refptr<Layer> grand_child = Layer::Create(layer_settings());
+  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> grand_child = Layer::Create();
   parent->AddChild(child);
   child->AddChild(grand_child);
 
   host()->SetRootLayer(parent);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
@@ skipping 78 matching lines @@
       parent->layer_tree_impl()->property_trees()->effect_tree;
   EffectNode* node = effect_tree.Node(child->effect_tree_index());
   const int transform_tree_size = parent->layer_tree_impl()
                                       ->property_trees()
                                       ->transform_tree.next_available_id();
   EXPECT_LT(node->data.transform_id, transform_tree_size);
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSingleLayer) {
   gfx::Transform identity_matrix;
-  scoped_refptr<Layer> layer = Layer::Create(layer_settings());
+  scoped_refptr<Layer> layer = Layer::Create();
 
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false);
   root->AddChild(layer);
 
   host()->SetRootLayer(root);
 
   TransformTree& tree = host()->property_trees()->transform_tree;
 
   // Case 2: Setting the bounds of the layer should not affect either the draw
   // transform or the screenspace transform.
@@ skipping 170 matching lines @@
                       sub_layer_screen_position.y() * kPageScale *
                           kDeviceScale));
   expected_transform.Scale(kPageScale * kDeviceScale,
                            kPageScale * kDeviceScale);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
                                   sublayer->DrawTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSimpleHierarchy) {
   gfx::Transform identity_matrix;
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child = Layer::Create(layer_settings());
-  scoped_refptr<Layer> grand_child = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> grand_child = Layer::Create();
   root->AddChild(parent);
   parent->AddChild(child);
   child->AddChild(grand_child);
 
   host()->SetRootLayer(root);
 
   // One-time setup of root layer
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false);
 
@@ skipping 579 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform,
                                   grand_child->ScreenSpaceTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_draw_transform,
                                   great_grand_child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_great_grand_child_screen_space_transform,
       great_grand_child->ScreenSpaceTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerFullyContainedWithinClipInTargetSpace) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   gfx::Transform child_transform;
   child_transform.Translate(50.0, 50.0);
   child_transform.RotateAboutZAxis(30.0);
 
   gfx::Transform grand_child_transform;
   grand_child_transform.RotateAboutYAxis(90.0);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
@@ skipping 2035 matching lines @@
   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), grand_child2->visible_layer_rect());
   EXPECT_TRUE(grand_child3->visible_layer_rect().IsEmpty());
 
   // All grandchild DrawableContentRects should also be clipped by child.
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), grand_child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 25, 25), grand_child2->drawable_content_rect());
   EXPECT_TRUE(grand_child3->drawable_content_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectWithClippingAndScaling) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(child);
   child->AddChild(grand_child);
 
   host()->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   gfx::Transform child_scale_matrix;
   child_scale_matrix.Scale(0.25f, 0.25f);
   gfx::Transform grand_child_scale_matrix;
   grand_child_scale_matrix.Scale(0.246f, 0.246f);
@@ skipping 471 matching lines @@
   // hence potentially occludes it).
   gfx::Rect layer_bounds = gfx::Rect(grand_child_ptr->bounds());
   EXPECT_EQ(
       layer_bounds,
       grand_child_ptr->draw_properties()
           .occlusion_in_content_space.GetUnoccludedContentRect(layer_bounds));
 }
 
 TEST_F(LayerTreeHostCommonTest,
        SingularTransformDoesNotPreventClearingDrawProperties) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(child);
 
   host()->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
 
   SetLayerPropertiesForTesting(root.get(),
                                uninvertible_matrix,
@@ skipping 23 matching lines @@
                                         end_transform_operations);
   EXPECT_TRUE(root->TransformIsAnimating());
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_FALSE(child->sorted_for_recursion());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        SingularNonAnimatingTransformDoesNotPreventClearingDrawProperties) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
 
   host()->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
 
   SetLayerPropertiesForTesting(root.get(),
                                uninvertible_matrix,
                                gfx::Point3F(),
@@ skipping 583 matching lines @@
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithoutPreserves3d) {
   // Verify the behavior of back-face culling when there are no preserve-3d
   // layers. Note that 3d transforms still apply in this case, but they are
   // "flattened" to each parent layer according to current W3C spec.
 
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> front_facing_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> back_facing_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> front_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> back_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent>
       front_facing_child_of_front_facing_surface =
-          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+          make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent>
       back_facing_child_of_front_facing_surface =
-          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+          make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent>
       front_facing_child_of_back_facing_surface =
-          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+          make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent>
       back_facing_child_of_back_facing_surface =
-          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+          make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   parent->AddChild(front_facing_child);
   parent->AddChild(back_facing_child);
   parent->AddChild(front_facing_surface);
   parent->AddChild(back_facing_surface);
   front_facing_surface->AddChild(front_facing_child_of_front_facing_surface);
   front_facing_surface->AddChild(back_facing_child_of_front_facing_surface);
   back_facing_surface->AddChild(front_facing_child_of_back_facing_surface);
   back_facing_surface->AddChild(back_facing_child_of_back_facing_surface);
 
@@ skipping 218 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
   // Verify that layers are appropriately culled when their back face is showing
   // and they are not double sided, while animations are going on.
   //
   // Layers that are animating do not get culled on the main thread, as their
   // transforms should be treated as "unknown" so we can not be sure that their
   // back face is really showing.
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> animating_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child_of_animating_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> animating_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   parent->AddChild(child);
   parent->AddChild(animating_surface);
   animating_surface->AddChild(child_of_animating_surface);
   parent->AddChild(animating_child);
   parent->AddChild(child2);
 
   host()->SetRootLayer(parent);
 
   // Nothing is double-sided
@@ skipping 95 matching lines @@
   EXPECT_EQ(child_of_animating_surface->visible_layer_rect(),
             gfx::Rect(child_of_animating_surface->bounds()));
 }
 
 TEST_F(LayerTreeHostCommonTest,
      BackFaceCullingWithPreserves3dForFlatteningSurface) {
   // Verify the behavior of back-face culling for a render surface that is
   // created when it flattens its subtree, and its parent has preserves-3d.
 
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> front_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> back_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   parent->AddChild(front_facing_surface);
   parent->AddChild(back_facing_surface);
   front_facing_surface->AddChild(child1);
   back_facing_surface->AddChild(child2);
 
   host()->SetRootLayer(parent);
 
   // RenderSurfaces are not double-sided
   front_facing_surface->SetDoubleSided(false);
@@ skipping 477 matching lines @@
       child->render_surface()->replica_draw_transform());
 
   gfx::Transform expected_replica_screen_space_transform;
   expected_replica_screen_space_transform.matrix().set(1, 1, -1.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_replica_screen_space_transform,
       child->render_surface()->replica_screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, SubtreeSearch) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child = Layer::Create(layer_settings());
-  scoped_refptr<Layer> grand_child = Layer::Create(layer_settings());
-  scoped_refptr<Layer> mask_layer = Layer::Create(layer_settings());
-  scoped_refptr<Layer> replica_layer = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> grand_child = Layer::Create();
+  scoped_refptr<Layer> mask_layer = Layer::Create();
+  scoped_refptr<Layer> replica_layer = Layer::Create();
 
   grand_child->SetReplicaLayer(replica_layer.get());
   child->AddChild(grand_child.get());
   child->SetMaskLayer(mask_layer.get());
   root->AddChild(child.get());
 
   host()->SetRootLayer(root);
 
   int nonexistent_id = -1;
   EXPECT_EQ(root.get(),
             LayerTreeHostCommon::FindLayerInSubtree(root.get(), root->id()));
   EXPECT_EQ(child.get(),
             LayerTreeHostCommon::FindLayerInSubtree(root.get(), child->id()));
   EXPECT_EQ(
       grand_child.get(),
       LayerTreeHostCommon::FindLayerInSubtree(root.get(), grand_child->id()));
   EXPECT_EQ(
       mask_layer.get(),
       LayerTreeHostCommon::FindLayerInSubtree(root.get(), mask_layer->id()));
   EXPECT_EQ(
       replica_layer.get(),
       LayerTreeHostCommon::FindLayerInSubtree(root.get(), replica_layer->id()));
   EXPECT_EQ(
       0, LayerTreeHostCommon::FindLayerInSubtree(root.get(), nonexistent_id));
 }
 
 TEST_F(LayerTreeHostCommonTest, TransparentChildRenderSurfaceCreation) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   SetLayerPropertiesForTesting(child.get(),
@@ skipping 98 matching lines @@
   inputs3.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs3);
 
   child_ptr = root->layer_tree_impl()->LayerById(2);
   tree = root->layer_tree_impl()->property_trees()->effect_tree;
   node = tree.Node(child_ptr->effect_tree_index());
   EXPECT_TRUE(node->data.is_drawn);
   EXPECT_TRUE(tree.ContributesToDrawnSurface(child_ptr->effect_tree_index()));
 }
 
-class LayerTreeSettingsForLCDTextTest : public LayerTreeSettings {
- public:
-  LayerTreeSettingsForLCDTextTest() {
-    use_compositor_animation_timelines = true;
-  }
-};
-
 using LCDTextTestParam = std::tr1::tuple<bool, bool, bool>;
 class LCDTextTest : public LayerTreeHostCommonTestBase,
                     public testing::TestWithParam<LCDTextTestParam> {
  public:
   LCDTextTest()
-      : LayerTreeHostCommonTestBase(LayerTreeSettingsForLCDTextTest()),
-        host_impl_(LayerTreeSettingsForLCDTextTest(),
-                   &task_runner_provider_,
+      : LayerTreeHostCommonTestBase(LayerTreeSettings()),
+        host_impl_(&task_runner_provider_,
                    &shared_bitmap_manager_,
                    &task_graph_runner_),
         root_(nullptr),
         child_(nullptr),
         grand_child_(nullptr) {}
 
   scoped_refptr<AnimationTimeline> timeline() { return timeline_; }
 
  protected:
   void SetUp() override {
@@ skipping 534 matching lines @@
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectInsideSurface) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
 
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
                                false);
   root->SetIsDrawable(true);
 
   // The surface is moved slightly outside of the viewport.
-  scoped_refptr<Layer> surface = Layer::Create(layer_settings());
+  scoped_refptr<Layer> surface = Layer::Create();
   SetLayerPropertiesForTesting(surface.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(-10, -20),
                                gfx::Size(),
                                true,
                                false);
   surface->SetForceRenderSurface(true);
 
-  scoped_refptr<Layer> surface_child = Layer::Create(layer_settings());
+  scoped_refptr<Layer> surface_child = Layer::Create();
   SetLayerPropertiesForTesting(surface_child.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
                                false);
   surface_child->SetIsDrawable(true);
 
   surface->AddChild(surface_child);
@@ skipping 1119 matching lines @@
   // Ensures that when we have a render surface between a fixed position layer
   // and its container, we compute the fixed position layer's draw transform
   // with respect to that intervening render surface, not with respect to its
   // container's render target.
   //
   // + root
   //   + render_surface
   //     + fixed
   //       + child
   //
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> render_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> fixed =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   root->AddChild(render_surface);
   render_surface->AddChild(fixed);
   fixed->AddChild(child);
 
   root->SetIsContainerForFixedPositionLayers(true);
   render_surface->SetForceRenderSurface(true);
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
@@ skipping 1100 matching lines @@
   EXPECT_FLOAT_EQ(0.f,
                   child1_layer->replica_layer()
                       ->mask_layer()
                       ->draw_properties()
                       .maximum_animation_contents_scale);
   EXPECT_FLOAT_EQ(
       96.f, child2_layer->draw_properties().maximum_animation_contents_scale);
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectInChildRenderSurface) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   SetLayerPropertiesForTesting(root.get(),
                                gfx::Transform(),
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(768 / 2, 3000),
                                true,
                                false);
   root->SetIsDrawable(true);
 
-  scoped_refptr<Layer> clip = Layer::Create(layer_settings());
+  scoped_refptr<Layer> clip = Layer::Create();
   SetLayerPropertiesForTesting(clip.get(),
                                gfx::Transform(),
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(768 / 2, 10000),
                                true,
                                false);
   clip->SetMasksToBounds(true);
 
-  scoped_refptr<Layer> content = Layer::Create(layer_settings());
+  scoped_refptr<Layer> content = Layer::Create();
   SetLayerPropertiesForTesting(content.get(),
                                gfx::Transform(),
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(768 / 2, 10000),
                                true,
                                false);
   content->SetIsDrawable(true);
   content->SetForceRenderSurface(true);
 
@@ skipping 77 matching lines @@
 
   root->SetBoundsDelta(gfx::Vector2dF(0.0, 50.0));
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   gfx::Rect affected_by_delta(0, 0, root_size.width(),
                               root_size.height() + 50);
   EXPECT_EQ(affected_by_delta, sublayer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, NodesAffectedByBoundsDeltaGetUpdated) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
-  scoped_refptr<Layer> inner_viewport_container_layer =
-      Layer::Create(layer_settings());
-  scoped_refptr<Layer> inner_viewport_scroll_layer =
-      Layer::Create(layer_settings());
-  scoped_refptr<Layer> outer_viewport_container_layer =
-      Layer::Create(layer_settings());
-  scoped_refptr<Layer> outer_viewport_scroll_layer =
-      Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> inner_viewport_container_layer = Layer::Create();
+  scoped_refptr<Layer> inner_viewport_scroll_layer = Layer::Create();
+  scoped_refptr<Layer> outer_viewport_container_layer = Layer::Create();
+  scoped_refptr<Layer> outer_viewport_scroll_layer = Layer::Create();
 
   root->AddChild(inner_viewport_container_layer);
   inner_viewport_container_layer->AddChild(inner_viewport_scroll_layer);
   inner_viewport_scroll_layer->AddChild(outer_viewport_container_layer);
   outer_viewport_container_layer->AddChild(outer_viewport_scroll_layer);
 
   inner_viewport_scroll_layer->SetScrollClipLayerId(
       inner_viewport_container_layer->id());
   outer_viewport_scroll_layer->SetScrollClipLayerId(
       outer_viewport_container_layer->id());
 
   inner_viewport_scroll_layer->SetIsContainerForFixedPositionLayers(true);
   outer_viewport_scroll_layer->SetIsContainerForFixedPositionLayers(true);
 
   host()->SetRootLayer(root);
   host()->RegisterViewportLayers(nullptr, root, inner_viewport_scroll_layer,
                                  outer_viewport_scroll_layer);
 
-  scoped_refptr<Layer> fixed_to_inner = Layer::Create(layer_settings());
-  scoped_refptr<Layer> fixed_to_outer = Layer::Create(layer_settings());
+  scoped_refptr<Layer> fixed_to_inner = Layer::Create();
+  scoped_refptr<Layer> fixed_to_outer = Layer::Create();
 
   inner_viewport_scroll_layer->AddChild(fixed_to_inner);
   outer_viewport_scroll_layer->AddChild(fixed_to_outer);
 
   LayerPositionConstraint fixed_to_right;
   fixed_to_right.set_is_fixed_position(true);
   fixed_to_right.set_is_fixed_to_right_edge(true);
 
   fixed_to_inner->SetPositionConstraint(fixed_to_right);
   fixed_to_outer->SetPositionConstraint(fixed_to_right);
@@ skipping 14 matching lines @@
 
   fixed_to_outer->SetPositionConstraint(fixed_to_left);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_FALSE(transform_tree.HasNodesAffectedByInnerViewportBoundsDelta());
   EXPECT_FALSE(transform_tree.HasNodesAffectedByOuterViewportBoundsDelta());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectForAnimatedLayer) {
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   root->AddChild(animated);
 
   host()->SetRootLayer(root);
 
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(animated.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false);
 
   root->SetMasksToBounds(true);
   root->SetForceRenderSurface(true);
   animated->SetOpacity(0.f);
 
   AddOpacityTransitionToLayerWithPlayer(animated->id(), timeline(), 10.0, 0.f,
                                         1.f, false);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   EXPECT_FALSE(animated->visible_layer_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleContentRectForAnimatedLayerWithSingularTransform) {
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
-  scoped_refptr<Layer> clip = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> clip = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> descendant_of_animation =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   root->AddChild(clip);
   clip->AddChild(animated);
   animated->AddChild(surface);
   surface->AddChild(descendant_of_animation);
 
   clip->SetMasksToBounds(true);
   surface->SetForceRenderSurface(true);
 
   host()->SetRootLayer(root);
@@ skipping 46 matching lines @@
   // This time, flattening does not make |animated|'s transform invertible. This
   // means the clip cannot be projected into |surface|'s space, so we treat
   // |surface| and layers that draw into it as having empty visible rect.
   EXPECT_EQ(gfx::Rect(), surface->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(), descendant_of_animation->visible_layer_rect());
 }
 
 // Verify that having an animated filter (but no current filter, as these
 // are mutually exclusive) correctly creates a render surface.
 TEST_F(LayerTreeHostCommonTest, AnimatedFilterCreatesRenderSurface) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child = Layer::Create(layer_settings());
-  scoped_refptr<Layer> grandchild = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> grandchild = Layer::Create();
   root->AddChild(child);
   child->AddChild(grandchild);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(child.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(grandchild.get(), identity_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
@@ skipping 12 matching lines @@
   EXPECT_TRUE(grandchild->filters().IsEmpty());
 
   EXPECT_FALSE(root->FilterIsAnimating());
   EXPECT_TRUE(child->FilterIsAnimating());
   EXPECT_FALSE(grandchild->FilterIsAnimating());
 }
 
 // Verify that having a filter animation with a delayed start time creates a
 // render surface.
 TEST_F(LayerTreeHostCommonTest, DelayedFilterAnimationCreatesRenderSurface) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child = Layer::Create(layer_settings());
-  scoped_refptr<Layer> grandchild = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> grandchild = Layer::Create();
   root->AddChild(child);
   child->AddChild(grandchild);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(child.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(grandchild.get(), identity_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
@@ skipping 30 matching lines @@
   EXPECT_FALSE(root->HasPotentiallyRunningFilterAnimation());
   EXPECT_FALSE(child->FilterIsAnimating());
   EXPECT_TRUE(child->HasPotentiallyRunningFilterAnimation());
   EXPECT_FALSE(grandchild->FilterIsAnimating());
   EXPECT_FALSE(grandchild->HasPotentiallyRunningFilterAnimation());
 }
 
 // Ensures that the property tree code accounts for offsets between fixed
 // position layers and their respective containers.
 TEST_F(LayerTreeHostCommonTest, PropertyTreesAccountForFixedParentOffset) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> grandchild =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   root->AddChild(child);
   child->AddChild(grandchild);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(child.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(1000, 1000), gfx::Size(50, 50), true,
                                false);
@@ skipping 15 matching lines @@
 
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), grandchild->visible_layer_rect());
 }
 
 // Ensures that the property tree code accounts for offsets between fixed
 // position containers and their transform tree parents, when a fixed position
 // layer's container is its layer tree parent, but this parent doesn't have its
 // own transform tree node.
 TEST_F(LayerTreeHostCommonTest,
        PropertyTreesAccountForFixedParentOffsetWhenContainerIsParent) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> grandchild =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   root->AddChild(child);
   child->AddChild(grandchild);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(child.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(1000, 1000), gfx::Size(50, 50), true,
                                false);
@@ skipping 19 matching lines @@
 TEST_F(LayerTreeHostCommonTest, CombineClipsUsingContentTarget) {
   // In the following layer tree, the layer |box|'s render target is |surface|.
   // |surface| also creates a transform node. We want to combine clips for |box|
   // in the space of its target (i.e., |surface|), not its target's target. This
   // test ensures that happens.
 
   gfx::Transform rotate;
   rotate.Rotate(5);
   gfx::Transform identity;
 
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(2500, 1500), true,
                                false);
 
-  scoped_refptr<Layer> frame_clip = Layer::Create(layer_settings());
+  scoped_refptr<Layer> frame_clip = Layer::Create();
   SetLayerPropertiesForTesting(frame_clip.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(2500, 1500), true,
                                false);
   frame_clip->SetMasksToBounds(true);
 
-  scoped_refptr<Layer> rotated = Layer::Create(layer_settings());
+  scoped_refptr<Layer> rotated = Layer::Create();
   SetLayerPropertiesForTesting(rotated.get(), rotate,
                                gfx::Point3F(1250, 250, 0), gfx::PointF(),
                                gfx::Size(2500, 500), true, false);
 
-  scoped_refptr<Layer> surface = Layer::Create(layer_settings());
+  scoped_refptr<Layer> surface = Layer::Create();
   SetLayerPropertiesForTesting(surface.get(), rotate, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(2500, 500), true,
                                false);
   surface->SetOpacity(0.5);
 
   scoped_refptr<LayerWithForcedDrawsContent> container =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   SetLayerPropertiesForTesting(container.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(300, 300), true, false);
 
   scoped_refptr<LayerWithForcedDrawsContent> box =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   SetLayerPropertiesForTesting(box.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
 
   root->AddChild(frame_clip);
   frame_clip->AddChild(rotated);
   rotated->AddChild(surface);
   surface->AddChild(container);
   surface->AddChild(box);
 
   host()->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, OnlyApplyFixedPositioningOnce) {
   gfx::Transform identity;
   gfx::Transform translate_z;
   translate_z.Translate3d(0, 0, 10);
 
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(800, 800), true, false);
   root->SetIsContainerForFixedPositionLayers(true);
 
-  scoped_refptr<Layer> frame_clip = Layer::Create(layer_settings());
+  scoped_refptr<Layer> frame_clip = Layer::Create();
   SetLayerPropertiesForTesting(frame_clip.get(), translate_z, gfx::Point3F(),
                                gfx::PointF(500, 100), gfx::Size(100, 100), true,
                                false);
   frame_clip->SetMasksToBounds(true);
 
   scoped_refptr<LayerWithForcedDrawsContent> fixed =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   SetLayerPropertiesForTesting(fixed.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1000, 1000), true,
                                false);
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
   fixed->SetPositionConstraint(constraint);
 
   root->AddChild(frame_clip);
   frame_clip->AddChild(fixed);
 
   host()->SetRootLayer(root);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   gfx::Rect expected(0, 0, 100, 100);
   EXPECT_EQ(expected, fixed->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        PropertyTreesAccountForScrollCompensationAdjustment) {
   gfx::Transform identity;
   gfx::Transform translate_z;
   translate_z.Translate3d(0, 0, 10);
 
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(800, 800), true, false);
   root->SetIsContainerForFixedPositionLayers(true);
 
-  scoped_refptr<Layer> frame_clip = Layer::Create(layer_settings());
+  scoped_refptr<Layer> frame_clip = Layer::Create();
   SetLayerPropertiesForTesting(frame_clip.get(), translate_z, gfx::Point3F(),
                                gfx::PointF(500, 100), gfx::Size(100, 100), true,
                                false);
   frame_clip->SetMasksToBounds(true);
 
   scoped_refptr<LayerWithForcedDrawsContent> scroller =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   SetLayerPropertiesForTesting(scroller.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1000, 1000), true,
                                false);
 
   scroller->SetScrollCompensationAdjustment(gfx::Vector2dF(0.3f, 0.7f));
   scroller->SetScrollOffset(gfx::ScrollOffset(0.3, 0.7));
   scroller->SetScrollClipLayerId(frame_clip->id());
 
   scoped_refptr<LayerWithForcedDrawsContent> fixed =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   SetLayerPropertiesForTesting(fixed.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
   fixed->SetPositionConstraint(constraint);
 
   scoped_refptr<LayerWithForcedDrawsContent> fixed_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   SetLayerPropertiesForTesting(fixed_child.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false);
 
   fixed_child->SetPositionConstraint(constraint);
 
   root->AddChild(frame_clip);
   frame_clip->AddChild(scroller);
   scroller->AddChild(fixed);
   fixed->AddChild(fixed_child);
 
   host()->SetRootLayer(root);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   gfx::Rect expected(0, 0, 50, 50);
   EXPECT_EQ(expected, fixed->visible_layer_rect());
 
   expected = gfx::Rect(0, 0, 10, 10);
   EXPECT_EQ(expected, fixed_child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, FixedClipsShouldBeAssociatedWithTheRightNode) {
   gfx::Transform identity;
 
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(800, 800), true, false);
   root->SetIsContainerForFixedPositionLayers(true);
 
-  scoped_refptr<Layer> frame_clip = Layer::Create(layer_settings());
+  scoped_refptr<Layer> frame_clip = Layer::Create();
   SetLayerPropertiesForTesting(frame_clip.get(), identity, gfx::Point3F(),
                                gfx::PointF(500, 100), gfx::Size(100, 100), true,
                                false);
   frame_clip->SetMasksToBounds(true);
 
   scoped_refptr<LayerWithForcedDrawsContent> scroller =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   SetLayerPropertiesForTesting(scroller.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1000, 1000), true,
                                false);
 
   scroller->SetScrollOffset(gfx::ScrollOffset(100, 100));
   scroller->SetScrollClipLayerId(frame_clip->id());
 
   scoped_refptr<LayerWithForcedDrawsContent> fixed =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   SetLayerPropertiesForTesting(fixed.get(), identity, gfx::Point3F(),
                                gfx::PointF(100, 100), gfx::Size(50, 50), true,
                                false);
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
   fixed->SetPositionConstraint(constraint);
   fixed->SetForceRenderSurface(true);
   fixed->SetMasksToBounds(true);
 
@@ skipping 10 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest, ChangingAxisAlignmentTriggersRebuild) {
   gfx::Transform identity;
   gfx::Transform translate;
   gfx::Transform rotate;
 
   translate.Translate(10, 10);
   rotate.Rotate(45);
 
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(800, 800), true, false);
   root->SetIsContainerForFixedPositionLayers(true);
 
   host()->SetRootLayer(root);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_FALSE(host()->property_trees()->needs_rebuild);
 
   root->SetTransform(translate);
   EXPECT_FALSE(host()->property_trees()->needs_rebuild);
 
   root->SetTransform(rotate);
   EXPECT_TRUE(host()->property_trees()->needs_rebuild);
 }
 
 TEST_F(LayerTreeHostCommonTest, ChangeTransformOrigin) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(child);
 
   host()->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   gfx::Transform scale_matrix;
   scale_matrix.Scale(2.f, 2.f);
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(child.get(), scale_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), child->visible_layer_rect());
 
   child->SetTransformOrigin(gfx::Point3F(10.f, 10.f, 10.f));
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(5, 5, 5, 5), child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, UpdateScrollChildPosition) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> scroll_parent =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> scroll_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   root->AddChild(scroll_child);
   root->AddChild(scroll_parent);
   scroll_child->SetScrollParent(scroll_parent.get());
   scroll_parent->SetScrollClipLayerId(root->id());
 
   host()->SetRootLayer(root);
 
   gfx::Transform identity_transform;
   gfx::Transform scale;
@@ skipping 19 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest, NumCopyRequestsInTargetSubtree) {
   // If the layer has a node in effect_tree, the return value of
   // num_copy_requests_in_target_subtree()  must be equal to the actual number
   // of copy requests in the sub-layer_tree; Otherwise, the number is expected
   // to be the value of its nearest ancestor that owns an effect node and
   // greater than or equal to the actual number of copy requests in the
   // sub-layer_tree.
 
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child1 = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child2 = Layer::Create(layer_settings());
-  scoped_refptr<Layer> grandchild = Layer::Create(layer_settings());
-  scoped_refptr<Layer> greatgrandchild = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> child1 = Layer::Create();
+  scoped_refptr<Layer> child2 = Layer::Create();
+  scoped_refptr<Layer> grandchild = Layer::Create();
+  scoped_refptr<Layer> greatgrandchild = Layer::Create();
 
   root->AddChild(child1);
   root->AddChild(child2);
   child1->AddChild(grandchild);
   grandchild->AddChild(greatgrandchild);
   host()->SetRootLayer(root);
 
   child1->RequestCopyOfOutput(
       CopyOutputRequest::CreateBitmapRequest(base::Bind(&CopyOutputCallback)));
   greatgrandchild->RequestCopyOfOutput(
       CopyOutputRequest::CreateBitmapRequest(base::Bind(&CopyOutputCallback)));
   child2->SetOpacity(0.f);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   EXPECT_EQ(root->num_copy_requests_in_target_subtree(), 2);
   EXPECT_EQ(child1->num_copy_requests_in_target_subtree(), 2);
   EXPECT_EQ(child2->num_copy_requests_in_target_subtree(), 0);
   EXPECT_EQ(grandchild->num_copy_requests_in_target_subtree(), 2);
   EXPECT_EQ(greatgrandchild->num_copy_requests_in_target_subtree(), 1);
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingSubtreeMain) {
   gfx::Transform identity;
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   FakeContentLayerClient client;
   client.set_bounds(root->bounds());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> grandchild =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<FakePictureLayer> greatgrandchild(
-      FakePictureLayer::Create(layer_settings(), &client));
+      FakePictureLayer::Create(&client));
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(child.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false);
   SetLayerPropertiesForTesting(grandchild.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false);
   SetLayerPropertiesForTesting(greatgrandchild.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false);
 
   root->AddChild(child);
@@ skipping 139 matching lines @@
   requests.push_back(CopyOutputRequest::CreateEmptyRequest());
 
   grandchild_ptr->PassCopyRequests(&requests);
   root.get()->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingLayer) {
   gfx::Transform identity;
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   FakeContentLayerClient client;
   client.set_bounds(root->bounds());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+      make_scoped_refptr(new LayerWithForcedDrawsContent());
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(child.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false);
   root->AddChild(child);
 
   host()->SetRootLayer(root);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), child->visible_layer_rect());
@@ skipping 19 matching lines @@
   child->SetTransform(identity);
 
   child->SetOpacity(0.f);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerTreeRebuildTest) {
   // Ensure that the treewalk in LayerTreeHostCommom::
   // PreCalculateMetaInformation happens when its required.
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
 
   root->AddChild(parent);
   parent->AddChild(child);
 
   child->SetClipParent(root.get());
 
   gfx::Transform identity;
 
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
@@ skipping 37 matching lines @@
   child->SetTouchEventHandlerRegion(gfx::Rect());
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(root->layer_or_descendant_has_touch_handler(), false);
 }
 
 TEST_F(LayerTreeHostCommonTest, ResetPropertyTreeIndices) {
   gfx::Transform identity;
   gfx::Transform translate_z;
   translate_z.Translate3d(0, 0, 10);
 
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(800, 800), true, false);
 
-  scoped_refptr<Layer> child = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child = Layer::Create();
   SetLayerPropertiesForTesting(child.get(), translate_z, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
 
   root->AddChild(child);
 
   host()->SetRootLayer(root);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_NE(-1, child->transform_tree_index());
 
   child->RemoveFromParent();
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(-1, child->transform_tree_index());
 }
 
 TEST_F(LayerTreeHostCommonTest, ResetLayerDrawPropertiestest) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
 
   root->AddChild(child);
   gfx::Transform identity;
 
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(child.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
 
   host()->SetRootLayer(root);
@@ skipping 735 matching lines @@
   // +----node---owner:5, id:6
   //
   // Extra check:
   //   scroll_tree_index() of:
   //     grand_child10:3
   //     parent3:1
   //     child8:4
   //     parent4:1
   //     child9:1
   //     grand_child12:1
-  scoped_refptr<Layer> root1 = Layer::Create(layer_settings());
-  scoped_refptr<Layer> page_scale_layer = Layer::Create(layer_settings());
-  scoped_refptr<Layer> parent2 = Layer::Create(layer_settings());
-  scoped_refptr<Layer> parent3 = Layer::Create(layer_settings());
-  scoped_refptr<Layer> parent4 = Layer::Create(layer_settings());
-  scoped_refptr<Layer> parent5 = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child6 = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child7 = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child8 = Layer::Create(layer_settings());
-  scoped_refptr<Layer> child9 = Layer::Create(layer_settings());
-  scoped_refptr<Layer> grand_child10 = Layer::Create(layer_settings());
-  scoped_refptr<Layer> grand_child11 = Layer::Create(layer_settings());
-  scoped_refptr<Layer> grand_child12 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> root1 = Layer::Create();
+  scoped_refptr<Layer> page_scale_layer = Layer::Create();
+  scoped_refptr<Layer> parent2 = Layer::Create();
+  scoped_refptr<Layer> parent3 = Layer::Create();
+  scoped_refptr<Layer> parent4 = Layer::Create();
+  scoped_refptr<Layer> parent5 = Layer::Create();
+  scoped_refptr<Layer> child6 = Layer::Create();
+  scoped_refptr<Layer> child7 = Layer::Create();
+  scoped_refptr<Layer> child8 = Layer::Create();
+  scoped_refptr<Layer> child9 = Layer::Create();
+  scoped_refptr<Layer> grand_child10 = Layer::Create();
+  scoped_refptr<Layer> grand_child11 = Layer::Create();
+  scoped_refptr<Layer> grand_child12 = Layer::Create();
 
   root1->AddChild(page_scale_layer);
   page_scale_layer->AddChild(parent2);
   page_scale_layer->AddChild(parent3);
   page_scale_layer->AddChild(parent4);
   page_scale_layer->AddChild(parent5);
   parent2->AddChild(child6);
   parent3->AddChild(child7);
   parent3->AddChild(child8);
   parent4->AddChild(child9);
@@ skipping 127 matching lines @@
   EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
   EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
 }
 
 }  // namespace
 }  // namespace cc