cc: Move RenderTarget Information to Effect Tree

cc/layers/layer_impl.cc

 // Copyright 2012 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_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 258 matching lines @@
   requests->clear();
 
   if (was_empty && layer_tree_impl()->IsActiveTree())
     layer_tree_impl()->AddLayerWithCopyOutputRequest(this);
 }
 
 void LayerImpl::TakeCopyRequestsAndTransformToTarget(
     std::vector<scoped_ptr<CopyOutputRequest>>* requests) {
   DCHECK(!copy_requests_.empty());
   DCHECK(layer_tree_impl()->IsActiveTree());
-  DCHECK_EQ(render_target(), this);
+  DCHECK(has_render_surface());
+  DCHECK_EQ(render_target(), render_surface());
 
   size_t first_inserted_request = requests->size();
   for (auto& request : copy_requests_)
     requests->push_back(std::move(request));
   copy_requests_.clear();
 
   for (size_t i = first_inserted_request; i < requests->size(); ++i) {
     CopyOutputRequest* request = (*requests)[i].get();
     if (!request->has_area())
       continue;
@@ skipping 1277 matching lines @@
 }
 
 gfx::Rect LayerImpl::GetScaledEnclosingRectInTargetSpace(float scale) const {
   gfx::Transform scaled_draw_transform = DrawTransform();
   scaled_draw_transform.Scale(SK_MScalar1 / scale, SK_MScalar1 / scale);
   gfx::Size scaled_bounds = gfx::ScaleToCeiledSize(bounds(), scale);
   return MathUtil::MapEnclosingClippedRect(scaled_draw_transform,
                                            gfx::Rect(scaled_bounds));
 }
 
+RenderSurfaceImpl* LayerImpl::render_target() {
+  EffectTree& effect_tree = layer_tree_impl_->property_trees()->effect_tree;
+  EffectNode* node = effect_tree.Node(effect_tree_index_);
+
+  if (node->data.render_surface)
+    return node->data.render_surface;
+  else
+    return effect_tree.Node(node->data.target_id)->data.render_surface;
+}
+
+const RenderSurfaceImpl* LayerImpl::render_target() const {
+  const EffectTree& effect_tree =
+      layer_tree_impl_->property_trees()->effect_tree;
+  const EffectNode* node = effect_tree.Node(effect_tree_index_);
+
+  if (node->data.render_surface)
+    return node->data.render_surface;
+  else
+    return effect_tree.Node(node->data.target_id)->data.render_surface;
+}
+
 bool LayerImpl::IsHidden() const {
   EffectTree& effect_tree = layer_tree_impl_->property_trees()->effect_tree;
   EffectNode* node = effect_tree.Node(effect_tree_index_);
   return node->data.screen_space_opacity == 0.f;
 }
 
 bool LayerImpl::InsideReplica() const {
   // There are very few render targets so this should be cheap to do for each
   // layer instead of something more complicated.
   EffectTree& effect_tree = layer_tree_impl_->property_trees()->effect_tree;
   EffectNode* node = effect_tree.Node(effect_tree_index_);
 
-  while (node) {
-    EffectNode* target_node = effect_tree.Node(node->data.target_id);
-    LayerImpl* target_layer =
-        layer_tree_impl()->LayerById(target_node->owner_id);
+  while (node->id > 0) {
+    LayerImpl* target_layer = layer_tree_impl()->LayerById(node->owner_id);
     DCHECK(target_layer);
     if (target_layer->has_replica())
       return true;
-    node = effect_tree.parent(target_node);
+    node = effect_tree.Node(node->data.target_id);
   }
 
   return false;
 }
 
 float LayerImpl::GetIdealContentsScale() const {
   float page_scale = IsAffectedByPageScale()
                          ? layer_tree_impl()->current_page_scale_factor()
                          : 1.f;
   float device_scale = layer_tree_impl()->device_scale_factor();
 
   float default_scale = page_scale * device_scale;
   if (!layer_tree_impl()
            ->settings()
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       DrawTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc