Detemplatize cc property nodes

cc/trees/layer_tree_host_common_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 22 matching lines @@
 #include "cc/test/fake_content_layer_client.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_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_picture_layer.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_tree_host_common_test.h"
 #include "cc/test/test_task_graph_runner.h"
+#include "cc/trees/clip_node.h"
 #include "cc/trees/draw_property_utils.h"
+#include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_impl.h"
+#include "cc/trees/scroll_node.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/task_runner_provider.h"
+#include "cc/trees/transform_node.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/effects/SkOffsetImageFilter.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 namespace {
 
@@ skipping 125 matching lines @@
                                gfx::PointF(10, 10), gfx::Size(100, 100), true,
                                false);
   child->test_properties()->opacity = 0.f;
   ExecuteCalculateDrawProperties(parent);
   EffectTree& effect_tree =
       parent->layer_tree_impl()->property_trees()->effect_tree;
   EffectNode* node = effect_tree.Node(child->effect_tree_index());
   const int transform_tree_size = parent->layer_tree_impl()
                                       ->property_trees()
                                       ->transform_tree.next_available_id();
-  EXPECT_LT(node->data.transform_id, transform_tree_size);
+  EXPECT_LT(node->transform_id, transform_tree_size);
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSingleLayer) {
   gfx::Transform identity_matrix;
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* layer = AddChild<LayerImpl>(root);
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false);
 
@@ skipping 1163 matching lines @@
   }
   // The layer is fully transparent, but has a background filter, so it
   // shouldn't be skipped and should be drawn.
   ASSERT_TRUE(parent->render_surface());
   EXPECT_EQ(1U, parent->render_surface()->layer_list().size());
   EXPECT_EQ(gfx::RectF(0, 0, 10, 10),
             parent->render_surface()->DrawableContentRect());
   EffectTree& effect_tree =
       parent->layer_tree_impl()->property_trees()->effect_tree;
   EffectNode* node = effect_tree.Node(render_surface1->effect_tree_index());
-  EXPECT_TRUE(node->data.is_drawn);
+  EXPECT_TRUE(node->is_drawn);
 
   // When parent is transparent, the layer should not be drawn.
   parent->OnOpacityAnimated(0.f);
   render_surface1->OnOpacityAnimated(1.f);
   render_surface1->set_visible_layer_rect(gfx::Rect());
   {
     LayerImplList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         parent, parent->bounds(), &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
   }
 
   node = effect_tree.Node(render_surface1->effect_tree_index());
-  EXPECT_FALSE(node->data.is_drawn);
+  EXPECT_FALSE(node->is_drawn);
   EXPECT_EQ(gfx::Rect(), render_surface1->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForFilter) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child1 = AddChild<LayerImpl>(parent);
   LayerImpl* child2 = AddChild<LayerImpl>(parent);
   child1->SetDrawsContent(true);
   child2->SetDrawsContent(true);
@@ skipping 298 matching lines @@
                                false);
 
   grand_child->test_properties()->should_flatten_transform = false;
 
   // Only grand_child should preserve 3d.
   EXPECT_TRUE(root->test_properties()->should_flatten_transform);
   EXPECT_TRUE(parent->test_properties()->should_flatten_transform);
   EXPECT_TRUE(child->test_properties()->should_flatten_transform);
   EXPECT_FALSE(grand_child->test_properties()->should_flatten_transform);
 
-  gfx::Transform expected_child_draw_transform = identity_matrix;
-  gfx::Transform expected_grand_child_draw_transform = identity_matrix;
-
   gfx::Transform flattened_rotation_about_y = rotation_about_y_axis;
   flattened_rotation_about_y.FlattenTo2d();
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(parent->render_surface());
   EXPECT_FALSE(child->render_surface());
   EXPECT_FALSE(grand_child->render_surface());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->DrawTransform());
@@ skipping 1945 matching lines @@
                                gfx::PointF(), gfx::Size(100, 100), false, true,
                                false);
 
   ExecuteCalculateDrawProperties(root);
 
   // Though all layers have invertible transforms, matrix multiplication using
   // floating-point math makes the draw transform uninvertible.
   EXPECT_FALSE(root->layer_tree_impl()
                    ->property_trees()
                    ->transform_tree.Node(grand_child->transform_tree_index())
-                   ->data.ancestors_are_invertible);
+                   ->ancestors_are_invertible);
 
   // CalcDrawProps skips a subtree when a layer's screen space transform is
   // uninvertible
   EXPECT_EQ(gfx::Rect(), grand_child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        OcclusionForLayerWithUninvertibleDrawTransform) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
