CC Animation: Erase cc::LayerSettings everywhere.

cc/layers/layer_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/layers/layer.h"
 
 #include <stddef.h>
 
 #include "base/thread_task_runner_handle.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/mutable_properties.h"
 #include "cc/base/math_util.h"
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/layers/layer_impl.h"
-#include "cc/layers/layer_settings.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/proto/layer.pb.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_test_common.h"
@@ skipping 96 matching lines @@
     if (src->clip_parent_)
       layer_tree_host_->RegisterLayer(src->clip_parent_);
     if (src->clip_children_) {
       for (auto* child : *(src->clip_children_))
         layer_tree_host_->RegisterLayer(child);
     }
     // Reset the LayerTreeHost registration for the |src| layer so
     // it can be re-used for the |dest| layer.
     src->SetLayerTreeHost(nullptr);
 
-    scoped_refptr<Layer> dest = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> dest = Layer::Create();
     dest->layer_id_ = src->layer_id_;
     dest->SetLayerTreeHost(layer_tree_host_.get());
     dest->FromLayerPropertiesProto(props);
 
     // Verify that both layers are equal.
     EXPECT_EQ(src->transform_origin_, dest->transform_origin_);
     EXPECT_EQ(src->background_color_, dest->background_color_);
     EXPECT_EQ(src->bounds_, dest->bounds_);
     EXPECT_EQ(src->transform_tree_index_, dest->transform_tree_index_);
     EXPECT_EQ(src->effect_tree_index_, dest->effect_tree_index_);
