cc: Plumbing for storing property trees

In order to commit property trees to the compositor thread, they need to
be stored on the LayerTreeHost/LayerTreeImpl.  This change adds plumbing
so that the PropertyTree computation is not entirely internal to CDP.

BUG=386793

Review URL: https://codereview.chromium.org/1062403002

Cr-Commit-Position: refs/heads/master@{#324331}

cc/trees/draw_property_utils.cc

@@ -306,21 +306,20 @@ void ComputeVisibleRectsUsingPropertyTrees(
     float device_scale_factor,
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
-    TransformTree* transform_tree,
-    ClipTree* clip_tree,
-    OpacityTree* opacity_tree) {
+    PropertyTrees* property_trees) {
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer, page_scale_layer, page_scale_factor, device_scale_factor,
-      viewport, device_transform, transform_tree, clip_tree, opacity_tree);
-  ComputeTransforms(transform_tree);
-  ComputeClips(clip_tree, *transform_tree);
+      viewport, device_transform, property_trees);
+  ComputeTransforms(&property_trees->transform_tree);
+  ComputeClips(&property_trees->clip_tree, property_trees->transform_tree);
 
   std::vector<Layer*> layers_to_update;
   const bool subtree_is_visible_from_ancestor = true;
-  FindLayersThatNeedVisibleRects(root_layer, *transform_tree,
+  FindLayersThatNeedVisibleRects(root_layer, property_trees->transform_tree,
                                  subtree_is_visible_from_ancestor,
                                  &layers_to_update);
-  CalculateVisibleRects(layers_to_update, *clip_tree, *transform_tree);
+  CalculateVisibleRects(layers_to_update, property_trees->clip_tree,
+                        property_trees->transform_tree);
 }
 
 }  // namespace cc

cc/trees/draw_property_utils.h

@@ -18,6 +18,7 @@ class ClipTree;
 class Layer;
 class OpacityTree;
 class TransformTree;
+class PropertyTrees;
 
 // Computes combined clips for every node in |clip_tree|. This function requires
 // that |transform_tree| has been updated via |ComputeTransforms|.
@@ -40,9 +41,7 @@ ComputeVisibleRectsUsingPropertyTrees(Layer* root_layer,
                                       float device_scale_factor,
                                       const gfx::Rect& viewport,
                                       const gfx::Transform& device_transform,
-                                      TransformTree* transform_tree,
-                                      ClipTree* clip_tree,
-                                      OpacityTree* opacity_tree);
+                                      PropertyTrees* property_trees);
 
 }  // namespace cc
 

cc/trees/layer_tree_host.cc

@@ -796,6 +796,7 @@ bool LayerTreeHost::UpdateLayers(Layer* root_layer,
     // that we won't be able to detect if a layer is part of |update_list|.
     // Change this if this information is required.
     int render_surface_layer_list_id = 0;
+    PropertyTrees property_trees;
     LayerTreeHostCommon::CalcDrawPropsMainInputs inputs(
         root_layer, device_viewport_size(), gfx::Transform(),
         device_scale_factor_, page_scale_factor_, page_scale_layer,
@@ -805,7 +806,7 @@ bool LayerTreeHost::UpdateLayers(Layer* root_layer,
         can_render_to_separate_surface,
         settings_.layer_transforms_should_scale_layer_contents,
         settings_.verify_property_trees, &update_list,
-        render_surface_layer_list_id);
+        render_surface_layer_list_id, &property_trees);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   }
 

cc/trees/layer_tree_host_common.cc

@@ -2504,9 +2504,6 @@ void LayerTreeHostCommon::CalculateDrawProperties(
 
     // The translation from layer to property trees is an intermediate state. We
     // will eventually get these data passed directly to the compositor.
-    TransformTree transform_tree;
-    ClipTree clip_tree;
-    OpacityTree opacity_tree;
     {
       TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
                    "LayerTreeHostCommon::ComputeVisibleRectsWithPropertyTrees");
@@ -2514,7 +2511,7 @@ void LayerTreeHostCommon::CalculateDrawProperties(
           inputs->root_layer, inputs->page_scale_application_layer,
           inputs->page_scale_factor, inputs->device_scale_factor,
           gfx::Rect(inputs->device_viewport_size), inputs->device_transform,
-          &transform_tree, &clip_tree, &opacity_tree);
+          inputs->property_trees);
     }
 
     LayerIterator<Layer> it, end;