@@ skipping 52 matching lines @@
                                    ->children[0]
                                    ->test_properties()
                                    ->children[0];
 
   // Though all layers have invertible transforms, matrix multiplication using
   // floating-point math makes the draw transform uninvertible.
   EXPECT_FALSE(
       host_impl.active_tree()
           ->property_trees()
           ->transform_tree.Node(grand_child_ptr->transform_tree_index())
-          ->data.ancestors_are_invertible);
+          ->ancestors_are_invertible);
 
   // Since |grand_child| has an uninvertible screen space transform, it is
   // skipped so
   // that we are not computing its occlusion_in_content_space.
   gfx::Rect layer_bounds = gfx::Rect();
   EXPECT_EQ(
       layer_bounds,
       grand_child_ptr->draw_properties()
           .occlusion_in_content_space.GetUnoccludedContentRect(layer_bounds));
 }
@@ skipping 1224 matching lines @@
   gfx::Transform expected_screen_space_transform;
   expected_screen_space_transform.Scale(device_scale_factor,
                                         device_scale_factor);
   expected_screen_space_transform.Translate(child->position().x(),
                                             child->position().y());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_screen_space_transform,
                                   child->ScreenSpaceTransform());
 
   gfx::Transform expected_duplicate_child_draw_transform =
       child->DrawTransform();
-  EXPECT_TRANSFORMATION_MATRIX_EQ(child->DrawTransform(),
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected_duplicate_child_draw_transform,
                                   duplicate_child_non_owner->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       child->ScreenSpaceTransform(),
       duplicate_child_non_owner->ScreenSpaceTransform());
   EXPECT_EQ(child->drawable_content_rect(),
             duplicate_child_non_owner->drawable_content_rect());
   EXPECT_EQ(child->bounds(), duplicate_child_non_owner->bounds());
 
   gfx::Transform expected_render_surface_draw_transform;
   expected_render_surface_draw_transform.Translate(
@@ skipping 193 matching lines @@
   LayerImplList render_surface_layer_list2;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs2(
       root_layer, root_layer->bounds(), &render_surface_layer_list2);
   inputs2.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs2);
 
   LayerImpl* child_ptr = root_layer->layer_tree_impl()->LayerById(2);
   EffectTree& tree =
       root_layer->layer_tree_impl()->property_trees()->effect_tree;
   EffectNode* node = tree.Node(child_ptr->effect_tree_index());
-  EXPECT_FALSE(node->data.is_drawn);
+  EXPECT_FALSE(node->is_drawn);
 
   // A layer should be drawn and it should contribute to drawn surface when
   // it has animating opacity even if it has opacity 0.
   root_layer->test_properties()->opacity = 1.0f;
   child_ptr->test_properties()->opacity = 0.0f;
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   LayerImplList render_surface_layer_list3;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs3(
       root_layer, root_layer->bounds(), &render_surface_layer_list3);
   inputs3.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs3);
 
   child_ptr = root_layer->layer_tree_impl()->LayerById(2);
   tree = root_layer->layer_tree_impl()->property_trees()->effect_tree;
   node = tree.Node(child_ptr->effect_tree_index());
-  EXPECT_TRUE(node->data.is_drawn);
+  EXPECT_TRUE(node->is_drawn);
   EXPECT_TRUE(tree.ContributesToDrawnSurface(child_ptr->effect_tree_index()));
 
   // But if the opacity of the layer remains 0 after activation, it should not
   // be drawn.
   host_impl.ActivateSyncTree();
   LayerImpl* active_root = host_impl.active_tree()->LayerById(root_layer->id());
   LayerImpl* active_child = host_impl.active_tree()->LayerById(child_ptr->id());
 
   EffectTree& active_effect_tree =
       host_impl.active_tree()->property_trees()->effect_tree;
   EXPECT_TRUE(active_effect_tree.needs_update());
 
   ExecuteCalculateDrawProperties(active_root);
 
   node = active_effect_tree.Node(active_child->effect_tree_index());