@@ skipping 91 matching lines @@
     dest->clip_parent_ = nullptr;
     if (src->clip_children_) {
       for (auto* child : *(src->clip_children_))
         layer_tree_host_->UnregisterLayer(child);
       src->clip_children_.reset();
       dest->clip_children_.reset();
     }
   }
 
   void RunNoMembersChangedTest() {
-    scoped_refptr<Layer> layer = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer = Layer::Create();
     VerifyBaseLayerPropertiesSerializationAndDeserialization(layer.get());
   }
 
   void RunArbitraryMembersChangedTest() {
-    scoped_refptr<Layer> layer = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer = Layer::Create();
     layer->transform_origin_ = gfx::Point3F(3.0f, 1.0f, 4.0f);
     layer->background_color_ = SK_ColorRED;
     layer->bounds_ = gfx::Size(3, 14);
     layer->transform_tree_index_ = -1;
     layer->effect_tree_index_ = -1;
     layer->clip_tree_index_ = 71;
     layer->offset_to_transform_parent_ = gfx::Vector2dF(3.14f, 1.618f);
     layer->double_sided_ = true;
     layer->draws_content_ = true;
     layer->hide_layer_and_subtree_ = false;
@@ skipping 26 matching lines @@
     layer->user_scrollable_horizontal_ = false;
     layer->user_scrollable_vertical_ = true;
     layer->scroll_offset_ = gfx::ScrollOffset(3, 14);
     layer->scroll_compensation_adjustment_ = gfx::Vector2dF(6.28f, 3.14f);
     layer->update_rect_ = gfx::Rect(14, 15);
 
     VerifyBaseLayerPropertiesSerializationAndDeserialization(layer.get());
   }
 
   void RunAllMembersChangedTest() {
-    scoped_refptr<Layer> layer = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer = Layer::Create();
     layer->transform_origin_ = gfx::Point3F(3.0f, 1.0f, 4.0f);
     layer->background_color_ = SK_ColorRED;
     layer->bounds_ = gfx::Size(3, 14);
     layer->transform_tree_index_ = 39;
     layer->effect_tree_index_ = 17;
     layer->clip_tree_index_ = 71;
     layer->offset_to_transform_parent_ = gfx::Vector2dF(3.14f, 1.618f);
     layer->double_sided_ = !layer->double_sided_;
     layer->draws_content_ = !layer->draws_content_;
     layer->hide_layer_and_subtree_ = !layer->hide_layer_and_subtree_;
@@ skipping 29 matching lines @@
     layer->user_scrollable_horizontal_ = !layer->user_scrollable_horizontal_;
     layer->user_scrollable_vertical_ = !layer->user_scrollable_vertical_;
     layer->scroll_offset_ = gfx::ScrollOffset(3, 14);
     layer->scroll_compensation_adjustment_ = gfx::Vector2dF(6.28f, 3.14f);
     layer->update_rect_ = gfx::Rect(14, 15);
 
     VerifyBaseLayerPropertiesSerializationAndDeserialization(layer.get());
   }
 
   void RunScrollAndClipLayersTest() {
-    scoped_refptr<Layer> layer = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer = Layer::Create();
 
-    scoped_refptr<Layer> scroll_parent = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> scroll_parent = Layer::Create();
     layer->scroll_parent_ = scroll_parent.get();
-    scoped_refptr<Layer> scroll_child = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> scroll_child = Layer::Create();
     layer->scroll_children_.reset(new std::set<Layer*>);
     layer->scroll_children_->insert(scroll_child.get());
 
-    scoped_refptr<Layer> clip_parent = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> clip_parent = Layer::Create();
     layer->clip_parent_ = clip_parent.get();
     layer->clip_children_.reset(new std::set<Layer*>);
-    scoped_refptr<Layer> clip_child1 = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> clip_child1 = Layer::Create();
     layer->clip_children_->insert(clip_child1.get());
-    scoped_refptr<Layer> clip_child2 = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> clip_child2 = Layer::Create();
     layer->clip_children_->insert(clip_child2.get());
 
     VerifyBaseLayerPropertiesSerializationAndDeserialization(layer.get());
   }
 
   void RunHierarchyDeserializationWithLayerTreeHostTest() {
     /* Testing serialization and deserialization of a tree that looks like this:
             root
                \
                 a
                  \
                   b
                    \
                     c
       The root layer has a LayerTreeHost, and it should propagate to all the
       children.
     */
-    scoped_refptr<Layer> layer_src_root = Layer::Create(LayerSettings());
-    scoped_refptr<Layer> layer_src_a = Layer::Create(LayerSettings());
-    scoped_refptr<Layer> layer_src_b = Layer::Create(LayerSettings());
-    scoped_refptr<Layer> layer_src_c = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer_src_root = Layer::Create();
+    scoped_refptr<Layer> layer_src_a = Layer::Create();
+    scoped_refptr<Layer> layer_src_b = Layer::Create();
+    scoped_refptr<Layer> layer_src_c = Layer::Create();
     layer_src_root->AddChild(layer_src_a);
     layer_src_a->AddChild(layer_src_b);
     layer_src_b->AddChild(layer_src_c);
 
     proto::LayerNode proto;
     layer_src_root->ToLayerNodeProto(&proto);
 
     Layer::LayerIdMap empty_dest_layer_map;
-    scoped_refptr<Layer> layer_dest_root = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer_dest_root = Layer::Create();
 
     // Forcefully set the layer tree host for the root layer, which should cause
     // it to propagate to all the children.
     layer_dest_root->layer_tree_host_ = layer_tree_host_.get();
 
     layer_dest_root->FromLayerNodeProto(proto, empty_dest_layer_map);
 
     EXPECT_EQ(layer_src_root->id(), layer_dest_root->id());
     EXPECT_EQ(nullptr, layer_dest_root->parent());
     ASSERT_EQ(1u, layer_dest_root->children().size());
@@ skipping 29 matching lines @@
     /* Testing serialization and deserialization of a tree that initially looks
        like this:
             root
             /
            a
        The source tree is then deserialized from the same structure which should
        re-use the Layers from last deserialization and importantly it should
        not have called InvalidatePropertyTreesIndices() for any of the layers,
        which would happen in for example SetLayerTreeHost(...) calls.
     */
-    scoped_refptr<Layer> layer_root = Layer::Create(LayerSettings());
-    scoped_refptr<Layer> layer_src_a = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer_root = Layer::Create();
+    scoped_refptr<Layer> layer_src_a = Layer::Create();
     layer_root->AddChild(layer_src_a);
     layer_root->transform_tree_index_ = 33;
     layer_src_a->transform_tree_index_ = 42;
 
     proto::LayerNode root_proto;
     layer_root->ToLayerNodeProto(&root_proto);
 
     Layer::LayerIdMap dest_layer_map;
     dest_layer_map[layer_root->id()] = layer_root;
     dest_layer_map[layer_src_a->id()] = layer_src_a;
@@ skipping 14 matching lines @@
            a    b
        The children are then re-ordered to:
            root
            /  \
           b    a
        The tree is then serialized and deserialized again, and the the end
        result should have the same structure and importantly it should
        not have called InvalidatePropertyTreesIndices() for any of the layers,
        which would happen in for example SetLayerTreeHost(...) calls.
     */
-    scoped_refptr<Layer> layer_src_root = Layer::Create(LayerSettings());
-    scoped_refptr<Layer> layer_src_a = Layer::Create(LayerSettings());
-    scoped_refptr<Layer> layer_src_b = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer_src_root = Layer::Create();
+    scoped_refptr<Layer> layer_src_a = Layer::Create();
+    scoped_refptr<Layer> layer_src_b = Layer::Create();
     layer_src_root->AddChild(layer_src_a);
     layer_src_root->AddChild(layer_src_b);
 
     // Copy tree-structure to new root.
     proto::LayerNode root_proto_1;
     layer_src_root->ToLayerNodeProto(&root_proto_1);
     Layer::LayerIdMap dest_layer_map;
-    scoped_refptr<Layer> layer_dest_root = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer_dest_root = Layer::Create();
     layer_dest_root->FromLayerNodeProto(root_proto_1, dest_layer_map);
 
     // Ensure initial copy is correct.
     ASSERT_EQ(2u, layer_dest_root->children().size());
     scoped_refptr<Layer> layer_dest_a = layer_dest_root->children()[0];
     EXPECT_EQ(layer_src_a->id(), layer_dest_a->id());
     scoped_refptr<Layer> layer_dest_b = layer_dest_root->children()[1];
     EXPECT_EQ(layer_src_b->id(), layer_dest_b->id());
 
     // Swap order of the children.
@@ skipping 33 matching lines @@
            a
        A child is then added to the root:
            root
            /  \
           b    a
        The tree is then serialized and deserialized again, and the the end
        result should have the same structure and importantly it should
        not have called InvalidatePropertyTreesIndices() for any of the layers,
        which would happen in for example SetLayerTreeHost(...) calls.
     */
-    scoped_refptr<Layer> layer_src_root = Layer::Create(LayerSettings());
-    scoped_refptr<Layer> layer_src_a = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer_src_root = Layer::Create();
+    scoped_refptr<Layer> layer_src_a = Layer::Create();
     layer_src_root->AddChild(layer_src_a);
 
     // Copy tree-structure to new root.
     proto::LayerNode root_proto_1;
     layer_src_root->ToLayerNodeProto(&root_proto_1);
     Layer::LayerIdMap dest_layer_map;
-    scoped_refptr<Layer> layer_dest_root = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer_dest_root = Layer::Create();
     layer_dest_root->FromLayerNodeProto(root_proto_1, dest_layer_map);
 
     // Ensure initial copy is correct.
     ASSERT_EQ(1u, layer_dest_root->children().size());
     scoped_refptr<Layer> layer_dest_a = layer_dest_root->children()[0];
     EXPECT_EQ(layer_src_a->id(), layer_dest_a->id());
 
     // Fake the fact that the destination layer |a| now has a valid index.
     layer_dest_root->transform_tree_index_ = 33;
     layer_dest_a->transform_tree_index_ = 42;
 
     // Add another child.
-    scoped_refptr<Layer> layer_src_b = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer_src_b = Layer::Create();
     layer_src_root->AddChild(layer_src_b);
 
     // Now serialize and deserialize again.
     proto::LayerNode root_proto_2;
     layer_src_root->ToLayerNodeProto(&root_proto_2);
     dest_layer_map[layer_dest_root->id()] = layer_dest_root;
     dest_layer_map[layer_dest_a->id()] = layer_dest_a;
     layer_dest_root->FromLayerNodeProto(root_proto_2, dest_layer_map);
 
     // Ensure second copy is correct.
@@ skipping 14 matching lines @@
            a    b
        The |b| child is the removed from the root:
            root
            /
           b
        The tree is then serialized and deserialized again, and the the end
        result should have the same structure and importantly it should
        not have called InvalidatePropertyTreesIndices() for any of the layers,
        which would happen in for example SetLayerTreeHost(...) calls.
     */
-    scoped_refptr<Layer> layer_src_root = Layer::Create(LayerSettings());
-    scoped_refptr<Layer> layer_src_a = Layer::Create(LayerSettings());
-    scoped_refptr<Layer> layer_src_b = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer_src_root = Layer::Create();
+    scoped_refptr<Layer> layer_src_a = Layer::Create();
+    scoped_refptr<Layer> layer_src_b = Layer::Create();
     layer_src_root->AddChild(layer_src_a);
     layer_src_root->AddChild(layer_src_b);
 
     // Copy tree-structure to new root.
     proto::LayerNode root_proto_1;
     layer_src_root->ToLayerNodeProto(&root_proto_1);
     Layer::LayerIdMap dest_layer_map;
-    scoped_refptr<Layer> layer_dest_root = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer_dest_root = Layer::Create();
     layer_dest_root->FromLayerNodeProto(root_proto_1, dest_layer_map);
 
     // Ensure initial copy is correct.
     ASSERT_EQ(2u, layer_dest_root->children().size());
     scoped_refptr<Layer> layer_dest_a = layer_dest_root->children()[0];
     EXPECT_EQ(layer_src_a->id(), layer_dest_a->id());
     scoped_refptr<Layer> layer_dest_b = layer_dest_root->children()[1];
     EXPECT_EQ(layer_src_b->id(), layer_dest_b->id());
 
     // Remove one child.
@@ skipping 32 matching lines @@
             root
            /    \
           a      b
          /
         c
        The tree is then serialized and deserialized again, and the the end
        result should have the same structure and importantly it should
        not have called InvalidatePropertyTreesIndices() for any of the layers,
        which would happen in for example SetLayerTreeHost(...) calls.
     */
-    scoped_refptr<Layer> layer_src_root = Layer::Create(LayerSettings());
-    scoped_refptr<Layer> layer_src_a = Layer::Create(LayerSettings());
-    scoped_refptr<Layer> layer_src_b = Layer::Create(LayerSettings());
-    scoped_refptr<Layer> layer_src_c = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer_src_root = Layer::Create();
+    scoped_refptr<Layer> layer_src_a = Layer::Create();
+    scoped_refptr<Layer> layer_src_b = Layer::Create();
+    scoped_refptr<Layer> layer_src_c = Layer::Create();
     layer_src_root->AddChild(layer_src_a);
     layer_src_root->AddChild(layer_src_b);
     layer_src_b->AddChild(layer_src_c);
 
     // Copy tree-structure to new root.
     proto::LayerNode root_proto_1;
     layer_src_root->ToLayerNodeProto(&root_proto_1);
     Layer::LayerIdMap dest_layer_map;
-    scoped_refptr<Layer> layer_dest_root = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer_dest_root = Layer::Create();
     layer_dest_root->FromLayerNodeProto(root_proto_1, dest_layer_map);
 
     // Ensure initial copy is correct.
     ASSERT_EQ(2u, layer_dest_root->children().size());
     scoped_refptr<Layer> layer_dest_a = layer_dest_root->children()[0];
     scoped_refptr<Layer> layer_dest_b = layer_dest_root->children()[1];
     EXPECT_EQ(layer_src_a->id(), layer_dest_a->id());
     EXPECT_EQ(layer_src_b->id(), layer_dest_b->id());
     ASSERT_EQ(1u, layer_dest_b->children().size());
     scoped_refptr<Layer> layer_dest_c = layer_dest_b->children()[0];
@@ skipping 46 matching lines @@
             root
            /    \
           a      b
                   \
                    c
        The tree is then serialized and deserialized again, and the the end
        result should have the same structure and importantly it should
        not have called InvalidatePropertyTreesIndices() for any of the layers,
        which would happen in for example SetLayerTreeHost(...) calls.
     */
-    scoped_refptr<Layer> layer_src_root = Layer::Create(LayerSettings());
-    scoped_refptr<Layer> layer_src_a = Layer::Create(LayerSettings());
-    scoped_refptr<Layer> layer_src_b = Layer::Create(LayerSettings());
-    scoped_refptr<Layer> layer_src_c = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer_src_root = Layer::Create();
+    scoped_refptr<Layer> layer_src_a = Layer::Create();
+    scoped_refptr<Layer> layer_src_b = Layer::Create();
+    scoped_refptr<Layer> layer_src_c = Layer::Create();
     layer_src_root->AddChild(layer_src_a);
     layer_src_root->AddChild(layer_src_b);
     layer_src_a->AddChild(layer_src_c);
 
     // Copy tree-structure to new root.
     proto::LayerNode root_proto_1;
     layer_src_root->ToLayerNodeProto(&root_proto_1);
     Layer::LayerIdMap dest_layer_map;
-    scoped_refptr<Layer> layer_dest_root = Layer::Create(LayerSettings());
+    scoped_refptr<Layer> layer_dest_root = Layer::Create();
     layer_dest_root->FromLayerNodeProto(root_proto_1, dest_layer_map);
 
     // Ensure initial copy is correct.
     ASSERT_EQ(2u, layer_dest_root->children().size());
     scoped_refptr<Layer> layer_dest_a = layer_dest_root->children()[0];
     scoped_refptr<Layer> layer_dest_b = layer_dest_root->children()[1];
     EXPECT_EQ(layer_src_a->id(), layer_dest_a->id());
     EXPECT_EQ(layer_src_b->id(), layer_dest_b->id());
     ASSERT_EQ(1u, layer_dest_a->children().size());
     scoped_refptr<Layer> layer_dest_c = layer_dest_a->children()[0];
@@ skipping 50 matching lines @@
                              base::ThreadTaskRunnerHandle::Get(), nullptr);
   }
 
   MOCK_METHOD0(SetNeedsCommit, void());
   MOCK_METHOD0(SetNeedsUpdateLayers, void());
   MOCK_METHOD0(SetNeedsFullTreeSync, void());
 };
 
 class LayerTreeSettingsForLayerTest : public LayerTreeSettings {
  public:
-  LayerTreeSettingsForLayerTest() { use_compositor_animation_timelines = true; }
+  LayerTreeSettingsForLayerTest() {}
 };
 
 class LayerTest : public testing::Test {
  public:
   LayerTest()
       : host_impl_(LayerTreeSettingsForLayerTest(),
                    &task_runner_provider_,
                    &shared_bitmap_manager_,
                    &task_graph_runner_),
         fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {
-    layer_settings_.use_compositor_animation_timelines =
-        settings().use_compositor_animation_timelines;
-    if (settings().use_compositor_animation_timelines) {
-      timeline_impl_ =
-          AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
-      timeline_impl_->set_is_impl_only(true);
-      host_impl_.animation_host()->AddAnimationTimeline(timeline_impl_);
-    }
+    timeline_impl_ =
+        AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
+    timeline_impl_->set_is_impl_only(true);
+    host_impl_.animation_host()->AddAnimationTimeline(timeline_impl_);
   }
 
   const LayerTreeSettings& settings() { return settings_; }
   scoped_refptr<AnimationTimeline> timeline_impl() { return timeline_impl_; }
 
  protected:
   void SetUp() override {
     LayerTreeHost::InitParams params;
     params.client = &fake_client_;
     params.settings = &settings_;
@@ skipping 33 matching lines @@
     EXPECT_EQ(child1_.get(), grand_child2_->parent());
 
     ASSERT_EQ(1U, child2_->children().size());
     EXPECT_EQ(grand_child3_, child2_->children()[0]);
     EXPECT_EQ(child2_.get(), grand_child3_->parent());
 
     ASSERT_EQ(0U, child3_->children().size());
   }
 
   void CreateSimpleTestTree() {
-    parent_ = Layer::Create(layer_settings_);
-    child1_ = Layer::Create(layer_settings_);
-    child2_ = Layer::Create(layer_settings_);
-    child3_ = Layer::Create(layer_settings_);
-    grand_child1_ = Layer::Create(layer_settings_);
-    grand_child2_ = Layer::Create(layer_settings_);
-    grand_child3_ = Layer::Create(layer_settings_);
+    parent_ = Layer::Create();
+    child1_ = Layer::Create();
+    child2_ = Layer::Create();
+    child3_ = Layer::Create();
+    grand_child1_ = Layer::Create();
+    grand_child2_ = Layer::Create();
+    grand_child3_ = Layer::Create();
 
     EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AnyNumber());
     layer_tree_host_->SetRootLayer(parent_);
 
     parent_->AddChild(child1_);
     parent_->AddChild(child2_);
     parent_->AddChild(child3_);
     child1_->AddChild(grand_child1_);
     child1_->AddChild(grand_child2_);
     child2_->AddChild(grand_child3_);
@@ skipping 14 matching lines @@
   scoped_refptr<Layer> child1_;
   scoped_refptr<Layer> child2_;
   scoped_refptr<Layer> child3_;
   scoped_refptr<Layer> grand_child1_;
   scoped_refptr<Layer> grand_child2_;
   scoped_refptr<Layer> grand_child3_;
 
   scoped_refptr<AnimationTimeline> timeline_impl_;
 
   LayerTreeSettingsForLayerTest settings_;
-  LayerSettings layer_settings_;
 };
 
 TEST_F(LayerTest, BasicCreateAndDestroy) {
-  scoped_refptr<Layer> test_layer = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> test_layer = Layer::Create();
   ASSERT_TRUE(test_layer.get());
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
   test_layer->SetLayerTreeHost(layer_tree_host_.get());
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(0);
   test_layer->SetLayerTreeHost(nullptr);
 }
 
 TEST_F(LayerTest, LayerPropertyChangedForSubtree) {
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AtLeast(1));
-  scoped_refptr<Layer> root = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child2 = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> grand_child = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> dummy_layer1 = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> dummy_layer2 = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> child2 = Layer::Create();
+  scoped_refptr<Layer> grand_child = Layer::Create();
+  scoped_refptr<Layer> dummy_layer1 = Layer::Create();
+  scoped_refptr<Layer> dummy_layer2 = Layer::Create();
 
   layer_tree_host_->SetRootLayer(root);
   root->AddChild(child);
   root->AddChild(child2);
   child->AddChild(grand_child);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
   child->SetForceRenderSurface(true);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
   child2->SetScrollParent(grand_child.get());
   SkXfermode::Mode arbitrary_blend_mode = SkXfermode::kMultiply_Mode;
