CC Animation: Erase cc::LayerSettings everywhere.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 242 matching lines @@
 SINGLE_AND_MULTI_THREAD_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(layer_settings(), &client_);
+        FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(1024, 1024));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer->bounds());
   }
 
   void AfterTest() override {
     EXPECT_TRUE(did_notify_ready_to_activate_);
@@ skipping 50 matching lines @@
 SINGLE_AND_MULTI_THREAD_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(layer_settings(), &client_);
+        FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(1024, 1024));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer->bounds());
   }
 
   void AfterTest() override {
     EXPECT_TRUE(did_notify_ready_to_draw_);
@@ skipping 17 matching lines @@
       : LayerTreeHostTest(),
         toggled_visibility_(false),
         did_notify_ready_to_draw_(false),
         did_draw_(false) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+        FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(1024, 1024));
     client_.set_bounds(root_layer->bounds());
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (!toggled_visibility_) {
@@ skipping 208 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(layer_settings());
+    scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   enum Properties {
     STARTUP,
     BOUNDS,
     HIDE_LAYER_AND_SUBTREE,
     DRAWS_CONTENT,
@@ skipping 72 matching lines @@
 
   int index_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPushPropertiesTo);
 
 // Verify damage status of property trees is preserved after commit.
 class LayerTreeHostTestPropertyTreesChangedSync : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
-    scoped_refptr<Layer> root = Layer::Create(layer_settings());
+    scoped_refptr<Layer> root = Layer::Create();
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   enum Animations {
     OPACITY,
     TRANSFORM,
     FILTER,
     END,
   };
@@ skipping 87 matching lines @@
 MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsRedraw);
 
 // 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 {
-    root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    root_layer_ = FakePictureLayer::Create(&client_);
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
     PostSetNeedsCommitToMainThread();
     client_.set_bounds(root_layer_->bounds());
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
@@ skipping 38 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(layer_settings(), &client_);
+    root_layer_ = FakePictureLayer::Create(&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_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(layer_settings());
+    root_layer_ = Layer::Create();
     root_layer_->SetBounds(gfx::Size(10, 20));
 
-    scaled_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    scaled_layer_ = FakePictureLayer::Create(&client_);
     scaled_layer_->SetBounds(gfx::Size(1, 1));
     root_layer_->AddChild(scaled_layer_);
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ skipping 27 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(layer_settings());
+    root_layer_ = Layer::Create();
     root_layer_->SetBounds(gfx::Size(10, 20));
 
     bool paint_scrollbar = true;
     bool has_thumb = false;
-    scrollbar_ = FakePaintedScrollbarLayer::Create(
-        layer_settings(), paint_scrollbar, has_thumb, root_layer_->id());
+    scrollbar_ = FakePaintedScrollbarLayer::Create(paint_scrollbar, has_thumb,
+                                                   root_layer_->id());
     scrollbar_->SetPosition(gfx::PointF(0.f, 10.f));
     scrollbar_->SetBounds(gfx::Size(10, 10));
 
     root_layer_->AddChild(scrollbar_);
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer_->bounds());
   }
 
