SubtreeShouldBeSkipped uses information from property trees

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 420 matching lines @@
       data.layers_are_clipped_when_surfaces_disabled();
   resets_clip = data.resets_clip();
 }
 
 EffectNodeData::EffectNodeData()
     : opacity(1.f),
       screen_space_opacity(1.f),
       has_render_surface(false),
       has_copy_request(false),
       has_background_filters(false),
+      node_or_ancestor_has_background_filters(false),
+      to_screen_opacity_is_animated(false),
+      node_or_ancestor_has_backface_visible_surface(false),
       is_drawn(true),
       has_animated_opacity(false),
       effect_changed(false),
       num_copy_requests_in_subtree(0),
       transform_id(0),
       clip_id(0) {}
 
 EffectNodeData::EffectNodeData(const EffectNodeData& other) = default;
 
 bool EffectNodeData::operator==(const EffectNodeData& other) const {
   return opacity == other.opacity &&
          screen_space_opacity == other.screen_space_opacity &&
          has_render_surface == other.has_render_surface &&
          has_copy_request == other.has_copy_request &&
          has_background_filters == other.has_background_filters &&
+         node_or_ancestor_has_background_filters ==
+             other.node_or_ancestor_has_background_filters &&
+         to_screen_opacity_is_animated == other.to_screen_opacity_is_animated &&
+         node_or_ancestor_has_backface_visible_surface ==
+             other.node_or_ancestor_has_backface_visible_surface &&
          is_drawn == other.is_drawn &&
          has_animated_opacity == other.has_animated_opacity &&
          effect_changed == other.effect_changed &&
          num_copy_requests_in_subtree == other.num_copy_requests_in_subtree &&
          transform_id == other.transform_id && clip_id == other.clip_id;
 }
 
 void EffectNodeData::ToProtobuf(proto::TreeNode* proto) const {
   DCHECK(!proto->has_effect_node_data());
   proto::EffectNodeData* data = proto->mutable_effect_node_data();
   data->set_opacity(opacity);
   data->set_screen_space_opacity(screen_space_opacity);
   data->set_has_render_surface(has_render_surface);
   data->set_has_copy_request(has_copy_request);
   data->set_has_background_filters(has_background_filters);
+  data->set_node_or_ancestor_has_background_filters(
+      node_or_ancestor_has_background_filters);
+  data->set_to_screen_opacity_is_animated(to_screen_opacity_is_animated);
+  data->set_node_or_ancestor_has_backface_visible_surface(
+      node_or_ancestor_has_backface_visible_surface);
   data->set_is_drawn(is_drawn);
   data->set_has_animated_opacity(has_animated_opacity);
   data->set_effect_changed(effect_changed);
   data->set_num_copy_requests_in_subtree(num_copy_requests_in_subtree);
   data->set_transform_id(transform_id);
   data->set_clip_id(clip_id);
 }
 
 void EffectNodeData::FromProtobuf(const proto::TreeNode& proto) {
   DCHECK(proto.has_effect_node_data());
   const proto::EffectNodeData& data = proto.effect_node_data();
 
   opacity = data.opacity();
   screen_space_opacity = data.screen_space_opacity();
   has_render_surface = data.has_render_surface();
   has_copy_request = data.has_copy_request();
   has_background_filters = data.has_background_filters();
+  node_or_ancestor_has_background_filters =
+      data.node_or_ancestor_has_background_filters();
+  to_screen_opacity_is_animated = data.to_screen_opacity_is_animated();
+  node_or_ancestor_has_backface_visible_surface =
+      data.node_or_ancestor_has_backface_visible_surface();
   is_drawn = data.is_drawn();
   has_animated_opacity = data.has_animated_opacity();
   effect_changed = data.effect_changed();
   num_copy_requests_in_subtree = data.num_copy_requests_in_subtree();
   transform_id = data.transform_id();
   clip_id = data.clip_id();
 }
 
 ScrollNodeData::ScrollNodeData()
     : scrollable(false),
