cc: Remove unused proto conversion code.

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/threading/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/base/math_util.h"
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/solid_color_scrollbar_layer.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_internals_for_test.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/stub_layer_tree_host_single_thread_client.h"
 #include "cc/test/test_task_graph_runner.h"
@@ skipping 45 matching lines @@
   EXPECT_FALSE(child->subtree_property_changed());                             \
   EXPECT_FALSE(                                                                \
       child->GetLayerTree()->LayerNeedsPushPropertiesForTesting(child.get())); \
   EXPECT_FALSE(grand_child->subtree_property_changed());                       \
   EXPECT_FALSE(                                                                \
       grand_child->GetLayerTree()->LayerNeedsPushPropertiesForTesting(         \
           grand_child.get()));
 
 namespace cc {
 
-// This class is a friend of Layer, and is used as a wrapper for all the tests
-// related to proto serialization. This is done so that it is unnecessary to
-// add FRIEND_TEST_ALL_PREFIXES in //cc/layers/layer.h for all the tests.
-// It is in the cc namespace so that it can be a friend of Layer.
-// The tests still have helpful names, and a test with the name FooBar would
-// have a wrapper method in this class called RunFooBarTest.
-class LayerSerializationTest : public testing::Test {
- protected:
-  void SetUp() override {
-    animation_host_ = AnimationHost::CreateForTesting(ThreadInstance::MAIN);
-    layer_tree_host_ = FakeLayerTreeHost::Create(
-        &fake_client_, &task_graph_runner_, animation_host_.get());
-  }
-
-  void TearDown() override {
-    layer_tree_host_->SetRootLayer(nullptr);
-    layer_tree_host_ = nullptr;
-  }
-
-  // Serializes |src| to proto and back again to a Layer, then verifies that
-  // the two Layers are equal for serialization purposes.
-  void VerifyBaseLayerPropertiesSerializationAndDeserialization(Layer* src) {
-    // This is required to ensure that properties are serialized.
-    src->SetNeedsPushProperties();
-    src->SetLayerTreeHost(layer_tree_host_.get());
-
-    // The following member is reset during serialization, so store the original
-    // values.
-    gfx::Rect update_rect = src->inputs_.update_rect;
-
-    // Serialize |src| to protobuf and read the first entry in the
-    // LayerUpdate. There are no descendants, so the serialization
-    // of |src| is the only entry.
-    proto::LayerUpdate layer_update;
-    src->ToLayerPropertiesProto(&layer_update, false);
-    ASSERT_EQ(1, layer_update.layers_size());
-    proto::LayerProperties props = layer_update.layers(0);
-
-    // The |dest| layer needs to be able to lookup the scroll and clip parents.
-    LayerTree* layer_tree = layer_tree_host_->GetLayerTree();
-    if (src->inputs_.scroll_parent)
-      layer_tree->RegisterLayer(src->inputs_.scroll_parent);
-    if (src->scroll_children_) {
-      for (auto* child : *(src->scroll_children_))
-        layer_tree->RegisterLayer(child);
-    }
-    if (src->inputs_.clip_parent)
-      layer_tree->RegisterLayer(src->inputs_.clip_parent);
-    if (src->clip_children_) {
-      for (auto* child : *(src->clip_children_))
-        layer_tree->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();
-    dest->inputs_.layer_id = src->inputs_.layer_id;
-    dest->SetLayerTreeHost(layer_tree_host_.get());
-    dest->FromLayerPropertiesProto(props);
-
-    // Verify that both layers are equal.
-    EXPECT_EQ(src->inputs_.transform_origin, dest->inputs_.transform_origin);
-    EXPECT_EQ(src->inputs_.background_color, dest->inputs_.background_color);
-    EXPECT_EQ(src->inputs_.bounds, dest->inputs_.bounds);
-    EXPECT_EQ(src->transform_tree_index_, dest->transform_tree_index_);
-    EXPECT_EQ(src->effect_tree_index_, dest->effect_tree_index_);
-    EXPECT_EQ(src->clip_tree_index_, dest->clip_tree_index_);
-    EXPECT_EQ(src->offset_to_transform_parent_,
-              dest->offset_to_transform_parent_);
-    EXPECT_EQ(src->inputs_.double_sided, dest->inputs_.double_sided);
-    EXPECT_EQ(src->draws_content_, dest->draws_content_);
-    EXPECT_EQ(src->may_contain_video_, dest->may_contain_video_);
-    EXPECT_EQ(src->inputs_.hide_layer_and_subtree,
-              dest->inputs_.hide_layer_and_subtree);
-    EXPECT_EQ(src->inputs_.masks_to_bounds, dest->inputs_.masks_to_bounds);
-    EXPECT_EQ(src->inputs_.main_thread_scrolling_reasons,
-              dest->inputs_.main_thread_scrolling_reasons);
-    EXPECT_EQ(src->inputs_.non_fast_scrollable_region,
-              dest->inputs_.non_fast_scrollable_region);
-    EXPECT_EQ(src->inputs_.touch_event_handler_region,
-              dest->inputs_.touch_event_handler_region);
-    EXPECT_EQ(src->inputs_.contents_opaque, dest->inputs_.contents_opaque);
-    EXPECT_EQ(src->inputs_.opacity, dest->inputs_.opacity);
-    EXPECT_EQ(src->inputs_.blend_mode, dest->inputs_.blend_mode);
-    EXPECT_EQ(src->inputs_.is_root_for_isolated_group,
-              dest->inputs_.is_root_for_isolated_group);
-    EXPECT_EQ(src->inputs_.position, dest->inputs_.position);
-    EXPECT_EQ(src->inputs_.is_container_for_fixed_position_layers,
-              dest->inputs_.is_container_for_fixed_position_layers);
-    EXPECT_EQ(src->inputs_.position_constraint,
-              dest->inputs_.position_constraint);
-    EXPECT_EQ(src->inputs_.should_flatten_transform,
-              dest->inputs_.should_flatten_transform);
-    EXPECT_EQ(src->should_flatten_transform_from_property_tree_,
-              dest->should_flatten_transform_from_property_tree_);
-    EXPECT_EQ(src->draw_blend_mode_, dest->draw_blend_mode_);
-    EXPECT_EQ(src->inputs_.use_parent_backface_visibility,
-              dest->inputs_.use_parent_backface_visibility);
-    EXPECT_EQ(src->inputs_.transform, dest->inputs_.transform);
-    EXPECT_EQ(src->inputs_.sorting_context_id,
-              dest->inputs_.sorting_context_id);
-    EXPECT_EQ(src->num_descendants_that_draw_content_,
-              dest->num_descendants_that_draw_content_);
-    EXPECT_EQ(src->inputs_.scroll_clip_layer_id,
-              dest->inputs_.scroll_clip_layer_id);
-    EXPECT_EQ(src->inputs_.user_scrollable_horizontal,
-              dest->inputs_.user_scrollable_horizontal);
-    EXPECT_EQ(src->inputs_.user_scrollable_vertical,
-              dest->inputs_.user_scrollable_vertical);
-    EXPECT_EQ(src->inputs_.scroll_offset, dest->inputs_.scroll_offset);
-    EXPECT_EQ(update_rect, dest->inputs_.update_rect);
-
-    if (src->inputs_.scroll_parent) {
-      ASSERT_TRUE(dest->inputs_.scroll_parent);
-      EXPECT_EQ(src->inputs_.scroll_parent->id(),
-                dest->inputs_.scroll_parent->id());
-    } else {
-      EXPECT_FALSE(dest->inputs_.scroll_parent);
-    }
-    if (src->scroll_children_) {
-      ASSERT_TRUE(dest->scroll_children_);
-      EXPECT_EQ(*(src->scroll_children_), *(dest->scroll_children_));
-    } else {
-      EXPECT_FALSE(dest->scroll_children_);
-    }
-
-    if (src->inputs_.clip_parent) {
-      ASSERT_TRUE(dest->inputs_.clip_parent);
-      EXPECT_EQ(src->inputs_.clip_parent->id(),
-                dest->inputs_.clip_parent->id());
-    } else {
-      ASSERT_FALSE(dest->inputs_.clip_parent);
-    }
-    if (src->clip_children_) {
-      ASSERT_TRUE(dest->clip_children_);
-      EXPECT_EQ(*(src->clip_children_), *(dest->clip_children_));
-    } else {
-      EXPECT_FALSE(dest->clip_children_);
-    }
-
-    // The following member should have been reset during serialization.
-    EXPECT_EQ(gfx::Rect(), src->inputs_.update_rect);
-
-    // Before deleting |dest|, the LayerTreeHost must be unset.
-    dest->SetLayerTreeHost(nullptr);
-
-    // Cleanup scroll tree.
-    if (src->inputs_.scroll_parent)
-      layer_tree->UnregisterLayer(src->inputs_.scroll_parent);
-    src->inputs_.scroll_parent = nullptr;
-    dest->inputs_.scroll_parent = nullptr;
-    if (src->scroll_children_) {
-      for (auto* child : *(src->scroll_children_))
-        layer_tree->UnregisterLayer(child);
-      src->scroll_children_.reset();
-      dest->scroll_children_.reset();
-    }
-
-    // Cleanup clip tree.
-    if (src->inputs_.clip_parent)
-      layer_tree->UnregisterLayer(src->inputs_.clip_parent);
-    src->inputs_.clip_parent = nullptr;
-    dest->inputs_.clip_parent = nullptr;
-    if (src->clip_children_) {
-      for (auto* child : *(src->clip_children_))
-        layer_tree->UnregisterLayer(child);
-      src->clip_children_.reset();
-      dest->clip_children_.reset();
-    }
-  }
-
-  void RunNoMembersChangedTest() {
-    scoped_refptr<Layer> layer = Layer::Create();
-    VerifyBaseLayerPropertiesSerializationAndDeserialization(layer.get());
-  }
-
-  void RunArbitraryMembersChangedTest() {
-    scoped_refptr<Layer> layer = Layer::Create();
-    layer->inputs_.transform_origin = gfx::Point3F(3.0f, 1.0f, 4.0f);
-    layer->inputs_.background_color = SK_ColorRED;
-    layer->inputs_.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->inputs_.double_sided = true;
-    layer->draws_content_ = true;
-    layer->may_contain_video_ = true;
-    layer->inputs_.hide_layer_and_subtree = false;
-    layer->inputs_.masks_to_bounds = true;
-    layer->inputs_.main_thread_scrolling_reasons =
-        MainThreadScrollingReason::kNotScrollingOnMain;
-    layer->inputs_.non_fast_scrollable_region = Region(gfx::Rect(5, 1, 14, 3));
-    layer->inputs_.touch_event_handler_region = Region(gfx::Rect(3, 14, 1, 5));
-    layer->inputs_.contents_opaque = true;
-    layer->inputs_.opacity = 1.f;
-    layer->inputs_.blend_mode = SkXfermode::kSrcOver_Mode;
-    layer->inputs_.is_root_for_isolated_group = true;
-    layer->inputs_.position = gfx::PointF(3.14f, 6.28f);
-    layer->inputs_.is_container_for_fixed_position_layers = true;
-    LayerPositionConstraint pos_con;
-    pos_con.set_is_fixed_to_bottom_edge(true);
-    layer->inputs_.position_constraint = pos_con;
-    layer->inputs_.should_flatten_transform = true;
-    layer->should_flatten_transform_from_property_tree_ = true;
-    layer->draw_blend_mode_ = SkXfermode::kSrcOut_Mode;
-    layer->inputs_.use_parent_backface_visibility = true;
-    gfx::Transform transform;
-    transform.Rotate(90);
-    layer->inputs_.transform = transform;
-    layer->inputs_.sorting_context_id = 0;
-    layer->num_descendants_that_draw_content_ = 5;
-    layer->inputs_.scroll_clip_layer_id = Layer::INVALID_ID;
-    layer->inputs_.user_scrollable_horizontal = false;
-    layer->inputs_.user_scrollable_vertical = true;
-    layer->inputs_.scroll_offset = gfx::ScrollOffset(3, 14);
-    layer->inputs_.update_rect = gfx::Rect(14, 15);
-
-    VerifyBaseLayerPropertiesSerializationAndDeserialization(layer.get());
-  }
-
-  void RunAllMembersChangedTest() {
-    scoped_refptr<Layer> layer = Layer::Create();
-    layer->inputs_.transform_origin = gfx::Point3F(3.0f, 1.0f, 4.0f);
-    layer->inputs_.background_color = SK_ColorRED;
-    layer->inputs_.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->inputs_.double_sided = !layer->inputs_.double_sided;
-    layer->draws_content_ = !layer->draws_content_;
-    layer->may_contain_video_ = !layer->may_contain_video_;
-    layer->inputs_.hide_layer_and_subtree =
-        !layer->inputs_.hide_layer_and_subtree;
-    layer->inputs_.masks_to_bounds = !layer->inputs_.masks_to_bounds;
-    layer->inputs_.main_thread_scrolling_reasons =
-        MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects;
-    layer->inputs_.non_fast_scrollable_region = Region(gfx::Rect(5, 1, 14, 3));
-    layer->inputs_.touch_event_handler_region = Region(gfx::Rect(3, 14, 1, 5));
-    layer->inputs_.contents_opaque = !layer->inputs_.contents_opaque;
-    layer->inputs_.opacity = 3.14f;
-    layer->inputs_.blend_mode = SkXfermode::kSrcIn_Mode;
-    layer->inputs_.is_root_for_isolated_group =
-        !layer->inputs_.is_root_for_isolated_group;
-    layer->inputs_.position = gfx::PointF(3.14f, 6.28f);
-    layer->inputs_.is_container_for_fixed_position_layers =
-        !layer->inputs_.is_container_for_fixed_position_layers;
-    LayerPositionConstraint pos_con;
-    pos_con.set_is_fixed_to_bottom_edge(true);
-    layer->inputs_.position_constraint = pos_con;
-    layer->inputs_.should_flatten_transform =
-        !layer->inputs_.should_flatten_transform;
-    layer->should_flatten_transform_from_property_tree_ =
-        !layer->should_flatten_transform_from_property_tree_;
-    layer->draw_blend_mode_ = SkXfermode::kSrcOut_Mode;
-    layer->inputs_.use_parent_backface_visibility =
-        !layer->inputs_.use_parent_backface_visibility;
-    gfx::Transform transform;
-    transform.Rotate(90);
-    layer->inputs_.transform = transform;
-    layer->inputs_.sorting_context_id = 42;
-    layer->num_descendants_that_draw_content_ = 5;
-    layer->inputs_.scroll_clip_layer_id = 17;
-    layer->inputs_.user_scrollable_horizontal =
-        !layer->inputs_.user_scrollable_horizontal;
-    layer->inputs_.user_scrollable_vertical =
-        !layer->inputs_.user_scrollable_vertical;
-    layer->inputs_.scroll_offset = gfx::ScrollOffset(3, 14);
-    layer->inputs_.update_rect = gfx::Rect(14, 15);
-
-    VerifyBaseLayerPropertiesSerializationAndDeserialization(layer.get());
-  }
-
-  void VerifySolidColorScrollbarLayerAfterSerializationAndDeserialization(
-      scoped_refptr<SolidColorScrollbarLayer> source_scrollbar) {
-    proto::LayerNode serialized_scrollbar_node;
-    source_scrollbar->ToLayerNodeProto(&serialized_scrollbar_node);
-
-    scoped_refptr<SolidColorScrollbarLayer> deserialized_scrollbar =
-        SolidColorScrollbarLayer::Create(ScrollbarOrientation::HORIZONTAL, -1,
-                                         -1, false, Layer::INVALID_ID);
-    deserialized_scrollbar->inputs_.layer_id =
-        source_scrollbar->inputs_.layer_id;
-
-    // FromLayerSpecificPropertiesProto expects a non-null LayerTreeHost to be
-    // set.
-    Layer::LayerIdMap layer_map;
-    deserialized_scrollbar->FromLayerNodeProto(
-        serialized_scrollbar_node, layer_map, layer_tree_host_.get());
-
-    EXPECT_EQ(source_scrollbar->solid_color_scrollbar_layer_inputs_.track_start,
-              deserialized_scrollbar->solid_color_scrollbar_layer_inputs_
-                  .track_start);
-    EXPECT_EQ(
-        source_scrollbar->solid_color_scrollbar_layer_inputs_.thumb_thickness,
-        deserialized_scrollbar->solid_color_scrollbar_layer_inputs_
-            .thumb_thickness);
-    EXPECT_EQ(
-        source_scrollbar->solid_color_scrollbar_layer_inputs_.scroll_layer_id,
-        deserialized_scrollbar->solid_color_scrollbar_layer_inputs_
-            .scroll_layer_id);
-    EXPECT_EQ(source_scrollbar->solid_color_scrollbar_layer_inputs_
-                  .is_left_side_vertical_scrollbar,
-              deserialized_scrollbar->solid_color_scrollbar_layer_inputs_
-                  .is_left_side_vertical_scrollbar);
-    EXPECT_EQ(source_scrollbar->solid_color_scrollbar_layer_inputs_.orientation,
-              deserialized_scrollbar->solid_color_scrollbar_layer_inputs_
-                  .orientation);
-
-    deserialized_scrollbar->SetLayerTreeHost(nullptr);
-  }
-
-  void RunScrollAndClipLayersTest() {
-    scoped_refptr<Layer> layer = Layer::Create();
-
-    scoped_refptr<Layer> scroll_parent = Layer::Create();
-    layer->inputs_.scroll_parent = scroll_parent.get();
-    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();
-    layer->inputs_.clip_parent = clip_parent.get();
-    layer->clip_children_.reset(new std::set<Layer*>);
-    scoped_refptr<Layer> clip_child1 = Layer::Create();
-    layer->clip_children_->insert(clip_child1.get());
-    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();
-    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();
-
-    layer_dest_root->FromLayerNodeProto(proto, empty_dest_layer_map,
-                                        layer_tree_host_.get());
-
-    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());
-    EXPECT_EQ(layer_tree_host_.get(), layer_dest_root->layer_tree_host_);
-
-    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(1u, layer_dest_a->children().size());
-    EXPECT_EQ(layer_tree_host_.get(), layer_dest_a->layer_tree_host_);
-
-    scoped_refptr<Layer> layer_dest_b = layer_dest_a->children()[0];
-    EXPECT_EQ(layer_src_b->id(), layer_dest_b->id());
-    EXPECT_EQ(layer_src_a->id(), layer_dest_b->parent()->id());
-    ASSERT_EQ(1u, layer_dest_b->children().size());
-    EXPECT_EQ(layer_tree_host_.get(), layer_dest_b->layer_tree_host_);
-
-    scoped_refptr<Layer> layer_dest_c = layer_dest_b->children()[0];
-    EXPECT_EQ(layer_src_c->id(), layer_dest_c->id());
-    EXPECT_EQ(layer_src_b->id(), layer_dest_c->parent()->id());
-    EXPECT_EQ(0u, layer_dest_c->children().size());
-    EXPECT_EQ(layer_tree_host_.get(), layer_dest_c->layer_tree_host_);
-
-    // The layers have not been added to the LayerTreeHost layer map, so the
-    // LTH pointers must be cleared manually.
-    layer_dest_root->layer_tree_host_ = nullptr;
-    layer_dest_a->layer_tree_host_ = nullptr;
-    layer_dest_b->layer_tree_host_ = nullptr;
-    layer_dest_c->layer_tree_host_ = nullptr;
-  }
-
-  void RunNonDestructiveDeserializationBaseCaseTest() {
-    /* 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();
-    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;
-    layer_root->ClearLayerTreePropertiesForDeserializationAndAddToMap(
-        &dest_layer_map);
-    layer_root->FromLayerNodeProto(root_proto, dest_layer_map,
-                                   layer_tree_host_.get());
-
-    EXPECT_EQ(33, layer_root->transform_tree_index_);
-    ASSERT_EQ(1u, layer_root->children().size());
-    scoped_refptr<Layer> layer_dest_a = layer_root->children()[0];
-    EXPECT_EQ(layer_src_a, layer_dest_a);
-    EXPECT_EQ(42, layer_dest_a->transform_tree_index_);
-
-    // Clear the reference to the LTH for all the layers.
-    layer_root->SetLayerTreeHost(nullptr);
-  }
-
-  void RunNonDestructiveDeserializationReorderChildrenTest() {
-    /* Testing serialization and deserialization of a tree that initially looks
-       like this:
-            root
-            /  \
-           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();
-    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();
-    layer_dest_root->FromLayerNodeProto(root_proto_1, dest_layer_map,
-                                        layer_tree_host_.get());
-
-    // 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.
-    scoped_refptr<Layer> tmp_a = layer_src_root->inputs_.children[0];
-    layer_src_root->inputs_.children[0] = layer_src_root->inputs_.children[1];
-    layer_src_root->inputs_.children[1] = tmp_a;
-
-    // Fake the fact that the destination layers have valid indexes.
-    layer_dest_root->transform_tree_index_ = 33;
-    layer_dest_a->transform_tree_index_ = 42;
-    layer_dest_b->transform_tree_index_ = 24;
-
-    // Now serialize and deserialize again.
-    proto::LayerNode root_proto_2;
-    layer_src_root->ToLayerNodeProto(&root_proto_2);
-    layer_dest_root->ClearLayerTreePropertiesForDeserializationAndAddToMap(
-        &dest_layer_map);
-    layer_dest_root->FromLayerNodeProto(root_proto_2, dest_layer_map,
-                                        layer_tree_host_.get());
-
-    // Ensure second copy is correct.
-    EXPECT_EQ(33, layer_dest_root->transform_tree_index_);
-    ASSERT_EQ(2u, layer_dest_root->children().size());
-    layer_dest_b = layer_dest_root->children()[0];
-    EXPECT_EQ(layer_src_b->id(), layer_dest_b->id());
-    EXPECT_EQ(24, layer_dest_b->transform_tree_index_);
-    layer_dest_a = layer_dest_root->children()[1];
-    EXPECT_EQ(layer_src_a->id(), layer_dest_a->id());
-    EXPECT_EQ(42, layer_dest_a->transform_tree_index_);
-
-    layer_dest_root->SetLayerTreeHost(nullptr);
-  }
-
-  void RunNonDestructiveDeserializationAddChildTest() {
-    /* Testing serialization and deserialization of a tree that initially looks
-       like this:
-            root
-            /
-           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();
-    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();
-    layer_dest_root->FromLayerNodeProto(root_proto_1, dest_layer_map,
-                                        layer_tree_host_.get());
-
-    // 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();
-    layer_src_root->AddChild(layer_src_b);
-
-    // Now serialize and deserialize again.
-    proto::LayerNode root_proto_2;
-    layer_src_root->ToLayerNodeProto(&root_proto_2);
-    layer_dest_root->ClearLayerTreePropertiesForDeserializationAndAddToMap(
-        &dest_layer_map);
-    layer_dest_root->FromLayerNodeProto(root_proto_2, dest_layer_map,
-                                        layer_tree_host_.get());
-
-    // Ensure second copy is correct.
-    EXPECT_EQ(33, layer_dest_root->transform_tree_index_);
-    ASSERT_EQ(2u, layer_dest_root->children().size());
-    layer_dest_a = layer_dest_root->children()[0];
-    EXPECT_EQ(layer_src_a->id(), layer_dest_a->id());
-    EXPECT_EQ(42, layer_dest_a->transform_tree_index_);
-    scoped_refptr<Layer> layer_dest_b = layer_dest_root->children()[1];
-    EXPECT_EQ(layer_src_b->id(), layer_dest_b->id());
-
-    layer_dest_root->SetLayerTreeHost(nullptr);
-  }
-
-  void RunNonDestructiveDeserializationRemoveChildTest() {
-    /* Testing serialization and deserialization of a tree that initially looks
-       like this:
-            root
-            /  \
-           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();
-    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();
-    layer_dest_root->FromLayerNodeProto(root_proto_1, dest_layer_map,
-                                        layer_tree_host_.get());
-
-    // 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.
-    layer_src_b->RemoveFromParent();
-
-    // Fake the fact that the destination layers have valid indexes.
-    layer_dest_root->transform_tree_index_ = 33;
-    layer_dest_a->transform_tree_index_ = 42;
-    layer_dest_b->transform_tree_index_ = 24;
-
-    // Now serialize and deserialize again.
-    proto::LayerNode root_proto_2;
-    layer_src_root->ToLayerNodeProto(&root_proto_2);
-    layer_dest_root->ClearLayerTreePropertiesForDeserializationAndAddToMap(
-        &dest_layer_map);
-    layer_dest_root->FromLayerNodeProto(root_proto_2, dest_layer_map,
-                                        layer_tree_host_.get());
-
-    // Ensure second copy is correct.
-    EXPECT_EQ(33, layer_dest_root->transform_tree_index_);
-    ASSERT_EQ(1u, layer_dest_root->children().size());
-    layer_dest_a = layer_dest_root->children()[0];
-    EXPECT_EQ(layer_src_a->id(), layer_dest_a->id());
-    EXPECT_EQ(42, layer_dest_a->transform_tree_index_);
-
-    layer_dest_root->SetLayerTreeHost(nullptr);
-  }
-
-  void RunNonDestructiveDeserializationMoveChildEarlierTest() {
-    /* Testing serialization and deserialization of a tree that initially looks
-       like this:
-            root
-            /   \
-           a     b
-                  \
-                   c
-       The |c| child of |b| is then moved to become a child of |a|:
-            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();
-    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();
-    layer_dest_root->FromLayerNodeProto(root_proto_1, dest_layer_map,
-                                        layer_tree_host_.get());
-
-    // 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];
-    EXPECT_EQ(layer_src_c->id(), layer_dest_c->id());
-
-    // Move child |c| from |b| to |a|.
-    layer_src_c->RemoveFromParent();
-    layer_src_a->AddChild(layer_src_c);
-
-    // Moving a child invalidates the |transform_tree_index_|, so forcefully
-    // set it afterwards on the destination layer.
-    layer_dest_root->transform_tree_index_ = 33;
-    layer_dest_a->transform_tree_index_ = 42;
-    layer_dest_b->transform_tree_index_ = 24;
-    layer_dest_c->transform_tree_index_ = 99;
-
-    // Now serialize and deserialize again.
-    proto::LayerNode root_proto_2;
-    layer_src_root->ToLayerNodeProto(&root_proto_2);
-    layer_dest_root->ClearLayerTreePropertiesForDeserializationAndAddToMap(
-        &dest_layer_map);
-    layer_dest_root->FromLayerNodeProto(root_proto_2, dest_layer_map,
-                                        layer_tree_host_.get());
-
-    // Ensure second copy is correct.
-    EXPECT_EQ(33, layer_dest_root->transform_tree_index_);
-    ASSERT_EQ(2u, layer_dest_root->children().size());
-    layer_dest_a = layer_dest_root->children()[0];
-    layer_dest_b = layer_dest_root->children()[1];
-    EXPECT_EQ(layer_src_a->id(), layer_dest_a->id());
-    EXPECT_EQ(42, layer_dest_a->transform_tree_index_);
-    EXPECT_EQ(layer_src_b->id(), layer_dest_b->id());
-    EXPECT_EQ(24, layer_dest_b->transform_tree_index_);
-    ASSERT_EQ(1u, layer_dest_a->children().size());
-    layer_dest_c = layer_dest_a->children()[0];
-    EXPECT_EQ(layer_src_c->id(), layer_dest_c->id());
-    EXPECT_EQ(99, layer_dest_c->transform_tree_index_);
-
-    layer_dest_root->SetLayerTreeHost(nullptr);
-  }
-
-  void RunNonDestructiveDeserializationMoveChildLaterTest() {
-    /* Testing serialization and deserialization of a tree that initially looks
-       like this:
-            root
-           /    \
-          a      b
-         /
-        c
-       The |c| child of |a| is then moved to become a child of |b|:
-            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();
-    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();
-    layer_dest_root->FromLayerNodeProto(root_proto_1, dest_layer_map,
-                                        layer_tree_host_.get());
-
-    // 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];
-    EXPECT_EQ(layer_src_c->id(), layer_dest_c->id());
-
-    // Move child |c| from |b| to |a|.
-    layer_src_c->RemoveFromParent();
-    layer_src_b->AddChild(layer_src_c);
-
-    // Moving a child invalidates the |transform_tree_index_|, so forcefully
-    // set it afterwards on the destination layer.
-    layer_dest_root->transform_tree_index_ = 33;
-    layer_dest_a->transform_tree_index_ = 42;
-    layer_dest_b->transform_tree_index_ = 24;
-    layer_dest_c->transform_tree_index_ = 99;
-
-    // Now serialize and deserialize again.
-    proto::LayerNode root_proto_2;
-    layer_src_root->ToLayerNodeProto(&root_proto_2);
-    layer_dest_root->ClearLayerTreePropertiesForDeserializationAndAddToMap(
-        &dest_layer_map);
-    layer_dest_root->FromLayerNodeProto(root_proto_2, dest_layer_map,
-                                        layer_tree_host_.get());
-
-    // Ensure second copy is correct.
-    EXPECT_EQ(33, layer_dest_root->transform_tree_index_);
-    ASSERT_EQ(2u, layer_dest_root->children().size());
-    layer_dest_a = layer_dest_root->children()[0];
-    layer_dest_b = layer_dest_root->children()[1];
-    EXPECT_EQ(layer_src_a->id(), layer_dest_a->id());
-    EXPECT_EQ(42, layer_dest_a->transform_tree_index_);
-    EXPECT_EQ(layer_src_b->id(), layer_dest_b->id());
-    EXPECT_EQ(24, layer_dest_b->transform_tree_index_);
-    ASSERT_EQ(1u, layer_dest_b->children().size());
-    layer_dest_c = layer_dest_b->children()[0];
-    EXPECT_EQ(layer_src_c->id(), layer_dest_c->id());
-    EXPECT_EQ(99, layer_dest_c->transform_tree_index_);
-
-    layer_dest_root->SetLayerTreeHost(nullptr);
-  }
-
-  TestTaskGraphRunner task_graph_runner_;
-  FakeLayerTreeHostClient fake_client_;
-  std::unique_ptr<AnimationHost> animation_host_;
-  std::unique_ptr<FakeLayerTreeHost> layer_tree_host_;
-};
-
 namespace {
 
 class MockLayerTree : public LayerTree {
  public:
   MockLayerTree(LayerTreeHostInProcess::InitParams* params,
                 LayerTreeHost* layer_tree_host)
       : LayerTree(params->mutator_host, layer_tree_host) {}
   ~MockLayerTree() override {}
 
   MOCK_METHOD0(SetNeedsFullTreeSync, void());
@@ skipping 1308 matching lines @@
   layer_internals.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_internals.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.
-  */
-  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();
-  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());
-
-  proto::LayerNode proto;
-  layer_src_root->ToLayerNodeProto(&proto);
-
-  Layer::LayerIdMap empty_dest_layer_map;
-  scoped_refptr<Layer> layer_dest_root = Layer::Create();
-  layer_dest_root->FromLayerNodeProto(proto, empty_dest_layer_map,
-                                      layer_tree_host_.get());
-
-  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());
-
-  scoped_refptr<Layer> layer_dest_b = layer_dest_root->children()[1];
-  EXPECT_EQ(layer_src_b->id(), layer_dest_b->id());
-  EXPECT_EQ(layer_src_root->id(), layer_dest_b->parent()->id());
-  ASSERT_EQ(1u, layer_dest_b->children().size());
-
-  scoped_refptr<Layer> layer_dest_c = layer_dest_b->children()[0];
-  EXPECT_EQ(layer_src_c->id(), layer_dest_c->id());
-  EXPECT_EQ(layer_src_b->id(), layer_dest_c->parent()->id());
-  EXPECT_EQ(0u, layer_dest_c->children().size());
-  EXPECT_EQ(layer_src_c_mask->id(), layer_dest_c->mask_layer()->id());
-
-  layer_dest_root->SetLayerTreeHost(nullptr);
-}
-
-TEST_F(LayerTest, RecursiveHierarchySerializationWithNodeReuse) {
-  /* Testing serialization and deserialization of a tree that initially looks
-     like this:
-          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();
-  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();
-  layer_dest_root->FromLayerNodeProto(root_proto_1, dest_layer_map_1,
-                                      layer_tree_host_.get());
-
-  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;
-  layer_dest_root->ClearLayerTreePropertiesForDeserializationAndAddToMap(
-      &dest_layer_map_2);
-
-  // Add Layer |b|.
-  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,
-                                      layer_tree_host_.get());
-
-  EXPECT_EQ(layer_src_root->id(), layer_dest_root->id());
-  ASSERT_EQ(2u, layer_dest_root->children().size());
-
-  scoped_refptr<Layer> layer_dest_a_2 = layer_dest_root->children()[0];
-  EXPECT_EQ(layer_src_a->id(), layer_dest_a_2->id());
-  EXPECT_EQ(layer_src_root->id(), layer_dest_a_2->parent()->id());
-  EXPECT_EQ(0u, layer_dest_a_2->children().size());
-
-  scoped_refptr<Layer> layer_dest_b_2 = layer_dest_root->children()[1];
-  EXPECT_EQ(layer_src_b->id(), layer_dest_b_2->id());
-  EXPECT_EQ(layer_src_root->id(), layer_dest_b_2->parent()->id());
-  EXPECT_EQ(0u, layer_dest_b_2->children().size());
-
-  // Layer |a| should be the same.
-  EXPECT_EQ(layer_dest_a_1.get(), layer_dest_a_2.get());
-
-  layer_dest_root->SetLayerTreeHost(nullptr);
-}
-
-TEST_F(LayerTest, DeletingSubtreeDeletesLayers) {
-  /* Testing serialization and deserialization of a tree that initially
-     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();
-  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();
-  layer_dest_root->FromLayerNodeProto(proto1, empty_dest_layer_map,
-                                      layer_tree_host_.get());
-
-  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];
-
-  // Delete the Layer |b| subtree.
-  layer_src_b->RemoveAllChildren();
-
-  // Serialization 2.
-  proto::LayerNode proto2;
-  layer_src_root->ToLayerNodeProto(&proto2);
-
-  // Deserialization 2.
-  Layer::LayerIdMap dest_layer_map_2;
-  layer_dest_root->ClearLayerTreePropertiesForDeserializationAndAddToMap(
-      &dest_layer_map_2);
-  layer_dest_root->FromLayerNodeProto(proto2, dest_layer_map_2,
-                                      layer_tree_host_.get());
-
-  EXPECT_EQ(0u, layer_dest_a->children().size());
-  EXPECT_EQ(0u, layer_dest_b->children().size());
-
-  layer_dest_root->SetLayerTreeHost(nullptr);
-}
-
-TEST_F(LayerTest, DeleteMaskLayer) {
-  scoped_refptr<Layer> layer_src_root = Layer::Create();
-  scoped_refptr<Layer> layer_src_mask = Layer::Create();
-  layer_src_root->SetMaskLayer(layer_src_mask.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();
-  layer_dest_root->FromLayerNodeProto(proto1, dest_layer_map,
-                                      layer_tree_host_.get());
-
-  EXPECT_EQ(layer_src_root->id(), layer_dest_root->id());
-  ASSERT_TRUE(layer_dest_root->mask_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.
-
-  // Clear mask layer.
-  layer_src_root->mask_layer()->RemoveFromParent();
-
-  // Serialization 2.
-  proto::LayerNode proto2;
-  layer_src_root->ToLayerNodeProto(&proto2);
-
-  // Deserialization 2.
-  layer_dest_root->ClearLayerTreePropertiesForDeserializationAndAddToMap(
-      &dest_layer_map);
-  layer_dest_root->FromLayerNodeProto(proto2, dest_layer_map,
-                                      layer_tree_host_.get());
-
-  EXPECT_EQ(nullptr, layer_dest_root->mask_layer());
-
-  layer_dest_root->SetLayerTreeHost(nullptr);
-}
-
-TEST_F(LayerSerializationTest, HierarchyDeserializationWithLayerTreeHost) {
-  RunHierarchyDeserializationWithLayerTreeHostTest();
-}
-
-TEST_F(LayerSerializationTest, NonDestructiveDeserializationBaseCase) {
-  RunNonDestructiveDeserializationBaseCaseTest();
-}
-
-TEST_F(LayerSerializationTest, NonDestructiveDeserializationReorderChildren) {
-  RunNonDestructiveDeserializationReorderChildrenTest();
-}
-
-TEST_F(LayerSerializationTest, NonDestructiveDeserializationAddChild) {
-  RunNonDestructiveDeserializationAddChildTest();
-}
-
-TEST_F(LayerSerializationTest, NonDestructiveDeserializationRemoveChild) {
-  RunNonDestructiveDeserializationRemoveChildTest();
-}
-
-TEST_F(LayerSerializationTest,
-       NonDestructiveDeserializationMoveChildEarlierTest) {
-  RunNonDestructiveDeserializationMoveChildEarlierTest();
-}
-
-TEST_F(LayerSerializationTest,
-       NonDestructiveDeserializationMoveChildLaterTest) {
-  RunNonDestructiveDeserializationMoveChildLaterTest();
-}
-
-TEST_F(LayerSerializationTest, NoMembersChanged) {
-  RunNoMembersChangedTest();
-}
-
-TEST_F(LayerSerializationTest, ArbitraryMembersChanged) {
-  RunArbitraryMembersChangedTest();
-}
-
-TEST_F(LayerSerializationTest, AllMembersChanged) {
-  RunAllMembersChangedTest();
-}
-
-TEST_F(LayerSerializationTest, ScrollAndClipLayers) {
-  RunScrollAndClipLayersTest();
-}
-
-TEST_F(LayerSerializationTest, SolidColorScrollbarSerialization) {
-  std::vector<scoped_refptr<SolidColorScrollbarLayer>> scrollbar_layers;
-
-  scrollbar_layers.push_back(SolidColorScrollbarLayer::Create(
-      ScrollbarOrientation::HORIZONTAL, 20, 5, true, 3));
-  scrollbar_layers.push_back(SolidColorScrollbarLayer::Create(
-      ScrollbarOrientation::VERTICAL, 20, 5, false, 3));
-  scrollbar_layers.push_back(SolidColorScrollbarLayer::Create(
-      ScrollbarOrientation::HORIZONTAL, 0, 0, true, 0));
-  scrollbar_layers.push_back(SolidColorScrollbarLayer::Create(
-      ScrollbarOrientation::VERTICAL, 10, 35, true, 3));
-
-  for (size_t i = 0; i < scrollbar_layers.size(); i++) {
-    VerifySolidColorScrollbarLayerAfterSerializationAndDeserialization(
-        scrollbar_layers[i]);
-  }
-}
-
 TEST_F(LayerTest, ElementIdAndMutablePropertiesArePushed) {
   scoped_refptr<Layer> test_layer = Layer::Create();
   std::unique_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_->SetRootLayer(test_layer));
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(2);
 
   test_layer->SetElementId(ElementId(2, 0));
   test_layer->SetMutableProperties(MutableProperty::kTransform);
 
   EXPECT_FALSE(impl_layer->element_id());
   EXPECT_EQ(MutableProperty::kNone, impl_layer->mutable_properties());
 
   test_layer->PushPropertiesTo(impl_layer.get());
 
   EXPECT_EQ(ElementId(2, 0), impl_layer->element_id());
   EXPECT_EQ(MutableProperty::kTransform, impl_layer->mutable_properties());
 }
 
 }  // namespace
 }  // namespace cc