CC: Plumb LayerSettings parameter for cc::Layer construction.

cc/trees/layer_tree_host_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.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/location.h"
@@ skipping 185 matching lines @@
 SINGLE_AND_MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestReadyToActivateEmpty);
 
 // Test if the LTHI receives ReadyToActivate notifications from the TileManager
 // when some raster tasks flagged as REQUIRED_FOR_ACTIVATION got scheduled.
 class LayerTreeHostTestReadyToActivateNonEmpty
     : public LayerTreeHostTestReadyToActivateEmpty {
  public:
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     root_layer->SetBounds(gfx::Size(1024, 1024));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
   }
 
   void AfterTest() override {
     EXPECT_TRUE(did_notify_ready_to_activate_);
     EXPECT_TRUE(all_tiles_required_for_activation_are_ready_to_draw_);
@@ skipping 49 matching lines @@
 SINGLE_AND_MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestReadyToDrawEmpty);
 
 // Test if the LTHI receives ReadyToDraw notifications from the TileManager when
 // some raster tasks flagged as REQUIRED_FOR_DRAW got scheduled.
 class LayerTreeHostTestReadyToDrawNonEmpty
     : public LayerTreeHostTestReadyToDrawEmpty {
  public:
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     root_layer->SetBounds(gfx::Size(1024, 1024));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
   }
 
   void AfterTest() override {
     EXPECT_TRUE(did_notify_ready_to_draw_);
     EXPECT_TRUE(all_tiles_required_for_draw_are_ready_to_draw_);
@@ skipping 74 matching lines @@
   int num_commits_;
   int num_draws_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsCommit2);
 
 // Verify that we pass property values in PushPropertiesTo.
 class LayerTreeHostTestPushPropertiesTo : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