@@ skipping 159 matching lines @@
   gfx::Transform arbitrary_transform;
   arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
   root->SetTransform(arbitrary_transform);
   node = layer_tree_host_->property_trees()->transform_tree.Node(
       root->transform_tree_index());
   EXPECT_TRUE(node->data.transform_changed);
 }
 
 TEST_F(LayerTest, AddAndRemoveChild) {
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
 
   // Upon creation, layers should not have children or parent.
   ASSERT_EQ(0U, parent->children().size());
   EXPECT_FALSE(child->parent());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(parent));
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->AddChild(child));
 
   ASSERT_EQ(1U, parent->children().size());
   EXPECT_EQ(child.get(), parent->children()[0].get());
   EXPECT_EQ(parent.get(), child->parent());
   EXPECT_EQ(parent.get(), child->RootLayer());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), child->RemoveFromParent());
 }
 
 TEST_F(LayerTest, AddSameChildTwice) {
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AtLeast(1));
 
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
 
   layer_tree_host_->SetRootLayer(parent);
 
   ASSERT_EQ(0u, parent->children().size());
 
   parent->AddChild(child);
   ASSERT_EQ(1u, parent->children().size());
   EXPECT_EQ(parent.get(), child->parent());
 
   parent->AddChild(child);
   ASSERT_EQ(1u, parent->children().size());
   EXPECT_EQ(parent.get(), child->parent());
 }
 
 TEST_F(LayerTest, InsertChild) {
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child1 = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child2 = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child3 = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child4 = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> child1 = Layer::Create();
+  scoped_refptr<Layer> child2 = Layer::Create();
+  scoped_refptr<Layer> child3 = Layer::Create();
+  scoped_refptr<Layer> child4 = Layer::Create();
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(parent));
 
   ASSERT_EQ(0U, parent->children().size());
 
   // Case 1: inserting to empty list.
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child3, 0));
   ASSERT_EQ(1U, parent->children().size());
   EXPECT_EQ(child3, parent->children()[0]);
   EXPECT_EQ(parent.get(), child3->parent());
