CC Animation: Erase cc::LayerSettings everywhere.

cc/layers/layer_proto_converter_unittest.cc

 // Copyright 2015 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_proto_converter.h"
 
 #include "cc/layers/empty_content_layer_client.h"
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/layer.h"
-#include "cc/layers/layer_settings.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/proto/layer.pb.h"
 #include "cc/test/fake_layer_tree_host.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
@@ skipping 20 matching lines @@
 
 TEST_F(LayerProtoConverterTest, TestKeepingRoot) {
   /* Test deserialization of a tree that looks like:
          root
         /   \
        a     b
               \
                c
      The old root node will be reused during deserialization.
   */
-  scoped_refptr<Layer> old_root = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> old_root = Layer::Create();
   proto::LayerNode root_node;
   root_node.set_id(old_root->id());
   root_node.set_type(proto::LayerNode::LAYER);
 
   proto::LayerNode* child_a_node = root_node.add_children();
   child_a_node->set_id(442);
   child_a_node->set_type(proto::LayerNode::LAYER);
   child_a_node->set_parent_id(old_root->id());  // root_node
 
   proto::LayerNode* child_b_node = root_node.add_children();
@@ skipping 75 matching lines @@
   proto::LayerNode* child_b_node = root_node.add_children();
   child_b_node->set_id(443);
   child_b_node->set_type(proto::LayerNode::LAYER);
   child_b_node->set_parent_id(root_node.id());
 
   proto::LayerNode* child_c_node = child_b_node->add_children();
   child_c_node->set_id(444);
   child_c_node->set_type(proto::LayerNode::LAYER);
   child_c_node->set_parent_id(child_b_node->id());
 
-  scoped_refptr<Layer> old_root = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> old_root = Layer::Create();
   scoped_refptr<Layer> new_root =
       LayerProtoConverter::DeserializeLayerHierarchy(old_root, root_node);
 
   // The new root should not be the same as the old root.
   EXPECT_EQ(root_node.id(), new_root->id());
   ASSERT_EQ(2u, new_root->children().size());
   scoped_refptr<Layer> child_a = new_root->children()[0];
   scoped_refptr<Layer> child_b = new_root->children()[1];
 
   EXPECT_EQ(child_a_node->id(), child_a->id());
@@ skipping 10 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;
   LayerProtoConverter::SerializeLayerProperties(layer_src_root.get(),
                                                 &layer_update);
@@ skipping 92 matching lines @@
   /* Testing serialization of properties for a tree that looks like this:
           root+
              \
               b*+[mask:*]
                \
                 c
      Layers marked with * have changed properties.
      Layers marked with + have descendants with changed properties.
      Layer b also has a mask layer.
   */
-  scoped_refptr<Layer> layer_src_root = 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_c = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> layer_src_root = Layer::Create();
+  scoped_refptr<Layer> layer_src_b = Layer::Create();
+  scoped_refptr<Layer> layer_src_b_mask = Layer::Create();
+  scoped_refptr<Layer> layer_src_c = Layer::Create();
   layer_src_root->AddChild(layer_src_b);
   layer_src_b->AddChild(layer_src_c);
   layer_src_b->SetMaskLayer(layer_src_b_mask.get());
 
   proto::LayerUpdate layer_update;
   LayerProtoConverter::SerializeLayerProperties(layer_src_root.get(),
                                                 &layer_update);
   // AddChild changes stacking order of child and we need to push proeprties of
   // child.
   ASSERT_EQ(3, layer_update.layers_size());
@@ skipping 43 matching lines @@
           root*+
           /  \
          a    b+
                \
                 c*
      Layers marked with * have changed properties.
      Layers marked with + have descendants with changed properties.
   */
   proto::LayerUpdate updates;
 
-  scoped_refptr<Layer> root = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> root = Layer::Create();
   root->SetLayerTreeHost(layer_tree_host_.get());
   proto::LayerProperties* root_props = updates.add_layers();
   root_props->set_id(root->id());
   root_props->set_needs_push_properties(true);
   root_props->set_num_dependents_need_push_properties(1);
   root_props->mutable_base();
 
-  scoped_refptr<Layer> a = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> a = Layer::Create();
   a->SetLayerTreeHost(layer_tree_host_.get());
   proto::LayerProperties* a_props = updates.add_layers();
   a_props->set_id(a->id());
   a_props->set_needs_push_properties(false);
   a_props->set_num_dependents_need_push_properties(0);
   root->AddChild(a);
 
-  scoped_refptr<Layer> b = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> b = Layer::Create();
   b->SetLayerTreeHost(layer_tree_host_.get());
   proto::LayerProperties* b_props = updates.add_layers();
   b_props->set_id(b->id());
   b_props->set_needs_push_properties(false);
   b_props->set_num_dependents_need_push_properties(1);
   root->AddChild(b);
 
-  scoped_refptr<Layer> c = Layer::Create(LayerSettings());
+  scoped_refptr<Layer> c = Layer::Create();
   c->SetLayerTreeHost(layer_tree_host_.get());
   proto::LayerProperties* c_props = updates.add_layers();
   c_props->set_id(c->id());
   c_props->set_needs_push_properties(true);
   c_props->set_num_dependents_need_push_properties(0);
   c_props->mutable_base();
   b->AddChild(c);
 
   LayerProtoConverter::DeserializeLayerProperties(root.get(), updates);
 
   EXPECT_TRUE(root->needs_push_properties());
   EXPECT_TRUE(root->descendant_needs_push_properties());
 
   EXPECT_FALSE(a->needs_push_properties());
   EXPECT_FALSE(a->descendant_needs_push_properties());
 
   EXPECT_FALSE(b->needs_push_properties());
   EXPECT_TRUE(b->descendant_needs_push_properties());
 
   EXPECT_TRUE(c->needs_push_properties());
   EXPECT_FALSE(c->descendant_needs_push_properties());
 
   // Recursively clear out LayerTreeHost.
   root->SetLayerTreeHost(nullptr);
 }
 
 TEST_F(LayerProtoConverterTest, PictureLayerTypeSerialization) {
   // Make sure that PictureLayers serialize to the
   // proto::LayerType::PICTURE_LAYER type.
-  scoped_refptr<PictureLayer> layer = PictureLayer::Create(
-      LayerSettings(), EmptyContentLayerClient::GetInstance());
+  scoped_refptr<PictureLayer> layer =
+      PictureLayer::Create(EmptyContentLayerClient::GetInstance());
 
   proto::LayerNode layer_hierarchy;
   LayerProtoConverter::SerializeLayerHierarchy(layer.get(), &layer_hierarchy);
   EXPECT_EQ(proto::LayerNode::PICTURE_LAYER, layer_hierarchy.type());
 }
 
 TEST_F(LayerProtoConverterTest, PictureLayerTypeDeserialization) {
   // Make sure that proto::LayerType::PICTURE_LAYER ends up building a
   // PictureLayer.
-  scoped_refptr<Layer> old_root = PictureLayer::Create(
-      LayerSettings(), EmptyContentLayerClient::GetInstance());
+  scoped_refptr<Layer> old_root =
+      PictureLayer::Create(EmptyContentLayerClient::GetInstance());
   proto::LayerNode root_node;
   root_node.set_id(old_root->id());
   root_node.set_type(proto::LayerNode::PICTURE_LAYER);
 
   scoped_refptr<Layer> new_root =
       LayerProtoConverter::DeserializeLayerHierarchy(old_root, root_node);
 
   // Validate that the ids are equal.
   EXPECT_EQ(old_root->id(), new_root->id());
 
   // Check that the layer type is equal by using the type this layer would
   // serialize to.
   proto::LayerNode layer_node;
   new_root->SetTypeForProtoSerialization(&layer_node);
   EXPECT_EQ(proto::LayerNode::PICTURE_LAYER, layer_node.type());
 }
 
 TEST_F(LayerProtoConverterTest, HudLayerTypeSerialization) {
   // Make sure that PictureLayers serialize to the
   // proto::LayerType::HEADS_UP_DISPLAY_LAYER type.
-  scoped_refptr<HeadsUpDisplayLayer> layer =
-      HeadsUpDisplayLayer::Create(LayerSettings());
+  scoped_refptr<HeadsUpDisplayLayer> layer = HeadsUpDisplayLayer::Create();
 
   proto::LayerNode layer_hierarchy;
   LayerProtoConverter::SerializeLayerHierarchy(layer.get(), &layer_hierarchy);
   EXPECT_EQ(proto::LayerNode::HEADS_UP_DISPLAY_LAYER, layer_hierarchy.type());
 }
 
 TEST_F(LayerProtoConverterTest, HudLayerTypeDeserialization) {
   // Make sure that proto::LayerType::HEADS_UP_DISPLAY_LAYER ends up building a
   // HeadsUpDisplayLayer.
-  scoped_refptr<Layer> old_root = HeadsUpDisplayLayer::Create(LayerSettings());
+  scoped_refptr<Layer> old_root = HeadsUpDisplayLayer::Create();
   proto::LayerNode root_node;
   root_node.set_id(old_root->id());
   root_node.set_type(proto::LayerNode::HEADS_UP_DISPLAY_LAYER);
 
   scoped_refptr<Layer> new_root =
       LayerProtoConverter::DeserializeLayerHierarchy(old_root, root_node);
 
   // Validate that the ids are equal.
   EXPECT_EQ(old_root->id(), new_root->id());
 
   // Check that the layer type is equal by using the type this layer would
   // serialize to.
   proto::LayerNode layer_node;
   new_root->SetTypeForProtoSerialization(&layer_node);
   EXPECT_EQ(proto::LayerNode::HEADS_UP_DISPLAY_LAYER, layer_node.type());
 }
 
 }  // namespace
 }  // namespace cc