@@ skipping 31 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestNoExtraCommitFromScrollbarInvalidate);
 
 class LayerTreeHostTestDeviceScaleFactorChange : public LayerTreeHostTest {
  public:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->layer_transforms_should_scale_layer_contents = true;
   }
 
   void SetupTree() override {
-    root_layer_ = Layer::Create(layer_settings());
+    root_layer_ = Layer::Create();
     root_layer_->SetBounds(gfx::Size(10, 20));
 
-    child_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    child_layer_ = FakePictureLayer::Create(&client_);
     child_layer_->SetBounds(gfx::Size(10, 10));
     root_layer_->AddChild(child_layer_);
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ skipping 39 matching lines @@
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestDeviceScaleFactorChange);
 
 class LayerTreeHostTestSetNextCommitForcesRedraw : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNextCommitForcesRedraw()
       : num_draws_(0), bounds_(50, 50), invalid_rect_(10, 10, 20, 20) {}
 
   void BeginTest() override {
-    root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    root_layer_ = FakePictureLayer::Create(&client_);
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
     PostSetNeedsCommitToMainThread();
     client_.set_bounds(root_layer_->bounds());
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (num_draws_ == 3)
@@ skipping 72 matching lines @@
 class LayerTreeHostTestUndrawnLayersDamageLater : public LayerTreeHostTest {
  public:
   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 {
-    root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    root_layer_ = FakePictureLayer::Create(&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.
-    parent_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    parent_layer_ = FakePictureLayer::Create(&client_);
     parent_layer_->SetBounds(gfx::Size(15, 15));
     parent_layer_->SetOpacity(0.0f);
     root_layer_->AddChild(parent_layer_);
 
-    child_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    child_layer_ = FakePictureLayer::Create(&client_);
     child_layer_->SetBounds(gfx::Size(25, 25));
     parent_layer_->AddChild(child_layer_);
     client_.set_bounds(root_layer_->bounds());
 
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
@@ skipping 64 matching lines @@
 class LayerTreeHostTestDamageWithScale : public LayerTreeHostTest {
  public:
   LayerTreeHostTestDamageWithScale() {}
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
 
     scoped_ptr<FakeDisplayListRecordingSource> recording(
         new FakeDisplayListRecordingSource);
     root_layer_ = FakePictureLayer::CreateWithRecordingSource(
-        layer_settings(), &client_, std::move(recording));
+        &client_, std::move(recording));
     root_layer_->SetBounds(gfx::Size(50, 50));
 
     recording.reset(new FakeDisplayListRecordingSource);
     child_layer_ = FakePictureLayer::CreateWithRecordingSource(
-        layer_settings(), &client_, std::move(recording));
+        &client_, std::move(recording));
     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();
     client_.set_bounds(root_layer_->bounds());
   }
 
@@ skipping 222 matching lines @@
 // from LayerTreeHost to LayerTreeHostImpl in the MT compositor.
 class LayerTreeHostTestStartPageScaleAnimation : public LayerTreeHostTest {
  public:
   LayerTreeHostTestStartPageScaleAnimation() {}
 
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     Layer* root_layer = layer_tree_host()->root_layer();
 
-    scoped_refptr<FakePictureLayer> layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+    scoped_refptr<FakePictureLayer> layer = FakePictureLayer::Create(&client_);
     layer->set_always_update_resources(true);
     scroll_layer_ = layer;
 
     scroll_layer_->SetBounds(gfx::Size(2 * root_layer->bounds().width(),
                                        2 * root_layer->bounds().height()));
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset());
 
-    CreateVirtualViewportLayers(root_layer,
-                                scroll_layer_,
-                                root_layer->bounds(),
-                                root_layer->bounds(),
-                                layer_tree_host(),
-                                layer_settings());
+    CreateVirtualViewportLayers(root_layer, scroll_layer_, root_layer->bounds(),
+                                root_layer->bounds(), layer_tree_host());
 
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.5f, 2.f);
     client_.set_bounds(root_layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void ApplyViewportDeltas(const gfx::Vector2dF& scroll_delta,
                            const gfx::Vector2dF&,
                            const gfx::Vector2dF& elastic_overscroll_delta,
@@ skipping 99 matching lines @@
 
 // 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 SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
-    update_check_picture_layer_ = FakePictureLayer::Create(
-        layer_settings(), &test_opacity_change_delegate_);
+    update_check_picture_layer_ =
+        FakePictureLayer::Create(&test_opacity_change_delegate_);
     test_opacity_change_delegate_.SetTestLayer(
         update_check_picture_layer_.get());
     layer_tree_host()->root_layer()->AddChild(update_check_picture_layer_);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override { EndTest(); }
 
   void AfterTest() override {
     // Update() should have been called once.
     EXPECT_EQ(1, update_check_picture_layer_->update_count());
   }
 
  private:
   TestOpacityChangeLayerDelegate test_opacity_change_delegate_;
   scoped_refptr<FakePictureLayer> update_check_picture_layer_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestOpacityChange);
 
 class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers() {}
 
   void BeginTest() override {
     client_.set_fill_with_nonsolid_color(true);
-    root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
-    child_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    root_layer_ = FakePictureLayer::Create(&client_);
+    child_layer_ = FakePictureLayer::Create(&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 85 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));
 
-    layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    layer_ = FakePictureLayer::Create(&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();
     client_.set_bounds(layer_->bounds());
   }
 
   void DidCommitAndDrawFrame() override {
@@ skipping 154 matching lines @@
   BeginFrameArgs current_begin_frame_args_;
 };
 
 SINGLE_THREAD_TEST_F(LayerTreeHostTestCompositeImmediatelyStateTransitions);
 
 class LayerTreeHostTestLCDChange : public LayerTreeHostTest {
  public:
   void SetupTree() override {
     num_tiles_rastered_ = 0;
 
-    scoped_refptr<Layer> root_layer =
-        PictureLayer::Create(layer_settings(), &client_);
+    scoped_refptr<Layer> root_layer = PictureLayer::Create(&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 217 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestAbortedCommitDoesntStallDisabledVsync);
 
 class LayerTreeHostTestUninvertibleTransformDoesNotBlockActivation
     : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
-    scoped_refptr<Layer> layer =
-        PictureLayer::Create(layer_settings(), &client_);
+    scoped_refptr<Layer> layer = PictureLayer::Create(&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);
     client_.set_bounds(layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     EndTest();
@@ skipping 31 matching lines @@
     bool FillsBoundsCompletely() const override { return false; }
     size_t GetApproximateUnsharedMemoryUsage() const override { return 0; }
 
    private:
     Layer* layer_;
   };
 
   LayerTreeHostTestChangeLayerPropertiesInPaintContents() : num_commits_(0) {}
 
   void SetupTree() override {
-    scoped_refptr<PictureLayer> root_layer =
-        PictureLayer::Create(layer_settings(), &client_);
+    scoped_refptr<PictureLayer> root_layer = PictureLayer::Create(&client_);
     root_layer->SetIsDrawable(true);
     root_layer->SetBounds(gfx::Size(1, 1));
     client_.set_layer(root_layer.get());
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
   void AfterTest() override {}
@@ skipping 61 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(layer_settings());
+    scoped_refptr<IOSurfaceLayer> io_surface_layer = IOSurfaceLayer::Create();
     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 125 matching lines @@
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNumFramesPending);
 
 class LayerTreeHostTestResourcelessSoftwareDraw : public LayerTreeHostTest {
  public:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->using_synchronous_renderer_compositor = true;
   }
 
   void SetupTree() override {
-    root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    root_layer_ = FakePictureLayer::Create(&client_);
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(50, 50));
 
-    parent_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    parent_layer_ = FakePictureLayer::Create(&client_);
     parent_layer_->SetIsDrawable(true);
     parent_layer_->SetBounds(gfx::Size(50, 50));
     parent_layer_->SetForceRenderSurface(true);
 
-    child_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    child_layer_ = FakePictureLayer::Create(&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();
     client_.set_bounds(root_layer_->bounds());
   }
@@ skipping 198 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(
-      const LayerSettings& settings) {
-    return new PushPropertiesCountingLayer(settings);
+  static scoped_refptr<PushPropertiesCountingLayer> Create() {
+    return new PushPropertiesCountingLayer();
   }
 
   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:
-  explicit PushPropertiesCountingLayer(const LayerSettings& settings)
-      : Layer(settings),
+  PushPropertiesCountingLayer()
+      : Layer(),
         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(layer_settings());
-    child_ = PushPropertiesCountingLayer::Create(layer_settings());
-    child2_ = PushPropertiesCountingLayer::Create(layer_settings());
-    grandchild_ = PushPropertiesCountingLayer::Create(layer_settings());
-    leaf_always_pushing_layer_ =
-        PushPropertiesCountingLayer::Create(layer_settings());
+    root_ = PushPropertiesCountingLayer::Create();
+    child_ = PushPropertiesCountingLayer::Create();
+    child2_ = PushPropertiesCountingLayer::Create();
+    grandchild_ = PushPropertiesCountingLayer::Create();
+    leaf_always_pushing_layer_ = PushPropertiesCountingLayer::Create();
     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(layer_settings());
+    other_root_ = PushPropertiesCountingLayer::Create();
 
     // Don't set the root layer here.
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   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 360 matching lines @@
 
 // In single thread there's no pending tree to push properties from.
 MULTI_THREAD_TEST_F(LayerTreeHostTestImplLayersPushProperties);
 
 class LayerTreeHostTestPropertyChangesDuringUpdateArePushed
     : public LayerTreeHostTest {
  protected:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void SetupTree() override {
-    root_ = Layer::Create(layer_settings());
+    root_ = Layer::Create();
     root_->SetBounds(gfx::Size(1, 1));
 
     bool paint_scrollbar = true;
     bool has_thumb = false;
     scrollbar_layer_ = FakePaintedScrollbarLayer::Create(
-        layer_settings(), paint_scrollbar, has_thumb, root_->id());
+        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(layer_settings());
-    child_ = PushPropertiesCountingLayer::Create(layer_settings());
+    root_ = PushPropertiesCountingLayer::Create();
+    child_ = PushPropertiesCountingLayer::Create();
     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(layer_settings());
-    child_ = PushPropertiesCountingLayer::Create(layer_settings());
-    grandchild1_ = PushPropertiesCountingLayer::Create(layer_settings());
-    grandchild2_ = PushPropertiesCountingLayer::Create(layer_settings());
-    grandchild3_ = PushPropertiesCountingLayer::Create(layer_settings());
+    root_ = PushPropertiesCountingLayer::Create();
+    child_ = PushPropertiesCountingLayer::Create();
+    grandchild1_ = PushPropertiesCountingLayer::Create();
+    grandchild2_ = PushPropertiesCountingLayer::Create();
+    grandchild3_ = PushPropertiesCountingLayer::Create();
 
     root_->AddChild(child_);
     child_->AddChild(grandchild1_);
     child_->AddChild(grandchild2_);
     child_->AddChild(grandchild3_);
 
     // Don't set the root layer here.
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
@@ skipping 476 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(
-        layer_settings(), &provider_, media::VIDEO_ROTATION_0);
+    scoped_refptr<VideoLayer> video_layer =
+        VideoLayer::Create(&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(layer_settings());
+    scoped_refptr<IOSurfaceLayer> layer = IOSurfaceLayer::Create();
     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;
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestIOSurfaceLayerInvalidate);
 
 class LayerTreeHostTestPushHiddenLayer : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
-    root_layer_ = Layer::Create(layer_settings());
+    root_layer_ = Layer::Create();
     root_layer_->SetPosition(gfx::PointF());
     root_layer_->SetBounds(gfx::Size(10, 10));
 
-    parent_layer_ = SolidColorLayer::Create(layer_settings());
+    parent_layer_ = SolidColorLayer::Create();
     parent_layer_->SetPosition(gfx::PointF());
     parent_layer_->SetBounds(gfx::Size(10, 10));
     parent_layer_->SetIsDrawable(true);
     root_layer_->AddChild(parent_layer_);
 
-    child_layer_ = SolidColorLayer::Create(layer_settings());
+    child_layer_ = SolidColorLayer::Create();
     child_layer_->SetPosition(gfx::PointF());
     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 35 matching lines @@
   scoped_refptr<Layer> root_layer_;
   scoped_refptr<SolidColorLayer> parent_layer_;
   scoped_refptr<SolidColorLayer> child_layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPushHiddenLayer);
 
 class LayerTreeHostTestUpdateLayerInEmptyViewport : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
-    root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    root_layer_ = FakePictureLayer::Create(&client_);
     root_layer_->SetBounds(gfx::Size(10, 10));
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer_->bounds());
   }
 
   void BeginTest() override {
     // The viewport is empty, but we still need to update layers on the main
     // thread.
@@ skipping 19 matching lines @@
 class LayerTreeHostTestElasticOverscroll : public LayerTreeHostTest {
  public:
   LayerTreeHostTestElasticOverscroll()
       : scroll_elasticity_helper_(nullptr), num_draws_(0) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->enable_elastic_overscroll = true;
   }
 
   void SetupTree() override {
-    root_layer_ = Layer::Create(layer_settings());
+    root_layer_ = Layer::Create();
     root_layer_->SetBounds(gfx::Size(10, 10));
 
-    scoped_refptr<Layer> inner_viewport_container_layer =
-        Layer::Create(layer_settings());
+    scoped_refptr<Layer> inner_viewport_container_layer = Layer::Create();
     inner_viewport_container_layer->SetBounds(gfx::Size(10, 10));
-    scoped_refptr<Layer> overscroll_elasticity_layer =
-        Layer::Create(layer_settings());
-    scoped_refptr<Layer> page_scale_layer = Layer::Create(layer_settings());
-    scoped_refptr<Layer> inner_viewport_scroll_layer =
-        Layer::Create(layer_settings());
+    scoped_refptr<Layer> overscroll_elasticity_layer = Layer::Create();
+    scoped_refptr<Layer> page_scale_layer = Layer::Create();
+    scoped_refptr<Layer> inner_viewport_scroll_layer = Layer::Create();
     inner_viewport_scroll_layer->SetScrollClipLayerId(
         inner_viewport_container_layer->id());
     inner_viewport_scroll_layer->SetIsContainerForFixedPositionLayers(true);
 
     root_layer_->AddChild(inner_viewport_container_layer);
     inner_viewport_container_layer->AddChild(overscroll_elasticity_layer);
     overscroll_elasticity_layer->AddChild(page_scale_layer);
     page_scale_layer->AddChild(inner_viewport_scroll_layer);
 
-    scoped_refptr<Layer> content_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+    scoped_refptr<Layer> content_layer = FakePictureLayer::Create(&client_);
     content_layer->SetBounds(gfx::Size(10, 10));
     inner_viewport_scroll_layer->AddChild(content_layer);
 
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->RegisterViewportLayers(
         overscroll_elasticity_layer, page_scale_layer,
         inner_viewport_scroll_layer, nullptr);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(content_layer->bounds());
   }
@@ skipping 80 matching lines @@
     output_surface->SetMemoryPolicyToSetAtBind(
         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;
   }
 
   void SetupTree() override {
-    root_ = FakePictureLayer::Create(layer_settings(), &client_);
+    root_ = FakePictureLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommitAndDrawFrame() override {
     // Lost context sometimes takes two frames to recreate. The third frame
@@ skipping 233 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_settings());
+    layer_ = SolidColorLayer::Create();
     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 299 matching lines @@
 
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     scoped_ptr<FakeDisplayListRecordingSource> recording_source(
         new FakeDisplayListRecordingSource);
     recording_source_ = recording_source.get();
 
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(
-            layer_settings(), &layer_client_, std::move(recording_source));
+            &layer_client_, std::move(recording_source));
     layer_ = layer.get();
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(layer);
     layer_client_.set_bounds(layer_->bounds());
   }
 
   void BeginTest() override {
     // Verify default value.
     EXPECT_FALSE(layer_tree_host()->has_gpu_rasterization_trigger());
@@ skipping 35 matching lines @@
  protected:
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     scoped_ptr<FakeDisplayListRecordingSource> recording_source(
         new FakeDisplayListRecordingSource);
     recording_source_ = recording_source.get();
 
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(
-            layer_settings(), &layer_client_, std::move(recording_source));
+            &layer_client_, std::move(recording_source));
     layer_ = layer.get();
     layer->SetBounds(gfx::Size());
     layer->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(layer);
     layer_client_.set_bounds(layer->bounds());
   }
 
   void BeginTest() override {
     // Setting gpu rasterization trigger does not enable gpu rasterization.
     layer_tree_host()->SetHasGpuRasterizationTrigger(true);
@@ skipping 37 matching lines @@
 
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     scoped_ptr<FakeDisplayListRecordingSource> recording_source(
         new FakeDisplayListRecordingSource);
     recording_source_ = recording_source.get();
 
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(
-            layer_settings(), &layer_client_, std::move(recording_source));
+            &layer_client_, std::move(recording_source));
     layer_ = layer.get();
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(layer);
     layer_client_.set_bounds(layer_->bounds());
   }
 
   void BeginTest() override {
     // Verify default value.
     EXPECT_FALSE(layer_tree_host()->has_gpu_rasterization_trigger());
@@ skipping 49 matching lines @@
 
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     scoped_ptr<FakeDisplayListRecordingSource> recording_source(
         new FakeDisplayListRecordingSource);
     recording_source_ = recording_source.get();
 
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(
-            layer_settings(), &layer_client_, std::move(recording_source));
+            &layer_client_, std::move(recording_source));
     layer_ = layer.get();
 
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(layer);
     layer_client_.set_bounds(layer_->bounds());
   }
 
   void BeginTest() override {
     // Verify default value.
@@ skipping 408 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_clip = Layer::Create(layer_settings());
+    scoped_refptr<Layer> root_clip = Layer::Create();
     root_clip->SetBounds(gfx::Size(500, 500));
-    scoped_refptr<Layer> page_scale_layer = Layer::Create(layer_settings());
+    scoped_refptr<Layer> page_scale_layer = Layer::Create();
     page_scale_layer->SetBounds(gfx::Size(500, 500));
 
-    scoped_refptr<Layer> pinch = Layer::Create(layer_settings());
+    scoped_refptr<Layer> pinch = Layer::Create();
     pinch->SetBounds(gfx::Size(500, 500));
     pinch->SetScrollClipLayerId(root_clip->id());
     pinch->SetIsContainerForFixedPositionLayers(true);
     page_scale_layer->AddChild(pinch);
     root_clip->AddChild(page_scale_layer);
 
     scoped_ptr<FakeDisplayListRecordingSource> recording(
         new FakeDisplayListRecordingSource);
     recording->SetPlaybackAllowedEvent(&playback_allowed_event_);
     scoped_refptr<FakePictureLayer> layer =
-        FakePictureLayer::CreateWithRecordingSource(layer_settings(), &client_,
+        FakePictureLayer::CreateWithRecordingSource(&client_,
                                                     std::move(recording));
     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.
     pinch->AddChild(layer);
 
     layer_tree_host()->RegisterViewportLayers(NULL, page_scale_layer, pinch,
                                               nullptr);
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
@@ skipping 177 matching lines @@
  protected:
   RasterizeWithGpuRasterizationCreatesResources() {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->gpu_rasterization_forced = true;
   }
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
 
-    scoped_refptr<Layer> root = Layer::Create(layer_settings());
+    scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(500, 500));
     client_.set_bounds(root->bounds());
 
     scoped_ptr<FakeDisplayListRecordingSource> recording(
         new FakeDisplayListRecordingSource);
     scoped_refptr<FakePictureLayer> layer =
-        FakePictureLayer::CreateWithRecordingSource(layer_settings(), &client_,
+        FakePictureLayer::CreateWithRecordingSource(&client_,
                                                     std::move(recording));
     layer->SetBounds(gfx::Size(500, 500));
     layer->SetContentsOpaque(true);
     root->AddChild(layer);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root->bounds());
   }
 
@@ skipping 21 matching lines @@
     settings->gpu_rasterization_enabled = true;
     settings->gpu_rasterization_forced = true;
   }
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
 
     scoped_ptr<FakeDisplayListRecordingSource> recording(
         new FakeDisplayListRecordingSource);
     scoped_refptr<FakePictureLayer> root =
