CC Animations: Make LayerAnimationController creation optional

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 <algorithm>
 #include <set>
 
 #include "cc/animation/layer_animation_controller.h"
@@ skipping 28 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:
-  LayerWithForcedDrawsContent() {}
+  explicit LayerWithForcedDrawsContent(const LayerSettings& settings)
+      : Layer(settings) {}
 
   bool DrawsContent() const override;
 
  private:
   ~LayerWithForcedDrawsContent() override {}
 };
 
 bool LayerWithForcedDrawsContent::DrawsContent() const { return true; }
 
 class MockContentLayerClient : public ContentLayerClient {
  public:
   MockContentLayerClient() {}
   ~MockContentLayerClient() override {}
   void PaintContents(SkCanvas* canvas,
                      const gfx::Rect& clip,
                      PaintingControlSetting picture_control) override {}
   void PaintContentsToDisplayList(
       DisplayItemList* display_list,
       const gfx::Rect& clip,
       PaintingControlSetting picture_control) override {
     NOTIMPLEMENTED();
   }
   bool FillsBoundsCompletely() const override { return false; }
 };
 
 scoped_refptr<FakePictureLayer> CreateDrawablePictureLayer(
+    const LayerSettings& settings,
     ContentLayerClient* delegate) {
   scoped_refptr<FakePictureLayer> to_return =
-      FakePictureLayer::Create(delegate);
+      FakePictureLayer::Create(settings, delegate);
   to_return->SetIsDrawable(true);
   return to_return;
 }
 
 scoped_refptr<ContentLayer> CreateDrawableContentLayer(
+    const LayerSettings& settings,
     ContentLayerClient* delegate) {
-  scoped_refptr<ContentLayer> to_return = ContentLayer::Create(delegate);
+  scoped_refptr<ContentLayer> to_return =
+      ContentLayer::Create(settings, delegate);
   to_return->SetIsDrawable(true);
   return to_return;
 }
 
 #define EXPECT_CONTENTS_SCALE_EQ(expected, layer)         \
   do {                                                    \
     EXPECT_FLOAT_EQ(expected, layer->contents_scale_x()); \
     EXPECT_FLOAT_EQ(expected, layer->contents_scale_y()); \
   } while (false)
 
 #define EXPECT_IDEAL_SCALE_EQ(expected, layer)                                \
   do {                                                                        \
     EXPECT_FLOAT_EQ(expected, layer->draw_properties().ideal_contents_scale); \
   } while (false)
 
 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();
-  scoped_refptr<Layer> child = Layer::Create();
-  scoped_refptr<Layer> grand_child = Layer::Create();
+  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());
   parent->AddChild(child);
   child->AddChild(grand_child);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
@@ skipping 21 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                   child->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                   grand_child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                   grand_child->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, DoNotSkipLayersWithHandlers) {
-  scoped_refptr<Layer> parent = Layer::Create();
-  scoped_refptr<Layer> child = Layer::Create();
-  scoped_refptr<Layer> grand_child = Layer::Create();
+  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());
   parent->AddChild(child);
   child->AddChild(grand_child);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
@@ skipping 24 matching lines @@
   ExecuteCalculateDrawProperties(parent.get());
 
   // Check that we've computed draw properties for the subtree rooted at
   // |child|.
   EXPECT_FALSE(child->draw_transform().IsIdentity());
   EXPECT_FALSE(grand_child->draw_transform().IsIdentity());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSingleLayer) {
   gfx::Transform identity_matrix;
-  scoped_refptr<Layer> layer = Layer::Create();
+  scoped_refptr<Layer> layer = Layer::Create(layer_settings());
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(1, 2),
                                true,
                                false);
   root->AddChild(layer);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
