cc: Set up the framework to restrict access to Layer internals.

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/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/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/test_gpu_memory_buffer_manager.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/geometry/point3_f.h"
@@ skipping 85 matching lines @@
 
   // 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->update_rect_;
+    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);
     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.
-    if (src->scroll_parent_)
-      layer_tree_host_->RegisterLayer(src->scroll_parent_);
+    if (src->inputs_.scroll_parent)
+      layer_tree_host_->RegisterLayer(src->inputs_.scroll_parent);
     if (src->scroll_children_) {
       for (auto* child : *(src->scroll_children_))
         layer_tree_host_->RegisterLayer(child);
     }
-    if (src->clip_parent_)
-      layer_tree_host_->RegisterLayer(src->clip_parent_);
+    if (src->inputs_.clip_parent)
+      layer_tree_host_->RegisterLayer(src->inputs_.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();
-    dest->layer_id_ = src->layer_id_;
+    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->transform_origin_, dest->transform_origin_);
-    EXPECT_EQ(src->background_color_, dest->background_color_);
-    EXPECT_EQ(src->bounds_, dest->bounds_);
+    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->double_sided_, dest->double_sided_);
+    EXPECT_EQ(src->inputs_.double_sided, dest->inputs_.double_sided);
     EXPECT_EQ(src->draws_content_, dest->draws_content_);
-    EXPECT_EQ(src->hide_layer_and_subtree_, dest->hide_layer_and_subtree_);
-    EXPECT_EQ(src->masks_to_bounds_, dest->masks_to_bounds_);
-    EXPECT_EQ(src->main_thread_scrolling_reasons_,
-              dest->main_thread_scrolling_reasons_);
-    EXPECT_EQ(src->non_fast_scrollable_region_,
-              dest->non_fast_scrollable_region_);
-    EXPECT_EQ(src->touch_event_handler_region_,
-              dest->touch_event_handler_region_);
-    EXPECT_EQ(src->contents_opaque_, dest->contents_opaque_);
-    EXPECT_EQ(src->opacity_, dest->opacity_);
-    EXPECT_EQ(src->blend_mode_, dest->blend_mode_);
-    EXPECT_EQ(src->is_root_for_isolated_group_,
-              dest->is_root_for_isolated_group_);
-    EXPECT_EQ(src->position_, dest->position_);
-    EXPECT_EQ(src->is_container_for_fixed_position_layers_,
-              dest->is_container_for_fixed_position_layers_);
-    EXPECT_EQ(src->position_constraint_, dest->position_constraint_);
-    EXPECT_EQ(src->should_flatten_transform_, dest->should_flatten_transform_);
+    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->use_parent_backface_visibility_,
-              dest->use_parent_backface_visibility_);
-    EXPECT_EQ(src->transform_, dest->transform_);
-    EXPECT_EQ(src->sorting_context_id_, dest->sorting_context_id_);
+    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->scroll_clip_layer_id_, dest->scroll_clip_layer_id_);
-    EXPECT_EQ(src->user_scrollable_horizontal_,
-              dest->user_scrollable_horizontal_);
-    EXPECT_EQ(src->user_scrollable_vertical_, dest->user_scrollable_vertical_);
-    EXPECT_EQ(src->scroll_offset_, dest->scroll_offset_);
-    EXPECT_EQ(update_rect, dest->update_rect_);
+    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->scroll_parent_) {
-      ASSERT_TRUE(dest->scroll_parent_);
-      EXPECT_EQ(src->scroll_parent_->id(), dest->scroll_parent_->id());
+    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->scroll_parent_);
+      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->clip_parent_) {
-      ASSERT_TRUE(dest->clip_parent_);
-      EXPECT_EQ(src->clip_parent_->id(), dest->clip_parent_->id());
+    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->clip_parent_);
+      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->update_rect_);
+    EXPECT_EQ(gfx::Rect(), src->inputs_.update_rect);
 
     // Before deleting |dest|, the LayerTreeHost must be unset.
     dest->SetLayerTreeHost(nullptr);
 
     // Cleanup scroll tree.
