cc: Move RenderTarget Information to Effect Tree

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>
 
@@ skipping 22 matching lines @@
       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);
+  if (target_node->id != 0)
+    return target_node->data.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);
+  if (target_node->id != 0)
+    return target_node->data.render_surface;
+  else
+    return this;
+}
+
 RenderSurfaceImpl::DrawProperties::DrawProperties() {
   draw_opacity = 1.f;
   is_clipped = false;
 }
 
 RenderSurfaceImpl::DrawProperties::~DrawProperties() {}
 
 gfx::RectF RenderSurfaceImpl::DrawableContentRect() const {
   gfx::RectF drawable_content_rect =
       MathUtil::MapClippedRect(draw_transform(), gfx::RectF(content_rect()));
@@ skipping 68 matching lines @@
 }
 
 void RenderSurfaceImpl::SetContentRect(const gfx::Rect& content_rect) {
   if (content_rect == draw_properties_.content_rect)
     return;
 
   surface_property_changed_ = true;
   draw_properties_.content_rect = content_rect;
 }
 
-void RenderSurfaceImpl::SetAccumulatedContentRect(
-    const gfx::Rect& content_rect) {
-  accumulated_content_rect_ = content_rect;
+void RenderSurfaceImpl::ClearAccumulatedContentRect() {
+  accumulated_content_rect_ = gfx::Rect();
+}
+
+void RenderSurfaceImpl::AccumulateContentRectFromContributingLayer(
+    LayerImpl* layer) {
+  DCHECK(layer->DrawsContent());
+  DCHECK_EQ(this, layer->render_target());
+
+  accumulated_content_rect_.Union(layer->drawable_content_rect());
+}
+
+void RenderSurfaceImpl::AccumulateContentRectFromContributingRenderSurface(
+    RenderSurfaceImpl* contributing_surface) {
+  DCHECK_NE(this, contributing_surface);
+  DCHECK_EQ(this, contributing_surface->render_target());
+
+  // The content rect of contributing surface is in its own space. Instead, we
+  // will use contributing surface's DrawableContentRect which is in target
+  // space (local space for this render surface) as required. We also need to
+  // clip it with this render surface's clip if the target is clipped.
+  accumulated_content_rect_.Union(
+      gfx::ToEnclosedRect(contributing_surface->DrawableContentRect()));
+  if (is_clipped())
+    accumulated_content_rect_.Intersect(clip_rect());

[ajuma, 2016/04/07 21:59:55]

This clipping seems like something that can be removed too, since I think we'll
apply this clip later before calling SetContentRect.

[ajuma, 2016/04/07 23:57:37]

Thinking about this some more:
In the old code, the contributing surface's drawable content rect is intersected
with the clip rect of the layer that owns the surface. That clip rect is in
surface space. But I don't see why it makes sense to intersect that way, since
the clip rect of the layer that owns the surface isn't going to be used to clip
the contributing surface at draw time.

And here, clip_rect() is actually in the space of the surface's target, so if we
wanted to intersect with it, we'd need to put the accumulated content rect into
the surface's target space, intersect there, and then project back. But that
already gets done before SetContentRect.

 }
 
 bool RenderSurfaceImpl::SurfacePropertyChanged() const {
   // Surface property changes are tracked as follows:
   //
   // - surface_property_changed_ is flagged when the clip_rect or content_rect
   //   change. As of now, these are the only two properties that can be affected
   //   by descendant layers.
   //
   // - all other property changes come from the owning layer (or some ancestor
@@ skipping 80 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,
                owning_layer_->background_filters());
 }
 
 }  // namespace cc