@@ skipping 175 matching lines @@
       MathUtil::Round(kTranslateX * kPageScale * kDeviceScale +
                       sub_layer_screen_position.x()),
       MathUtil::Round(kTranslateY * kPageScale * kDeviceScale +
                       sub_layer_screen_position.y()));
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
                                   sublayer->draw_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSimpleHierarchy) {
   gfx::Transform identity_matrix;
-  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();
+  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());
   root->AddChild(parent);
   parent->AddChild(child);
   child->AddChild(grand_child);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   // One-time setup of root layer
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
@@ skipping 102 matching lines @@
                                   child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform,
                                   child->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform,
                                   grand_child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform,
                                   grand_child->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSingleRenderSurface) {
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> parent = Layer::Create();
-  scoped_refptr<Layer> child = Layer::Create();
+  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<LayerWithForcedDrawsContent> grand_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(parent);
   parent->AddChild(child);
   child->AddChild(grand_child);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   // One-time setup of root layer
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
@@ skipping 70 matching lines @@
       child->render_target()->render_surface()->draw_transform());
 
   // The screen space is the same as the target since the child surface draws
   // into the root.
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       surface_sublayer_composite_transform,
       child->render_target()->render_surface()->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForReplica) {
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> parent = Layer::Create();
-  scoped_refptr<Layer> child = Layer::Create();
-  scoped_refptr<Layer> child_replica = Layer::Create();
+  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> child_replica = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(parent);
   parent->AddChild(child);
   child->AddChild(grand_child);
   child->SetReplicaLayer(child_replica.get());
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   // One-time setup of root layer
   gfx::Transform identity_matrix;
@@ skipping 80 matching lines @@
   //   transforms described w.r.t. that surface
   //   - A render surface described w.r.t. an ancestor render surface: should
   //   have a draw transform described w.r.t. that ancestor surface
   //   - Replicas of a render surface are described w.r.t. the replica's
   //   transform around its anchor, along with the surface itself.
   //   - Sanity check on recursion: verify transforms of layers described w.r.t.
   //   a render surface that is described w.r.t. an ancestor render surface.
   //   - verifying that each layer has a reference to the correct render surface
   //   and render target values.
 
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> parent = Layer::Create();
-  scoped_refptr<Layer> render_surface1 = Layer::Create();
-  scoped_refptr<Layer> render_surface2 = Layer::Create();
-  scoped_refptr<Layer> child_of_root = Layer::Create();
-  scoped_refptr<Layer> child_of_rs1 = Layer::Create();
-  scoped_refptr<Layer> child_of_rs2 = Layer::Create();
-  scoped_refptr<Layer> replica_of_rs1 = Layer::Create();
-  scoped_refptr<Layer> replica_of_rs2 = Layer::Create();
-  scoped_refptr<Layer> grand_child_of_root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface1 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface2 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child_of_root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child_of_rs1 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child_of_rs2 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> replica_of_rs1 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> replica_of_rs2 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> grand_child_of_root = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> grand_child_of_rs1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> grand_child_of_rs2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(parent);
   parent->AddChild(render_surface1);
   parent->AddChild(child_of_root);
   render_surface1->AddChild(child_of_rs1);
   render_surface1->AddChild(render_surface2);
   render_surface2->AddChild(child_of_rs2);
   child_of_root->AddChild(grand_child_of_root);
   child_of_rs1->AddChild(grand_child_of_rs1);
   child_of_rs2->AddChild(grand_child_of_rs2);
   render_surface1->SetReplicaLayer(replica_of_rs1.get());
@@ skipping 252 matching lines @@
   EXPECT_FLOAT_EQ(
       5.0, grand_child_of_rs2->screen_space_transform().matrix().get(1, 3));
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForFlatteningLayer) {
   // For layers that flatten their subtree, there should be an orthographic
   // projection (for x and y values) in the middle of the transform sequence.
   // Note that the way the code is currently implemented, it is not expected to
   // use a canonical orthographic projection.
 
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> great_grand_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   gfx::Transform rotation_about_y_axis;
   rotation_about_y_axis.RotateAboutYAxis(30.0);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
@@ skipping 70 matching lines @@
 TEST_F(LayerTreeHostCommonTest, TransformsForDegenerateIntermediateLayer) {
   // A layer that is empty in one axis, but not the other, was accidentally
   // skipping a necessary translation.  Without that translation, the coordinate
   // space of the layer's draw transform is incorrect.
   //
   // Normally this isn't a problem, because the layer wouldn't be drawn anyway,
   // but if that layer becomes a render surface, then its draw transform is
   // implicitly inherited by the rest of the subtree, which then is positioned
   // incorrectly as a result.
 
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   // The child height is zero, but has non-zero width that should be accounted
   // for while computing draw transforms.
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
@@ skipping 29 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                   grand_child->draw_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
   // Transformations applied at the root of the tree should be forwarded
   // to child layers instead of applied to the root RenderSurface.
   const gfx::Transform identity_matrix;
   scoped_refptr<LayerWithForcedDrawsContent> root =
-      new LayerWithForcedDrawsContent;
+      new LayerWithForcedDrawsContent(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      new LayerWithForcedDrawsContent;
+      new LayerWithForcedDrawsContent(layer_settings());
   child->SetScrollClipLayerId(root->id());
   root->AddChild(child);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
@@ skipping 131 matching lines @@
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         compositeSquared, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         compositeSquared, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceListForRenderSurfaceWithClippedLayer) {
-  scoped_refptr<Layer> parent = Layer::Create();
-  scoped_refptr<Layer> render_surface1 = Layer::Create();
+  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface1 = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
@@ skipping 30 matching lines @@
   // The child layer's content is entirely outside the parent's clip rect, so
   // the intermediate render surface should not be listed here, even if it was
   // forced to be created. Render surfaces without children or visible content
   // are unexpected at draw time (e.g. we might try to create a content texture
   // of size 0).
   ASSERT_TRUE(parent->render_surface());
   EXPECT_EQ(1U, render_surface_layer_list.size());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForTransparentChild) {
-  scoped_refptr<Layer> parent = Layer::Create();
-  scoped_refptr<Layer> render_surface1 = Layer::Create();
+  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface1 = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(render_surface1.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
@@ skipping 22 matching lines @@
   // not have gotten added anywhere.  Also, the drawable content rect should not
   // have been extended by the children.
   ASSERT_TRUE(parent->render_surface());
   EXPECT_EQ(0U, parent->render_surface()->layer_list().size());
   EXPECT_EQ(1U, render_surface_layer_list.size());
   EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
   EXPECT_EQ(gfx::Rect(), parent->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceForBlendMode) {
-  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   const gfx::Transform identity_matrix;
   const SkXfermode::Mode blend_mode = SkXfermode::kMultiply_Mode;
   SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false);
 
   parent->AddChild(child);
   child->SetBlendMode(blend_mode);
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       parent.get(), parent->bounds(), &render_surface_layer_list);
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Since the child layer has a blend mode other than normal, it should get
   // its own render surface. Also, layer's draw_properties should contain the
   // default blend mode, since the render surface becomes responsible for
   // applying the blend mode.
   ASSERT_TRUE(child->render_surface());
   EXPECT_EQ(1U, child->render_surface()->layer_list().size());
   EXPECT_EQ(SkXfermode::kSrcOver_Mode, child->draw_properties().blend_mode);
 }
 
 TEST_F(LayerTreeHostCommonTest, ForceRenderSurface) {
-  scoped_refptr<Layer> parent = Layer::Create();
-  scoped_refptr<Layer> render_surface1 = Layer::Create();
+  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface1 = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   render_surface1->SetForceRenderSurface(true);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
@@ skipping 45 matching lines @@
     EXPECT_TRUE(parent->render_surface());
     EXPECT_FALSE(render_surface1->render_surface());
     EXPECT_EQ(1U, render_surface_layer_list.size());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfacesFlattenScreenSpaceTransform) {
   // Render surfaces act as a flattening point for their subtree, so should
   // always flatten the target-to-screen space transform seen by descendants.
 
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   gfx::Transform rotation_about_y_axis;
   rotation_about_y_axis.RotateAboutYAxis(30.0);
   // Make |parent| have a render surface.
   parent->SetOpacity(0.9f);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(parent.get(), rotation_about_y_axis,
@@ skipping 56 matching lines @@
   //  - child has masksToBounds=true to cause clipping.
   //  - grand_child is positioned outside of the child's bounds
   //  - great_grand_child is also kept outside child's bounds.
   //
   // In this configuration, grand_child and great_grand_child are completely
   // outside the clip rect, and they should never get scheduled on the list of
   // render surfaces.
   //
 
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> parent = Layer::Create();
-  scoped_refptr<Layer> child = Layer::Create();
-  scoped_refptr<Layer> grand_child = Layer::Create();
-  scoped_refptr<Layer> great_grand_child = Layer::Create();
+  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> great_grand_child = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> leaf_node1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> leaf_node2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   parent->AddChild(child);
   child->AddChild(grand_child);
   grand_child->AddChild(great_grand_child);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   // leaf_node1 ensures that parent and child are kept on the
   // render_surface_layer_list, even though grand_child and great_grand_child
   // should be clipped.
@@ skipping 73 matching lines @@
   //  - grand_child is a render surface, and the only visible content in child.
   //  It is positioned outside of the clip rect from parent.
 
   // In this configuration, grand_child should be outside the clipped
   // content rect of the child, making grand_child not appear in the
   // render_surface_layer_list. However, when we place an animation on the
   // child, this clipping should be avoided and we should keep the grand_child
   // in the render_surface_layer_list.
 
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> parent = Layer::Create();
-  scoped_refptr<Layer> child = Layer::Create();
-  scoped_refptr<Layer> grand_child = Layer::Create();
+  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<LayerWithForcedDrawsContent> leaf_node =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   parent->AddChild(child);
   child->AddChild(grand_child);
   grand_child->AddChild(leaf_node);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
@@ skipping 70 matching lines @@
   //  - a surface is clipped by an ancestor that contributes to the same
   //    render target.
   //
   // In particular, for a layer that owns a render surface:
   //  - the render surface inherits any clip from ancestors, and does NOT
   //    pass that clipped status to the layer itself.
   //  - but if the layer itself masks to bounds, it is considered clipped
   //    and propagates the clip to the subtree.
 
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> parent = Layer::Create();
-  scoped_refptr<Layer> child1 = Layer::Create();
-  scoped_refptr<Layer> child2 = Layer::Create();
-  scoped_refptr<Layer> grand_child = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child1 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child2 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> grand_child = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> leaf_node1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> leaf_node2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(parent);
   parent->AddChild(child1);
   parent->AddChild(child2);
   child1->AddChild(grand_child);
   child2->AddChild(leaf_node2);
   grand_child->AddChild(leaf_node1);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
@@ skipping 132 matching lines @@
   //   grand_child2 - partially clipped but NOT masksToBounds; the clip rect
   //   will be the intersection of layer bounds and the mask region.
   //   grand_child3 - partially clipped and masksToBounds; the
   //   DrawableContentRect will still be the intersection of layer bounds and
   //   the mask region.
   //   grand_child4 - outside parent's clip rect; the DrawableContentRect should
   //   be empty.
   //
 
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> parent = Layer::Create();
-  scoped_refptr<Layer> child = Layer::Create();
-  scoped_refptr<Layer> grand_child1 = Layer::Create();
-  scoped_refptr<Layer> grand_child2 = Layer::Create();
-  scoped_refptr<Layer> grand_child3 = Layer::Create();
-  scoped_refptr<Layer> grand_child4 = Layer::Create();
+  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child = Layer::Create(layer_settings());
+  scoped_refptr<Layer> grand_child1 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> grand_child2 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> grand_child3 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> grand_child4 = Layer::Create(layer_settings());
 
   parent->AddChild(child);
   child->AddChild(grand_child1);
   child->AddChild(grand_child2);
   child->AddChild(grand_child3);
   child->AddChild(grand_child4);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
@@ skipping 64 matching lines @@
 
 TEST_F(LayerTreeHostCommonTest, ClipRectIsPropagatedCorrectlyToSurfaces) {
   // Verify that render surfaces (and their layers) get the appropriate
   // clip rects when their parent masksToBounds is true.
   //
   // Layers that own render surfaces (at least for now) do not inherit any
   // clipping; instead the surface will enforce the clip for the entire subtree.
   // They may still have a clip rect of their own layer bounds, however, if
   // masksToBounds was true.
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> parent = Layer::Create();
-  scoped_refptr<Layer> child = Layer::Create();
-  scoped_refptr<Layer> grand_child1 = Layer::Create();
-  scoped_refptr<Layer> grand_child2 = Layer::Create();
-  scoped_refptr<Layer> grand_child3 = Layer::Create();
-  scoped_refptr<Layer> grand_child4 = Layer::Create();
+  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child = Layer::Create(layer_settings());
+  scoped_refptr<Layer> grand_child1 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> grand_child2 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> grand_child3 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> grand_child4 = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> leaf_node1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> leaf_node2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> leaf_node3 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> leaf_node4 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   parent->AddChild(child);
   child->AddChild(grand_child1);
   child->AddChild(grand_child2);
   child->AddChild(grand_child3);
   child->AddChild(grand_child4);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
@@ skipping 104 matching lines @@
   // masksToBounds.
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20),
             grand_child1->render_surface()->clip_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20),
             grand_child2->render_surface()->clip_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20),
             grand_child3->render_surface()->clip_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, AnimationsForRenderSurfaceHierarchy) {
-  scoped_refptr<Layer> parent = Layer::Create();
-  scoped_refptr<Layer> render_surface1 = Layer::Create();
-  scoped_refptr<Layer> render_surface2 = Layer::Create();
-  scoped_refptr<Layer> child_of_root = Layer::Create();
-  scoped_refptr<Layer> child_of_rs1 = Layer::Create();
-  scoped_refptr<Layer> child_of_rs2 = Layer::Create();
-  scoped_refptr<Layer> grand_child_of_root = Layer::Create();
+  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface1 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface2 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child_of_root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child_of_rs1 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child_of_rs2 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> grand_child_of_root = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> grand_child_of_rs1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> grand_child_of_rs2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   parent->AddChild(render_surface1);
   parent->AddChild(child_of_root);
   render_surface1->AddChild(child_of_rs1);
   render_surface1->AddChild(render_surface2);
   render_surface2->AddChild(child_of_rs2);
   child_of_root->AddChild(grand_child_of_root);
   child_of_rs1->AddChild(grand_child_of_rs1);
   child_of_rs2->AddChild(grand_child_of_rs2);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
@@ skipping 466 matching lines @@
   // Only the corner of the layer is not visible on the surface because of being
   // clipped. But, the net result of rounding visible region to an axis-aligned
   // rect is that the entire layer should still be considered visible.
   gfx::Rect expected = gfx::Rect(-10, -10, 20, 20);
   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_EQ(expected, actual);
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsForSimpleLayers) {
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child3 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(child1);
   root->AddChild(child2);
   root->AddChild(child3);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
@@ skipping 39 matching lines @@
   EXPECT_TRUE(child3->visible_content_rect().IsEmpty());
 
   // layer drawable_content_rects are not clipped.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsForLayersClippedByLayer) {
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> grand_child1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> grand_child2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> grand_child3 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(child);
   child->AddChild(grand_child1);
   child->AddChild(grand_child2);
   child->AddChild(grand_child3);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
@@ skipping 50 matching lines @@
   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), grand_child2->visible_content_rect());
   EXPECT_TRUE(grand_child3->visible_content_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();
-  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(child);
   child->AddChild(grand_child);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   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;
@@ skipping 10 matching lines @@
   ExecuteCalculateDrawProperties(root.get());
 
   // The visible rect is expanded to integer coordinates in target space before
   // being projected back to layer space, where it is once again expanded to
   // integer coordinates.
   EXPECT_EQ(gfx::Rect(49, 49), grand_child->visible_rect_from_property_trees());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsForLayersInUnclippedRenderSurface) {
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> render_surface1 = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface1 = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child3 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(render_surface1);
   render_surface1->AddChild(child1);
   render_surface1->AddChild(child2);
   render_surface1->AddChild(child3);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
@@ skipping 55 matching lines @@
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_content_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_content_rect());
 
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleContentRectsForClippedSurfaceWithEmptyClip) {
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child3 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(child1);
   root->AddChild(child2);
   root->AddChild(child3);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false);