-    if (src->scroll_parent_)
-      layer_tree_host_->UnregisterLayer(src->scroll_parent_);
-    src->scroll_parent_ = nullptr;
-    dest->scroll_parent_ = nullptr;
+    if (src->inputs_.scroll_parent)
+      layer_tree_host_->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_host_->UnregisterLayer(child);
       src->scroll_children_.reset();
       dest->scroll_children_.reset();
     }
 
     // Cleanup clip tree.
-    if (src->clip_parent_)
-      layer_tree_host_->UnregisterLayer(src->clip_parent_);
-    src->clip_parent_ = nullptr;
-    dest->clip_parent_ = nullptr;
+    if (src->inputs_.clip_parent)
+      layer_tree_host_->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_host_->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->transform_origin_ = gfx::Point3F(3.0f, 1.0f, 4.0f);
-    layer->background_color_ = SK_ColorRED;
-    layer->bounds_ = gfx::Size(3, 14);
+    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->double_sided_ = true;
+    layer->inputs_.double_sided = true;
     layer->draws_content_ = true;
-    layer->hide_layer_and_subtree_ = false;
-    layer->masks_to_bounds_ = true;
-    layer->main_thread_scrolling_reasons_ =
+    layer->inputs_.hide_layer_and_subtree = false;
+    layer->inputs_.masks_to_bounds = true;
+    layer->inputs_.main_thread_scrolling_reasons =
         MainThreadScrollingReason::kNotScrollingOnMain;
-    layer->non_fast_scrollable_region_ = Region(gfx::Rect(5, 1, 14, 3));
-    layer->touch_event_handler_region_ = Region(gfx::Rect(3, 14, 1, 5));
-    layer->contents_opaque_ = true;
-    layer->opacity_ = 1.f;
-    layer->blend_mode_ = SkXfermode::kSrcOver_Mode;
-    layer->is_root_for_isolated_group_ = true;
-    layer->position_ = gfx::PointF(3.14f, 6.28f);
-    layer->is_container_for_fixed_position_layers_ = true;
+    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->position_constraint_ = pos_con;
-    layer->should_flatten_transform_ = 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->use_parent_backface_visibility_ = true;
+    layer->inputs_.use_parent_backface_visibility = true;
     gfx::Transform transform;
     transform.Rotate(90);
-    layer->transform_ = transform;
-    layer->sorting_context_id_ = 0;
+    layer->inputs_.transform = transform;
+    layer->inputs_.sorting_context_id = 0;
     layer->num_descendants_that_draw_content_ = 5;
-    layer->scroll_clip_layer_id_ = Layer::INVALID_ID;
-    layer->user_scrollable_horizontal_ = false;
-    layer->user_scrollable_vertical_ = true;
-    layer->scroll_offset_ = gfx::ScrollOffset(3, 14);
-    layer->update_rect_ = gfx::Rect(14, 15);
+    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->transform_origin_ = gfx::Point3F(3.0f, 1.0f, 4.0f);
-    layer->background_color_ = SK_ColorRED;
-    layer->bounds_ = gfx::Size(3, 14);
+    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->double_sided_ = !layer->double_sided_;
+    layer->inputs_.double_sided = !layer->inputs_.double_sided;
     layer->draws_content_ = !layer->draws_content_;
