cc : Layers with singular transforms and copy request should be drawn

cc/trees/layer_tree_host_common.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>
 
@@ skipping 304 matching lines @@
   if (is_occlusion_immune) {
     render_surface->SetNearestOcclusionImmuneAncestor(render_surface);
   } else if (is_root) {
     render_surface->SetNearestOcclusionImmuneAncestor(nullptr);
   } else {
     render_surface->SetNearestOcclusionImmuneAncestor(
         render_surface->render_target()->nearest_occlusion_immune_ancestor());
   }
 }
 
+static bool SkipForInvertibility(const LayerImpl* layer,
+                                 PropertyTrees* property_trees) {
+  const TransformNode* transform_node =
+      property_trees->transform_tree.Node(layer->transform_tree_index());
+  const EffectNode* effect_node =
+      property_trees->effect_tree.Node(layer->effect_tree_index());
+  bool non_root_copy_request =
+      effect_node->closest_ancestor_with_copy_request_id >
+      EffectTree::kContentsRootNodeId;
+  gfx::Transform from_target;
+  // If there is a copy request, we check the invertibility of the transform
+  // between the node corresponding to the layer and the node corresponding to
+  // the copy request. Otherwise, we are interested in the invertibility of
+  // screen space transform which is already cached on the transform node.
+  return non_root_copy_request
+             ? !property_trees->GetFromTarget(
+                   layer->transform_tree_index(),
+                   effect_node->closest_ancestor_with_copy_request_id,
+                   &from_target)
+             : !transform_node->ancestors_are_invertible;
+}
+
 static void ComputeInitialRenderSurfaceList(
     LayerTreeImpl* layer_tree_impl,
     PropertyTrees* property_trees,
     RenderSurfaceList* render_surface_list,
     bool can_render_to_separate_surface) {
   EffectTree& effect_tree = property_trees->effect_tree;
   for (int i = EffectTree::kContentsRootNodeId;
        i < static_cast<int>(effect_tree.size()); ++i) {
     if (RenderSurfaceImpl* render_surface = effect_tree.GetRenderSurface(i)) {
       render_surface->set_is_render_surface_list_member(false);
@@ skipping 12 matching lines @@
   // surface's accumulated content rect.
   for (LayerImpl* layer : *layer_tree_impl) {
     layer->set_contributes_to_drawn_render_surface(false);
 
     bool is_root = layer_tree_impl->IsRootLayer(layer);
 
     bool skip_draw_properties_computation =
         draw_property_utils::LayerShouldBeSkippedForDrawPropertiesComputation(
             layer, property_trees->transform_tree, property_trees->effect_tree);
 
-    const TransformNode* transform_node =
-        property_trees->transform_tree.Node(layer->transform_tree_index());
-    bool skip_for_invertibility = !transform_node->ancestors_are_invertible;
+    bool skip_for_invertibility = SkipForInvertibility(layer, property_trees);
 
     bool skip_layer = !is_root && (skip_draw_properties_computation ||
                                    skip_for_invertibility);
 
     layer->set_raster_even_if_not_in_rsll(skip_for_invertibility &&
                                           !skip_draw_properties_computation);
     if (skip_layer)
       continue;
 
     bool layer_is_drawn =
@@ skipping 292 matching lines @@
 
 PropertyTrees* GetPropertyTrees(Layer* layer) {
   return layer->layer_tree_host()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer) {
   return layer->layer_tree_impl()->property_trees();
 }
 
 }  // namespace cc