@@ skipping 23 matching lines @@
   // Visible content rect calculation will check if the target surface is
   // clipped or not. An empty clip rect does not indicate the render surface
   // is unclipped.
   EXPECT_EQ(empty, child1->visible_content_rect());
   EXPECT_EQ(empty, child2->visible_content_rect());
   EXPECT_EQ(empty, child3->visible_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsForLayersWithUninvertibleTransform) {
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(child);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   // Case 1: a truly degenerate matrix
   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());
 
@@ skipping 51 matching lines @@
                                false);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(child->visible_content_rect().IsEmpty());
   EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        SingularTransformDoesNotPreventClearingDrawProperties) {
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(child);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   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(),
@@ skipping 24 matching lines @@
 
   EXPECT_TRUE(root->TransformIsAnimating());
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_FALSE(child->draw_properties().sorted_for_recursion);
 }
 
 TEST_F(LayerTreeHostCommonTest,
        SingularNonAnimatingTransformDoesNotPreventClearingDrawProperties) {
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   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(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
 
   root->draw_properties().sorted_for_recursion = true;
 
   EXPECT_FALSE(root->TransformIsAnimating());
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_FALSE(root->draw_properties().sorted_for_recursion);
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsForLayersInClippedRenderSurface) {
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> render_surface1 = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface1 = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child3 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(render_surface1);
   render_surface1->AddChild(child1);
   render_surface1->AddChild(child2);
   render_surface1->AddChild(child3);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
@@ skipping 59 matching lines @@
 
   // But the DrawableContentRects are unclipped.
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsForSurfaceHierarchy) {
   // Check that clipping does not propagate down surfaces.
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> render_surface1 = Layer::Create();
-  scoped_refptr<Layer> render_surface2 = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface1 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface2 = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child3 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(render_surface1);
   render_surface1->AddChild(render_surface2);
   render_surface2->AddChild(child1);
   render_surface2->AddChild(child2);
   render_surface2->AddChild(child3);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
@@ skipping 77 matching lines @@
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsWithTransformOnUnclippedSurface) {
   // Layers that have non-axis aligned bounds (due to transforms) have an
   // expanded, axis-aligned DrawableContentRect and visible content rect.
 
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> render_surface1 = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface1 = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(render_surface1);
   render_surface1->AddChild(child1);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   gfx::Transform child_rotation;
   child_rotation.Rotate(45.0);
   SetLayerPropertiesForTesting(root.get(),
@@ skipping 45 matching lines @@
   // All layers that draw content into the unclipped surface are also unclipped.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_content_rect());
   EXPECT_EQ(expected_surface_drawable_content, child1->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsWithTransformOnClippedSurface) {
   // Layers that have non-axis aligned bounds (due to transforms) have an
   // expanded, axis-aligned DrawableContentRect and visible content rect.
 
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> render_surface1 = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface1 = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(render_surface1);
   render_surface1->AddChild(child1);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   gfx::Transform child_rotation;
   child_rotation.Rotate(45.0);
   SetLayerPropertiesForTesting(root.get(),
@@ skipping 44 matching lines @@
   // Given the floating point math, this number is a little bit fuzzy.
   EXPECT_EQ(gfx::Rect(0, 0, 26, 50), child1->visible_content_rect());
 
   // The child's DrawableContentRect is unclipped.
   EXPECT_EQ(unclipped_surface_content, child1->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsInHighDPI) {
   MockContentLayerClient client;
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   scoped_refptr<FakePictureLayer> render_surface1 =
-      CreateDrawablePictureLayer(&client);
+      CreateDrawablePictureLayer(layer_settings(), &client);
   scoped_refptr<FakePictureLayer> render_surface2 =
-      CreateDrawablePictureLayer(&client);
-  scoped_refptr<FakePictureLayer> child1 = CreateDrawablePictureLayer(&client);
-  scoped_refptr<FakePictureLayer> child2 = CreateDrawablePictureLayer(&client);
-  scoped_refptr<FakePictureLayer> child3 = CreateDrawablePictureLayer(&client);
+      CreateDrawablePictureLayer(layer_settings(), &client);
+  scoped_refptr<FakePictureLayer> child1 =
+      CreateDrawablePictureLayer(layer_settings(), &client);
+  scoped_refptr<FakePictureLayer> child2 =
+      CreateDrawablePictureLayer(layer_settings(), &client);
+  scoped_refptr<FakePictureLayer> child3 =
+      CreateDrawablePictureLayer(layer_settings(), &client);
   root->AddChild(render_surface1);
   render_surface1->AddChild(render_surface2);
   render_surface2->AddChild(child1);
   render_surface2->AddChild(child2);
   render_surface2->AddChild(child3);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
@@ skipping 78 matching lines @@
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_content_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_content_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();
+  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> front_facing_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> back_facing_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> front_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> back_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent>
       front_facing_child_of_front_facing_surface =
-          make_scoped_refptr(new LayerWithForcedDrawsContent());
+          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent>
       back_facing_child_of_front_facing_surface =
-          make_scoped_refptr(new LayerWithForcedDrawsContent());
+          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent>
       front_facing_child_of_back_facing_surface =
-          make_scoped_refptr(new LayerWithForcedDrawsContent());
+          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent>
       back_facing_child_of_back_facing_surface =
-          make_scoped_refptr(new LayerWithForcedDrawsContent());
+          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   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 161 matching lines @@
                 ->layer_list()
                 .at(0)
                 ->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithPreserves3d) {
   // Verify the behavior of back-face culling when preserves-3d transform style
   // is used.
 
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> front_facing_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> back_facing_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> front_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> back_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent>
-  front_facing_child_of_front_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      front_facing_child_of_front_facing_surface =
+          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent>
-  back_facing_child_of_front_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      back_facing_child_of_front_facing_surface =
+          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent>
-  front_facing_child_of_back_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      front_facing_child_of_back_facing_surface =
+          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent>
-  back_facing_child_of_back_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      back_facing_child_of_back_facing_surface =
+          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> dummy_replica_layer1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> dummy_replica_layer2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   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 140 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();
+  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> animating_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child_of_animating_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> animating_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   parent->AddChild(child);
   parent->AddChild(animating_surface);
   animating_surface->AddChild(child_of_animating_surface);
   parent->AddChild(animating_child);
   parent->AddChild(child2);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
@@ skipping 118 matching lines @@
   EXPECT_EQ(child_of_animating_surface->visible_content_rect(),
             gfx::Rect(child_of_animating_surface->content_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();
+  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> front_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> back_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   parent->AddChild(front_facing_surface);
   parent->AddChild(back_facing_surface);
   front_facing_surface->AddChild(child1);
   back_facing_surface->AddChild(child2);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   // RenderSurfaces are not double-sided
@@ skipping 81 matching lines @@
   EXPECT_EQ(front_facing_surface->id(),
             render_surface_layer_list.at(1)
                 ->render_surface()->layer_list().at(0)->id());
   EXPECT_EQ(child1->id(),
             render_surface_layer_list.at(1)
                 ->render_surface()->layer_list().at(1)->id());
 }
 
 class NoScaleContentLayer : public ContentLayer {
  public:
-  static scoped_refptr<NoScaleContentLayer> Create(ContentLayerClient* client) {
-    return make_scoped_refptr(new NoScaleContentLayer(client));
+  static scoped_refptr<NoScaleContentLayer> Create(
+      const LayerSettings& settings,
+      ContentLayerClient* client) {
+    return make_scoped_refptr(new NoScaleContentLayer(settings, client));
   }
 
   void CalculateContentsScale(float ideal_contents_scale,
                               float* contents_scale_x,
                               float* contents_scale_y,
                               gfx::Size* content_bounds) override {
     // Skip over the ContentLayer to the base Layer class.
     Layer::CalculateContentsScale(ideal_contents_scale,
                                   contents_scale_x,
                                   contents_scale_y,
                                   content_bounds);
   }
 
  protected:
-  explicit NoScaleContentLayer(ContentLayerClient* client)
-      : ContentLayer(client) {}
+  NoScaleContentLayer(const LayerSettings& settings, ContentLayerClient* client)
+      : ContentLayer(settings, client) {}
   ~NoScaleContentLayer() override {}
 };
 
 scoped_refptr<NoScaleContentLayer> CreateNoScaleDrawableContentLayer(
+    const LayerSettings& settings,
     ContentLayerClient* delegate) {
   scoped_refptr<NoScaleContentLayer> to_return =
-      NoScaleContentLayer::Create(delegate);
+      NoScaleContentLayer::Create(settings, delegate);
   to_return->SetIsDrawable(true);
   return to_return;
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerTransformsInHighDPI) {
   // Verify draw and screen space transforms of layers not in a surface.
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   scoped_refptr<FakePictureLayer> parent =
-      CreateDrawablePictureLayer(&delegate);
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
-  scoped_refptr<FakePictureLayer> child = CreateDrawablePictureLayer(&delegate);
+  scoped_refptr<FakePictureLayer> child =
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(child.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<FakePictureLayer> child_empty =
-      CreateDrawablePictureLayer(&delegate);
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(child_empty.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(),
                                false,
                                true);
 
   parent->AddChild(child);
   parent->AddChild(child_empty);
@@ skipping 80 matching lines @@
   // Verify draw and screen space transforms of layers in a surface.
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   gfx::Transform perspective_matrix;
   perspective_matrix.ApplyPerspectiveDepth(2.0);
 
   gfx::Transform scale_small_matrix;
   scale_small_matrix.Scale(SK_MScalar1 / 10.f, SK_MScalar1 / 12.f);
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
 
   scoped_refptr<FakePictureLayer> parent =
-      CreateDrawablePictureLayer(&delegate);
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
   scoped_refptr<FakePictureLayer> perspective_surface =
-      CreateDrawablePictureLayer(&delegate);
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(perspective_surface.get(),
                                perspective_matrix * scale_small_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<FakePictureLayer> scale_surface =
-      CreateDrawablePictureLayer(&delegate);
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(scale_surface.get(),
                                scale_small_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   perspective_surface->SetForceRenderSurface(true);
   scale_surface->SetForceRenderSurface(true);
@@ skipping 72 matching lines @@
       perspective_surface->draw_transform());
 }
 
 // TODO(sohanjg): Remove this test when ContentLayer is removed.
 TEST_F(LayerTreeHostCommonTest,
      LayerTransformsInHighDPIAccurateScaleZeroChildPosition) {
   // Verify draw and screen space transforms of layers not in a surface.
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<ContentLayer> parent =
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(133, 133),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> child = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<ContentLayer> child =
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(child.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(13, 13),
                                false,
                                true);
 
   scoped_refptr<NoScaleContentLayer> child_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+      CreateNoScaleDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(child_no_scale.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(13, 13),
                                false,
                                true);
 
   parent->AddChild(child);
   parent->AddChild(child_no_scale);
@@ skipping 82 matching lines @@
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 1.75;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 1.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   root->SetBounds(gfx::Size(100, 100));
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<ContentLayer> parent =
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
   scoped_refptr<ContentLayer> child_scale =
-      CreateDrawableContentLayer(&delegate);
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<ContentLayer> child_empty =
-      CreateDrawableContentLayer(&delegate);
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(child_empty.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(),
                                false,
                                true);
 
   scoped_refptr<NoScaleContentLayer> child_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+      CreateNoScaleDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(child_no_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(12.f, 12.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   root->AddChild(parent);
 
@@ skipping 134 matching lines @@
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 1.75;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 1.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   root->SetBounds(gfx::Size(100, 100));
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<ContentLayer> parent =
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
   scoped_refptr<ContentLayer> child_scale =
-      CreateDrawableContentLayer(&delegate);
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<ContentLayer> child_empty =
-      CreateDrawableContentLayer(&delegate);
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(child_empty.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(),
                                false,
                                true);
 
   scoped_refptr<NoScaleContentLayer> child_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+      CreateNoScaleDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(child_no_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(12.f, 12.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   root->AddChild(parent);
 
@@ skipping 50 matching lines @@
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 1.75;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 0.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   root->SetBounds(gfx::Size(100, 100));
 
   scoped_refptr<FakePictureLayer> parent =
-      CreateDrawablePictureLayer(&delegate);
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
   scoped_refptr<FakePictureLayer> child_scale =
-      CreateDrawablePictureLayer(&delegate);
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   root->AddChild(parent);
 
@@ skipping 33 matching lines @@
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 2.0;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 3.0;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   root->SetBounds(gfx::Size(100, 100));
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<ContentLayer> parent =
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
   scoped_refptr<ContentLayer> surface_scale =
-      CreateDrawableContentLayer(&delegate);
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(surface_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<ContentLayer> surface_scale_child_scale =
-      CreateDrawableContentLayer(&delegate);
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(surface_scale_child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<NoScaleContentLayer> surface_scale_child_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+      CreateNoScaleDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(surface_scale_child_no_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<NoScaleContentLayer> surface_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+      CreateNoScaleDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(surface_no_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(12.f, 12.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<ContentLayer> surface_no_scale_child_scale =
-      CreateDrawableContentLayer(&delegate);
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(surface_no_scale_child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<NoScaleContentLayer> surface_no_scale_child_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+      CreateNoScaleDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(surface_no_scale_child_no_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   root->AddChild(parent);
 
@@ skipping 118 matching lines @@
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 2.0;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 3.0;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   root->SetBounds(gfx::Size(100, 100));
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<ContentLayer> parent =
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
   scoped_refptr<ContentLayer> surface_scale =
-      CreateDrawableContentLayer(&delegate);
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(surface_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<ContentLayer> surface_scale_child_scale =
-      CreateDrawableContentLayer(&delegate);
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(surface_scale_child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<NoScaleContentLayer> surface_scale_child_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+      CreateNoScaleDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(surface_scale_child_no_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<NoScaleContentLayer> surface_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+      CreateNoScaleDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(surface_no_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(12.f, 12.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<ContentLayer> surface_no_scale_child_scale =
-      CreateDrawableContentLayer(&delegate);
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(surface_no_scale_child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<NoScaleContentLayer> surface_no_scale_child_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+      CreateNoScaleDrawableContentLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(surface_no_scale_child_no_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   root->AddChild(parent);
 
@@ skipping 124 matching lines @@
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 1.75;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 1.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   root->SetBounds(gfx::Size(100, 100));
 
   scoped_refptr<FakePictureLayer> parent =
-      CreateDrawablePictureLayer(&delegate);
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
   scoped_refptr<FakePictureLayer> child_scale =
-      CreateDrawablePictureLayer(&delegate);
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   root->AddChild(parent);
 
@@ skipping 14 matching lines @@
     // they are static.
     EXPECT_IDEAL_SCALE_EQ(initial_child_scale * initial_parent_scale,
                           child_scale);
   }
 }
 
 // TODO(sohanjg): Remove this test when ContentLayer is removed.
 TEST_F(LayerTreeHostCommonTest,
        ChangeInContentBoundsOrScaleTriggersPushProperties) {
   MockContentLayerClient delegate;
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> child = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child =
+      CreateDrawableContentLayer(layer_settings(), &delegate);
   root->AddChild(child);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
@@ skipping 32 matching lines @@
   ExecuteCalculateDrawProperties(root.get(), 2.f);
   EXPECT_FALSE(root->needs_push_properties());
   EXPECT_FALSE(child->needs_push_properties());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceTransformsInHighDPI) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   scoped_refptr<FakePictureLayer> parent =
-      CreateDrawablePictureLayer(&delegate);
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(30, 30),
                                false,
                                true);
 
-  scoped_refptr<FakePictureLayer> child = CreateDrawablePictureLayer(&delegate);
+  scoped_refptr<FakePictureLayer> child =
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(child.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   gfx::Transform replica_transform;
   replica_transform.Scale(1.0, -1.0);
   scoped_refptr<FakePictureLayer> replica =
-      CreateDrawablePictureLayer(&delegate);
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(replica.get(),
                                replica_transform,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   // This layer should end up in the same surface as child, with the same draw
   // and screen space transforms.
   scoped_refptr<FakePictureLayer> duplicate_child_non_owner =
-      CreateDrawablePictureLayer(&delegate);
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(duplicate_child_non_owner.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   parent->AddChild(child);
   child->AddChild(duplicate_child_non_owner);
@@ skipping 86 matching lines @@
       expected_replica_screen_space_transform,
       child->render_surface()->replica_screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest,
      RenderSurfaceTransformsInHighDPIAccurateScaleZeroPosition) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   scoped_refptr<FakePictureLayer> parent =
-      CreateDrawablePictureLayer(&delegate);
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(33, 31),
                                false,
                                true);
 
-  scoped_refptr<FakePictureLayer> child = CreateDrawablePictureLayer(&delegate);
+  scoped_refptr<FakePictureLayer> child =
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(child.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(13, 11),
                                false,
                                true);
 
   gfx::Transform replica_transform;
   replica_transform.Scale(1.0, -1.0);
   scoped_refptr<FakePictureLayer> replica =
-      CreateDrawablePictureLayer(&delegate);
+      CreateDrawablePictureLayer(layer_settings(), &delegate);
   SetLayerPropertiesForTesting(replica.get(),
                                replica_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(13, 11),
                                false,
                                true);
 
   parent->AddChild(child);
   child->SetReplicaLayer(replica.get());
@@ skipping 29 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();
-  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();
+  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());
 
   grand_child->SetReplicaLayer(replica_layer.get());
   child->AddChild(grand_child.get());
   child->SetMaskLayer(mask_layer.get());
   root->AddChild(child.get());
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   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();
-  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   SetLayerPropertiesForTesting(child.get(),
@@ skipping 250 matching lines @@
                                          testing::Bool(),
                                          testing::Bool()));
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayer) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
                                false);
   root->SetIsDrawable(true);
 
-  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(child.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(40, 40),
                                true,
                                false);
   child->SetIsDrawable(true);
 
-  scoped_refptr<Layer> grand_child = Layer::Create();
+  scoped_refptr<Layer> grand_child = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(grand_child.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(30, 30),
                                true,
                                false);
   grand_child->SetIsDrawable(true);
   grand_child->SetHideLayerAndSubtree(true);
 
@@ skipping 62 matching lines @@
   EXPECT_EQ(2, root->render_surface()->layer_list().at(1)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayers) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
                                false);
   root->SetIsDrawable(true);
 
-  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(child.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(40, 40),
                                true,
                                false);
   child->SetIsDrawable(true);
   child->SetHideLayerAndSubtree(true);
 
-  scoped_refptr<Layer> grand_child = Layer::Create();
+  scoped_refptr<Layer> grand_child = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(grand_child.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(30, 30),
                                true,
                                false);
   grand_child->SetIsDrawable(true);
 
   child->AddChild(grand_child);
@@ skipping 60 matching lines @@
 
 void EmptyCopyOutputCallback(scoped_ptr<CopyOutputResult> result) {}
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
                                false);
   root->SetIsDrawable(true);
 
-  scoped_refptr<Layer> copy_grand_parent = Layer::Create();
+  scoped_refptr<Layer> copy_grand_parent = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(copy_grand_parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(40, 40),
                                true,
                                false);
   copy_grand_parent->SetIsDrawable(true);
 
-  scoped_refptr<Layer> copy_parent = Layer::Create();
+  scoped_refptr<Layer> copy_parent = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(copy_parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(30, 30),
                                true,
                                false);
   copy_parent->SetIsDrawable(true);
   copy_parent->SetForceRenderSurface(true);
 
-  scoped_refptr<Layer> copy_layer = Layer::Create();
+  scoped_refptr<Layer> copy_layer = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(copy_layer.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(20, 20),
                                true,
                                false);
   copy_layer->SetIsDrawable(true);
 
-  scoped_refptr<Layer> copy_child = Layer::Create();
+  scoped_refptr<Layer> copy_child = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(copy_child.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(20, 20),
                                true,
                                false);
   copy_child->SetIsDrawable(true);
 
-  scoped_refptr<Layer> copy_grand_parent_sibling_before = Layer::Create();
+  scoped_refptr<Layer> copy_grand_parent_sibling_before =
+      Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(copy_grand_parent_sibling_before.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(40, 40),
                                true,
                                false);
   copy_grand_parent_sibling_before->SetIsDrawable(true);
 
-  scoped_refptr<Layer> copy_grand_parent_sibling_after = Layer::Create();
+  scoped_refptr<Layer> copy_grand_parent_sibling_after =
+      Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(copy_grand_parent_sibling_after.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(40, 40),
                                true,
                                false);
   copy_grand_parent_sibling_after->SetIsDrawable(true);
 
   copy_layer->AddChild(copy_child);
@@ skipping 65 matching lines @@
             copy_layer->render_surface()->layer_list().at(1)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClippedOutCopyRequest) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
                                false);
   root->SetIsDrawable(true);
 
-  scoped_refptr<Layer> copy_parent = Layer::Create();
+  scoped_refptr<Layer> copy_parent = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(copy_parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(),
                                true,
                                false);
   copy_parent->SetIsDrawable(true);
   copy_parent->SetMasksToBounds(true);
 
-  scoped_refptr<Layer> copy_layer = Layer::Create();
+  scoped_refptr<Layer> copy_layer = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(copy_layer.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(30, 30),
                                true,
                                false);
   copy_layer->SetIsDrawable(true);
 
-  scoped_refptr<Layer> copy_child = Layer::Create();
+  scoped_refptr<Layer> copy_child = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(copy_child.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(20, 20),
                                true,
                                false);
   copy_child->SetIsDrawable(true);
 
   copy_layer->AddChild(copy_child);
@@ skipping 23 matching lines @@
   EXPECT_EQ(root->id(), root->render_surface()->layer_list().at(0)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectInsideSurface) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   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();
+  scoped_refptr<Layer> surface = Layer::Create(layer_settings());
   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();
+  scoped_refptr<Layer> surface_child = Layer::Create(layer_settings());
   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 19 matching lines @@
   // problem. Constructs the following layer tree.
   //
   //   root (a render surface)
   //     + render_surface
   //       + clip_parent (scaled)
   //         + intervening_clipping_layer
   //           + clip_child
   //
   // The render surface should be resized correctly and the clip child should
   // inherit the right clip rect.
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> render_surface = Layer::Create();
-  scoped_refptr<Layer> clip_parent = Layer::Create();
-  scoped_refptr<Layer> intervening = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface = Layer::Create(layer_settings());
+  scoped_refptr<Layer> clip_parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> intervening = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> clip_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   root->AddChild(render_surface);
   render_surface->AddChild(clip_parent);
   clip_parent->AddChild(intervening);
   intervening->AddChild(clip_child);
 
   clip_child->SetClipParent(clip_parent.get());
 
   intervening->SetMasksToBounds(true);
   clip_parent->SetMasksToBounds(true);
@@ skipping 76 matching lines @@
   // case. In the following tree, both render surfaces should be resized to
   // accomodate for the clip child, despite an intervening clip.
   //
   //   root (a render surface)
   //    + clip_parent (masks to bounds)
   //      + render_surface1 (sets opacity)
   //        + intervening (masks to bounds)
   //          + render_surface2 (also sets opacity)
   //            + clip_child
   //
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> clip_parent = Layer::Create();
-  scoped_refptr<Layer> render_surface1 = Layer::Create();
-  scoped_refptr<Layer> intervening = Layer::Create();
-  scoped_refptr<Layer> render_surface2 = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> clip_parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface1 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> intervening = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface2 = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> clip_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   root->AddChild(clip_parent);
   clip_parent->AddChild(render_surface1);
   render_surface1->AddChild(intervening);
   intervening->AddChild(render_surface2);
   render_surface2->AddChild(clip_child);
 
   clip_child->SetClipParent(clip_parent.get());
 
   intervening->SetMasksToBounds(true);
@@ skipping 100 matching lines @@
   // is a scroll involved. Note, we do _not_ have to consider any other sort
   // of transform.
   //
   //   root (a render surface)
   //    + clip_parent (masks to bounds)
   //      + render_surface1 (sets opacity)
   //        + intervening (masks to bounds AND scrolls)
   //          + render_surface2 (also sets opacity)
   //            + clip_child
   //
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> clip_parent = Layer::Create();
-  scoped_refptr<Layer> render_surface1 = Layer::Create();
-  scoped_refptr<Layer> intervening = Layer::Create();
-  scoped_refptr<Layer> render_surface2 = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> clip_parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface1 = Layer::Create(layer_settings());
+  scoped_refptr<Layer> intervening = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface2 = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> clip_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   root->AddChild(clip_parent);
   clip_parent->AddChild(render_surface1);
   render_surface1->AddChild(intervening);
   intervening->AddChild(render_surface2);
   render_surface2->AddChild(clip_child);
 
   clip_child->SetClipParent(clip_parent.get());
 
   intervening->SetMasksToBounds(true);
@@ skipping 99 matching lines @@
 
 TEST_F(LayerTreeHostCommonTest, DescendantsOfClipChildren) {
   // Ensures that descendants of the clip child inherit the correct clip.
   //
   //   root (a render surface)
   //    + clip_parent (masks to bounds)
   //      + intervening (masks to bounds)
   //        + clip_child
   //          + child
   //
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> clip_parent = Layer::Create();
-  scoped_refptr<Layer> intervening = Layer::Create();
-  scoped_refptr<Layer> clip_child = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> clip_parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> intervening = Layer::Create(layer_settings());
+  scoped_refptr<Layer> clip_child = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   root->AddChild(clip_parent);
   clip_parent->AddChild(intervening);
   intervening->AddChild(clip_child);
   clip_child->AddChild(child);
 
   clip_child->SetClipParent(clip_parent.get());
 
   intervening->SetMasksToBounds(true);
   clip_parent->SetMasksToBounds(true);
@@ skipping 58 matching lines @@
   // render surfaces.
   //
   //   root (a render surface)
   //    + clip_parent (masks to bounds)
   //      + render_surface1
   //        + clip_child
   //      + render_surface2
   //        + non_clip_child
   //
   // In this example render_surface2 should be unaffected by clip_child.
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> clip_parent = Layer::Create();
-  scoped_refptr<Layer> render_surface1 = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> clip_parent = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface1 = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> clip_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
-  scoped_refptr<Layer> render_surface2 = Layer::Create();
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+  scoped_refptr<Layer> render_surface2 = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> non_clip_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   root->AddChild(clip_parent);
   clip_parent->AddChild(render_surface1);
   render_surface1->AddChild(clip_child);
   clip_parent->AddChild(render_surface2);
   render_surface2->AddChild(non_clip_child);
 
   clip_child->SetClipParent(clip_parent.get());
 
   clip_parent->SetMasksToBounds(true);
@@ skipping 181 matching lines @@
     // Only root layer has a render surface.
     EXPECT_EQ(1, count_represents_target_render_surface);
     // No layer contributes a render surface to root render surface.
     EXPECT_EQ(0, count_represents_contributing_render_surface);
     // All 4 layers represent itself.
     EXPECT_EQ(4, count_represents_itself);
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleSurfaces) {
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> render_surface = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> render_surface = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   root->AddChild(render_surface);
   render_surface->AddChild(child);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
@@ skipping 48 matching lines @@
 TEST_F(LayerTreeHostCommonTest, ClippedByScrollParent) {
   // Checks that the simple case (being clipped by a scroll parent that would
   // have been processed before you anyhow) results in the right clips.
   //
   // + root
   //   + scroll_parent_border
   //   | + scroll_parent_clip
   //   |   + scroll_parent
   //   + scroll_child
   //
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> scroll_parent_border = Layer::Create();
-  scoped_refptr<Layer> scroll_parent_clip = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> scroll_parent_border = Layer::Create(layer_settings());
+  scoped_refptr<Layer> scroll_parent_clip = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> scroll_parent =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> scroll_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   root->AddChild(scroll_child);
 
   root->AddChild(scroll_parent_border);
   scroll_parent_border->AddChild(scroll_parent_clip);
   scroll_parent_clip->AddChild(scroll_parent);
 
   scroll_parent_clip->SetMasksToBounds(true);
 
   scroll_child->SetScrollParent(scroll_parent.get());
@@ skipping 42 matching lines @@
 
   EXPECT_TRUE(root->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30).ToString(),
             scroll_child->clip_rect().ToString());
   EXPECT_TRUE(scroll_child->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest, SingularTransformSubtreesDoNotDraw) {
   scoped_refptr<LayerWithForcedDrawsContent> root =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> parent =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   root->AddChild(parent);
   parent->AddChild(child);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
@@ skipping 47 matching lines @@
 TEST_F(LayerTreeHostCommonTest, ClippedByOutOfOrderScrollParent) {
   // Checks that clipping by a scroll parent that follows you in paint order
   // still results in correct clipping.
   //
   // + root
   //   + scroll_child
   //   + scroll_parent_border
   //     + scroll_parent_clip
   //       + scroll_parent
   //
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> scroll_parent_border = Layer::Create();
-  scoped_refptr<Layer> scroll_parent_clip = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> scroll_parent_border = Layer::Create(layer_settings());
+  scoped_refptr<Layer> scroll_parent_clip = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> scroll_parent =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> scroll_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   root->AddChild(scroll_parent_border);
   scroll_parent_border->AddChild(scroll_parent_clip);
   scroll_parent_clip->AddChild(scroll_parent);
 
   root->AddChild(scroll_child);
 
   scroll_parent_clip->SetMasksToBounds(true);
 
   scroll_child->SetScrollParent(scroll_parent.get());
@@ skipping 53 matching lines @@
   //
   // + root
   //   + scroll_child
   //   + scroll_parent_border
   //   | + scroll_parent_clip
   //   |   + scroll_parent
   //   + scroll_grandparent_border
   //     + scroll_grandparent_clip
   //       + scroll_grandparent
   //
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> scroll_parent_border = Layer::Create();
-  scoped_refptr<Layer> scroll_parent_clip = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> scroll_parent_border = Layer::Create(layer_settings());
+  scoped_refptr<Layer> scroll_parent_clip = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> scroll_parent =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
-  scoped_refptr<Layer> scroll_grandparent_border = Layer::Create();
-  scoped_refptr<Layer> scroll_grandparent_clip = Layer::Create();
+  scoped_refptr<Layer> scroll_grandparent_border =
+      Layer::Create(layer_settings());
+  scoped_refptr<Layer> scroll_grandparent_clip =
+      Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> scroll_grandparent =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   scoped_refptr<LayerWithForcedDrawsContent> scroll_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   root->AddChild(scroll_child);
 
   root->AddChild(scroll_parent_border);
   scroll_parent_border->AddChild(scroll_parent_clip);
   scroll_parent_clip->AddChild(scroll_parent);
 
   root->AddChild(scroll_grandparent_border);
   scroll_grandparent_border->AddChild(scroll_grandparent_clip);
   scroll_grandparent_clip->AddChild(scroll_grandparent);
@@ skipping 92 matching lines @@
   //   + scroll_parent_border
   //     + scroll_parent_clip
   //       + scroll_parent
   //         + render_surface1
   //   + scroll_grandparent_border
   //     + scroll_grandparent_clip
   //       + scroll_grandparent
   //         + render_surface2
   //
   scoped_refptr<LayerWithForcedDrawsContent> root =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
-  scoped_refptr<Layer> scroll_parent_border = Layer::Create();
-  scoped_refptr<Layer> scroll_parent_clip = Layer::Create();
+  scoped_refptr<Layer> scroll_parent_border = Layer::Create(layer_settings());
+  scoped_refptr<Layer> scroll_parent_clip = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> scroll_parent =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> render_surface1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
-  scoped_refptr<Layer> scroll_grandparent_border = Layer::Create();
-  scoped_refptr<Layer> scroll_grandparent_clip = Layer::Create();
+  scoped_refptr<Layer> scroll_grandparent_border =
+      Layer::Create(layer_settings());
+  scoped_refptr<Layer> scroll_grandparent_clip =
+      Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> scroll_grandparent =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> render_surface2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   scoped_refptr<LayerWithForcedDrawsContent> scroll_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   root->AddChild(scroll_child);
 
   root->AddChild(scroll_parent_border);
   scroll_parent_border->AddChild(scroll_parent_clip);
   scroll_parent_clip->AddChild(scroll_parent);
   scroll_parent->AddChild(render_surface2);
 
   root->AddChild(scroll_grandparent_border);
   scroll_grandparent_border->AddChild(scroll_grandparent_clip);
@@ skipping 113 matching lines @@
 TEST_F(LayerTreeHostCommonTest, FixedPositionWithInterveningRenderSurface) {
   // 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
   //
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> render_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> fixed =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   root->AddChild(render_surface);
   render_surface->AddChild(fixed);
 
   root->SetIsContainerForFixedPositionLayers(true);
   render_surface->SetForceRenderSurface(true);
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
   fixed->SetPositionConstraint(constraint);
@@ skipping 944 matching lines @@
       4.f, child1_layer->mask_layer()->draw_properties().device_scale_factor);
   EXPECT_FLOAT_EQ(4.f,
                   child1_layer->replica_layer()
                       ->mask_layer()
                       ->draw_properties()
                       .device_scale_factor);
   EXPECT_FLOAT_EQ(4.f, child2_layer->draw_properties().device_scale_factor);
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectInChildRenderSurface) {
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   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();
+  scoped_refptr<Layer> clip = Layer::Create(layer_settings());
   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();
+  scoped_refptr<Layer> content = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(content.get(),
                                gfx::Transform(),
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(768 / 2, 10000),
                                true,
                                false);
   content->SetIsDrawable(true);
   content->SetForceRenderSurface(true);
 
@@ skipping 82 matching lines @@
 
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   gfx::Rect affected_by_delta(0, 0, root_size.width(),
                               root_size.height() + 50);
   EXPECT_EQ(affected_by_delta, sublayer->visible_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectForAnimatedLayer) {
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> animated =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   root->AddChild(animated);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   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);
 
   AddOpacityTransitionToController(animated->layer_animation_controller(), 10.0,
                                    0.f, 1.f, false);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_FALSE(animated->visible_rect_from_property_trees().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleContentRectForAnimatedLayerWithSingularTransform) {
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> clip = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> clip = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> animated =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> descendant_of_animation =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   root->AddChild(clip);
   clip->AddChild(animated);
   animated->AddChild(surface);
   surface->AddChild(descendant_of_animation);
 
   clip->SetMasksToBounds(true);
   surface->SetForceRenderSurface(true);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
@@ skipping 49 matching lines @@
   // means the clip cannot be projected into |surface|'s space, so we treat
   // |surface| and layers that draw into it as fully visible.
   EXPECT_EQ(gfx::Rect(100, 100), surface->visible_rect_from_property_trees());
   EXPECT_EQ(gfx::Rect(200, 200),
             descendant_of_animation->visible_rect_from_property_trees());
 }
 
 // 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();
-  scoped_refptr<Layer> child = Layer::Create();
-  scoped_refptr<Layer> grandchild = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child = Layer::Create(layer_settings());
+  scoped_refptr<Layer> grandchild = Layer::Create(layer_settings());
   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 14 matching lines @@
   EXPECT_TRUE(grandchild->filters().IsEmpty());
 
   EXPECT_FALSE(root->FilterIsAnimating());
   EXPECT_TRUE(child->FilterIsAnimating());
   EXPECT_FALSE(grandchild->FilterIsAnimating());
 }
 
 // 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();
-  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
+  scoped_refptr<Layer> child = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> grandchild =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   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 21 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();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(2500, 1500), true,
                                false);
 
-  scoped_refptr<Layer> frame_clip = Layer::Create();
+  scoped_refptr<Layer> frame_clip = Layer::Create(layer_settings());
   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();
+  scoped_refptr<Layer> rotated = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(rotated.get(), rotate,
                                gfx::Point3F(1250, 250, 0), gfx::PointF(),
                                gfx::Size(2500, 500), true, false);
 
-  scoped_refptr<Layer> surface = Layer::Create();
+  scoped_refptr<Layer> surface = Layer::Create(layer_settings());
   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());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   SetLayerPropertiesForTesting(container.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(300, 300), true, false);
 
   scoped_refptr<LayerWithForcedDrawsContent> box =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   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);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   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();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(800, 800), true, false);
   root->SetIsContainerForFixedPositionLayers(true);
 
-  scoped_refptr<Layer> frame_clip = Layer::Create();
+  scoped_refptr<Layer> frame_clip = Layer::Create(layer_settings());
   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());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   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);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   gfx::Rect expected(0, 0, 100, 100);
   EXPECT_EQ(expected, fixed->visible_rect_from_property_trees());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        PropertyTreesAccountForScrollCompensationAdjustment) {
   gfx::Transform identity;
   gfx::Transform translate_z;
   translate_z.Translate3d(0, 0, 10);
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(800, 800), true, false);
   root->SetIsContainerForFixedPositionLayers(true);
 
-  scoped_refptr<Layer> frame_clip = Layer::Create();
+  scoped_refptr<Layer> frame_clip = Layer::Create(layer_settings());
   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());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   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());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   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());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   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);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   gfx::Rect expected(0, 0, 50, 50);
   EXPECT_EQ(expected, fixed->visible_rect_from_property_trees());
 
   expected = gfx::Rect(0, 0, 10, 10);
   EXPECT_EQ(expected, fixed_child->visible_rect_from_property_trees());
 }
 
 TEST_F(LayerTreeHostCommonTest, FixedClipsShouldBeAssociatedWithTheRightNode) {
   gfx::Transform identity;
 
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(800, 800), true, false);
   root->SetIsContainerForFixedPositionLayers(true);
 
-  scoped_refptr<Layer> frame_clip = Layer::Create();
+  scoped_refptr<Layer> frame_clip = Layer::Create(layer_settings());
   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());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   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());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   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 11 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();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(800, 800), true, false);
   root->SetIsContainerForFixedPositionLayers(true);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   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();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   root->AddChild(child);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   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);
 
   ExecuteCalculateDrawProperties(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), child->visible_rect_from_property_trees());
 
   child->SetTransformOrigin(gfx::Point3F(10.f, 10.f, 10.f));
 
   ExecuteCalculateDrawProperties(root.get());
   EXPECT_EQ(gfx::Rect(5, 5, 5, 5), child->visible_rect_from_property_trees());
 }
 
 TEST_F(LayerTreeHostCommonTest, UpdateScrollChildPosition) {
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> scroll_parent =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> scroll_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent);
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
   root->AddChild(scroll_child);
   root->AddChild(scroll_parent);
   scroll_child->SetScrollParent(scroll_parent.get());
   scroll_parent->SetScrollClipLayerId(root->id());
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_transform;
@@ skipping 17 matching lines @@
   EXPECT_EQ(gfx::Rect(0, 5, 25, 25),
             scroll_child->visible_rect_from_property_trees());
 }
 
 static void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingSubtreeMain) {
   gfx::Transform identity;
   FakeContentLayerClient client;
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> grandchild =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<FakeContentLayer> greatgrandchild(
-      FakeContentLayer::Create(&client));
+      FakeContentLayer::Create(layer_settings(), &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 135 matching lines @@
 
   greatgrandchild_ptr->PassCopyRequests(&requests);
   ExecuteCalculateDrawProperties(root.get());
   EXPECT_EQ(gfx::Rect(10, 10),
             grandchild_ptr->visible_rect_from_property_trees());
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingLayer) {
   gfx::Transform identity;
   FakeContentLayerClient client;
-  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> root = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
+      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   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);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
@@ skipping 19 matching lines @@
   child->SetDoubleSided(true);
   child->SetTransform(identity);
 
   child->SetOpacity(0.f);
   ExecuteCalculateDrawProperties(root.get());
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_rect_from_property_trees());
 }
 
 }  // namespace
 }  // namespace cc