@@ skipping 20 matching lines @@
   EXPECT_EQ(child1, parent->children()[0]);
   EXPECT_EQ(child2, parent->children()[1]);
   EXPECT_EQ(child3, parent->children()[2]);
   EXPECT_EQ(child4, parent->children()[3]);
   EXPECT_EQ(parent.get(), child4->parent());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(nullptr));
 }
 
 TEST_F(LayerTest, InsertChildPastEndOfList) {
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child1 = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child2 = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> child1 = Layer::Create();
+  scoped_refptr<Layer> child2 = Layer::Create();
 
   ASSERT_EQ(0U, parent->children().size());
 
   // insert to an out-of-bounds index
   parent->InsertChild(child1, 53);
 
   ASSERT_EQ(1U, parent->children().size());
   EXPECT_EQ(child1, parent->children()[0]);
 
   // insert another child to out-of-bounds, when list is not already empty.
   parent->InsertChild(child2, 2459);
 
   ASSERT_EQ(2U, parent->children().size());
   EXPECT_EQ(child1, parent->children()[0]);
   EXPECT_EQ(child2, parent->children()[1]);
 }
 
 TEST_F(LayerTest, InsertSameChildTwice) {
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child1 = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child2 = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> child1 = Layer::Create();
+  scoped_refptr<Layer> child2 = Layer::Create();
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(parent));
 
   ASSERT_EQ(0U, parent->children().size());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child1, 0));
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child2, 1));
 
   ASSERT_EQ(2U, parent->children().size());
   EXPECT_EQ(child1, parent->children()[0]);
   EXPECT_EQ(child2, parent->children()[1]);
 
   // Inserting the same child again should cause the child to be removed and
   // re-inserted at the new location.
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), parent->InsertChild(child1, 1));
 
   // child1 should now be at the end of the list.
   ASSERT_EQ(2U, parent->children().size());
   EXPECT_EQ(child2, parent->children()[0]);
   EXPECT_EQ(child1, parent->children()[1]);
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(nullptr));
 }
 
 TEST_F(LayerTest, ReplaceChildWithNewChild) {
   CreateSimpleTestTree();
-  scoped_refptr<Layer> child4 = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> child4 = Layer::Create();
 
   EXPECT_FALSE(child4->parent());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(
       AtLeast(1), parent_->ReplaceChild(child2_.get(), child4));
   EXPECT_FALSE(parent_->NeedsDisplayForTesting());
   EXPECT_FALSE(child1_->NeedsDisplayForTesting());
   EXPECT_FALSE(child2_->NeedsDisplayForTesting());
   EXPECT_FALSE(child3_->NeedsDisplayForTesting());
   EXPECT_FALSE(child4->NeedsDisplayForTesting());
 
   ASSERT_EQ(static_cast<size_t>(3), parent_->children().size());
   EXPECT_EQ(child1_, parent_->children()[0]);
   EXPECT_EQ(child4, parent_->children()[1]);
   EXPECT_EQ(child3_, parent_->children()[2]);
   EXPECT_EQ(parent_.get(), child4->parent());
 
   EXPECT_FALSE(child2_->parent());
 }
 
 TEST_F(LayerTest, ReplaceChildWithNewChildThatHasOtherParent) {
   CreateSimpleTestTree();
 
   // create another simple tree with test_layer and child4.
-  scoped_refptr<Layer> test_layer = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child4 = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> test_layer = Layer::Create();
+  scoped_refptr<Layer> child4 = Layer::Create();
   test_layer->AddChild(child4);
   ASSERT_EQ(1U, test_layer->children().size());
   EXPECT_EQ(child4, test_layer->children()[0]);
   EXPECT_EQ(test_layer.get(), child4->parent());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(
       AtLeast(1), parent_->ReplaceChild(child2_.get(), child4));
 
   ASSERT_EQ(3U, parent_->children().size());
   EXPECT_EQ(child1_, parent_->children()[0]);
   EXPECT_EQ(child4, parent_->children()[1]);
   EXPECT_EQ(child3_, parent_->children()[2]);
   EXPECT_EQ(parent_.get(), child4->parent());
 
   // test_layer should no longer have child4,
   // and child2 should no longer have a parent.
   ASSERT_EQ(0U, test_layer->children().size());
   EXPECT_FALSE(child2_->parent());
 }
 
 TEST_F(LayerTest, DeleteRemovedScrollParent) {
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child1 = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child2 = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> child1 = Layer::Create();
+  scoped_refptr<Layer> child2 = Layer::Create();
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(parent));
 
   ASSERT_EQ(0U, parent->children().size());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child1, 0));
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child2, 1));
 
   ASSERT_EQ(2U, parent->children().size());
   EXPECT_EQ(child1, parent->children()[0]);
   EXPECT_EQ(child2, parent->children()[1]);
 
   EXPECT_SET_NEEDS_COMMIT(2, child1->SetScrollParent(child2.get()));
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, child2->RemoveFromParent());
 
   child1->reset_needs_push_properties_for_testing();
 
   EXPECT_SET_NEEDS_COMMIT(1, child2 = nullptr);
 
   EXPECT_TRUE(child1->needs_push_properties());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(nullptr));
 }
 
 TEST_F(LayerTest, DeleteRemovedScrollChild) {
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child1 = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child2 = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> child1 = Layer::Create();
+  scoped_refptr<Layer> child2 = Layer::Create();
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(parent));
 
   ASSERT_EQ(0U, parent->children().size());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child1, 0));
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->InsertChild(child2, 1));
 
   ASSERT_EQ(2U, parent->children().size());
   EXPECT_EQ(child1, parent->children()[0]);
@@ skipping 29 matching lines @@
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(3), parent_->RemoveAllChildren());
 
   ASSERT_EQ(0U, parent_->children().size());
   EXPECT_FALSE(child1_->parent());
   EXPECT_FALSE(child2_->parent());
   EXPECT_FALSE(child3_->parent());
 }
 
 TEST_F(LayerTest, SetChildren) {
-  scoped_refptr<Layer> old_parent = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> new_parent = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> old_parent = Layer::Create();
+  scoped_refptr<Layer> new_parent = Layer::Create();
 
-  scoped_refptr<Layer> child1 = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child2 = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> child1 = Layer::Create();
+  scoped_refptr<Layer> child2 = Layer::Create();
 
   LayerList new_children;
   new_children.push_back(child1);
   new_children.push_back(child2);
 
   // Set up and verify initial test conditions: child1 has a parent, child2 has
   // no parent.
   old_parent->AddChild(child1);
   ASSERT_EQ(0U, new_parent->children().size());
   EXPECT_EQ(old_parent.get(), child1->parent());
   EXPECT_FALSE(child2->parent());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(
       1, layer_tree_host_->SetRootLayer(new_parent));
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(
       AtLeast(1), new_parent->SetChildren(new_children));
 
   ASSERT_EQ(2U, new_parent->children().size());
   EXPECT_EQ(new_parent.get(), child1->parent());
   EXPECT_EQ(new_parent.get(), child2->parent());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(nullptr));
 }
 
 TEST_F(LayerTest, HasAncestor) {
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> parent = Layer::Create();
   EXPECT_FALSE(parent->HasAncestor(parent.get()));
 
-  scoped_refptr<Layer> child = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> child = Layer::Create();
   parent->AddChild(child);
 
   EXPECT_FALSE(child->HasAncestor(child.get()));
   EXPECT_TRUE(child->HasAncestor(parent.get()));
   EXPECT_FALSE(parent->HasAncestor(child.get()));
 
-  scoped_refptr<Layer> child_child = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> child_child = Layer::Create();
   child->AddChild(child_child);
 
   EXPECT_FALSE(child_child->HasAncestor(child_child.get()));
   EXPECT_TRUE(child_child->HasAncestor(parent.get()));
   EXPECT_TRUE(child_child->HasAncestor(child.get()));
   EXPECT_FALSE(parent->HasAncestor(child.get()));
   EXPECT_FALSE(parent->HasAncestor(child_child.get()));
 }
 
 TEST_F(LayerTest, GetRootLayerAfterTreeManipulations) {
   CreateSimpleTestTree();
 
   // For this test we don't care about SetNeedsFullTreeSync calls.
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AnyNumber());
 
-  scoped_refptr<Layer> child4 = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> child4 = Layer::Create();
 
   EXPECT_EQ(parent_.get(), parent_->RootLayer());
   EXPECT_EQ(parent_.get(), child1_->RootLayer());
   EXPECT_EQ(parent_.get(), child2_->RootLayer());
   EXPECT_EQ(parent_.get(), child3_->RootLayer());
   EXPECT_EQ(child4.get(),   child4->RootLayer());
   EXPECT_EQ(parent_.get(), grand_child1_->RootLayer());
   EXPECT_EQ(parent_.get(), grand_child2_->RootLayer());
   EXPECT_EQ(parent_.get(), grand_child3_->RootLayer());
 