@@ -2533,14 +2530,16 @@ void LayerTreeHostCommon::CalculateDrawProperties(
           << " actual: "
           << current_layer->visible_rect_from_property_trees().ToString();
 
-      const bool draw_transforms_match = ApproximatelyEqual(
-          current_layer->draw_transform(),
-          current_layer->draw_transform_from_property_trees(transform_tree));
+      const bool draw_transforms_match =
+          ApproximatelyEqual(current_layer->draw_transform(),
+                             current_layer->draw_transform_from_property_trees(
+                                 inputs->property_trees->transform_tree));
       CHECK(draw_transforms_match);
 
       const bool draw_opacities_match =
           current_layer->draw_opacity() ==
-          current_layer->DrawOpacityFromPropertyTrees(opacity_tree);
+          current_layer->DrawOpacityFromPropertyTrees(
+              inputs->property_trees->opacity_tree);
       CHECK(draw_opacities_match);
     }
   }

cc/trees/layer_tree_host_common.h

@@ -13,6 +13,7 @@
 #include "cc/base/cc_export.h"
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/layers/layer_lists.h"
+#include "cc/trees/property_tree.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/transform.h"
@@ -22,6 +23,7 @@ namespace cc {
 class LayerImpl;
 class Layer;
 class SwapPromise;
+class PropertyTrees;
 
 class CC_EXPORT LayerTreeHostCommon {
  public:
@@ -47,7 +49,8 @@ class CC_EXPORT LayerTreeHostCommon {
                         bool can_adjust_raster_scales,
                         bool verify_property_trees,
                         RenderSurfaceLayerListType* render_surface_layer_list,
-                        int current_render_surface_layer_list_id)
+                        int current_render_surface_layer_list_id,
+                        PropertyTrees* property_trees)
         : root_layer(root_layer),
           device_viewport_size(device_viewport_size),
           device_transform(device_transform),
@@ -65,7 +68,8 @@ class CC_EXPORT LayerTreeHostCommon {
           verify_property_trees(verify_property_trees),
           render_surface_layer_list(render_surface_layer_list),
           current_render_surface_layer_list_id(
-              current_render_surface_layer_list_id) {}
+              current_render_surface_layer_list_id),
+          property_trees(property_trees) {}
 
     LayerType* root_layer;
     gfx::Size device_viewport_size;
@@ -83,6 +87,7 @@ class CC_EXPORT LayerTreeHostCommon {
     bool verify_property_trees;
     RenderSurfaceLayerListType* render_surface_layer_list;
     int current_render_surface_layer_list_id;
+    PropertyTrees* property_trees;
   };
 
   template <typename LayerType, typename RenderSurfaceLayerListType>
@@ -100,6 +105,7 @@ class CC_EXPORT LayerTreeHostCommon {
 
    private:
     const gfx::Transform identity_transform_;
+    PropertyTrees property_trees;
   };
 
   typedef CalcDrawPropsInputs<Layer, RenderSurfaceLayerList>
@@ -251,7 +257,8 @@ LayerTreeHostCommon::CalcDrawPropsInputsForTesting<LayerType,
           false,
           true,
           render_surface_layer_list,
-          0) {
+          0,
+          &property_trees) {
   DCHECK(root_layer);
   DCHECK(render_surface_layer_list);
 }
@@ -279,7 +286,8 @@ LayerTreeHostCommon::CalcDrawPropsInputsForTesting<LayerType,
           false,
           true,
           render_surface_layer_list,
-          0) {
+          0,
+          &property_trees) {
   DCHECK(root_layer);
   DCHECK(render_surface_layer_list);
 }

cc/trees/layer_tree_host_common_perftest.cc

@@ -89,6 +89,7 @@ class CalcDrawPropsMainTest : public LayerTreeHostCommonPerfTest {
       bool verify_property_trees = false;
       int max_texture_size = 8096;
       RenderSurfaceLayerList update_list;
+      PropertyTrees property_trees;
       LayerTreeHostCommon::CalcDrawPropsMainInputs inputs(
           layer_tree_host()->root_layer(),
           layer_tree_host()->device_viewport_size(), gfx::Transform(),
@@ -103,7 +104,7 @@ class CalcDrawPropsMainTest : public LayerTreeHostCommonPerfTest {
           layer_tree_host()
               ->settings()
               .layer_transforms_should_scale_layer_contents,
-          verify_property_trees, &update_list, 0);
+          verify_property_trees, &update_list, 0, &property_trees);
       LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
       timer_.NextLap();
@@ -144,6 +145,7 @@ class CalcDrawPropsImplTest : public LayerTreeHostCommonPerfTest {
                                 LayerTreeImpl* active_tree,
                                 LayerTreeHostImpl* host_impl) {
     LayerImplList update_list;
+    PropertyTrees property_trees;
     bool verify_property_trees = false;
     LayerTreeHostCommon::CalcDrawPropsImplInputs inputs(
         active_tree->root_layer(), active_tree->DrawViewportSize(),
@@ -156,7 +158,7 @@ class CalcDrawPropsImplTest : public LayerTreeHostCommonPerfTest {
         host_impl->settings().layers_always_allowed_lcd_text,
         can_render_to_separate_surface,
         host_impl->settings().layer_transforms_should_scale_layer_contents,
-        verify_property_trees, &update_list, 0);
+        verify_property_trees, &update_list, 0, &property_trees);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   }
 };