-        FakePictureLayer::CreateWithRecordingSource(layer_settings(), &client_,
+        FakePictureLayer::CreateWithRecordingSource(&client_,
                                                     std::move(recording));
     root->SetBounds(gfx::Size(10000, 10000));
     client_.set_bounds(root->bounds());
     root->SetContentsOpaque(true);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
     layer_tree_host()->SetViewportSize(viewport_size_);
     client_.set_bounds(root->bounds());
   }
@@ skipping 21 matching lines @@
     : public LayerTreeHostTest {
  protected:
   LayerTreeHostTestContinuousDrawWhenCreatingVisibleTiles()
       : playback_allowed_event_(true, true) {}
 
   void SetupTree() override {
     step_ = 1;
     continuous_draws_ = 0;
     client_.set_fill_with_nonsolid_color(true);
 
-    scoped_refptr<Layer> root_clip = Layer::Create(layer_settings());
+    scoped_refptr<Layer> root_clip = Layer::Create();
     root_clip->SetBounds(gfx::Size(500, 500));
-    scoped_refptr<Layer> page_scale_layer = Layer::Create(layer_settings());
+    scoped_refptr<Layer> page_scale_layer = Layer::Create();
     page_scale_layer->SetBounds(gfx::Size(500, 500));
 
-    scoped_refptr<Layer> pinch = Layer::Create(layer_settings());
+    scoped_refptr<Layer> pinch = Layer::Create();
     pinch->SetBounds(gfx::Size(500, 500));
     pinch->SetScrollClipLayerId(root_clip->id());
     pinch->SetIsContainerForFixedPositionLayers(true);
     page_scale_layer->AddChild(pinch);
     root_clip->AddChild(page_scale_layer);
 
     scoped_ptr<FakeDisplayListRecordingSource> recording(
         new FakeDisplayListRecordingSource);
     recording->SetPlaybackAllowedEvent(&playback_allowed_event_);
     scoped_refptr<FakePictureLayer> layer =
-        FakePictureLayer::CreateWithRecordingSource(layer_settings(), &client_,
+        FakePictureLayer::CreateWithRecordingSource(&client_,
                                                     std::move(recording));
     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.
     pinch->AddChild(layer);
 
     layer_tree_host()->RegisterViewportLayers(NULL, page_scale_layer, pinch,
                                               nullptr);
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
@@ skipping 140 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(layer_settings(), &client_);
+        FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(1500, 1500));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer->bounds());
   }
 
   void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(16, 16));