@@ skipping 34 matching lines @@
   EXPECT_EQ(parent_.get(), grand_child2_->RootLayer());
   EXPECT_EQ(grand_child3_.get(), grand_child3_->RootLayer());
 }
 
 TEST_F(LayerTest, CheckSetNeedsDisplayCausesCorrectBehavior) {
   // The semantics for SetNeedsDisplay which are tested here:
   //   1. sets NeedsDisplay flag appropriately.
   //   2. indirectly calls SetNeedsUpdate, exactly once for each call to
   //      SetNeedsDisplay.
 
-  scoped_refptr<Layer> test_layer = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> test_layer = Layer::Create();
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(
       1, layer_tree_host_->SetRootLayer(test_layer));
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetIsDrawable(true));
 
   gfx::Size test_bounds = gfx::Size(501, 508);
 
   gfx::Rect dirty1 = gfx::Rect(10, 15, 1, 2);
   gfx::Rect dirty2 = gfx::Rect(20, 25, 3, 4);
   gfx::Rect out_of_bounds_dirty_rect = gfx::Rect(400, 405, 500, 502);
 
@@ skipping 32 matching lines @@
 
   // Case 4: SetNeedsDisplay() with a non-drawable layer
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetIsDrawable(false));
   test_layer->ResetNeedsDisplayForTesting();
   EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
   EXPECT_SET_NEEDS_UPDATE(0, test_layer->SetNeedsDisplayRect(dirty1));
   EXPECT_TRUE(test_layer->NeedsDisplayForTesting());
 }
 
 TEST_F(LayerTest, TestSettingMainThreadScrollingReason) {
-  scoped_refptr<Layer> test_layer = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> test_layer = Layer::Create();
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
                                   layer_tree_host_->SetRootLayer(test_layer));
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetIsDrawable(true));
 
   // sanity check of initial test condition
   EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
 
   uint32_t reasons = 0, reasons_to_clear = 0, reasons_after_clearing = 0;
   reasons |= MainThreadScrollingReason::kEventHandlers;
   reasons |= MainThreadScrollingReason::kContinuingMainThreadScroll;
@@ skipping 30 matching lines @@
       0, test_layer->ClearMainThreadScrollingReasons(reasons_to_clear));
   EXPECT_EQ(reasons_after_clearing,
             test_layer->main_thread_scrolling_reasons());
 
   // Check that adding an existing condition doesn't set needs commit.
   EXPECT_SET_NEEDS_COMMIT(0, test_layer->AddMainThreadScrollingReasons(
                                  MainThreadScrollingReason::kEventHandlers));
 }
 
 TEST_F(LayerTest, CheckPropertyChangeCausesCorrectBehavior) {
-  scoped_refptr<Layer> test_layer = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> test_layer = Layer::Create();
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(
       1, layer_tree_host_->SetRootLayer(test_layer));
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetIsDrawable(true));
 
