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

cc/trees/property_tree.cc

 // Copyright 2014 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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 766 matching lines @@
 #if DCHECK_IS_ON()
   EffectTree tree;
   DCHECK(tree == *this);
 #endif
 }
 
 float EffectTree::EffectiveOpacity(const EffectNode* node) const {
   return node->subtree_hidden ? 0.f : node->opacity;
 }
 
+void EffectTree::UpdateClosestAncestorWithCopyRequestId(
+    EffectNode* node,
+    EffectNode* parent_node) {
+  if (node->has_copy_request)
+    node->closest_ancestor_with_copy_request_id = node->id;
+  else if (parent_node)
+    node->closest_ancestor_with_copy_request_id =
+        parent_node->closest_ancestor_with_copy_request_id;
+  else
+    DCHECK_EQ(node->closest_ancestor_with_copy_request_id,
+              EffectTree::kInvalidNodeId);
+}
+
 void EffectTree::UpdateOpacities(EffectNode* node, EffectNode* parent_node) {
   node->screen_space_opacity = EffectiveOpacity(node);
 
   if (parent_node)
     node->screen_space_opacity *= parent_node->screen_space_opacity;
 }
 
 void EffectTree::UpdateIsDrawn(EffectNode* node, EffectNode* parent_node) {
   // Nodes that have screen space opacity 0 are hidden. So they are not drawn.
   // Exceptions:
@@ skipping 92 matching lines @@
   node->effect_changed = true;
   property_trees()->changed = true;
   property_trees()->effect_tree.set_needs_update(true);
   return true;
 }
 
 void EffectTree::UpdateEffects(int id) {
   EffectNode* node = Node(id);
   EffectNode* parent_node = parent(node);
 
+  UpdateClosestAncestorWithCopyRequestId(node, parent_node);
   UpdateOpacities(node, parent_node);
   UpdateIsDrawn(node, parent_node);
   UpdateEffectChanged(node, parent_node);
   UpdateBackfaceVisibility(node, parent_node);
   UpdateSurfaceContentsScale(node);
 }
 
 void EffectTree::AddCopyRequest(int node_id,
                                 std::unique_ptr<CopyOutputRequest> request) {
   copy_requests_.insert(std::make_pair(node_id, std::move(request)));
@@ skipping 70 matching lines @@
     node.subtree_has_copy_request = false;
     node.has_copy_request = false;
   }
 
   // Any copy requests that are still left will be aborted (sending an empty
   // result) on destruction.
   copy_requests_.clear();
   set_needs_update(true);
 }
 
-int EffectTree::ClosestAncestorWithCopyRequest(int id) const {
-  DCHECK_GE(id, EffectTree::kRootNodeId);
-  const EffectNode* node = Node(id);
-  while (node->id > EffectTree::kContentsRootNodeId) {
-    if (node->has_copy_request)
-      return node->id;
-
-    node = parent(node);
-  }
-
-  if (node->has_copy_request)
-    return node->id;
-  else
-    return EffectTree::kInvalidNodeId;
-}
-
 int EffectTree::LowestCommonAncestorWithRenderSurface(int id_1,
                                                       int id_2) const {
   DCHECK(GetRenderSurface(id_1));
   DCHECK(GetRenderSurface(id_2));
   while (id_1 != id_2) {
     if (id_1 < id_2)
       id_2 = Node(id_2)->target_id;
     else
       id_1 = Node(id_1)->target_id;
   }
@@ skipping 1127 matching lines @@
   const EffectNode* effect_node = effect_tree.Node(effect_id);
 
   if (effect_node->surface_contents_scale.x() != 0.0 &&
       effect_node->surface_contents_scale.y() != 0.0)
     screen_space_transform.Scale(1.0 / effect_node->surface_contents_scale.x(),
                                  1.0 / effect_node->surface_contents_scale.y());
   return screen_space_transform;
 }
 
 }  // namespace cc