@@ skipping 35 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestOneActivatePerPrepareTiles);
 
 class LayerTreeHostTestFrameTimingRequestsSaveTimestamps
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestFrameTimingRequestsSaveTimestamps()
       : check_results_on_commit_(false) {}
 
   void SetupTree() override {
     scoped_refptr<FakePictureLayer> root_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+        FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(200, 200));
     root_layer->SetIsDrawable(true);
 
     scoped_refptr<FakePictureLayer> child_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+        FakePictureLayer::Create(&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 62 matching lines @@
 MULTI_THREAD_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(layer_settings(), &client_);
+        FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(150, 150));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
     client_.set_bounds(root_layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ skipping 58 matching lines @@
 
  private:
   bool did_commit_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNoTasksBetweenWillAndDidCommit);
 
 class LayerTreeHostTestUpdateCopyRequests : public LayerTreeHostTest {
  protected:
   void SetupTree() override {
-    root = Layer::Create(layer_settings());
-    child = Layer::Create(layer_settings());
+    root = Layer::Create();
+    child = Layer::Create();
     root->AddChild(child);
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   static void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {}
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void WillCommit() override {
@@ skipping 37 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(layer_settings());
+    scoped_refptr<Layer> root = Layer::Create();
 
-    scoped_refptr<Layer> clipping_layer = Layer::Create(layer_settings());
+    scoped_refptr<Layer> clipping_layer = Layer::Create();
     root->AddChild(clipping_layer);
 
     scoped_refptr<FakePictureLayer> content_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+        FakePictureLayer::Create(&client_);
     clipping_layer->AddChild(content_layer);
 
     scoped_refptr<FakePictureLayer> content_child_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+        FakePictureLayer::Create(&client_);
     content_layer->AddChild(content_child_layer);
 
     scoped_refptr<FakePictureLayer> mask_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+        FakePictureLayer::Create(&client_);
     content_layer->SetMaskLayer(mask_layer.get());
 
     gfx::Size root_size(100, 100);
     root->SetBounds(root_size);
 
     gfx::PointF clipping_origin(20.f, 10.f);
     gfx::Size clipping_size(10, 20);
     clipping_layer->SetBounds(clipping_size);
     clipping_layer->SetPosition(clipping_origin);
     clipping_layer->SetMasksToBounds(true);
@@ skipping 62 matching lines @@
   }
 
   void SetupTree() override {
     // Root
     //  |
     //  +-- Scaling Layer (adds a 2x scale)
     //       |
     //       +-- Content Layer
     //             +--Mask
 
-    scoped_refptr<Layer> root = Layer::Create(layer_settings());
+    scoped_refptr<Layer> root = Layer::Create();
 
-    scoped_refptr<Layer> scaling_layer = Layer::Create(layer_settings());
+    scoped_refptr<Layer> scaling_layer = Layer::Create();
     root->AddChild(scaling_layer);
 
     scoped_refptr<FakePictureLayer> content_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+        FakePictureLayer::Create(&client_);
     scaling_layer->AddChild(content_layer);
 
     scoped_refptr<FakePictureLayer> mask_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+        FakePictureLayer::Create(&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 65 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(layer_settings());
+    scoped_refptr<Layer> root = Layer::Create();
 
     scoped_refptr<FakePictureLayer> content_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+        FakePictureLayer::Create(&client_);
     root->AddChild(content_layer);
 
     scoped_refptr<FakePictureLayer> mask_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+        FakePictureLayer::Create(&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 61 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(layer_settings());
+    scoped_refptr<Layer> root = Layer::Create();
 
     scoped_refptr<FakePictureLayer> content_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+        FakePictureLayer::Create(&client_);
     root->AddChild(content_layer);
 
-    scoped_refptr<Layer> replica_layer = Layer::Create(layer_settings());
+    scoped_refptr<Layer> replica_layer = Layer::Create();
     content_layer->SetReplicaLayer(replica_layer.get());
 
     scoped_refptr<FakePictureLayer> mask_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+        FakePictureLayer::Create(&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 63 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(layer_settings());
+    scoped_refptr<Layer> root = Layer::Create();
 
     scoped_refptr<FakePictureLayer> content_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+        FakePictureLayer::Create(&client_);
     root->AddChild(content_layer);
 
-    content_child_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    content_child_layer_ = FakePictureLayer::Create(&client_);
     content_layer->AddChild(content_child_layer_);
 
-    scoped_refptr<Layer> replica_layer = Layer::Create(layer_settings());
+    scoped_refptr<Layer> replica_layer = Layer::Create();
     content_layer->SetReplicaLayer(replica_layer.get());
 
     scoped_refptr<FakePictureLayer> mask_layer =
-        FakePictureLayer::Create(layer_settings(), &client_);
+        FakePictureLayer::Create(&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 71 matching lines @@
  protected:
   void SetupTree() override {
     // -root
     //   -pre page scale
     //   -page scale
     //     -page scale child1
     //       -page scale grandchild
     //     -page scale child2
     //   -post page scale
 
-    scoped_refptr<Layer> root = Layer::Create(layer_settings());
-    scoped_refptr<Layer> pre_page_scale = Layer::Create(layer_settings());
-    scoped_refptr<Layer> page_scale = Layer::Create(layer_settings());
-    scoped_refptr<Layer> page_scale_child1 = Layer::Create(layer_settings());
-    scoped_refptr<Layer> page_scale_grandchild =
-        Layer::Create(layer_settings());
-    scoped_refptr<Layer> page_scale_child2 = Layer::Create(layer_settings());
-    scoped_refptr<Layer> post_page_scale = Layer::Create(layer_settings());
+    scoped_refptr<Layer> root = Layer::Create();
+    scoped_refptr<Layer> pre_page_scale = Layer::Create();
+    scoped_refptr<Layer> page_scale = Layer::Create();
+    scoped_refptr<Layer> page_scale_child1 = Layer::Create();
+    scoped_refptr<Layer> page_scale_grandchild = Layer::Create();
+    scoped_refptr<Layer> page_scale_child2 = Layer::Create();
+    scoped_refptr<Layer> post_page_scale = Layer::Create();
 
     root->AddChild(pre_page_scale);
     root->AddChild(page_scale);
     root->AddChild(post_page_scale);
 
     page_scale->AddChild(page_scale_child1);
     page_scale->AddChild(page_scale_child2);
     page_scale_child1->AddChild(page_scale_grandchild);
 
     layer_tree_host()->SetRootLayer(root);
@@ skipping 41 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeTestPageScaleFlags);
 
 class LayerTreeHostScrollingAndScalingUpdatesLayers : public LayerTreeHostTest {
  public:
   LayerTreeHostScrollingAndScalingUpdatesLayers()
       : requested_update_layers_(false), commit_count_(0) {}
 
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
     Layer* root_layer = layer_tree_host()->root_layer();
-    scoped_refptr<Layer> scroll_layer = Layer::Create(layer_settings());
+    scoped_refptr<Layer> scroll_layer = Layer::Create();
     CreateVirtualViewportLayers(root_layer, scroll_layer, root_layer->bounds(),
-                                root_layer->bounds(), layer_tree_host(),
-                                layer_settings());
+                                root_layer->bounds(), layer_tree_host());
   }
 
   void BeginTest() override {
     LayerTreeHostCommon::ScrollUpdateInfo scroll;
     scroll.layer_id = layer_tree_host()->root_layer()->id();
     scroll.scroll_delta = gfx::Vector2d(0, 33);
     scroll_info_.scrolls.push_back(scroll);
 
     scale_info_.page_scale_delta = 2.71f;
 
@@ skipping 75 matching lines @@
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPaintedDeviceScaleFactor);
 
 }  // namespace
 }  // namespace cc