cc/trees/layer_tree_impl.cc

@@ -539,6 +539,10 @@ bool LayerTreeImpl::UpdateDrawProperties(bool update_lcd_text) {
          DRAW_MODE_RESOURCELESS_SOFTWARE);
 
     ++render_surface_layer_list_id_;
+
+    // TODO(enne): Synchronize property trees to compositor thread and use
+    // them here.
+    PropertyTrees* property_trees = nullptr;
     LayerTreeHostCommon::CalcDrawPropsImplInputs inputs(
         root_layer(), DrawViewportSize(),
         layer_tree_host_impl_->DrawTransform(), device_scale_factor(),
@@ -548,8 +552,8 @@ bool LayerTreeImpl::UpdateDrawProperties(bool update_lcd_text) {
         settings().can_use_lcd_text, settings().layers_always_allowed_lcd_text,
         can_render_to_separate_surface,
         settings().layer_transforms_should_scale_layer_contents,
-        settings().verify_property_trees,
-        &render_surface_layer_list_, render_surface_layer_list_id_);
+        settings().verify_property_trees, &render_surface_layer_list_,
+        render_surface_layer_list_id_, property_trees);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   }
 

cc/trees/property_tree.h

@@ -197,6 +197,13 @@ class CC_EXPORT ClipTree final : public PropertyTree<ClipNode> {};
 
 class CC_EXPORT OpacityTree final : public PropertyTree<OpacityNode> {};
 
+class CC_EXPORT PropertyTrees final {
+ public:
+  TransformTree transform_tree;
+  OpacityTree opacity_tree;
+  ClipTree clip_tree;
+};
+
 }  // namespace cc
 
 #endif  // CC_TREES_PROPERTY_TREE_H_

cc/trees/property_tree_builder.cc

@@ -318,13 +318,11 @@ void PropertyTreeBuilder::BuildPropertyTrees(
     float device_scale_factor,
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
-    TransformTree* transform_tree,
-    ClipTree* clip_tree,
-    OpacityTree* opacity_tree) {
+    PropertyTrees* property_trees) {
   DataForRecursion data_for_recursion;
-  data_for_recursion.transform_tree = transform_tree;
-  data_for_recursion.clip_tree = clip_tree;
-  data_for_recursion.opacity_tree = opacity_tree;
+  data_for_recursion.transform_tree = &property_trees->transform_tree;
+  data_for_recursion.clip_tree = &property_trees->clip_tree;
+  data_for_recursion.opacity_tree = &property_trees->opacity_tree;
   data_for_recursion.transform_tree_parent = nullptr;
   data_for_recursion.transform_fixed_parent = nullptr;
   data_for_recursion.render_target = root_layer;
@@ -340,7 +338,8 @@ void PropertyTreeBuilder::BuildPropertyTrees(
   ClipNode root_clip;
   root_clip.data.clip = viewport;
   root_clip.data.transform_id = 0;
-  data_for_recursion.clip_tree_parent = clip_tree->Insert(root_clip, 0);
+  data_for_recursion.clip_tree_parent =
+      data_for_recursion.clip_tree->Insert(root_clip, 0);
   BuildPropertyTreesInternal(root_layer, data_for_recursion);
 }
 

cc/trees/property_tree_builder.h

@@ -24,9 +24,7 @@ class PropertyTreeBuilder {
                                  float device_scale_factor,
                                  const gfx::Rect& viewport,
                                  const gfx::Transform& device_transform,
-                                 TransformTree* transform_tree,
-                                 ClipTree* clip_tree,
-                                 OpacityTree* opacity_tree);
+                                 PropertyTrees* property_trees);
 };
 
 }  // namespace cc