@@ skipping 700 matching lines @@
     node->data.is_drawn = true;
 }
 
 void EffectTree::UpdateEffectChanged(EffectNode* node,
                                      EffectNode* parent_node) {
   if (parent_node && parent_node->data.effect_changed) {
     node->data.effect_changed = true;
   }
 }
 
+void EffectTree::UpdateBackfaceVisibility(EffectNode* node,
+                                          EffectNode* parent_node) {
+  if (node->owner_id == -1) {

[jaydasika, 2016/03/29 15:48:43]

Are there any cases where the owner id will be -1 ?

[sunxd, 2016/03/30 15:21:34]

The only case is the dummy tree root. Another option to check whether it's the
root are its id or parent id.

[ajuma, 2016/03/30 17:10:11]

How about just checking if parent_node is null?

+    node->data.node_or_ancestor_has_backface_visible_surface = false;
+    return;
+  }
+  if (parent_node &&
+      parent_node->data.node_or_ancestor_has_backface_visible_surface) {
+    node->data.node_or_ancestor_has_backface_visible_surface = true;

[ajuma, 2016/03/29 17:06:46]

I think this early-out is only valid if we're taking double-sidededness into
account. That is, if we have a non-double-sided backfacing ancestor surface,
then the subtree rooted at that ancestor is invisible. But if that backfacing
ancestor is double-sided, then it doesn't cause its descendants to be invisible.

[sunxd, 2016/03/30 15:21:34]

Done.

+    return;
+  }
+
+  TransformTree& transform_tree = property_trees()->transform_tree;
+  TransformNode* transform_node = transform_tree.Node(node->data.transform_id);

[ajuma, 2016/03/29 17:06:46]

Is this the right transform id? I think this is the parent node of the node
corresponding to this surface.

[sunxd, 2016/03/30 15:21:34]

I think it is the correct one. In AddEffectNodeIfNeeded, the transform_id for a
render surface is transform_tree's next available id.
(https://code.google.com/p/chromium/codesearch#chromium/src/cc/trees/property_...)

+  if (node->data.has_render_surface) {
+    if (transform_node->data.is_invertible &&
+        transform_node->data.ancestors_are_invertible) {
+      if (transform_node->data.sorting_context_id) {
+        const TransformNode* parent_transform_node =
+            transform_tree.parent(transform_node);
+        if (parent_transform_node &&
+            parent_transform_node->data.sorting_context_id ==
+                transform_node->data.sorting_context_id) {
+          gfx::Transform surface_draw_transform;
+          transform_tree.ComputeTransform(transform_node->id,
+                                          transform_node->data.target_id,
+                                          &surface_draw_transform);
+          node->data.node_or_ancestor_has_backface_visible_surface =
+              surface_draw_transform.IsBackFaceVisible();
+        } else {
+          node->data.node_or_ancestor_has_backface_visible_surface =
+              transform_node->data.local.IsBackFaceVisible();
+        }
+        return;
+      }
+    }
+  }
+  node->data.node_or_ancestor_has_backface_visible_surface = false;
+}
+
 void EffectTree::UpdateEffects(int id) {
   EffectNode* node = Node(id);
   EffectNode* parent_node = parent(node);
 
   UpdateOpacities(node, parent_node);
   UpdateIsDrawn(node, parent_node);
   UpdateEffectChanged(node, parent_node);
+  UpdateBackfaceVisibility(node, parent_node);
 }
 
 void EffectTree::ClearCopyRequests() {
   for (auto& node : nodes()) {
     node.data.num_copy_requests_in_subtree = 0;
     node.data.has_copy_request = false;
   }
   set_needs_update(true);
 }
 
@@ skipping 625 matching lines @@
       break;
     case ALL_TREES:
       transform_tree.ResetChangeTracking();
       effect_tree.ResetChangeTracking();
   }
   changed = false;
   full_tree_damaged = false;
 }
 
 }  // namespace cc