-    layer->hide_layer_and_subtree_ = !layer->hide_layer_and_subtree_;
-    layer->masks_to_bounds_ = !layer->masks_to_bounds_;
-    layer->main_thread_scrolling_reasons_ =
+    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->non_fast_scrollable_region_ = Region(gfx::Rect(5, 1, 14, 3));
-    layer->touch_event_handler_region_ = Region(gfx::Rect(3, 14, 1, 5));
-    layer->contents_opaque_ = !layer->contents_opaque_;
-    layer->opacity_ = 3.14f;
-    layer->blend_mode_ = SkXfermode::kSrcIn_Mode;
-    layer->is_root_for_isolated_group_ = !layer->is_root_for_isolated_group_;
-    layer->position_ = gfx::PointF(3.14f, 6.28f);
-    layer->is_container_for_fixed_position_layers_ =
-        !layer->is_container_for_fixed_position_layers_;
+    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->position_constraint_ = pos_con;
-    layer->should_flatten_transform_ = !layer->should_flatten_transform_;
+    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->use_parent_backface_visibility_ =
-        !layer->use_parent_backface_visibility_;
+    layer->inputs_.use_parent_backface_visibility =
+        !layer->inputs_.use_parent_backface_visibility;
     gfx::Transform transform;
     transform.Rotate(90);
-    layer->transform_ = transform;
-    layer->sorting_context_id_ = 42;
+    layer->inputs_.transform = transform;
+    layer->inputs_.sorting_context_id = 42;
     layer->num_descendants_that_draw_content_ = 5;
-    layer->scroll_clip_layer_id_ = 17;
-    layer->user_scrollable_horizontal_ = !layer->user_scrollable_horizontal_;
-    layer->user_scrollable_vertical_ = !layer->user_scrollable_vertical_;
-    layer->scroll_offset_ = gfx::ScrollOffset(3, 14);
-    layer->update_rect_ = gfx::Rect(14, 15);
+    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::LayerProperties serialized_scrollbar;
     source_scrollbar->LayerSpecificPropertiesToProto(&serialized_scrollbar);
 
     scoped_refptr<SolidColorScrollbarLayer> deserialized_scrollbar =
         SolidColorScrollbarLayer::Create(ScrollbarOrientation::HORIZONTAL, -1,
                                          -1, false, Layer::INVALID_ID);
-    deserialized_scrollbar->layer_id_ = source_scrollbar->layer_id_;
+    deserialized_scrollbar->inputs_.layer_id =
+        source_scrollbar->inputs_.layer_id;
 
     // FromLayerSpecificPropertiesProto expects a non-null LayerTreeHost to be
     // set.
     deserialized_scrollbar->SetLayerTreeHost(layer_tree_host_.get());
     deserialized_scrollbar->FromLayerSpecificPropertiesProto(
         serialized_scrollbar);
 
     EXPECT_EQ(source_scrollbar->track_start_,
               deserialized_scrollbar->track_start_);
     EXPECT_EQ(source_scrollbar->thumb_thickness_,
               deserialized_scrollbar->thumb_thickness_);
     EXPECT_EQ(source_scrollbar->scroll_layer_id_,
               deserialized_scrollbar->scroll_layer_id_);
     EXPECT_EQ(source_scrollbar->is_left_side_vertical_scrollbar_,
               deserialized_scrollbar->is_left_side_vertical_scrollbar_);
     EXPECT_EQ(source_scrollbar->orientation_,
               deserialized_scrollbar->orientation_);
 
     deserialized_scrollbar->SetLayerTreeHost(nullptr);
   }
 
   void RunScrollAndClipLayersTest() {
     scoped_refptr<Layer> layer = Layer::Create();
 
     scoped_refptr<Layer> scroll_parent = Layer::Create();
-    layer->scroll_parent_ = scroll_parent.get();
+    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->clip_parent_ = clip_parent.get();
+    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() {
@@ skipping 122 matching lines @@
                                         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->children_[0];
-    layer_src_root->children_[0] = layer_src_root->children_[1];
-    layer_src_root->children_[1] = tmp_a;
+    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(
@@ skipping 1627 matching lines @@
   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();
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(layer));
 
+  LayerInternalsForTest layer_internals(layer.get());
+
   EXPECT_CALL(*layer_tree_host_, SetNeedsUpdateLayers()).Times(1);
-  layer->OnOpacityAnimated(0.5f);
+  layer_internals.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);
+  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->OnScrollOffsetAnimated(gfx::ScrollOffset(10, 10));
+  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
@@ skipping 297 matching lines @@
   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