-  EXPECT_FALSE(node->data.is_drawn);
+  EXPECT_FALSE(node->is_drawn);
   EXPECT_FALSE(active_effect_tree.ContributesToDrawnSurface(
       active_child->effect_tree_index()));
 }
 
 using LCDTextTestParam = std::tr1::tuple<bool, bool, bool>;
 class LCDTextTest : public LayerTreeHostCommonTestBase,
                     public testing::TestWithParam<LCDTextTestParam> {
  public:
   LCDTextTest()
       : LayerTreeHostCommonTestBase(LCDTextTestLayerTreeSettings()),
@@ skipping 463 matching lines @@
   EXPECT_EQ(copy_child_layer->id(),
             copy_layer->render_surface()->layer_list().at(1)->id());
 
   // copy_grand_parent, copy_parent shouldn't be drawn because they are hidden,
   // but the copy_layer and copy_child should be drawn for the copy request.
   // copy grand child should not be drawn as its hidden even in the copy
   // request.
   EffectTree& tree =
       root_layer->layer_tree_impl()->property_trees()->effect_tree;
   EffectNode* node = tree.Node(copy_grand_parent_layer->effect_tree_index());
-  EXPECT_FALSE(node->data.is_drawn);
+  EXPECT_FALSE(node->is_drawn);
   node = tree.Node(copy_parent_layer->effect_tree_index());
-  EXPECT_FALSE(node->data.is_drawn);
+  EXPECT_FALSE(node->is_drawn);
   node = tree.Node(copy_layer->effect_tree_index());
-  EXPECT_TRUE(node->data.is_drawn);
+  EXPECT_TRUE(node->is_drawn);
   node = tree.Node(copy_child_layer->effect_tree_index());
-  EXPECT_TRUE(node->data.is_drawn);
+  EXPECT_TRUE(node->is_drawn);
   node = tree.Node(copy_grand_child_layer->effect_tree_index());
-  EXPECT_FALSE(node->data.is_drawn);
+  EXPECT_FALSE(node->is_drawn);
 
   // Though copy_layer is drawn, it shouldn't contribute to drawn surface as its
   // actually hidden.
   EXPECT_FALSE(copy_layer->render_surface()->contributes_to_drawn_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClippedOutCopyRequest) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
@@ skipping 898 matching lines @@
                                false, true, true);
 
   render_surface1->test_properties()->double_sided = false;
   render_surface2->test_properties()->double_sided = false;
 
   ExecuteCalculateDrawProperties(root);
 
   const EffectTree& tree =
       root->layer_tree_impl()->property_trees()->effect_tree;
   EXPECT_TRUE(tree.Node(render_surface1->effect_tree_index())
-                  ->data.hidden_by_backface_visibility);
+                  ->hidden_by_backface_visibility);
   EXPECT_TRUE(tree.Node(render_surface2->effect_tree_index())
-                  ->data.hidden_by_backface_visibility);
+                  ->hidden_by_backface_visibility);
 
   back_facing->OnTransformAnimated(identity_transform);
   render_surface2->OnTransformAnimated(rotate_about_y);
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(tree.Node(render_surface1->effect_tree_index())
-                   ->data.hidden_by_backface_visibility);
+                   ->hidden_by_backface_visibility);
   EXPECT_TRUE(tree.Node(render_surface2->effect_tree_index())
-                  ->data.hidden_by_backface_visibility);
+                  ->hidden_by_backface_visibility);
 
   render_surface1->OnTransformAnimated(rotate_about_y);
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRUE(tree.Node(render_surface1->effect_tree_index())
-                  ->data.hidden_by_backface_visibility);
+                  ->hidden_by_backface_visibility);
   EXPECT_TRUE(tree.Node(render_surface2->effect_tree_index())
-                  ->data.hidden_by_backface_visibility);
+                  ->hidden_by_backface_visibility);
 }
 
 TEST_F(LayerTreeHostCommonTest, ClippedByScrollParent) {
   // Checks that the simple case (being clipped by a scroll parent that would
   // have been processed before you anyhow) results in the right clips.
   //
   // + root
   //   + scroll_parent_border
   //   | + scroll_parent_clip
   //   |   + scroll_parent
@@ skipping 2644 matching lines @@
   EXPECT_EQ(transform_node->owner_id, significant_transform->id());
 
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_FALSE(significant_transform->has_render_surface());
   EXPECT_TRUE(layer_clips_subtree->has_render_surface());
   EXPECT_TRUE(render_surface->has_render_surface());
   EXPECT_FALSE(test_layer->has_render_surface());
 
   ClipTree& clip_tree = root->layer_tree_impl()->property_trees()->clip_tree;
   ClipNode* clip_node = clip_tree.Node(render_surface->clip_tree_index());
-  EXPECT_FALSE(clip_node->data.applies_local_clip);
+  EXPECT_FALSE(clip_node->applies_local_clip);
   EXPECT_EQ(gfx::Rect(20, 20), test_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformOfParentClipNodeAncestorOfTarget) {
   // Ensure that when parent clip node's transform is an ancestor of current
   // clip node's target, clip is 'projected' from parent space to current
   // target space and visible rects are calculated correctly.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_layer = AddChild<LayerImpl>(root);
   LayerImpl* target_layer = AddChild<LayerImpl>(clip_layer);
@@ skipping 627 matching lines @@
   // We want layer between the two targets to create a clip node and transform
   // node but it shouldn't create a render surface.
   between_targets->SetMasksToBounds(true);
   between_targets->Set3dSortingContextId(2);
 
   ExecuteCalculateDrawProperties(root);
 
   TransformTree& tree =
       root->layer_tree_impl()->property_trees()->transform_tree;
   TransformNode* node = tree.Node(render_surface1->transform_tree_index());
-  EXPECT_EQ(node->data.sublayer_scale, gfx::Vector2dF(2.f, 2.f));
+  EXPECT_EQ(node->sublayer_scale, gfx::Vector2dF(2.f, 2.f));
 
   node = tree.Node(between_targets->transform_tree_index());
-  EXPECT_EQ(node->data.sublayer_scale, gfx::Vector2dF(1.f, 1.f));
+  EXPECT_EQ(node->sublayer_scale, gfx::Vector2dF(1.f, 1.f));
 
   node = tree.Node(render_surface2->transform_tree_index());
-  EXPECT_EQ(node->data.sublayer_scale, gfx::Vector2dF(2.f, 2.f));
+  EXPECT_EQ(node->sublayer_scale, gfx::Vector2dF(2.f, 2.f));
 
   EXPECT_EQ(gfx::Rect(15, 15), test_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, LargeTransformTest) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
 
   const gfx::Transform identity_matrix;
@@ skipping 119 matching lines @@
   animation->set_fill_mode(Animation::FillMode::NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
   Animation* animation_ptr = animation.get();
   AddAnimationToElementWithExistingPlayer(animated->element_id(), timeline(),
                                           std::move(animation));
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   EffectTree& tree = root->layer_tree_host()->property_trees()->effect_tree;
   EffectNode* node = tree.Node(animated->effect_tree_index());
-  EXPECT_FALSE(node->data.is_currently_animating_opacity);
-  EXPECT_TRUE(node->data.has_potential_opacity_animation);
+  EXPECT_FALSE(node->is_currently_animating_opacity);
+  EXPECT_TRUE(node->has_potential_opacity_animation);
 
   animation_ptr->set_time_offset(base::TimeDelta::FromMilliseconds(0));
   root->layer_tree_host()->AnimateLayers(
       base::TimeTicks::FromInternalValue(std::numeric_limits<int64_t>::max()));
   node = tree.Node(animated->effect_tree_index());
-  EXPECT_TRUE(node->data.is_currently_animating_opacity);
-  EXPECT_TRUE(node->data.has_potential_opacity_animation);
+  EXPECT_TRUE(node->is_currently_animating_opacity);
+  EXPECT_TRUE(node->has_potential_opacity_animation);
 
   player->AbortAnimations(TargetProperty::OPACITY, false /*needs_completion*/);
   node = tree.Node(animated->effect_tree_index());
-  EXPECT_FALSE(node->data.is_currently_animating_opacity);
-  EXPECT_FALSE(node->data.has_potential_opacity_animation);
+  EXPECT_FALSE(node->is_currently_animating_opacity);
+  EXPECT_FALSE(node->has_potential_opacity_animation);
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformAnimationsTrackingTest) {
   const gfx::Transform identity_matrix;
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(animated);
 
   host()->SetRootLayer(root);
@@ skipping 30 matching lines @@
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
   Animation* animation_ptr = animation.get();
   AddAnimationToElementWithExistingPlayer(animated->element_id(), timeline(),
                                           std::move(animation));
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   TransformTree& tree =
       root->layer_tree_host()->property_trees()->transform_tree;
   TransformNode* node = tree.Node(animated->transform_tree_index());
-  EXPECT_FALSE(node->data.is_currently_animating);
-  EXPECT_TRUE(node->data.has_potential_animation);
+  EXPECT_FALSE(node->is_currently_animating);
+  EXPECT_TRUE(node->has_potential_animation);
 
   animation_ptr->set_time_offset(base::TimeDelta::FromMilliseconds(0));
   root->layer_tree_host()->AnimateLayers(
       base::TimeTicks::FromInternalValue(std::numeric_limits<int64_t>::max()));
   node = tree.Node(animated->transform_tree_index());
-  EXPECT_TRUE(node->data.is_currently_animating);
-  EXPECT_TRUE(node->data.has_potential_animation);
+  EXPECT_TRUE(node->is_currently_animating);
+  EXPECT_TRUE(node->has_potential_animation);
 
   player->AbortAnimations(TargetProperty::TRANSFORM,
                           false /*needs_completion*/);
   node = tree.Node(animated->transform_tree_index());
-  EXPECT_FALSE(node->data.is_currently_animating);
-  EXPECT_FALSE(node->data.has_potential_animation);
+  EXPECT_FALSE(node->is_currently_animating);
+  EXPECT_FALSE(node->has_potential_animation);
 }
 
 TEST_F(LayerTreeHostCommonTest, SerializeScrollUpdateInfo) {
   LayerTreeHostCommon::ScrollUpdateInfo scroll;
   scroll.layer_id = 2;
   scroll.scroll_delta = gfx::Vector2d(5, 10);
 
   proto::ScrollUpdateInfo proto;
   scroll.ToProtobuf(&proto);
   LayerTreeHostCommon::ScrollUpdateInfo new_scroll;
@@ skipping 116 matching lines @@
   // Property tree root
   ScrollTree& scroll_tree = host()->property_trees()->scroll_tree;
   PropertyTrees property_trees;
   property_trees.is_main_thread = true;
   property_trees.is_active = false;
   ScrollTree& expected_scroll_tree = property_trees.scroll_tree;
   ScrollNode* property_tree_root = expected_scroll_tree.Node(0);
   property_tree_root->id = kRootPropertyTreeNodeId;
   property_tree_root->parent_id = kInvalidPropertyTreeNodeId;
   property_tree_root->owner_id = kInvalidPropertyTreeNodeId;
-  property_tree_root->data.scrollable = false;
-  property_tree_root->data.main_thread_scrolling_reasons =
+  property_tree_root->scrollable = false;
+  property_tree_root->main_thread_scrolling_reasons =
       MainThreadScrollingReason::kNotScrollingOnMain;
-  property_tree_root->data.contains_non_fast_scrollable_region = false;
-  property_tree_root->data.transform_id = kRootPropertyTreeNodeId;
+  property_tree_root->contains_non_fast_scrollable_region = false;
+  property_tree_root->transform_id = kRootPropertyTreeNodeId;
 
   // The node owned by root1
   ScrollNode scroll_root1;
   scroll_root1.id = 1;
   scroll_root1.owner_id = root1->id();
-  scroll_root1.data.user_scrollable_horizontal = true;
-  scroll_root1.data.user_scrollable_vertical = true;
-  scroll_root1.data.transform_id = root1->transform_tree_index();
+  scroll_root1.user_scrollable_horizontal = true;
+  scroll_root1.user_scrollable_vertical = true;
+  scroll_root1.transform_id = root1->transform_tree_index();
   expected_scroll_tree.Insert(scroll_root1, 0);
 
   // The node owned by parent2
   ScrollNode scroll_parent2;
   scroll_parent2.id = 2;
   scroll_parent2.owner_id = parent2->id();
-  scroll_parent2.data.scrollable = true;
-  scroll_parent2.data.main_thread_scrolling_reasons =
+  scroll_parent2.scrollable = true;
+  scroll_parent2.main_thread_scrolling_reasons =
       parent2->main_thread_scrolling_reasons();
-  scroll_parent2.data.scroll_clip_layer_bounds = root1->bounds();
-  scroll_parent2.data.bounds = parent2->bounds();
-  scroll_parent2.data.max_scroll_offset_affected_by_page_scale = true;
-  scroll_parent2.data.is_inner_viewport_scroll_layer = true;
-  scroll_parent2.data.user_scrollable_horizontal = true;
-  scroll_parent2.data.user_scrollable_vertical = true;
-  scroll_parent2.data.transform_id = parent2->transform_tree_index();
+  scroll_parent2.scroll_clip_layer_bounds = root1->bounds();
+  scroll_parent2.bounds = parent2->bounds();
+  scroll_parent2.max_scroll_offset_affected_by_page_scale = true;
+  scroll_parent2.is_inner_viewport_scroll_layer = true;
+  scroll_parent2.user_scrollable_horizontal = true;
+  scroll_parent2.user_scrollable_vertical = true;
+  scroll_parent2.transform_id = parent2->transform_tree_index();
   expected_scroll_tree.Insert(scroll_parent2, 1);
 
   // The node owned by child6
   ScrollNode scroll_child6;
   scroll_child6.id = 3;
   scroll_child6.owner_id = child6->id();
-  scroll_child6.data.main_thread_scrolling_reasons =
+  scroll_child6.main_thread_scrolling_reasons =
       child6->main_thread_scrolling_reasons();
-  scroll_child6.data.should_flatten = true;
-  scroll_child6.data.user_scrollable_horizontal = true;
-  scroll_child6.data.user_scrollable_vertical = true;
-  scroll_child6.data.transform_id = child6->transform_tree_index();
+  scroll_child6.should_flatten = true;
+  scroll_child6.user_scrollable_horizontal = true;
+  scroll_child6.user_scrollable_vertical = true;
+  scroll_child6.transform_id = child6->transform_tree_index();
   expected_scroll_tree.Insert(scroll_child6, 2);
 
   // The node owned by child7, child7 also owns a transform node
   ScrollNode scroll_child7;
   scroll_child7.id = 4;
   scroll_child7.owner_id = child7->id();
-  scroll_child7.data.scrollable = true;
-  scroll_child7.data.scroll_clip_layer_bounds = parent3->bounds();
-  scroll_child7.data.bounds = child7->bounds();
-  scroll_child7.data.user_scrollable_horizontal = true;
-  scroll_child7.data.user_scrollable_vertical = true;
-  scroll_child7.data.transform_id = child7->transform_tree_index();
+  scroll_child7.scrollable = true;
+  scroll_child7.scroll_clip_layer_bounds = parent3->bounds();
+  scroll_child7.bounds = child7->bounds();
+  scroll_child7.user_scrollable_horizontal = true;
+  scroll_child7.user_scrollable_vertical = true;
+  scroll_child7.transform_id = child7->transform_tree_index();
   expected_scroll_tree.Insert(scroll_child7, 1);
 
   // The node owned by grand_child11, grand_child11 also owns a transform node
   ScrollNode scroll_grand_child11;
   scroll_grand_child11.id = 5;
   scroll_grand_child11.owner_id = grand_child11->id();
-  scroll_grand_child11.data.scrollable = true;
-  scroll_grand_child11.data.user_scrollable_horizontal = true;
-  scroll_grand_child11.data.user_scrollable_vertical = true;
-  scroll_grand_child11.data.transform_id =
-      grand_child11->transform_tree_index();
+  scroll_grand_child11.scrollable = true;
+  scroll_grand_child11.user_scrollable_horizontal = true;
+  scroll_grand_child11.user_scrollable_vertical = true;
+  scroll_grand_child11.transform_id = grand_child11->transform_tree_index();
   expected_scroll_tree.Insert(scroll_grand_child11, 4);
 
   // The node owned by parent5
   ScrollNode scroll_parent5;
   scroll_parent5.id = 8;
   scroll_parent5.owner_id = parent5->id();
-  scroll_parent5.data.contains_non_fast_scrollable_region = true;
-  scroll_parent5.data.bounds = gfx::Size(10, 10);
-  scroll_parent5.data.should_flatten = true;
-  scroll_parent5.data.user_scrollable_horizontal = true;
-  scroll_parent5.data.user_scrollable_vertical = true;
-  scroll_parent5.data.transform_id = parent5->transform_tree_index();
+  scroll_parent5.contains_non_fast_scrollable_region = true;
+  scroll_parent5.bounds = gfx::Size(10, 10);
+  scroll_parent5.should_flatten = true;
+  scroll_parent5.user_scrollable_horizontal = true;
+  scroll_parent5.user_scrollable_vertical = true;
+  scroll_parent5.transform_id = parent5->transform_tree_index();
   expected_scroll_tree.Insert(scroll_parent5, 1);
 
   expected_scroll_tree.SetScrollOffset(parent2->id(), gfx::ScrollOffset(0, 0));
   expected_scroll_tree.SetScrollOffset(child7->id(), gfx::ScrollOffset(0, 0));
   expected_scroll_tree.SetScrollOffset(grand_child11->id(),
                                        gfx::ScrollOffset(0, 0));
   expected_scroll_tree.set_needs_update(false);
 
   EXPECT_EQ(expected_scroll_tree, scroll_tree);
 
   // Check other layers' scroll_tree_index
   EXPECT_EQ(scroll_root1.id, page_scale_layer->scroll_tree_index());
   EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
   EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
 }
 
 }  // namespace
 }  // namespace cc