-  scoped_refptr<Layer> dummy_layer1 = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> dummy_layer2 = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> dummy_layer1 = Layer::Create();
+  scoped_refptr<Layer> dummy_layer2 = Layer::Create();
 
   // sanity check of initial test condition
   EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
 
   // Next, test properties that should call SetNeedsCommit (but not
   // SetNeedsDisplay). All properties need to be set to new values in order for
   // SetNeedsCommit to be called.
   EXPECT_SET_NEEDS_COMMIT(
       1, test_layer->SetTransformOrigin(gfx::Point3F(1.23f, 4.56f, 0.f)));
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetBackgroundColor(SK_ColorLTGRAY));
@@ skipping 30 matching lines @@
       dummy_layer2.get()));
 
   // The above tests should not have caused a change to the needs_display flag.
   EXPECT_FALSE(test_layer->NeedsDisplayForTesting());
 
   // As layers are removed from the tree, they will cause a tree sync.
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times((AnyNumber()));
 }
 
 TEST_F(LayerTest, PushPropertiesAccumulatesUpdateRect) {
-  scoped_refptr<Layer> test_layer = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> test_layer = Layer::Create();
   scoped_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
                                   layer_tree_host_->SetRootLayer(test_layer));
 
   test_layer->SetNeedsDisplayRect(gfx::Rect(5, 5));
   test_layer->PushPropertiesTo(impl_layer.get());
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 5.f, 5.f),
                        impl_layer->update_rect());
 
   // The LayerImpl's update_rect() should be accumulated here, since we did not
   // do anything to clear it.
   test_layer->SetNeedsDisplayRect(gfx::Rect(10, 10, 5, 5));
   test_layer->PushPropertiesTo(impl_layer.get());
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(0.f, 0.f, 15.f, 15.f),
                        impl_layer->update_rect());
 
   // If we do clear the LayerImpl side, then the next update_rect() should be
   // fresh without accumulation.
   impl_layer->ResetAllChangeTrackingForSubtree();
   test_layer->SetNeedsDisplayRect(gfx::Rect(10, 10, 5, 5));
   test_layer->PushPropertiesTo(impl_layer.get());
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(10.f, 10.f, 5.f, 5.f),
                        impl_layer->update_rect());
 }
 
 TEST_F(LayerTest, PushPropertiesCausesLayerPropertyChangedForTransform) {
-  scoped_refptr<Layer> test_layer = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> test_layer = Layer::Create();
   scoped_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
                                   layer_tree_host_->SetRootLayer(test_layer));
 
   gfx::Transform transform;
   transform.Rotate(45.0);
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetTransform(transform));
 
   EXPECT_FALSE(impl_layer->LayerPropertyChanged());
 
   test_layer->PushPropertiesTo(impl_layer.get());
 
   EXPECT_TRUE(impl_layer->LayerPropertyChanged());
 }
 
 TEST_F(LayerTest, PushPropertiesCausesLayerPropertyChangedForOpacity) {
-  scoped_refptr<Layer> test_layer = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> test_layer = Layer::Create();
   scoped_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
                                   layer_tree_host_->SetRootLayer(test_layer));
 
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetOpacity(0.5f));
 
   EXPECT_FALSE(impl_layer->LayerPropertyChanged());
 
   test_layer->PushPropertiesTo(impl_layer.get());
 
   EXPECT_TRUE(impl_layer->LayerPropertyChanged());
 }
 
 TEST_F(LayerTest, MaskAndReplicaHasParent) {
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> mask = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> replica = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> replica_mask = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> mask_replacement = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> replica_replacement = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> replica_mask_replacement =
-      Layer::Create(layer_settings_);
+  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> mask = Layer::Create();
+  scoped_refptr<Layer> replica = Layer::Create();
+  scoped_refptr<Layer> replica_mask = Layer::Create();
+  scoped_refptr<Layer> mask_replacement = Layer::Create();
+  scoped_refptr<Layer> replica_replacement = Layer::Create();
+  scoped_refptr<Layer> replica_mask_replacement = Layer::Create();
 
   parent->AddChild(child);
   child->SetMaskLayer(mask.get());
   child->SetReplicaLayer(replica.get());
   replica->SetMaskLayer(replica_mask.get());
 
   EXPECT_EQ(parent.get(), child->parent());
   EXPECT_EQ(child.get(), mask->parent());
   EXPECT_EQ(child.get(), replica->parent());
   EXPECT_EQ(replica.get(), replica_mask->parent());
 
   replica->SetMaskLayer(replica_mask_replacement.get());
   EXPECT_EQ(nullptr, replica_mask->parent());
   EXPECT_EQ(replica.get(), replica_mask_replacement->parent());
 
   child->SetMaskLayer(mask_replacement.get());
   EXPECT_EQ(nullptr, mask->parent());
   EXPECT_EQ(child.get(), mask_replacement->parent());
 
   child->SetReplicaLayer(replica_replacement.get());
   EXPECT_EQ(nullptr, replica->parent());
   EXPECT_EQ(child.get(), replica_replacement->parent());
 
   EXPECT_EQ(replica.get(), replica->mask_layer()->parent());
 }
 
 TEST_F(LayerTest, CheckTransformIsInvertible) {
-  scoped_refptr<Layer> layer = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> layer = Layer::Create();
   scoped_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(1);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(layer);
 
   EXPECT_TRUE(layer->transform_is_invertible());
 
   gfx::Transform singular_transform;
   singular_transform.Scale3d(
@@ skipping 10 matching lines @@
 
   layer->SetTransform(rotation_transform);
   layer->PushPropertiesTo(impl_layer.get());
   EXPECT_TRUE(layer->transform_is_invertible());
   EXPECT_TRUE(impl_layer->transform_is_invertible());
 
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 }
 
 TEST_F(LayerTest, TransformIsInvertibleAnimation) {
-  scoped_refptr<Layer> layer = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> layer = Layer::Create();
   scoped_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(1);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(layer);
 
   EXPECT_TRUE(layer->transform_is_invertible());
 
   gfx::Transform singular_transform;
   singular_transform.Scale3d(
@@ skipping 47 matching lines @@
   for (size_t i = 0; i < layer->children().size(); ++i)
     AssertLayerTreeHostMatchesForSubtree(layer->children()[i].get(), host);
 
   if (layer->mask_layer())
     AssertLayerTreeHostMatchesForSubtree(layer->mask_layer(), host);
 
   if (layer->replica_layer())
     AssertLayerTreeHostMatchesForSubtree(layer->replica_layer(), host);
 }
 
-class LayerLayerTreeHostTest : public testing::Test {
- public:
-  LayerLayerTreeHostTest() {
-    layer_settings_.use_compositor_animation_timelines = true;
-  }
-
- protected:
-  LayerSettings layer_settings_;
-};
+class LayerLayerTreeHostTest : public testing::Test {};
 
 TEST_F(LayerLayerTreeHostTest, EnteringTree) {
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> mask = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> replica = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> replica_mask = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> mask = Layer::Create();
+  scoped_refptr<Layer> replica = Layer::Create();
+  scoped_refptr<Layer> replica_mask = Layer::Create();
 
   // Set up a detached tree of layers. The host pointer should be nil for these
   // layers.
   parent->AddChild(child);
   child->SetMaskLayer(mask.get());
   child->SetReplicaLayer(replica.get());
   replica->SetMaskLayer(replica_mask.get());
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(), nullptr);
 
   LayerTreeHostFactory factory;
   scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
   // Setting the root layer should set the host pointer for all layers in the
   // tree.
   layer_tree_host->SetRootLayer(parent.get());
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(), layer_tree_host.get());
 
   // Clearing the root layer should also clear out the host pointers for all
   // layers in the tree.
   layer_tree_host->SetRootLayer(nullptr);
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(), nullptr);
 }
 
 TEST_F(LayerLayerTreeHostTest, AddingLayerSubtree) {
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> parent = Layer::Create();
   LayerTreeHostFactory factory;
   scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
 
   layer_tree_host->SetRootLayer(parent.get());
 
   EXPECT_EQ(parent->layer_tree_host(), layer_tree_host.get());
 
   // Adding a subtree to a layer already associated with a host should set the
   // host pointer on all layers in that subtree.
-  scoped_refptr<Layer> child = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> grand_child = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> grand_child = Layer::Create();
   child->AddChild(grand_child);
 
   // Masks, replicas, and replica masks should pick up the new host too.
-  scoped_refptr<Layer> child_mask = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> child_mask = Layer::Create();
   child->SetMaskLayer(child_mask.get());
-  scoped_refptr<Layer> child_replica = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> child_replica = Layer::Create();
   child->SetReplicaLayer(child_replica.get());
-  scoped_refptr<Layer> child_replica_mask = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> child_replica_mask = Layer::Create();
   child_replica->SetMaskLayer(child_replica_mask.get());
 
   parent->AddChild(child);
   AssertLayerTreeHostMatchesForSubtree(parent.get(), layer_tree_host.get());
 
   layer_tree_host->SetRootLayer(nullptr);
 }
 
 TEST_F(LayerLayerTreeHostTest, ChangeHost) {
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> mask = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> replica = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> replica_mask = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
+  scoped_refptr<Layer> mask = Layer::Create();
+  scoped_refptr<Layer> replica = Layer::Create();
+  scoped_refptr<Layer> replica_mask = Layer::Create();
 
   // Same setup as the previous test.
   parent->AddChild(child);
   child->SetMaskLayer(mask.get());
   child->SetReplicaLayer(replica.get());
   replica->SetMaskLayer(replica_mask.get());
 
   LayerTreeHostFactory factory;
   scoped_ptr<LayerTreeHost> first_layer_tree_host = factory.Create();
   first_layer_tree_host->SetRootLayer(parent.get());
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(),
                                        first_layer_tree_host.get());
 
   // Now re-root the tree to a new host (simulating what we do on a context lost
   // event). This should update the host pointers for all layers in the tree.
   scoped_ptr<LayerTreeHost> second_layer_tree_host = factory.Create();
   second_layer_tree_host->SetRootLayer(parent.get());
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(),
                                        second_layer_tree_host.get());
 
   second_layer_tree_host->SetRootLayer(nullptr);
 }
 
 TEST_F(LayerLayerTreeHostTest, ChangeHostInSubtree) {
-  scoped_refptr<Layer> first_parent = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> first_child = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> second_parent = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> second_child = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> second_grand_child = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> first_parent = Layer::Create();
+  scoped_refptr<Layer> first_child = Layer::Create();
+  scoped_refptr<Layer> second_parent = Layer::Create();
+  scoped_refptr<Layer> second_child = Layer::Create();
+  scoped_refptr<Layer> second_grand_child = Layer::Create();
 
   // First put all children under the first parent and set the first host.
   first_parent->AddChild(first_child);
   second_child->AddChild(second_grand_child);
   first_parent->AddChild(second_child);
 
   LayerTreeHostFactory factory;
   scoped_ptr<LayerTreeHost> first_layer_tree_host = factory.Create();
   first_layer_tree_host->SetRootLayer(first_parent.get());
 
@@ skipping 11 matching lines @@
   EXPECT_EQ(second_layer_tree_host.get(), second_child->layer_tree_host());
   EXPECT_EQ(second_layer_tree_host.get(),
             second_grand_child->layer_tree_host());
 
   // Test over, cleanup time.
   first_layer_tree_host->SetRootLayer(nullptr);
   second_layer_tree_host->SetRootLayer(nullptr);
 }
 
 TEST_F(LayerLayerTreeHostTest, ReplaceMaskAndReplicaLayer) {
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> mask = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> replica = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> mask_child = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> replica_child = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> mask_replacement = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> replica_replacement = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> parent = Layer::Create();
+  scoped_refptr<Layer> mask = Layer::Create();
+  scoped_refptr<Layer> replica = Layer::Create();
+  scoped_refptr<Layer> mask_child = Layer::Create();
+  scoped_refptr<Layer> replica_child = Layer::Create();
+  scoped_refptr<Layer> mask_replacement = Layer::Create();
+  scoped_refptr<Layer> replica_replacement = Layer::Create();
 
   parent->SetMaskLayer(mask.get());
   parent->SetReplicaLayer(replica.get());
   mask->AddChild(mask_child);
   replica->AddChild(replica_child);
 
   LayerTreeHostFactory factory;
   scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
   layer_tree_host->SetRootLayer(parent.get());
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(), layer_tree_host.get());
 
   // Replacing the mask should clear out the old mask's subtree's host pointers.
   parent->SetMaskLayer(mask_replacement.get());
   EXPECT_EQ(nullptr, mask->layer_tree_host());
   EXPECT_EQ(nullptr, mask_child->layer_tree_host());
 
   // Same for replacing a replica layer.
   parent->SetReplicaLayer(replica_replacement.get());
   EXPECT_EQ(nullptr, replica->layer_tree_host());
   EXPECT_EQ(nullptr, replica_child->layer_tree_host());
 
   // Test over, cleanup time.
   layer_tree_host->SetRootLayer(nullptr);
 }
 
 TEST_F(LayerLayerTreeHostTest, DestroyHostWithNonNullRootLayer) {
-  scoped_refptr<Layer> root = Layer::Create(layer_settings_);
-  scoped_refptr<Layer> child = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> root = Layer::Create();
+  scoped_refptr<Layer> child = Layer::Create();
   root->AddChild(child);
   LayerTreeHostFactory factory;
   scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
   layer_tree_host->SetRootLayer(root);
 }
 
 TEST_F(LayerTest, SafeOpaqueBackgroundColor) {
   LayerTreeHostFactory factory;
   scoped_ptr<LayerTreeHost> layer_tree_host = factory.Create();
 
-  scoped_refptr<Layer> layer = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> layer = Layer::Create();
   layer_tree_host->SetRootLayer(layer);
 
   for (int contents_opaque = 0; contents_opaque < 2; ++contents_opaque) {
     for (int layer_opaque = 0; layer_opaque < 2; ++layer_opaque) {
       for (int host_opaque = 0; host_opaque < 2; ++host_opaque) {
         layer->SetContentsOpaque(!!contents_opaque);
         layer->SetBackgroundColor(layer_opaque ? SK_ColorRED
                                                : SK_ColorTRANSPARENT);
         layer_tree_host->set_background_color(
             host_opaque ? SK_ColorRED : SK_ColorTRANSPARENT);
@@ skipping 10 matching lines @@
               << "Flags: " << contents_opaque << ", " << layer_opaque << ", "
               << host_opaque << "\n";
         }
       }
     }
   }
 }
 
 class DrawsContentChangeLayer : public Layer {
  public:
-  static scoped_refptr<DrawsContentChangeLayer> Create(
-      const LayerSettings& settings) {
-    return make_scoped_refptr(new DrawsContentChangeLayer(settings));
+  static scoped_refptr<DrawsContentChangeLayer> Create() {
+    return make_scoped_refptr(new DrawsContentChangeLayer());
   }
 
   void SetLayerTreeHost(LayerTreeHost* host) override {
     Layer::SetLayerTreeHost(host);
     SetFakeDrawsContent(!fake_draws_content_);
   }
 
   bool HasDrawableContent() const override {
     return fake_draws_content_ && Layer::HasDrawableContent();
   }
 
   void SetFakeDrawsContent(bool fake_draws_content) {
     fake_draws_content_ = fake_draws_content;
     UpdateDrawsContent(HasDrawableContent());
   }
 
  private:
-  explicit DrawsContentChangeLayer(const LayerSettings& settings)
-      : Layer(settings), fake_draws_content_(false) {}
+  DrawsContentChangeLayer() : Layer(), fake_draws_content_(false) {}
   ~DrawsContentChangeLayer() override {}
 
   bool fake_draws_content_;
 };
 
 TEST_F(LayerTest, DrawsContentChangedInSetLayerTreeHost) {
-  scoped_refptr<Layer> root_layer = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> root_layer = Layer::Create();
   scoped_refptr<DrawsContentChangeLayer> becomes_not_draws_content =
-      DrawsContentChangeLayer::Create(layer_settings_);
+      DrawsContentChangeLayer::Create();
   scoped_refptr<DrawsContentChangeLayer> becomes_draws_content =
-      DrawsContentChangeLayer::Create(layer_settings_);
+      DrawsContentChangeLayer::Create();
   root_layer->SetIsDrawable(true);
   becomes_not_draws_content->SetIsDrawable(true);
   becomes_not_draws_content->SetFakeDrawsContent(true);
   EXPECT_EQ(0, root_layer->NumDescendantsThatDrawContent());
   root_layer->AddChild(becomes_not_draws_content);
   EXPECT_EQ(0, root_layer->NumDescendantsThatDrawContent());
 
   becomes_draws_content->SetIsDrawable(true);
   root_layer->AddChild(becomes_draws_content);
   EXPECT_EQ(1, root_layer->NumDescendantsThatDrawContent());
 }
 
 void ReceiveCopyOutputResult(int* result_count,
                              scoped_ptr<CopyOutputResult> result) {
   ++(*result_count);
 }
 
 TEST_F(LayerTest, DedupesCopyOutputRequestsBySource) {
-  scoped_refptr<Layer> layer = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> layer = Layer::Create();
   int result_count = 0;
 
   // Create identical requests without the source being set, and expect the
   // layer does not abort either one.
   scoped_ptr<CopyOutputRequest> request = CopyOutputRequest::CreateRequest(
       base::Bind(&ReceiveCopyOutputResult, &result_count));
   layer->RequestCopyOfOutput(std::move(request));
   EXPECT_EQ(0, result_count);
   request = CopyOutputRequest::CreateRequest(
       base::Bind(&ReceiveCopyOutputResult, &result_count));
   layer->RequestCopyOfOutput(std::move(request));
   EXPECT_EQ(0, result_count);
 
   // When the layer is destroyed, expect both requests to be aborted.
   layer = nullptr;
   EXPECT_EQ(2, result_count);
 
-  layer = Layer::Create(layer_settings_);
+  layer = Layer::Create();
   result_count = 0;
 
   // Create identical requests, but this time the source is being set.  Expect
   // the first request from |this| source aborts immediately when the second
   // request from |this| source is made.
   int did_receive_first_result_from_this_source = 0;
   request = CopyOutputRequest::CreateRequest(base::Bind(
       &ReceiveCopyOutputResult, &did_receive_first_result_from_this_source));
   request->set_source(this);
   layer->RequestCopyOfOutput(std::move(request));
@@ skipping 25 matching lines @@
 
   // When the layer is destroyed, the other three requests should be aborted.
   layer = nullptr;
   EXPECT_EQ(1, did_receive_first_result_from_this_source);
   EXPECT_EQ(1, did_receive_result_from_different_source);
   EXPECT_EQ(1, did_receive_result_from_anonymous_source);
   EXPECT_EQ(1, did_receive_second_result_from_this_source);
 }
 
 TEST_F(LayerTest, AnimationSchedulesLayerUpdate) {
-  scoped_refptr<Layer> layer = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> layer = Layer::Create();
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(layer));
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsUpdateLayers()).Times(1);
   layer->OnOpacityAnimated(0.5f);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsUpdateLayers()).Times(1);
   gfx::Transform transform;
   transform.Rotate(45.0);
   layer->OnTransformAnimated(transform);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   // Scroll offset animation should not schedule a layer update since it is
   // handled similarly to normal compositor scroll updates.
   EXPECT_CALL(*layer_tree_host_, SetNeedsUpdateLayers()).Times(0);
   layer->OnScrollOffsetAnimated(gfx::ScrollOffset(10, 10));
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 }
 
 TEST_F(LayerTest, RecursiveHierarchySerialization) {
   /* Testing serialization and deserialization of a tree that looks like this:
           root
           /  \
          a    b
                \
                 c
      Layer c also has a mask layer and a replica layer.
   */
-  scoped_refptr<Layer> layer_src_root = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_a = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_b = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_c = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_c_mask = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_c_replica = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_src_root = Layer::Create();
+  scoped_refptr<Layer> layer_src_a = Layer::Create();
+  scoped_refptr<Layer> layer_src_b = Layer::Create();
+  scoped_refptr<Layer> layer_src_c = Layer::Create();
+  scoped_refptr<Layer> layer_src_c_mask = Layer::Create();
+  scoped_refptr<Layer> layer_src_c_replica = Layer::Create();
   layer_src_root->AddChild(layer_src_a);
   layer_src_root->AddChild(layer_src_b);
   layer_src_b->AddChild(layer_src_c);
   layer_src_c->SetMaskLayer(layer_src_c_mask.get());
   layer_src_c->SetReplicaLayer(layer_src_c_replica.get());
 
   proto::LayerNode proto;
   layer_src_root->ToLayerNodeProto(&proto);
 
   Layer::LayerIdMap empty_dest_layer_map;
-  scoped_refptr<Layer> layer_dest_root = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_dest_root = Layer::Create();
   layer_dest_root->FromLayerNodeProto(proto, empty_dest_layer_map);
 
   EXPECT_EQ(layer_src_root->id(), layer_dest_root->id());
   EXPECT_EQ(nullptr, layer_dest_root->parent());
   ASSERT_EQ(2u, layer_dest_root->children().size());
 
   scoped_refptr<Layer> layer_dest_a = layer_dest_root->children()[0];
   EXPECT_EQ(layer_src_a->id(), layer_dest_a->id());
   EXPECT_EQ(layer_src_root->id(), layer_dest_a->parent()->id());
   EXPECT_EQ(0u, layer_dest_a->children().size());
@@ skipping 17 matching lines @@
           root
           /
          a
      The source tree is then updated by adding layer |b|:
           root
           /  \
          a    b
      The deserialization should then re-use the Layers from last
      deserialization.
   */
-  scoped_refptr<Layer> layer_src_root = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_a = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_src_root = Layer::Create();
+  scoped_refptr<Layer> layer_src_a = Layer::Create();
   layer_src_root->AddChild(layer_src_a);
 
   proto::LayerNode root_proto_1;
   layer_src_root->ToLayerNodeProto(&root_proto_1);
 
   Layer::LayerIdMap dest_layer_map_1;
-  scoped_refptr<Layer> layer_dest_root = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_dest_root = Layer::Create();
   layer_dest_root->FromLayerNodeProto(root_proto_1, dest_layer_map_1);
 
   EXPECT_EQ(layer_src_root->id(), layer_dest_root->id());
   ASSERT_EQ(1u, layer_dest_root->children().size());
   scoped_refptr<Layer> layer_dest_a_1 = layer_dest_root->children()[0];
   EXPECT_EQ(layer_src_a->id(), layer_dest_a_1->id());
 
   // Setup new destination layer map.
   Layer::LayerIdMap dest_layer_map_2;
   dest_layer_map_2[layer_dest_root->id()] = layer_dest_root;
   dest_layer_map_2[layer_dest_a_1->id()] = layer_dest_a_1;
 
   // Add Layer |b|.
-  scoped_refptr<Layer> layer_src_b = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_src_b = Layer::Create();
   layer_src_root->AddChild(layer_src_b);
 
   // Second serialization.
   proto::LayerNode root_proto_2;
   layer_src_root->ToLayerNodeProto(&root_proto_2);
 
   // Second deserialization.
   layer_dest_root->FromLayerNodeProto(root_proto_2, dest_layer_map_2);
 
   EXPECT_EQ(layer_src_root->id(), layer_dest_root->id());
@@ skipping 18 matching lines @@
      looks like this:
           root
           /  \
          a    b
                \
                 c
                  \
                   d
      Then the subtree rooted at node |b| is deleted in the next update.
   */
-  scoped_refptr<Layer> layer_src_root = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_a = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_b = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_c = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_d = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_src_root = Layer::Create();
+  scoped_refptr<Layer> layer_src_a = Layer::Create();
+  scoped_refptr<Layer> layer_src_b = Layer::Create();
+  scoped_refptr<Layer> layer_src_c = Layer::Create();
+  scoped_refptr<Layer> layer_src_d = Layer::Create();
   layer_src_root->AddChild(layer_src_a);
   layer_src_root->AddChild(layer_src_b);
   layer_src_b->AddChild(layer_src_c);
   layer_src_c->AddChild(layer_src_d);
 
   // Serialization 1.
   proto::LayerNode proto1;
   layer_src_root->ToLayerNodeProto(&proto1);
 
   // Deserialization 1.
   Layer::LayerIdMap empty_dest_layer_map;
-  scoped_refptr<Layer> layer_dest_root = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_dest_root = Layer::Create();
   layer_dest_root->FromLayerNodeProto(proto1, empty_dest_layer_map);
 
   EXPECT_EQ(layer_src_root->id(), layer_dest_root->id());
   ASSERT_EQ(2u, layer_dest_root->children().size());
   scoped_refptr<Layer> layer_dest_a = layer_dest_root->children()[0];
   scoped_refptr<Layer> layer_dest_b = layer_dest_root->children()[1];
   ASSERT_EQ(1u, layer_dest_b->children().size());
   scoped_refptr<Layer> layer_dest_c = layer_dest_b->children()[0];
   ASSERT_EQ(1u, layer_dest_c->children().size());
   scoped_refptr<Layer> layer_dest_d = layer_dest_c->children()[0];
@@ skipping 10 matching lines @@
   dest_layer_map_2[layer_dest_root->id()] = layer_dest_root;
   dest_layer_map_2[layer_dest_a->id()] = layer_dest_a;
   dest_layer_map_2[layer_dest_b->id()] = layer_dest_b;
   layer_dest_root->FromLayerNodeProto(proto2, dest_layer_map_2);
 
   EXPECT_EQ(0u, layer_dest_a->children().size());
   EXPECT_EQ(0u, layer_dest_b->children().size());
 }
 
 TEST_F(LayerTest, DeleteMaskAndReplicaLayer) {
-  scoped_refptr<Layer> layer_src_root = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_mask = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_replica = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_src_root = Layer::Create();
+  scoped_refptr<Layer> layer_src_mask = Layer::Create();
+  scoped_refptr<Layer> layer_src_replica = Layer::Create();
   layer_src_root->SetMaskLayer(layer_src_mask.get());
   layer_src_root->SetReplicaLayer(layer_src_replica.get());
 
   // Serialization 1.
   proto::LayerNode proto1;
   layer_src_root->ToLayerNodeProto(&proto1);
 
   // Deserialization 1.
   Layer::LayerIdMap dest_layer_map;
-  scoped_refptr<Layer> layer_dest_root = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_dest_root = Layer::Create();
   layer_dest_root->FromLayerNodeProto(proto1, dest_layer_map);
 
   EXPECT_EQ(layer_src_root->id(), layer_dest_root->id());
   ASSERT_TRUE(layer_dest_root->mask_layer());
   ASSERT_TRUE(layer_dest_root->replica_layer());
   EXPECT_EQ(layer_src_root->mask_layer()->id(),
             layer_dest_root->mask_layer()->id());
   // TODO(nyquist): Add test for is_mask_ when PictureLayer is supported.
   EXPECT_EQ(layer_src_root->replica_layer()->id(),
             layer_dest_root->replica_layer()->id());
@@ skipping 54 matching lines @@
   /* Testing serialization of properties for a tree that looks like this:
           root+
           /  \
          a*   b*+[mask:*,replica]
         /      \
        c        d*
      Layers marked with * have changed properties.
      Layers marked with + have descendants with changed properties.
      Layer b also has a mask layer and a replica layer.
   */
-  scoped_refptr<Layer> layer_src_root = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_a = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_b = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_b_mask = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_b_replica = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_c = Layer::Create(LayerSettings());
-  scoped_refptr<Layer> layer_src_d = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_src_root = Layer::Create();
+  scoped_refptr<Layer> layer_src_a = Layer::Create();
+  scoped_refptr<Layer> layer_src_b = Layer::Create();
+  scoped_refptr<Layer> layer_src_b_mask = Layer::Create();
+  scoped_refptr<Layer> layer_src_b_replica = Layer::Create();
+  scoped_refptr<Layer> layer_src_c = Layer::Create();
+  scoped_refptr<Layer> layer_src_d = Layer::Create();
   layer_src_root->AddChild(layer_src_a);
   layer_src_root->AddChild(layer_src_b);
   layer_src_a->AddChild(layer_src_c);
   layer_src_b->AddChild(layer_src_d);
   layer_src_b->SetMaskLayer(layer_src_b_mask.get());
   layer_src_b->SetReplicaLayer(layer_src_b_replica.get());
 
   proto::LayerUpdate layer_update_root;
   // Only layers with descendants that require pushing properties will
   // return true from ToLayerPropertiesProto and AddChild will change the
@@ skipping 82 matching lines @@
   EXPECT_TRUE(dest_d.needs_push_properties());
   EXPECT_EQ(0, dest_d.num_dependents_need_push_properties());
   EXPECT_TRUE(dest_d.has_base());
 
   EXPECT_TRUE(dest_b_mask.needs_push_properties());
   EXPECT_EQ(0, dest_b_mask.num_dependents_need_push_properties());
   EXPECT_TRUE(dest_b_mask.has_base());
 }
 
 TEST_F(LayerSerializationTest, SimplePropertiesDeserialization) {
-  scoped_refptr<Layer> layer = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer = Layer::Create();
   layer->SetLayerTreeHost(layer_tree_host_.get());
   proto::LayerProperties properties;
   properties.set_id(layer->id());
 
   properties.set_needs_push_properties(true);
   properties.set_num_dependents_need_push_properties(2);
   properties.mutable_base();
   layer->FromLayerPropertiesProto(properties);
   EXPECT_TRUE(layer->needs_push_properties());
   EXPECT_TRUE(layer->descendant_needs_push_properties());
@@ skipping 28 matching lines @@
 
 TEST_F(LayerSerializationTest, AllMembersChanged) {
   RunAllMembersChangedTest();
 }
 
 TEST_F(LayerSerializationTest, ScrollAndClipLayers) {
   RunScrollAndClipLayersTest();
 }
 
 TEST_F(LayerTest, ElementIdAndMutablePropertiesArePushed) {
-  scoped_refptr<Layer> test_layer = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> test_layer = Layer::Create();
   scoped_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
                                   layer_tree_host_->SetRootLayer(test_layer));
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(2);
 
   test_layer->SetElementId(2);
   test_layer->SetMutableProperties(MutableProperty::kTransform);
 
   EXPECT_EQ(0lu, impl_layer->element_id());
   EXPECT_EQ(MutableProperty::kNone, impl_layer->mutable_properties());
 
   test_layer->PushPropertiesTo(impl_layer.get());
 
   EXPECT_EQ(2lu, impl_layer->element_id());
   EXPECT_EQ(MutableProperty::kTransform, impl_layer->mutable_properties());
 }
 
 }  // namespace
 }  // namespace cc