Add a flag for enabling compositor property trees

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/draw_properties.h"
@@ skipping 570 matching lines @@
   for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i)
     effect_tree->UpdateOpacities(i);
   effect_tree->set_needs_update(false);
 }
 
 template <typename LayerType>
 void ComputeVisibleRectsUsingPropertyTreesInternal(
     LayerType* root_layer,
     PropertyTrees* property_trees,
     bool can_render_to_separate_surface,
-    typename LayerType::LayerListType* update_layer_list) {
+    typename LayerType::LayerListType* update_layer_list,
+    std::vector<LayerType*>* visible_layer_list) {
   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())
     property_trees->clip_tree.set_needs_update(true);
   ComputeTransforms(&property_trees->transform_tree);
   ComputeClips(&property_trees->clip_tree, property_trees->transform_tree,
                can_render_to_separate_surface);
   ComputeOpacities(&property_trees->effect_tree);
 
   const bool subtree_is_visible_from_ancestor = true;
-  std::vector<LayerType*> visible_layer_list;
   FindLayersThatNeedUpdates(root_layer, property_trees->transform_tree,
                             subtree_is_visible_from_ancestor, update_layer_list,
-                            &visible_layer_list);
+                            visible_layer_list);
   CalculateVisibleRects<LayerType>(
-      visible_layer_list, property_trees->clip_tree,
+      *visible_layer_list, property_trees->clip_tree,
       property_trees->transform_tree, can_render_to_separate_surface);
 }
 
 void BuildPropertyTreesAndComputeVisibleRects(
     Layer* root_layer,
     const Layer* page_scale_layer,
     const Layer* inner_viewport_scroll_layer,
     const Layer* outer_viewport_scroll_layer,
     float page_scale_factor,
     float device_scale_factor,
@@ skipping 15 matching lines @@
     LayerImpl* root_layer,
     const LayerImpl* page_scale_layer,
     const LayerImpl* inner_viewport_scroll_layer,
     const LayerImpl* outer_viewport_scroll_layer,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
     bool can_render_to_separate_surface,
     PropertyTrees* property_trees,
-    LayerImplList* update_layer_list) {
+    LayerImplList* visible_layer_list) {
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, page_scale_factor, device_scale_factor,
       viewport, device_transform, property_trees);
   ComputeVisibleRectsUsingPropertyTrees(root_layer, property_trees,
                                         can_render_to_separate_surface,
-                                        update_layer_list);
+                                        visible_layer_list);
 }
 
 void ComputeVisibleRectsUsingPropertyTrees(Layer* root_layer,
                                            PropertyTrees* property_trees,
                                            bool can_render_to_separate_surface,
                                            LayerList* update_layer_list) {
-  ComputeVisibleRectsUsingPropertyTreesInternal(root_layer, property_trees,
-                                                can_render_to_separate_surface,
-                                                update_layer_list);
+  std::vector<Layer*> visible_layer_list;
+  ComputeVisibleRectsUsingPropertyTreesInternal(
+      root_layer, property_trees, can_render_to_separate_surface,
+      update_layer_list, &visible_layer_list);
 }
 
 void ComputeVisibleRectsUsingPropertyTrees(LayerImpl* root_layer,
                                            PropertyTrees* property_trees,
                                            bool can_render_to_separate_surface,
-                                           LayerImplList* update_layer_list) {
-  ComputeVisibleRectsUsingPropertyTreesInternal(root_layer, property_trees,
-                                                can_render_to_separate_surface,
-                                                update_layer_list);
+                                           LayerImplList* visible_layer_list) {
+  LayerImplList update_layer_list;
+  ComputeVisibleRectsUsingPropertyTreesInternal(
+      root_layer, property_trees, can_render_to_separate_surface,
+      &update_layer_list, visible_layer_list);
 }
 
 template <typename LayerType>
 gfx::Transform DrawTransformFromPropertyTreesInternal(
     const LayerType* layer,
     const TransformNode* node) {
   gfx::Transform xform;
   const bool owns_non_root_surface =
       layer->parent() && layer->has_render_surface();
   if (!owns_non_root_surface) {
@@ skipping 368 matching lines @@
     const Layer* page_scale_layer,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Transform device_transform) {
   UpdatePageScaleFactorInPropertyTreesInternal(
       property_trees, page_scale_layer, page_scale_factor, device_scale_factor,
       device_transform);
 }
 
 }  // namespace cc