Detemplatize cc property nodes

cc/layers/render_surface_impl.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/render_surface_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/render_pass_sink.h"
 #include "cc/output/filter_operations.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/draw_property_utils.h"
+#include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 RenderSurfaceImpl::RenderSurfaceImpl(LayerImpl* owning_layer)
     : owning_layer_(owning_layer),
       surface_property_changed_(false),
       contributes_to_drawn_surface_(false),
       nearest_occlusion_immune_ancestor_(nullptr),
       target_render_surface_layer_index_history_(0),
       current_layer_index_history_(0) {
   damage_tracker_ = DamageTracker::Create();
 }
 
 RenderSurfaceImpl::~RenderSurfaceImpl() {}
 
 RenderSurfaceImpl* RenderSurfaceImpl::render_target() {
   EffectTree& effect_tree =
       owning_layer_->layer_tree_impl()->property_trees()->effect_tree;
   EffectNode* node = effect_tree.Node(EffectTreeIndex());
-  EffectNode* target_node = effect_tree.Node(node->data.target_id);
+  EffectNode* target_node = effect_tree.Node(node->target_id);
   if (target_node->id != 0)
-    return target_node->data.render_surface;
+    return target_node->render_surface;
   else
     return this;
 }
 
 const RenderSurfaceImpl* RenderSurfaceImpl::render_target() const {
   const EffectTree& effect_tree =
       owning_layer_->layer_tree_impl()->property_trees()->effect_tree;
   const EffectNode* node = effect_tree.Node(EffectTreeIndex());
-  const EffectNode* target_node = effect_tree.Node(node->data.target_id);
+  const EffectNode* target_node = effect_tree.Node(node->target_id);
   if (target_node->id != 0)
-    return target_node->data.render_surface;
+    return target_node->render_surface;
   else
     return this;
 }
 
 RenderSurfaceImpl::DrawProperties::DrawProperties() {
   draw_opacity = 1.f;
   is_clipped = false;
 }
 
 RenderSurfaceImpl::DrawProperties::~DrawProperties() {}
@@ skipping 46 matching lines @@
 float RenderSurfaceImpl::GetReplicaDebugBorderWidth() const {
   return DebugColors::SurfaceReplicaBorderWidth(
       owning_layer_->layer_tree_impl());
 }
 
 int RenderSurfaceImpl::OwningLayerId() const {
   return owning_layer_ ? owning_layer_->id() : 0;
 }
 
 bool RenderSurfaceImpl::HasReplica() const {
-  return OwningEffectNode()->data.replica_layer_id != -1;
+  return OwningEffectNode()->replica_layer_id != -1;
 }
 
 const LayerImpl* RenderSurfaceImpl::ReplicaLayer() const {
-  int replica_layer_id = OwningEffectNode()->data.replica_layer_id;
+  int replica_layer_id = OwningEffectNode()->replica_layer_id;
   return owning_layer_->layer_tree_impl()->LayerById(replica_layer_id);
 }
 
 LayerImpl* RenderSurfaceImpl::ReplicaLayer() {
-  int replica_layer_id = OwningEffectNode()->data.replica_layer_id;
+  int replica_layer_id = OwningEffectNode()->replica_layer_id;
   return owning_layer_->layer_tree_impl()->LayerById(replica_layer_id);
 }
 
 LayerImpl* RenderSurfaceImpl::MaskLayer() {
-  int mask_layer_id = OwningEffectNode()->data.mask_layer_id;
+  int mask_layer_id = OwningEffectNode()->mask_layer_id;
   return owning_layer_->layer_tree_impl()->LayerById(mask_layer_id);
 }
 
 bool RenderSurfaceImpl::HasMask() const {
-  return OwningEffectNode()->data.mask_layer_id != -1;
+  return OwningEffectNode()->mask_layer_id != -1;
 }
 
 LayerImpl* RenderSurfaceImpl::ReplicaMaskLayer() {
-  int replica_mask_layer_id = OwningEffectNode()->data.replica_mask_layer_id;
+  int replica_mask_layer_id = OwningEffectNode()->replica_mask_layer_id;
   return owning_layer_->layer_tree_impl()->LayerById(replica_mask_layer_id);
 }
 
 bool RenderSurfaceImpl::HasReplicaMask() const {
-  return OwningEffectNode()->data.replica_mask_layer_id != -1;
+  return OwningEffectNode()->replica_mask_layer_id != -1;
 }
 
 const FilterOperations& RenderSurfaceImpl::BackgroundFilters() const {
-  return OwningEffectNode()->data.background_filters;
+  return OwningEffectNode()->background_filters;
 }
 
 bool RenderSurfaceImpl::HasCopyRequest() const {
-  return OwningEffectNode()->data.has_copy_request;
+  return OwningEffectNode()->has_copy_request;
 }
 
 int RenderSurfaceImpl::TransformTreeIndex() const {
   return owning_layer_->transform_tree_index();
 }
 
 int RenderSurfaceImpl::ClipTreeIndex() const {
   return owning_layer_->clip_tree_index();
 }
 
@@ skipping 218 matching lines @@
 
   RenderPassDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   quad->SetNew(shared_quad_state, content_rect(), visible_layer_rect,
                render_pass_id, mask_resource_id, mask_uv_scale,
                mask_texture_size, owning_layer_->filters(),
                owning_layer_to_target_scale, BackgroundFilters());
 }
 
 }  // namespace cc