-    scoped_refptr<Layer> root = Layer::Create();
+    scoped_refptr<Layer> root = Layer::Create(layer_settings());
     root->CreateRenderSurface();
     root->SetBounds(gfx::Size(10, 10));
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   enum Properties {
     STARTUP,
     BOUNDS,
     HIDE_LAYER_AND_SUBTREE,
@@ skipping 114 matching lines @@
 
 // After setNeedsRedrawRect(invalid_rect) the final damage_rect
 // must contain invalid_rect.
 class LayerTreeHostTestSetNeedsRedrawRect : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNeedsRedrawRect()
       : num_draws_(0), bounds_(50, 50), invalid_rect_(10, 10, 20, 20) {}
 
   void BeginTest() override {
     if (layer_tree_host()->settings().impl_side_painting)
-      root_layer_ = FakePictureLayer::Create(&client_);
+      root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     else
-      root_layer_ = ContentLayer::Create(&client_);
+      root_layer_ = ContentLayer::Create(layer_settings(), &client_);
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
     PostSetNeedsCommitToMainThread();
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
@@ skipping 37 matching lines @@
 
 // Ensure the texture size of the pending and active trees are identical when a
 // layer is not in the viewport and a resize happens on the viewport
 class LayerTreeHostTestGpuRasterDeviceSizeChanged : public LayerTreeHostTest {
  public:
   LayerTreeHostTestGpuRasterDeviceSizeChanged()
       : num_draws_(0), bounds_(500, 64), invalid_rect_(10, 10, 20, 20) {}
 
   void BeginTest() override {
     client_.set_fill_with_nonsolid_color(true);
-    root_layer_ = FakePictureLayer::Create(&client_);
+    root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     root_layer_->SetIsDrawable(true);
     gfx::Transform transform;
     // Translate the layer out of the viewport to force it to not update its
     // tile size via PushProperties.
     transform.Translate(10000.0, 10000.0);
     root_layer_->SetTransform(transform);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
 
@@ skipping 57 matching lines @@
 SINGLE_AND_MULTI_THREAD_IMPL_TEST_F(
     LayerTreeHostTestGpuRasterDeviceSizeChanged);
 
 class LayerTreeHostTestNoExtraCommitFromInvalidate : public LayerTreeHostTest {
  public:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->layer_transforms_should_scale_layer_contents = true;
   }
 
   void SetupTree() override {
-    root_layer_ = Layer::Create();
+    root_layer_ = Layer::Create(layer_settings());
     root_layer_->SetBounds(gfx::Size(10, 20));
     root_layer_->CreateRenderSurface();
 
     if (layer_tree_host()->settings().impl_side_painting)
-      scaled_layer_ = FakePictureLayer::Create(&client_);
+      scaled_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     else
-      scaled_layer_ = FakeContentLayer::Create(&client_);
+      scaled_layer_ = FakeContentLayer::Create(layer_settings(), &client_);
     scaled_layer_->SetBounds(gfx::Size(1, 1));
     root_layer_->AddChild(scaled_layer_);
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
@@ skipping 26 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNoExtraCommitFromInvalidate);
 
 class LayerTreeHostTestNoExtraCommitFromScrollbarInvalidate
     : public LayerTreeHostTest {
  public:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->layer_transforms_should_scale_layer_contents = true;
   }
 
   void SetupTree() override {
-    root_layer_ = Layer::Create();
+    root_layer_ = Layer::Create(layer_settings());
     root_layer_->SetBounds(gfx::Size(10, 20));
     root_layer_->CreateRenderSurface();
 
     bool paint_scrollbar = true;
     bool has_thumb = false;
     scrollbar_ = FakePaintedScrollbarLayer::Create(
-        paint_scrollbar, has_thumb, root_layer_->id());
+        layer_settings(), paint_scrollbar, has_thumb, root_layer_->id());
     scrollbar_->SetPosition(gfx::Point(0, 10));
     scrollbar_->SetBounds(gfx::Size(10, 10));
 
     root_layer_->AddChild(scrollbar_);
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
@@ skipping 30 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestNoExtraCommitFromScrollbarInvalidate);
 
 class LayerTreeHostTestSetNextCommitForcesRedraw : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNextCommitForcesRedraw()
       : num_draws_(0), bounds_(50, 50), invalid_rect_(10, 10, 20, 20) {}
 
   void BeginTest() override {
     if (layer_tree_host()->settings().impl_side_painting)
-      root_layer_ = FakePictureLayer::Create(&client_);
+      root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     else
-      root_layer_ = ContentLayer::Create(&client_);
+      root_layer_ = ContentLayer::Create(layer_settings(), &client_);
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
     PostSetNeedsCommitToMainThread();
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (num_draws_ == 3 && host_impl->settings().impl_side_painting)
       host_impl->SetNeedsRedrawRect(invalid_rect_);
@@ skipping 77 matching lines @@
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     // If we don't set the minimum contents scale, it's harder to verify whether
     // the damage we get is correct. For other scale amounts, please see
     // LayerTreeHostTestDamageWithScale.
     settings->minimum_contents_scale = 1.f;
   }
 
   void SetupTree() override {
     if (layer_tree_host()->settings().impl_side_painting)
-      root_layer_ = FakePictureLayer::Create(&client_);
+      root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     else
-      root_layer_ = ContentLayer::Create(&client_);
+      root_layer_ = ContentLayer::Create(layer_settings(), &client_);
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(50, 50));
     layer_tree_host()->SetRootLayer(root_layer_);
 
     // The initially transparent layer has a larger child layer, which is
     // not initially drawn because of the this (parent) layer.
     if (layer_tree_host()->settings().impl_side_painting)
-      parent_layer_ = FakePictureLayer::Create(&client_);
+      parent_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     else
-      parent_layer_ = FakeContentLayer::Create(&client_);
+      parent_layer_ = FakeContentLayer::Create(layer_settings(), &client_);
     parent_layer_->SetBounds(gfx::Size(15, 15));
     parent_layer_->SetOpacity(0.0f);
     root_layer_->AddChild(parent_layer_);
 
     if (layer_tree_host()->settings().impl_side_painting)
-      child_layer_ = FakePictureLayer::Create(&client_);
+      child_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     else
-      child_layer_ = FakeContentLayer::Create(&client_);
+      child_layer_ = FakeContentLayer::Create(layer_settings(), &client_);
     child_layer_->SetBounds(gfx::Size(25, 25));
     parent_layer_->AddChild(child_layer_);
 
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
@@ skipping 63 matching lines @@
 class LayerTreeHostTestDamageWithScale : public LayerTreeHostTest {
  public:
   LayerTreeHostTestDamageWithScale() {}
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
 
     scoped_ptr<FakePicturePile> pile(
         new FakePicturePile(ImplSidePaintingSettings().minimum_contents_scale,
                             ImplSidePaintingSettings().default_tile_grid_size));
-    root_layer_ =
-        FakePictureLayer::CreateWithRecordingSource(&client_, pile.Pass());
+    root_layer_ = FakePictureLayer::CreateWithRecordingSource(
+        layer_settings(), &client_, pile.Pass());
     root_layer_->SetBounds(gfx::Size(50, 50));
 
     pile.reset(
         new FakePicturePile(ImplSidePaintingSettings().minimum_contents_scale,
                             ImplSidePaintingSettings().default_tile_grid_size));
-    child_layer_ =
-        FakePictureLayer::CreateWithRecordingSource(&client_, pile.Pass());
+    child_layer_ = FakePictureLayer::CreateWithRecordingSource(
+        layer_settings(), &client_, pile.Pass());
     child_layer_->SetBounds(gfx::Size(25, 25));
     child_layer_->SetIsDrawable(true);
     child_layer_->SetContentsOpaque(true);
     root_layer_->AddChild(child_layer_);
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
@@ skipping 74 matching lines @@
 
 MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestDamageWithScale);
 
 // Tests that if a layer is not drawn because of some reason in the parent,
 // causing its content bounds to not be computed, then when it is later drawn,
 // its content bounds get pushed.
 class LayerTreeHostTestUndrawnLayersPushContentBoundsLater
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestUndrawnLayersPushContentBoundsLater()
-      : root_layer_(Layer::Create()) {}
+      : root_layer_(Layer::Create(layer_settings())) {}
 
   void SetupTree() override {
     root_layer_->CreateRenderSurface();
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(20, 20));
     layer_tree_host()->SetRootLayer(root_layer_);
 
-    parent_layer_ = Layer::Create();
+    parent_layer_ = Layer::Create(layer_settings());
     parent_layer_->SetBounds(gfx::Size(20, 20));
     parent_layer_->SetOpacity(0.0f);
     root_layer_->AddChild(parent_layer_);
 
-    child_layer_ = Layer::Create();
+    child_layer_ = Layer::Create(layer_settings());
     child_layer_->SetBounds(gfx::Size(15, 15));
     parent_layer_->AddChild(child_layer_);
 
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     LayerImpl* root = host_impl->active_tree()->root_layer();
@@ skipping 177 matching lines @@
 
 // Verifies that StartPageScaleAnimation events propagate correctly
 // from LayerTreeHost to LayerTreeHostImpl in the MT compositor.
 class LayerTreeHostTestStartPageScaleAnimation : public LayerTreeHostTest {
  public:
   LayerTreeHostTestStartPageScaleAnimation() {}
 
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
-    scoped_refptr<FakePictureLayer> layer = FakePictureLayer::Create(&client_);
+    scoped_refptr<FakePictureLayer> layer =
+        FakePictureLayer::Create(layer_settings(), &client_);
     layer->set_always_update_resources(true);
     scroll_layer_ = layer;
 
     Layer* root_layer = layer_tree_host()->root_layer();
     scroll_layer_->SetScrollClipLayerId(root_layer->id());
     scroll_layer_->SetIsContainerForFixedPositionLayers(true);
     scroll_layer_->SetBounds(gfx::Size(2 * root_layer->bounds().width(),
                                        2 * root_layer->bounds().height()));
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset());
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
@@ skipping 100 matching lines @@
   }
   bool FillsBoundsCompletely() const override { return false; }
 
  private:
   Layer* test_layer_;
 };
 
 class ContentLayerWithUpdateTracking : public ContentLayer {
  public:
   static scoped_refptr<ContentLayerWithUpdateTracking> Create(
+      const LayerSettings& settings,
       ContentLayerClient* client) {
-    return make_scoped_refptr(new ContentLayerWithUpdateTracking(client));
+    return make_scoped_refptr(
+        new ContentLayerWithUpdateTracking(settings, client));
   }
 
   int PaintContentsCount() { return paint_contents_count_; }
   void ResetPaintContentsCount() { paint_contents_count_ = 0; }
 
   bool Update(ResourceUpdateQueue* queue,
               const OcclusionTracker<Layer>* occlusion) override {
     bool updated = ContentLayer::Update(queue, occlusion);
     paint_contents_count_++;
     return updated;
   }
 
  private:
-  explicit ContentLayerWithUpdateTracking(ContentLayerClient* client)
-      : ContentLayer(client), paint_contents_count_(0) {
+  ContentLayerWithUpdateTracking(const LayerSettings& settings,
+                                 ContentLayerClient* client)
+      : ContentLayer(settings, client), paint_contents_count_(0) {
     SetBounds(gfx::Size(10, 10));
     SetIsDrawable(true);
   }
   ~ContentLayerWithUpdateTracking() override {}
 
   int paint_contents_count_;
 };
 
 // Layer opacity change during paint should not prevent compositor resources
 // from being updated during commit.
 class LayerTreeHostTestOpacityChange : public LayerTreeHostTest {
  public:
   LayerTreeHostTestOpacityChange() : test_opacity_change_delegate_() {}
 
   void BeginTest() override {
     if (layer_tree_host()->settings().impl_side_painting) {
-      update_check_picture_layer_ =
-          FakePictureLayer::Create(&test_opacity_change_delegate_);
+      update_check_picture_layer_ = FakePictureLayer::Create(
+          layer_settings(), &test_opacity_change_delegate_);
       test_opacity_change_delegate_.SetTestLayer(
           update_check_picture_layer_.get());
       is_impl_paint_ = true;
     } else {
       update_check_content_layer_ = ContentLayerWithUpdateTracking::Create(
-          &test_opacity_change_delegate_);
+          layer_settings(), &test_opacity_change_delegate_);
       test_opacity_change_delegate_.SetTestLayer(
           update_check_content_layer_.get());
       is_impl_paint_ = false;
     }
     layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
     if (layer_tree_host()->settings().impl_side_painting)
       layer_tree_host()->root_layer()->AddChild(update_check_picture_layer_);
     else
       layer_tree_host()->root_layer()->AddChild(update_check_content_layer_);
 
@@ skipping 24 matching lines @@
  public:
   LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers() {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     // PictureLayer can only be used with impl side painting enabled.
     settings->impl_side_painting = true;
   }
 
   void BeginTest() override {
     client_.set_fill_with_nonsolid_color(true);
-    root_layer_ = FakePictureLayer::Create(&client_);
-    child_layer_ = FakePictureLayer::Create(&client_);
+    root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    child_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
 
     layer_tree_host()->SetViewportSize(gfx::Size(60, 60));
     layer_tree_host()->SetDeviceScaleFactor(1.5);
     EXPECT_EQ(gfx::Size(60, 60), layer_tree_host()->device_viewport_size());
 
     root_layer_->AddChild(child_layer_);
 
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(30, 30));
 
@@ skipping 87 matching lines @@
  public:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->renderer_settings.texture_id_allocation_chunk_size = 1;
     // Make sure partial texture updates are turned off.
     settings->max_partial_texture_updates = 0;
     // Linear fade animator prevents scrollbars from drawing immediately.
     settings->scrollbar_animator = LayerTreeSettings::NO_ANIMATOR;
   }
 
   void SetupTree() override {
-    layer_ = FakeContentLayer::Create(&client_);
+    layer_ = FakeContentLayer::Create(layer_settings(), &client_);
     layer_->SetBounds(gfx::Size(10, 20));
 
     bool paint_scrollbar = true;
     bool has_thumb = false;
     scrollbar_ = FakePaintedScrollbarLayer::Create(
-        paint_scrollbar, has_thumb, layer_->id());
+        layer_settings(), paint_scrollbar, has_thumb, layer_->id());
     scrollbar_->SetPosition(gfx::Point(0, 10));
     scrollbar_->SetBounds(gfx::Size(10, 10));
 
     layer_->AddChild(scrollbar_);
 
     layer_tree_host()->SetRootLayer(layer_);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override {
@@ skipping 148 matching lines @@
  public:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->renderer_settings.texture_id_allocation_chunk_size = 1;
     // Allow one partial texture update.
     settings->max_partial_texture_updates = 1;
     // No partial updates when impl side painting is enabled.
     settings->impl_side_painting = false;
   }
 
   void SetupTree() override {
-    parent_ = FakeContentLayer::Create(&client_);
+    parent_ = FakeContentLayer::Create(layer_settings(), &client_);
     parent_->SetBounds(gfx::Size(10, 20));
 
-    child_ = FakeContentLayer::Create(&client_);
+    child_ = FakeContentLayer::Create(layer_settings(), &client_);
     child_->SetPosition(gfx::Point(0, 10));
     child_->SetBounds(gfx::Size(3, 10));
 
     parent_->AddChild(child_);
 
     layer_tree_host()->SetRootLayer(parent_);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
@@ skipping 142 matching lines @@
 
 // Partial updates are not possible with a delegating renderer.
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostTestAtomicCommitWithPartialUpdate);
 
 // TODO(sohanjg) : Make it work with impl-side painting.
 class LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit
     : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
-    root_layer_ = FakeContentLayer::Create(&client_);
+    root_layer_ = FakeContentLayer::Create(layer_settings(), &client_);
     root_layer_->SetBounds(gfx::Size(100, 100));
 
-    surface_layer1_ = FakeContentLayer::Create(&client_);
+    surface_layer1_ = FakeContentLayer::Create(layer_settings(), &client_);
     surface_layer1_->SetBounds(gfx::Size(100, 100));
     surface_layer1_->SetForceRenderSurface(true);
     surface_layer1_->SetOpacity(0.5f);
     root_layer_->AddChild(surface_layer1_);
 
-    surface_layer2_ = FakeContentLayer::Create(&client_);
+    surface_layer2_ = FakeContentLayer::Create(layer_settings(), &client_);
     surface_layer2_->SetBounds(gfx::Size(100, 100));
     surface_layer2_->SetForceRenderSurface(true);
     surface_layer2_->SetOpacity(0.5f);
     surface_layer1_->AddChild(surface_layer2_);
 
-    replica_layer1_ = FakeContentLayer::Create(&client_);
+    replica_layer1_ = FakeContentLayer::Create(layer_settings(), &client_);
     surface_layer1_->SetReplicaLayer(replica_layer1_.get());
 
-    replica_layer2_ = FakeContentLayer::Create(&client_);
+    replica_layer2_ = FakeContentLayer::Create(layer_settings(), &client_);
     surface_layer2_->SetReplicaLayer(replica_layer2_.get());
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     Renderer* renderer = host_impl->renderer();
@@ skipping 50 matching lines @@
   scoped_refptr<FakeContentLayer> surface_layer2_;
   scoped_refptr<FakeContentLayer> replica_layer2_;
 };
 
 // Surfaces don't exist with a delegated renderer.
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(
     LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit);
 
 class EvictionTestLayer : public Layer {
  public:
-  static scoped_refptr<EvictionTestLayer> Create() {
-    return make_scoped_refptr(new EvictionTestLayer());
+  static scoped_refptr<EvictionTestLayer> Create(
+      const LayerSettings& settings) {
+    return make_scoped_refptr(new EvictionTestLayer(settings));
   }
 
   bool Update(ResourceUpdateQueue*, const OcclusionTracker<Layer>*) override;
   bool DrawsContent() const override { return true; }
 
   scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl) override;
   void PushPropertiesTo(LayerImpl* impl) override;
   void SetTexturePriorities(const PriorityCalculator&) override;
 
   bool HaveBackingTexture() const {
     return texture_.get() ? texture_->have_backing_texture() : false;
   }
 
  private:
-  EvictionTestLayer() : Layer() {}
+  explicit EvictionTestLayer(const LayerSettings& settings) : Layer(settings) {}
   ~EvictionTestLayer() override {}
 
   void CreateTextureIfNeeded() {
     if (texture_)
       return;
     texture_ = PrioritizedResource::Create(
         layer_tree_host()->contents_texture_manager());
     texture_->SetDimensions(gfx::Size(10, 10), RGBA_8888);
     bitmap_.allocN32Pixels(10, 10);
   }
@@ skipping 54 matching lines @@
   Layer::PushPropertiesTo(layer_impl);
 
   EvictionTestLayerImpl* test_layer_impl =
       static_cast<EvictionTestLayerImpl*>(layer_impl);
   test_layer_impl->SetHasTexture(texture_->have_backing_texture());
 }
 
 class LayerTreeHostTestEvictTextures : public LayerTreeHostTest {
  public:
   LayerTreeHostTestEvictTextures()
-      : layer_(EvictionTestLayer::Create()),
+      : layer_(EvictionTestLayer::Create(layer_settings())),
         impl_for_evict_textures_(0),
         num_commits_(0) {}
 
   void BeginTest() override {
     layer_tree_host()->SetRootLayer(layer_);
     layer_tree_host()->SetViewportSize(gfx::Size(10, 20));
 
     gfx::Transform identity_matrix;
     SetLayerPropertiesForTesting(layer_.get(),
                                  0,
@@ skipping 115 matching lines @@
 class LayerTreeHostTestContinuousInvalidate : public LayerTreeHostTest {
  public:
   LayerTreeHostTestContinuousInvalidate()
       : num_commit_complete_(0), num_draw_layers_(0) {}
 
   void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
     layer_tree_host()->root_layer()->SetBounds(gfx::Size(10, 10));
 
     if (layer_tree_host()->settings().impl_side_painting)
-      layer_ = FakePictureLayer::Create(&client_);
+      layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     else
-      layer_ = FakeContentLayer::Create(&client_);
+      layer_ = FakeContentLayer::Create(layer_settings(), &client_);
 
     layer_->SetBounds(gfx::Size(10, 10));
     layer_->SetPosition(gfx::PointF(0.f, 0.f));
     layer_->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(layer_);
 
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommitAndDrawFrame() override {
@@ skipping 322 matching lines @@
   host->Composite(base::TimeTicks::Now());
 
   EXPECT_EQ(0u, host->MaxPartialTextureUpdates());
 }
 
 // TODO(sohanjg) : Remove it once impl-side painting ships everywhere.
 class LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted()
-      : root_layer_(FakeContentLayer::Create(&client_)),
-        child_layer1_(FakeContentLayer::Create(&client_)),
-        child_layer2_(FakeContentLayer::Create(&client_)),
+      : root_layer_(FakeContentLayer::Create(layer_settings(), &client_)),
+        child_layer1_(FakeContentLayer::Create(layer_settings(), &client_)),
+        child_layer2_(FakeContentLayer::Create(layer_settings(), &client_)),
         num_commits_(0) {}
 
   void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(100, 100));
     root_layer_->SetBounds(gfx::Size(100, 100));
     child_layer1_->SetBounds(gfx::Size(100, 100));
     child_layer2_->SetBounds(gfx::Size(100, 100));
     root_layer_->AddChild(child_layer1_);
     root_layer_->AddChild(child_layer2_);
     layer_tree_host()->SetRootLayer(root_layer_);
@@ skipping 59 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_NOIMPL_TEST_F(
     LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted);
 
 class LayerTreeHostTestLCDChange : public LayerTreeHostTest {
  public:
   void SetupTree() override {
     num_tiles_rastered_ = 0;
 
-    scoped_refptr<Layer> root_layer = PictureLayer::Create(&client_);
+    scoped_refptr<Layer> root_layer =
+        PictureLayer::Create(layer_settings(), &client_);
     client_.set_fill_with_nonsolid_color(true);
     root_layer->SetIsDrawable(true);
     root_layer->SetBounds(gfx::Size(10, 10));
     root_layer->SetContentsOpaque(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
 
     // The expectations are based on the assumption that the default
     // LCD settings are:
     EXPECT_TRUE(layer_tree_host()->settings().can_use_lcd_text);
@@ skipping 211 matching lines @@
 class LayerTreeHostTestUninvertibleTransformDoesNotBlockActivation
     : public LayerTreeHostTest {
  protected:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
   }
 
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
-    scoped_refptr<Layer> layer = PictureLayer::Create(&client_);
+    scoped_refptr<Layer> layer =
+        PictureLayer::Create(layer_settings(), &client_);
     layer->SetTransform(gfx::Transform(0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
     layer->SetBounds(gfx::Size(10, 10));
     layer_tree_host()->root_layer()->AddChild(layer);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     EndTest();
   }
@@ skipping 31 matching lines @@
     bool FillsBoundsCompletely() const override { return false; }
 
    private:
     Layer* layer_;
   };
 
   LayerTreeHostTestChangeLayerPropertiesInPaintContents() : num_commits_(0) {}
 
   void SetupTree() override {
     if (layer_tree_host()->settings().impl_side_painting) {
-      scoped_refptr<PictureLayer> root_layer = PictureLayer::Create(&client_);
+      scoped_refptr<PictureLayer> root_layer =
+          PictureLayer::Create(layer_settings(), &client_);
       layer_tree_host()->SetRootLayer(root_layer);
     } else {
-      scoped_refptr<ContentLayer> root_layer = ContentLayer::Create(&client_);
+      scoped_refptr<ContentLayer> root_layer =
+          ContentLayer::Create(layer_settings(), &client_);
       layer_tree_host()->SetRootLayer(root_layer);
     }
     Layer* root_layer = layer_tree_host()->root_layer();
     root_layer->SetIsDrawable(true);
     root_layer->SetBounds(gfx::Size(1, 1));
 
     client_.set_layer(root_layer);
 
     LayerTreeHostTest::SetupTree();
   }
@@ skipping 63 matching lines @@
   }
 
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     layer_tree_host()->root_layer()->SetIsDrawable(false);
 
     io_surface_id_ = 9;
     io_surface_size_ = gfx::Size(6, 7);
 
-    scoped_refptr<IOSurfaceLayer> io_surface_layer = IOSurfaceLayer::Create();
+    scoped_refptr<IOSurfaceLayer> io_surface_layer =
+        IOSurfaceLayer::Create(layer_settings());
     io_surface_layer->SetBounds(gfx::Size(10, 10));
     io_surface_layer->SetIsDrawable(true);
     io_surface_layer->SetContentsOpaque(true);
     io_surface_layer->SetIOSurfaceProperties(io_surface_id_, io_surface_size_);
     layer_tree_host()->root_layer()->AddChild(io_surface_layer);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
@@ skipping 132 matching lines @@
   RunTest(true, true, true);
 }
 
 TEST_F(LayerTreeHostTestNumFramesPending, DISABLED_GLRenderer) {
   RunTest(true, false, true);
 }
 
 class LayerTreeHostTestResourcelessSoftwareDraw : public LayerTreeHostTest {
  public:
   void SetupTree() override {
-    root_layer_ = FakePictureLayer::Create(&client_);
+    root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(50, 50));
 
-    parent_layer_ = FakePictureLayer::Create(&client_);
+    parent_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     parent_layer_->SetIsDrawable(true);
     parent_layer_->SetBounds(gfx::Size(50, 50));
     parent_layer_->SetForceRenderSurface(true);
 
-    child_layer_ = FakePictureLayer::Create(&client_);
+    child_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     child_layer_->SetIsDrawable(true);
     child_layer_->SetBounds(gfx::Size(50, 50));
 
     root_layer_->AddChild(parent_layer_);
     parent_layer_->AddChild(child_layer_);
     layer_tree_host()->SetRootLayer(root_layer_);
 
     LayerTreeHostTest::SetupTree();
   }
 
@@ skipping 196 matching lines @@
 
   PushPropertiesCountingLayerImpl(LayerTreeImpl* tree_impl, int id)
       : LayerImpl(tree_impl, id),
         push_properties_count_(0) {
     SetBounds(gfx::Size(1, 1));
   }
 };
 
 class PushPropertiesCountingLayer : public Layer {
  public:
-  static scoped_refptr<PushPropertiesCountingLayer> Create() {
-    return new PushPropertiesCountingLayer();
+  static scoped_refptr<PushPropertiesCountingLayer> Create(
+      const LayerSettings& settings) {
+    return new PushPropertiesCountingLayer(settings);
   }
 
   void PushPropertiesTo(LayerImpl* layer) override {
     Layer::PushPropertiesTo(layer);
     push_properties_count_++;
     if (persist_needs_push_properties_)
       needs_push_properties_ = true;
   }
 
   // Something to make this layer push properties, but no other layer.
   void MakePushProperties() { SetContentsOpaque(!contents_opaque()); }
 
   scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl) override {
     return PushPropertiesCountingLayerImpl::Create(tree_impl, id());
   }
 
   void SetDrawsContent(bool draws_content) { SetIsDrawable(draws_content); }
 
   size_t push_properties_count() const { return push_properties_count_; }
   void reset_push_properties_count() { push_properties_count_ = 0; }
 
   void set_persist_needs_push_properties(bool persist) {
     persist_needs_push_properties_ = persist;
   }
 
  private:
-  PushPropertiesCountingLayer()
-      : push_properties_count_(0), persist_needs_push_properties_(false) {
+  explicit PushPropertiesCountingLayer(const LayerSettings& settings)
+      : Layer(settings),
+        push_properties_count_(0),
+        persist_needs_push_properties_(false) {
     SetBounds(gfx::Size(1, 1));
   }
   ~PushPropertiesCountingLayer() override {}
 
   size_t push_properties_count_;
   bool persist_needs_push_properties_;
 };
 
 class LayerTreeHostTestLayersPushProperties : public LayerTreeHostTest {
  protected:
   void BeginTest() override {
     num_commits_ = 0;
     expected_push_properties_root_ = 0;
     expected_push_properties_child_ = 0;
     expected_push_properties_grandchild_ = 0;
     expected_push_properties_child2_ = 0;
     expected_push_properties_other_root_ = 0;
     expected_push_properties_leaf_layer_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   void SetupTree() override {
-    root_ = PushPropertiesCountingLayer::Create();
+    root_ = PushPropertiesCountingLayer::Create(layer_settings());
     root_->CreateRenderSurface();
-    child_ = PushPropertiesCountingLayer::Create();
-    child2_ = PushPropertiesCountingLayer::Create();
-    grandchild_ = PushPropertiesCountingLayer::Create();
-    leaf_always_pushing_layer_ = PushPropertiesCountingLayer::Create();
+    child_ = PushPropertiesCountingLayer::Create(layer_settings());
+    child2_ = PushPropertiesCountingLayer::Create(layer_settings());
+    grandchild_ = PushPropertiesCountingLayer::Create(layer_settings());
+    leaf_always_pushing_layer_ =
+        PushPropertiesCountingLayer::Create(layer_settings());
     leaf_always_pushing_layer_->set_persist_needs_push_properties(true);
 
     root_->AddChild(child_);
     root_->AddChild(child2_);
     child_->AddChild(grandchild_);
     child2_->AddChild(leaf_always_pushing_layer_);
 
-    other_root_ = PushPropertiesCountingLayer::Create();
+    other_root_ = PushPropertiesCountingLayer::Create(layer_settings());
     other_root_->CreateRenderSurface();
 
     // Don't set the root layer here.
     LayerTreeHostTest::SetupTree();
   }
 
   void DidCommitAndDrawFrame() override {
     EXPECT_EQ(expected_push_properties_root_, root_->push_properties_count())
         << "num_commits: " << num_commits_;
     EXPECT_EQ(expected_push_properties_child_, child_->push_properties_count())
@@ skipping 358 matching lines @@
 TEST_F(LayerTreeHostTestImplLayersPushProperties, DelegatingRenderer) {
   RunTestWithImplSidePainting();
 }
 
 class LayerTreeHostTestPropertyChangesDuringUpdateArePushed
     : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void SetupTree() override {
-    root_ = Layer::Create();
+    root_ = Layer::Create(layer_settings());
     root_->CreateRenderSurface();
     root_->SetBounds(gfx::Size(1, 1));
 
     bool paint_scrollbar = true;
     bool has_thumb = false;
     scrollbar_layer_ = FakePaintedScrollbarLayer::Create(
-        paint_scrollbar, has_thumb, root_->id());
+        layer_settings(), paint_scrollbar, has_thumb, root_->id());
 
     root_->AddChild(scrollbar_layer_);
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
   void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
@@ skipping 29 matching lines @@
   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestPropertyChangesDuringUpdateArePushed);
 
 class LayerTreeHostTestSetDrawableCausesCommit : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void SetupTree() override {
-    root_ = PushPropertiesCountingLayer::Create();
+    root_ = PushPropertiesCountingLayer::Create(layer_settings());
     root_->CreateRenderSurface();
-    child_ = PushPropertiesCountingLayer::Create();
+    child_ = PushPropertiesCountingLayer::Create(layer_settings());
     root_->AddChild(child_);
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
   void DidCommitAndDrawFrame() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         break;
@@ skipping 39 matching lines @@
   void BeginTest() override {
     expected_push_properties_root_ = 0;
     expected_push_properties_child_ = 0;
     expected_push_properties_grandchild1_ = 0;
     expected_push_properties_grandchild2_ = 0;
     expected_push_properties_grandchild3_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   void SetupTree() override {
-    root_ = PushPropertiesCountingLayer::Create();
+    root_ = PushPropertiesCountingLayer::Create(layer_settings());
     root_->CreateRenderSurface();
-    child_ = PushPropertiesCountingLayer::Create();
-    grandchild1_ = PushPropertiesCountingLayer::Create();
-    grandchild2_ = PushPropertiesCountingLayer::Create();
-    grandchild3_ = PushPropertiesCountingLayer::Create();
+    child_ = PushPropertiesCountingLayer::Create(layer_settings());
+    grandchild1_ = PushPropertiesCountingLayer::Create(layer_settings());
+    grandchild2_ = PushPropertiesCountingLayer::Create(layer_settings());
+    grandchild3_ = PushPropertiesCountingLayer::Create(layer_settings());
 
     root_->AddChild(child_);
     child_->AddChild(grandchild1_);
     child_->AddChild(grandchild2_);
     child_->AddChild(grandchild3_);
 
     // Don't set the root layer here.
     LayerTreeHostTest::SetupTree();
   }
 
@@ skipping 487 matching lines @@
   int num_draws_;
 };
 
 // VideoLayer must support being invalidated and then passing that along
 // to the compositor thread, even though no resources are updated in
 // response to that invalidation.
 class LayerTreeHostTestVideoLayerInvalidate : public LayerInvalidateCausesDraw {
  public:
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
-    scoped_refptr<VideoLayer> video_layer =
-        VideoLayer::Create(&provider_, media::VIDEO_ROTATION_0);
+    scoped_refptr<VideoLayer> video_layer = VideoLayer::Create(
+        layer_settings(), &provider_, media::VIDEO_ROTATION_0);
     video_layer->SetBounds(gfx::Size(10, 10));
     video_layer->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(video_layer);
 
     invalidate_layer_ = video_layer;
   }
 
  private:
   FakeVideoFrameProvider provider_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestVideoLayerInvalidate);
 
 // IOSurfaceLayer must support being invalidated and then passing that along
 // to the compositor thread, even though no resources are updated in
 // response to that invalidation.
 class LayerTreeHostTestIOSurfaceLayerInvalidate
     : public LayerInvalidateCausesDraw {
  public:
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
-    scoped_refptr<IOSurfaceLayer> layer = IOSurfaceLayer::Create();
+    scoped_refptr<IOSurfaceLayer> layer =
+        IOSurfaceLayer::Create(layer_settings());
     layer->SetBounds(gfx::Size(10, 10));
     uint32_t fake_io_surface_id = 7;
     layer->SetIOSurfaceProperties(fake_io_surface_id, layer->bounds());
     layer->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(layer);
 
     invalidate_layer_ = layer;
   }
 };
 
 // TODO(danakj): IOSurface layer can not be transported. crbug.com/239335
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostTestIOSurfaceLayerInvalidate);
 
 class LayerTreeHostTestPushHiddenLayer : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
-    root_layer_ = Layer::Create();
+    root_layer_ = Layer::Create(layer_settings());
     root_layer_->CreateRenderSurface();
     root_layer_->SetPosition(gfx::Point());
     root_layer_->SetBounds(gfx::Size(10, 10));
 
-    parent_layer_ = SolidColorLayer::Create();
+    parent_layer_ = SolidColorLayer::Create(layer_settings());
     parent_layer_->SetPosition(gfx::Point());
     parent_layer_->SetBounds(gfx::Size(10, 10));
     parent_layer_->SetIsDrawable(true);
     root_layer_->AddChild(parent_layer_);
 
-    child_layer_ = SolidColorLayer::Create();
+    child_layer_ = SolidColorLayer::Create(layer_settings());
     child_layer_->SetPosition(gfx::Point());
     child_layer_->SetBounds(gfx::Size(10, 10));
     child_layer_->SetIsDrawable(true);
     parent_layer_->AddChild(child_layer_);
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
@@ skipping 39 matching lines @@
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPushHiddenLayer);
 
 class LayerTreeHostTestUpdateLayerInEmptyViewport : public LayerTreeHostTest {
  protected:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
   }
 
   void SetupTree() override {
-    root_layer_ = FakePictureLayer::Create(&client_);
+    root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     root_layer_->SetBounds(gfx::Size(10, 10));
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override {
     // The viewport is empty, but we still need to update layers on the main
     // thread.
     layer_tree_host()->SetViewportSize(gfx::Size(0, 0));
@@ skipping 15 matching lines @@
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestUpdateLayerInEmptyViewport);
 
 class LayerTreeHostTestAbortEvictedTextures : public LayerTreeHostTest {
  public:
   LayerTreeHostTestAbortEvictedTextures()
       : num_will_begin_main_frames_(0), num_impl_commits_(0) {}
 
  protected:
   void SetupTree() override {
-    scoped_refptr<SolidColorLayer> root_layer = SolidColorLayer::Create();
+    scoped_refptr<SolidColorLayer> root_layer =
+        SolidColorLayer::Create(layer_settings());
     root_layer->SetBounds(gfx::Size(200, 200));
     root_layer->SetIsDrawable(true);
     root_layer->CreateRenderSurface();
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ skipping 55 matching lines @@
     context_provider->SetMaxTransferBufferUsageBytes(512 * 512);
     if (delegating_renderer())
       return FakeOutputSurface::CreateDelegating3d(context_provider);
     else
       return FakeOutputSurface::Create3d(context_provider);
   }
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     root_layer->SetBounds(gfx::Size(1024, 1024));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
@@ skipping 134 matching lines @@
         make_scoped_ptr(new ManagedMemoryPolicy(
             second_context_provider_.get() ? second_output_surface_memory_limit_
                                            : first_output_surface_memory_limit_,
             gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE,
             ManagedMemoryPolicy::kDefaultNumResourcesLimit)));
     return output_surface.Pass();
   }
 
   void SetupTree() override {
     if (layer_tree_host()->settings().impl_side_painting)
-      root_ = FakePictureLayer::Create(&client_);
+      root_ = FakePictureLayer::Create(layer_settings(), &client_);
     else
-      root_ = FakeContentLayer::Create(&client_);
+      root_ = FakeContentLayer::Create(layer_settings(), &client_);
     root_->SetBounds(gfx::Size(20, 20));
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommitAndDrawFrame() override {
     // Lost context sometimes takes two frames to recreate. The third frame
     // is sometimes aborted, so wait until the fourth frame to verify that
@@ skipping 181 matching lines @@
   TestSwapPromiseResult swap_promise_result_[3];
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestBreakSwapPromise);
 
 class LayerTreeHostTestKeepSwapPromise : public LayerTreeTest {
  public:
   LayerTreeHostTestKeepSwapPromise() {}
 
   void BeginTest() override {
-    layer_ = SolidColorLayer::Create();
+    layer_ = SolidColorLayer::Create(layer_settings());
     layer_->SetIsDrawable(true);
     layer_->SetBounds(gfx::Size(10, 10));
     layer_tree_host()->SetRootLayer(layer_);
     gfx::Size bounds(100, 100);
     layer_tree_host()->SetViewportSize(bounds);
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
     MainThreadTaskRunner()->PostTask(
@@ skipping 298 matching lines @@
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
 
     EXPECT_FALSE(settings->gpu_rasterization_enabled);
     EXPECT_FALSE(settings->gpu_rasterization_forced);
   }
 
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
-    scoped_refptr<PictureLayer> layer = PictureLayer::Create(&layer_client_);
+    scoped_refptr<PictureLayer> layer =
+        PictureLayer::Create(layer_settings(), &layer_client_);
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(layer);
   }
 
   void BeginTest() override {
     Layer* root = layer_tree_host()->root_layer();
     PictureLayer* layer = static_cast<PictureLayer*>(root->child_at(0));
     RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
 
@@ skipping 33 matching lines @@
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
 
     EXPECT_FALSE(settings->gpu_rasterization_enabled);
     settings->gpu_rasterization_enabled = true;
   }
 
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
-    scoped_refptr<PictureLayer> layer = PictureLayer::Create(&layer_client_);
+    scoped_refptr<PictureLayer> layer =
+        PictureLayer::Create(layer_settings(), &layer_client_);
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(layer);
   }
 
   void BeginTest() override {
     Layer* root = layer_tree_host()->root_layer();
     PictureLayer* layer = static_cast<PictureLayer*>(root->child_at(0));
     RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
 
@@ skipping 43 matching lines @@
     ASSERT_TRUE(settings->impl_side_painting);
 
     EXPECT_FALSE(settings->gpu_rasterization_forced);
     settings->gpu_rasterization_forced = true;
   }
 
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     scoped_refptr<FakePictureLayer> layer =
-        FakePictureLayer::Create(&layer_client_);
+        FakePictureLayer::Create(layer_settings(), &layer_client_);
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(layer);
   }
 
   void BeginTest() override {
     Layer* root = layer_tree_host()->root_layer();
     PictureLayer* layer = static_cast<PictureLayer*>(root->child_at(0));
     RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
 
@@ skipping 39 matching lines @@
 
 class LayerTreeHostTestContinuousPainting : public LayerTreeHostTest {
  public:
   LayerTreeHostTestContinuousPainting()
       : num_commits_(0), num_draws_(0), bounds_(20, 20), child_layer_(NULL) {}
 
  protected:
   enum { kExpectedNumCommits = 10 };
 
   void SetupTree() override {
-    scoped_refptr<Layer> root_layer = Layer::Create();
+    scoped_refptr<Layer> root_layer = Layer::Create(layer_settings());
     root_layer->SetBounds(bounds_);
     root_layer->CreateRenderSurface();
 
     if (layer_tree_host()->settings().impl_side_painting) {
-      picture_layer_ = FakePictureLayer::Create(&client_);
+      picture_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
       child_layer_ = picture_layer_.get();
     } else {
-      content_layer_ = ContentLayerWithUpdateTracking::Create(&client_);
+      content_layer_ =
+          ContentLayerWithUpdateTracking::Create(layer_settings(), &client_);
       child_layer_ = content_layer_.get();
     }
     child_layer_->SetBounds(bounds_);
     child_layer_->SetIsDrawable(true);
     root_layer->AddChild(child_layer_);
 
     layer_tree_host()->SetRootLayer(root_layer);
     layer_tree_host()->SetViewportSize(bounds_);
     LayerTreeHostTest::SetupTree();
   }
@@ skipping 379 matching lines @@
 class LayerTreeHostTestCrispUpAfterPinchEnds : public LayerTreeHostTest {
  protected:
   LayerTreeHostTestCrispUpAfterPinchEnds()
       : playback_allowed_event_(true, true) {}
 
   void SetupTree() override {
     frame_ = 1;
     posted_ = false;
     client_.set_fill_with_nonsolid_color(true);
 
-    scoped_refptr<Layer> root = Layer::Create();
+    scoped_refptr<Layer> root = Layer::Create(layer_settings());
     root->SetBounds(gfx::Size(500, 500));
 
-    scoped_refptr<Layer> pinch = Layer::Create();
+    scoped_refptr<Layer> pinch = Layer::Create(layer_settings());
     pinch->SetBounds(gfx::Size(500, 500));
     pinch->SetScrollClipLayerId(root->id());
     pinch->SetIsContainerForFixedPositionLayers(true);
     root->AddChild(pinch);
 
     scoped_ptr<FakePicturePile> pile(
         new FakePicturePile(ImplSidePaintingSettings().minimum_contents_scale,
                             ImplSidePaintingSettings().default_tile_grid_size));
     pile->SetPlaybackAllowedEvent(&playback_allowed_event_);
     scoped_refptr<FakePictureLayer> layer =
-        FakePictureLayer::CreateWithRecordingSource(&client_, pile.Pass());
+        FakePictureLayer::CreateWithRecordingSource(layer_settings(), &client_,
+                                                    pile.Pass());
     layer->SetBounds(gfx::Size(500, 500));
     layer->SetContentsOpaque(true);
     // Avoid LCD text on the layer so we don't cause extra commits when we
     // pinch.
     layer->disable_lcd_text();
     pinch->AddChild(layer);
 
     layer_tree_host()->RegisterViewportLayers(NULL, root, pinch, pinch);
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
     layer_tree_host()->SetRootLayer(root);
@@ skipping 176 matching lines @@
   RasterizeWithGpuRasterizationCreatesResources() {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
     settings->gpu_rasterization_forced = true;
   }
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
 
-    scoped_refptr<Layer> root = Layer::Create();
+    scoped_refptr<Layer> root = Layer::Create(layer_settings());
     root->SetBounds(gfx::Size(500, 500));
 
     scoped_ptr<FakePicturePile> pile(
         new FakePicturePile(ImplSidePaintingSettings().minimum_contents_scale,
                             ImplSidePaintingSettings().default_tile_grid_size));
     scoped_refptr<FakePictureLayer> layer =
-        FakePictureLayer::CreateWithRecordingSource(&client_, pile.Pass());
+        FakePictureLayer::CreateWithRecordingSource(layer_settings(), &client_,
+                                                    pile.Pass());
     layer->SetBounds(gfx::Size(500, 500));
     layer->SetContentsOpaque(true);
     root->AddChild(layer);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ skipping 21 matching lines @@
     settings->gpu_rasterization_forced = true;
   }
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
 
     scoped_ptr<FakePicturePile> pile(
         new FakePicturePile(ImplSidePaintingSettings().minimum_contents_scale,
                             ImplSidePaintingSettings().default_tile_grid_size));
     scoped_refptr<FakePictureLayer> root =
-        FakePictureLayer::CreateWithRecordingSource(&client_, pile.Pass());
+        FakePictureLayer::CreateWithRecordingSource(layer_settings(), &client_,
+                                                    pile.Pass());
     root->SetBounds(gfx::Size(10000, 10000));
     root->SetContentsOpaque(true);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
     layer_tree_host()->SetViewportSize(viewport_size_);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ skipping 22 matching lines @@
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
   }
 
   void SetupTree() override {
     step_ = 1;
     continuous_draws_ = 0;
     client_.set_fill_with_nonsolid_color(true);
 
-    scoped_refptr<Layer> root = Layer::Create();
+    scoped_refptr<Layer> root = Layer::Create(layer_settings());
     root->SetBounds(gfx::Size(500, 500));
 
-    scoped_refptr<Layer> pinch = Layer::Create();
+    scoped_refptr<Layer> pinch = Layer::Create(layer_settings());
     pinch->SetBounds(gfx::Size(500, 500));
     pinch->SetScrollClipLayerId(root->id());
     pinch->SetIsContainerForFixedPositionLayers(true);
     root->AddChild(pinch);
 
     scoped_ptr<FakePicturePile> pile(
         new FakePicturePile(ImplSidePaintingSettings().minimum_contents_scale,
                             ImplSidePaintingSettings().default_tile_grid_size));
     pile->SetPlaybackAllowedEvent(&playback_allowed_event_);
     scoped_refptr<FakePictureLayer> layer =
-        FakePictureLayer::CreateWithRecordingSource(&client_, pile.Pass());
+        FakePictureLayer::CreateWithRecordingSource(layer_settings(), &client_,
+                                                    pile.Pass());
     layer->SetBounds(gfx::Size(500, 500));
     layer->SetContentsOpaque(true);
     // Avoid LCD text on the layer so we don't cause extra commits when we
     // pinch.
     layer->disable_lcd_text();
     pinch->AddChild(layer);
 
     layer_tree_host()->RegisterViewportLayers(NULL, root, pinch, pinch);
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
     layer_tree_host()->SetRootLayer(root);
@@ skipping 138 matching lines @@
 
 class LayerTreeHostTestOneActivatePerPrepareTiles : public LayerTreeHostTest {
  public:
   LayerTreeHostTestOneActivatePerPrepareTiles()
       : notify_ready_to_activate_count_(0u),
         scheduled_prepare_tiles_count_(0) {}
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     root_layer->SetBounds(gfx::Size(1500, 1500));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(16, 16));
     PostSetNeedsCommitToMainThread();
@@ skipping 34 matching lines @@
 MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestOneActivatePerPrepareTiles);
 
 class LayerTreeHostTestFrameTimingRequestsSaveTimestamps
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestFrameTimingRequestsSaveTimestamps()
       : check_results_on_commit_(false) {}
 
   void SetupTree() override {
     scoped_refptr<FakePictureLayer> root_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     root_layer->SetBounds(gfx::Size(200, 200));
     root_layer->SetIsDrawable(true);
 
     scoped_refptr<FakePictureLayer> child_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     child_layer->SetBounds(gfx::Size(1500, 1500));
     child_layer->SetIsDrawable(true);
 
     std::vector<FrameTimingRequest> requests;
     requests.push_back(FrameTimingRequest(1, gfx::Rect(0, 0, 100, 100)));
     requests.push_back(FrameTimingRequest(2, gfx::Rect(300, 0, 100, 100)));
     child_layer->SetFrameTimingRequests(requests);
 
     root_layer->AddChild(child_layer);
     layer_tree_host()->SetRootLayer(root_layer);
@@ skipping 60 matching lines @@
 MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestFrameTimingRequestsSaveTimestamps);
 
 class LayerTreeHostTestActivationCausesPrepareTiles : public LayerTreeHostTest {
  public:
   LayerTreeHostTestActivationCausesPrepareTiles()
       : scheduled_prepare_tiles_count_(0) {}
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     root_layer->SetBounds(gfx::Size(150, 150));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void NotifyReadyToActivateOnThread(LayerTreeHostImpl* impl) override {
@@ skipping 59 matching lines @@
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNoTasksBetweenWillAndDidCommit);
 
 // Verify that if a LayerImpl holds onto a copy request for multiple
 // frames that it will continue to have a render surface through
 // multiple commits, even though the Layer itself has no reason
 // to have a render surface.
 class LayerPreserveRenderSurfaceFromOutputRequests : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
-    scoped_refptr<Layer> root = Layer::Create();
+    scoped_refptr<Layer> root = Layer::Create(layer_settings());
     root->CreateRenderSurface();
     root->SetBounds(gfx::Size(10, 10));
-    child_ = Layer::Create();
+    child_ = Layer::Create(layer_settings());
     child_->SetBounds(gfx::Size(20, 20));
     root->AddChild(child_);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   static void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {}
 
   void BeginTest() override {
@@ skipping 51 matching lines @@
 
  private:
   scoped_refptr<Layer> child_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerPreserveRenderSurfaceFromOutputRequests);
 
 class LayerTreeHostTestUpdateCopyRequests : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
-    root = Layer::Create();
-    child = Layer::Create();
+    root = Layer::Create(layer_settings());
+    child = Layer::Create(layer_settings());
     root->AddChild(child);
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   static void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
@@ skipping 21 matching lines @@
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestUpdateCopyRequests);
 
 class LayerTreeTestMaskLayerForSurfaceWithClippedLayer : public LayerTreeTest {
  protected:
   void SetupTree() override {
     // The masked layer has bounds 50x50, but it has a child that causes
     // the surface bounds to be larger. It also has a parent that clips the
     // masked layer and its surface.
 
-    scoped_refptr<Layer> root = Layer::Create();
+    scoped_refptr<Layer> root = Layer::Create(layer_settings());
 
-    scoped_refptr<Layer> clipping_layer = Layer::Create();
+    scoped_refptr<Layer> clipping_layer = Layer::Create(layer_settings());
     root->AddChild(clipping_layer);
 
     scoped_refptr<FakePictureLayer> content_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     clipping_layer->AddChild(content_layer);
 
     scoped_refptr<FakePictureLayer> content_child_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     content_layer->AddChild(content_child_layer);
 
     scoped_refptr<FakePictureLayer> mask_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     content_layer->SetMaskLayer(mask_layer.get());
 
     gfx::Size root_size(100, 100);
     root->SetBounds(root_size);
 
     gfx::Rect clipping_rect(20, 10, 10, 20);
     clipping_layer->SetBounds(clipping_rect.size());
     clipping_layer->SetPosition(clipping_rect.origin());
     clipping_layer->SetMasksToBounds(true);
 
@@ skipping 59 matching lines @@
   }
 
   void SetupTree() override {
     // Root
     //  |
     //  +-- Scaling Layer (adds a 2x scale)
     //       |
     //       +-- Content Layer
     //             +--Mask
 
-    scoped_refptr<Layer> root = Layer::Create();
+    scoped_refptr<Layer> root = Layer::Create(layer_settings());
 
-    scoped_refptr<Layer> scaling_layer = Layer::Create();
+    scoped_refptr<Layer> scaling_layer = Layer::Create(layer_settings());
     root->AddChild(scaling_layer);
 
     scoped_refptr<FakePictureLayer> content_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     scaling_layer->AddChild(content_layer);
 
     scoped_refptr<FakePictureLayer> mask_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     content_layer->SetMaskLayer(mask_layer.get());
 
     gfx::Size root_size(100, 100);
     root->SetBounds(root_size);
 
     gfx::Size scaling_layer_size(50, 50);
     scaling_layer->SetBounds(scaling_layer_size);
     gfx::Transform scale;
     scale.Scale(2.f, 2.f);
     scaling_layer->SetTransform(scale);
@@ skipping 64 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeTestMaskLayerWithScaling);
 
 class LayerTreeTestMaskLayerWithDifferentBounds : public LayerTreeTest {
  protected:
   void SetupTree() override {
     // The mask layer has bounds 100x100 but is attached to a layer with bounds
     // 50x50.
 
-    scoped_refptr<Layer> root = Layer::Create();
+    scoped_refptr<Layer> root = Layer::Create(layer_settings());
 
     scoped_refptr<FakePictureLayer> content_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     root->AddChild(content_layer);
 
     scoped_refptr<FakePictureLayer> mask_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     content_layer->SetMaskLayer(mask_layer.get());
 
     gfx::Size root_size(100, 100);
     root->SetBounds(root_size);
 
     gfx::Size layer_size(50, 50);
     content_layer->SetBounds(layer_size);
 
     gfx::Size mask_size(100, 100);
     mask_layer->SetBounds(mask_size);
@@ skipping 60 matching lines @@
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeTestMaskLayerWithDifferentBounds);
 
 class LayerTreeTestReflectionMaskLayerWithDifferentBounds
     : public LayerTreeTest {
  protected:
   void SetupTree() override {
     // The replica's mask layer has bounds 100x100 but the replica is of a
     // layer with bounds 50x50.
 
-    scoped_refptr<Layer> root = Layer::Create();
+    scoped_refptr<Layer> root = Layer::Create(layer_settings());
 
     scoped_refptr<FakePictureLayer> content_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     root->AddChild(content_layer);
 
-    scoped_refptr<Layer> replica_layer = Layer::Create();
+    scoped_refptr<Layer> replica_layer = Layer::Create(layer_settings());
     content_layer->SetReplicaLayer(replica_layer.get());
 
     scoped_refptr<FakePictureLayer> mask_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     replica_layer->SetMaskLayer(mask_layer.get());
 
     gfx::Size root_size(100, 100);
     root->SetBounds(root_size);
 
     gfx::Size layer_size(50, 50);
     content_layer->SetBounds(layer_size);
 
     gfx::Size mask_size(100, 100);
     mask_layer->SetBounds(mask_size);
@@ skipping 62 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeTestReflectionMaskLayerWithDifferentBounds);
 
 class LayerTreeTestReflectionMaskLayerForSurfaceWithUnclippedChild
     : public LayerTreeTest {
  protected:
   void SetupTree() override {
     // The replica is of a layer with bounds 50x50, but it has a child that
     // causes the surface bounds to be larger.
 
-    scoped_refptr<Layer> root = Layer::Create();
+    scoped_refptr<Layer> root = Layer::Create(layer_settings());
 
     scoped_refptr<FakePictureLayer> content_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     root->AddChild(content_layer);
 
-    content_child_layer_ = FakePictureLayer::Create(&client_);
+    content_child_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     content_layer->AddChild(content_child_layer_);
 
-    scoped_refptr<Layer> replica_layer = Layer::Create();
+    scoped_refptr<Layer> replica_layer = Layer::Create(layer_settings());
     content_layer->SetReplicaLayer(replica_layer.get());
 
     scoped_refptr<FakePictureLayer> mask_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::Create(layer_settings(), &client_);
     replica_layer->SetMaskLayer(mask_layer.get());
 
     gfx::Size root_size(100, 100);
     root->SetBounds(root_size);
 
     gfx::Size layer_size(50, 50);
     content_layer->SetBounds(layer_size);
     content_child_layer_->SetBounds(layer_size);
     content_child_layer_->SetPosition(gfx::PointF(50.f, 0.f));
 
@@ skipping 60 matching lines @@
   void AfterTest() override {}
 
   scoped_refptr<FakePictureLayer> content_child_layer_;
   FakeContentLayerClient client_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeTestReflectionMaskLayerForSurfaceWithUnclippedChild);
 
 }  // namespace cc