cc: Update effect_tree backface visibility when transform is updated.

cc/trees/draw_property_utils.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 "cc/trees/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 770 matching lines @@
       property_trees->transform_tree, can_render_to_separate_surface);
 }
 
 void UpdatePropertyTrees(PropertyTrees* property_trees,
                          bool can_render_to_separate_surface) {
   if (property_trees->non_root_surfaces_enabled !=
       can_render_to_separate_surface) {
     property_trees->non_root_surfaces_enabled = can_render_to_separate_surface;
     property_trees->transform_tree.set_needs_update(true);
   }
-  if (property_trees->transform_tree.needs_update())
+  if (property_trees->transform_tree.needs_update()) {
     property_trees->clip_tree.set_needs_update(true);
+    property_trees->effect_tree.set_needs_update(true);

[jaydasika, 2016/05/19 17:07:58]

I think it will be better if we call set_needs_update on effect tree only when
its actually needed. One possible way to do that would be to check in
OnTransformAnimated if bf-visibility can change and set_needs_update on effect
tree to true there itself if it can change. (For instance, if the old and the
new transforms in OnTransformAnimated are both translations, then bf-visibility
cannot change. On the other hand, if one of them is rotation, it can change).
WDYT?

[ajuma, 2016/05/19 17:18:14]

That's a good point. If we did that, we'd also have to check this in other
places where the transform can change (e.g., when updating newly-pushed property
trees with animated transforms from the existing tree). Given that this CL needs
to get merged to 51, I think it's safest to do the simple thing first and merge
that, and then implement your suggestion in a follow-up.

[Peter Mayo, 2016/05/19 17:33:20]

It is not true that a translation can never change the visible face.  For
example, when looking down a long tunnel with perspective, if you translate one
side to the other you see the other face.  This is similar to the error of using
the z component to determine backface visibility.

[jaydasika, 2016/05/19 17:52:18]

Ya, we will need to consider perspective also.

[jaydasika, 2016/05/19 17:52:18]

Agreed, we should do the simple thing as this needs to be merged to 51.

[sunxd, 2016/05/19 17:59:56]

Yes, we can discuss about that after this CL.

+  }
   ComputeTransforms(&property_trees->transform_tree);
   ComputeClips(&property_trees->clip_tree, property_trees->transform_tree,
                can_render_to_separate_surface);
   ComputeEffects(&property_trees->effect_tree);
 }
 
 void ComputeVisibleRectsForTesting(PropertyTrees* property_trees,
                                    bool can_render_to_separate_surface,
                                    LayerList* update_layer_list) {
   CalculateVisibleRects<Layer>(*update_layer_list, property_trees->clip_tree,
@@ skipping 446 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc