Add a telemetry measurement for property tree performance.

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 <vector>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
@@ skipping 140 matching lines @@
 
 static bool IsInvisibleDueToTransform(Layer* layer, const TransformTree& tree) {
   return HasSingularTransform(layer, tree) || IsBackFaceInvisible(layer, tree);
 }
 
 void FindLayersThatNeedVisibleRects(Layer* layer,
                                     const TransformTree& tree,
                                     bool subtree_is_visible_from_ancestor,
                                     std::vector<Layer*>* layers_to_update) {
   const bool subtree_is_invisble =
-      layer->opacity() == 0.0f ||

[Ian Vollick, 2015/02/15 06:27:18]

Is it bogus to calculate visible content rects for layers with zero opacity, or
just inefficient? This check was causing some failures for me (missing VCRs). I
assume that this will all be subsumed with your modifications to this method in
your switch-to-property-trees patch.

[enne (OOO), 2015/02/17 17:40:14]

I don't think this function goes away.  Where was it failing?

[Ian Vollick, 2015/02/18 05:22:43]

Sorry, I didn't mean to imply that it was going away. I think the problem is in
the conflation of the I-need-a-visible-content-rect and I-need-to-be-in-the-RSLL
concepts and that your patch will fix that. I constantly tripping the checks in
the property tree verification code due to zero opacity layers that needed VCRs.
This seemed strange to me at first (what were these zero opacity layers) but it
looks like these were just overlay scollbars. Here's a portion of the layer tree
from NTP:


        7 Root Transform Layer, (hidden)
          8 Inner Viewport Container Layer, (hidden)
            bounds: (1270, 940)
            9 Overscroll Elasticity Layer, (hidden)
              10 Page Scale Layer, (hidden)
                11 Inner Viewport Scroll Layer, (hidden)
                  bounds: (1270, 940)
                  2 Overflow Controls Host Layer, (hidden)
                    bounds: (1270, 940)
                    3 LocalFrame Clipping Layer, (hidden)
                      bounds: (1270, 940)
                      4 LocalFrame Scrolling Layer, (hidden)
                        bounds: (1270, 940)
                        1 Content Root Layer, (hidden)
                          bounds: (1270, 940)
                          19 RenderView #document, reasons(Is the root layer)
                            bounds: (1270, 940)
                            transform originr: (635, 470, 0)
            12 Overlay Scrollbar Horizontal Layer, (hidden)
              bounds: (1260, 10)
              position: (0, 930)
              draw_transform:
              1 0 0 0
              0 1 0 930
              0 0 1 0
              0 0 0 1
              14 ContentsLayer for Overlay Scrollbar Horizontal Layer
                bounds: (1260, 10)
                draw_transform:
                1 0 0 0
                0 1 0 930
                0 0 1 0
                0 0 0 1
                opacity:0
            13 Overlay Scrollbar Vertical Layer, (hidden)
              bounds: (10, 930)
              position: (1260, 0)
              draw_transform:
              1 0 0 1260
              0 1 0 0
              0 0 1 0
              0 0 0 1
              [*] 15 ContentsLayer for Overlay Scrollbar Vertical Layer
                bounds: (10, 930)
                draw_transform:
                1 0 0 1260
                0 1 0 0
                0 0 1 0
                0 0 0 1
                opacity:0

[Ian Vollick, 2015/02/19 07:07:44]

Stepping through this example, it looks like the problem is that the scrollbars
have impl-only-animations. Matching the opacity check in LTHC's
SubtreeShouldBeSkipped catches this case and we no longer crash. Should be fixed
now.

       (layer->has_render_surface() && !layer->double_sided() &&
        IsSurfaceBackFaceExposed(layer, tree));
 
   if (subtree_is_invisble)
     return;
 
   bool layer_is_drawn =
       layer->HasCopyRequest() ||
       (subtree_is_visible_from_ancestor && !layer->hide_layer_and_subtree());
 
@@ skipping 99 matching lines @@
 
   std::vector<Layer*> layers_to_update;
   const bool subtree_is_visible_from_ancestor = true;
   FindLayersThatNeedVisibleRects(root_layer, *transform_tree,
                                  subtree_is_visible_from_ancestor,
                                  &layers_to_update);
   CalculateVisibleRects(layers_to_update, *clip_tree, *transform_tree);
 }
 
 }  // namespace cc