Add a flag for enabling compositor property trees

cc/trees/layer_tree_host_common.cc

 // Copyright 2011 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/layer_tree_host_common.h"
 
 #include <algorithm>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 61 matching lines @@
     const LayerImpl* inner_viewport_scroll_layer,
     const LayerImpl* outer_viewport_scroll_layer,
     const gfx::Vector2dF& elastic_overscroll,
     const LayerImpl* elastic_overscroll_application_layer,
     int max_texture_size,
     bool can_use_lcd_text,
     bool layers_always_allowed_lcd_text,
     bool can_render_to_separate_surface,
     bool can_adjust_raster_scales,
     bool verify_property_trees,
+    bool use_property_trees,
     LayerImplList* render_surface_layer_list,
     int current_render_surface_layer_list_id,
     PropertyTrees* property_trees)
     : root_layer(root_layer),
       device_viewport_size(device_viewport_size),
       device_transform(device_transform),
       device_scale_factor(device_scale_factor),
       page_scale_factor(page_scale_factor),
       page_scale_layer(page_scale_layer),
       inner_viewport_scroll_layer(inner_viewport_scroll_layer),
       outer_viewport_scroll_layer(outer_viewport_scroll_layer),
       elastic_overscroll(elastic_overscroll),
       elastic_overscroll_application_layer(
           elastic_overscroll_application_layer),
       max_texture_size(max_texture_size),
       can_use_lcd_text(can_use_lcd_text),
       layers_always_allowed_lcd_text(layers_always_allowed_lcd_text),
       can_render_to_separate_surface(can_render_to_separate_surface),
       can_adjust_raster_scales(can_adjust_raster_scales),
       verify_property_trees(verify_property_trees),
+      use_property_trees(use_property_trees),
       render_surface_layer_list(render_surface_layer_list),
       current_render_surface_layer_list_id(
           current_render_surface_layer_list_id),
       property_trees(property_trees) {}
 
 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting::
     CalcDrawPropsImplInputsForTesting(LayerImpl* root_layer,
                                       const gfx::Size& device_viewport_size,
                                       const gfx::Transform& device_transform,
                                       LayerImplList* render_surface_layer_list)
     : CalcDrawPropsImplInputs(root_layer,
                               device_viewport_size,
                               device_transform,
                               1.f,
                               1.f,
                               NULL,
                               NULL,
                               NULL,
                               gfx::Vector2dF(),
                               NULL,
                               std::numeric_limits<int>::max() / 2,
                               false,
                               false,
                               true,
                               false,
                               true,
+                              false,
                               render_surface_layer_list,
                               0,
                               GetPropertyTrees(root_layer)) {
   DCHECK(root_layer);
   DCHECK(render_surface_layer_list);
 }
 
 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting::
     CalcDrawPropsImplInputsForTesting(LayerImpl* root_layer,
                                       const gfx::Size& device_viewport_size,
@@ skipping 2290 matching lines @@
 void CalculateRenderSurfaceLayerListInternal(
     LayerImpl* layer,
     PropertyTrees* property_trees,
     LayerImplList* render_surface_layer_list,
     LayerImplList* descendants,
     RenderSurfaceImpl* nearest_occlusion_immune_ancestor,
     bool subtree_visible_from_ancestor,
     const bool can_render_to_separate_surface,
     const int current_render_surface_layer_list_id,
     const int max_texture_size,
-    const bool verify_property_trees) {
+    const bool verify_property_trees,
+    const bool use_property_trees) {
   // This calculates top level Render Surface Layer List, and Layer List for all
   // Render Surfaces.
 
   // |layer| is current layer.
 
   // |render_surface_layer_list| is the top level RenderSurfaceLayerList.
 
   // |descendants| is used to determine what's in current layer's render
   // surface's layer list.
 
@@ skipping 24 matching lines @@
       (can_render_to_separate_surface && layer->render_surface());
 
   if (render_to_separate_surface) {
     DCHECK(layer->render_surface());
     if (!layer->double_sided() &&
         IsSurfaceBackFaceVisible(layer, layer->draw_transform())) {
       layer->ClearRenderSurfaceLayerList();
       layer->draw_properties().render_target = nullptr;
       return;
     }
+
+    if (use_property_trees) {
+      RenderSurfaceDrawProperties draw_properties;
+      ComputeSurfaceDrawPropertiesUsingPropertyTrees(
+          layer->render_surface(), property_trees, &draw_properties);
+      // TODO(ajuma): Once property tree verification is removed, make the above
+      // call directly set the surface's properties, so that the copying below
+      // is no longer needed.
+      layer->render_surface()->SetIsClipped(draw_properties.is_clipped);
+      layer->render_surface()->SetDrawOpacity(draw_properties.draw_opacity);
+      layer->render_surface()->SetDrawTransform(draw_properties.draw_transform);
+      layer->render_surface()->SetScreenSpaceTransform(
+          draw_properties.screen_space_transform);
+      layer->render_surface()->SetReplicaDrawTransform(
+          draw_properties.replica_draw_transform);
+      layer->render_surface()->SetReplicaScreenSpaceTransform(
+          draw_properties.replica_screen_space_transform);
+      layer->render_surface()->SetClipRect(draw_properties.clip_rect);
+    }
+
     if (IsRootLayer(layer)) {
       // The root surface does not contribute to any other surface, it has no
       // target.
       layer->render_surface()->set_contributes_to_drawn_surface(false);
     } else {
       // Even if the |layer_is_drawn|, it only contributes to a drawn surface
       // when the |layer_is_visible|.
       layer->render_surface()->set_contributes_to_drawn_surface(
           layer_is_visible);
     }
@@ skipping 21 matching lines @@
 
   size_t descendants_size = descendants->size();
 
   bool layer_should_be_skipped = LayerShouldBeSkipped(layer, layer_is_drawn);
   if (!layer_should_be_skipped) {
     MarkLayerWithRenderSurfaceLayerListId(layer,
                                           current_render_surface_layer_list_id);
     descendants->push_back(layer);
   }
 
+  bool compute_content_rects = verify_property_trees || use_property_trees;
+
   // Clear the old accumulated content rect of surface.
-  if (verify_property_trees && render_to_separate_surface)
+  if (compute_content_rects && render_to_separate_surface)
     layer->render_surface()->SetAccumulatedContentRect(gfx::Rect());
 
   for (auto& child_layer : layer->children()) {
     CalculateRenderSurfaceLayerListInternal(
         child_layer, property_trees, render_surface_layer_list, descendants,
         nearest_occlusion_immune_ancestor, layer_is_drawn,
         can_render_to_separate_surface, current_render_surface_layer_list_id,
-        max_texture_size, verify_property_trees);
+        max_texture_size, verify_property_trees, use_property_trees);
 
     // If the child is its own render target, then it has a render surface.
     if (child_layer->render_target() == child_layer &&
         !child_layer->render_surface()->layer_list().empty() &&
         !child_layer->render_surface()->content_rect().IsEmpty()) {
       // This child will contribute its render surface, which means
       // we need to mark just the mask layer (and replica mask layer)
       // with the id.
       MarkMasksWithRenderSurfaceLayerListId(
           child_layer, current_render_surface_layer_list_id);
       descendants->push_back(child_layer);
     }
 
     if (child_layer->layer_or_descendant_is_drawn()) {
       bool layer_or_descendant_is_drawn = true;
       layer->set_layer_or_descendant_is_drawn(layer_or_descendant_is_drawn);
     }
   }
 
   if (render_to_separate_surface && !IsRootLayer(layer) &&
       layer->render_surface()->layer_list().empty()) {
     RemoveSurfaceForEarlyExit(layer, render_surface_layer_list);
     return;
   }
 
   // The render surface's content rect is the union of drawable content rects
   // of the layers that draw into the surface. If the render surface is clipped,
   // it is also intersected with the render's surface clip rect.
-  if (verify_property_trees) {
+  if (compute_content_rects) {
     if (!IsRootLayer(layer)) {
       if (render_to_separate_surface) {
         gfx::Rect surface_content_rect =
             layer->render_surface()->accumulated_content_rect();
         // If the owning layer of a render surface draws content, the content
         // rect of the render surface is expanded to include the drawable
         // content rect of the layer.
         if (layer->DrawsContent())
           surface_content_rect.Union(layer->drawable_content_rect());
 
@@ skipping 10 matching lines @@
                     layer->render_surface()->draw_transform());
             surface_content_rect.Intersect(surface_clip_rect);
           }
         }
         // The RenderSurfaceImpl backing texture cannot exceed the maximum
         // supported texture size.
         surface_content_rect.set_width(
             std::min(surface_content_rect.width(), max_texture_size));
         surface_content_rect.set_height(
             std::min(surface_content_rect.height(), max_texture_size));
-        layer->render_surface()->SetContentRectFromPropertyTrees(
-            surface_content_rect);
+        if (use_property_trees)
+          layer->render_surface()->SetContentRect(surface_content_rect);
+        if (verify_property_trees) {
+          layer->render_surface()->SetContentRectFromPropertyTrees(
+              surface_content_rect);
+        }
       }
       const LayerImpl* parent_target = layer->parent()->render_target();
       if (!IsRootLayer(parent_target)) {
         gfx::Rect surface_content_rect =
             parent_target->render_surface()->accumulated_content_rect();
         if (render_to_separate_surface) {
           // If the layer owns a surface, then the content rect is in the wrong
           // space. Instead, we will use the surface's DrawableContentRect which
           // is in target space as required. We also need to clip it with the
           // target's clip if the target is clipped.
           surface_content_rect.Union(gfx::ToEnclosedRect(
               layer->render_surface()->DrawableContentRect()));
           if (parent_target->is_clipped())
             surface_content_rect.Intersect(parent_target->clip_rect());
         } else if (layer->DrawsContent()) {
           surface_content_rect.Union(layer->drawable_content_rect());
         }
         parent_target->render_surface()->SetAccumulatedContentRect(
             surface_content_rect);
       }
     } else {
       // The root layer's surface content rect is always the entire viewport.
       gfx::Rect viewport =
           gfx::ToEnclosingRect(property_trees->clip_tree.ViewportClip());
-      layer->render_surface()->SetContentRectFromPropertyTrees(viewport);
+      if (use_property_trees)
+        layer->render_surface()->SetContentRect(viewport);
+      if (verify_property_trees)
+        layer->render_surface()->SetContentRectFromPropertyTrees(viewport);
     }
   }
 
   if (render_to_separate_surface && !IsRootLayer(layer) &&
       layer->render_surface()->DrawableContentRect().IsEmpty()) {
     RemoveSurfaceForEarlyExit(layer, render_surface_layer_list);
     return;
   }
 
   // If neither this layer nor any of its children were added, early out.
@@ skipping 16 matching lines @@
 }
 
 void CalculateRenderSurfaceLayerList(
     LayerTreeHostCommon::CalcDrawPropsImplInputs* inputs) {
   const bool subtree_visible_from_ancestor = true;
   CalculateRenderSurfaceLayerListInternal(
       inputs->root_layer, inputs->property_trees,
       inputs->render_surface_layer_list, nullptr, nullptr,
       subtree_visible_from_ancestor, inputs->can_render_to_separate_surface,
       inputs->current_render_surface_layer_list_id, inputs->max_texture_size,
-      inputs->verify_property_trees);
+      inputs->verify_property_trees, inputs->use_property_trees);
+}
+
+static void ComputeMaskLayerDrawProperties(const LayerImpl* layer,
+                                           LayerImpl* mask_layer) {
+  DrawProperties& mask_layer_draw_properties = mask_layer->draw_properties();
+  mask_layer_draw_properties.visible_layer_rect = gfx::Rect(layer->bounds());
+  mask_layer_draw_properties.target_space_transform = layer->draw_transform();
+  mask_layer_draw_properties.maximum_animation_contents_scale =
+      layer->draw_properties().maximum_animation_contents_scale;
+  mask_layer_draw_properties.starting_animation_contents_scale =
+      layer->draw_properties().starting_animation_contents_scale;
 }
 
 void CalculateDrawPropertiesAndVerify(
     LayerTreeHostCommon::CalcDrawPropsImplInputs* inputs,
     PropertyTreeOption property_tree_option) {
-  SubtreeGlobals globals;
-  DataForRecursion data_for_recursion;
   inputs->render_surface_layer_list->clear();
 
-  ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion);
   UpdateMetaInformationSequenceNumber(inputs->root_layer);
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformationInternal(inputs->root_layer, &recursive_data);
 
   const bool should_measure_property_tree_performance =
       inputs->verify_property_trees &&
       (property_tree_option == BUILD_PROPERTY_TREES_IF_NEEDED);
 
-  if (inputs->verify_property_trees) {
-    LayerImplList update_layer_list;
-
+  LayerImplList visible_layer_list;
+  if (inputs->verify_property_trees || inputs->use_property_trees) {
     switch (property_tree_option) {
       case BUILD_PROPERTY_TREES_IF_NEEDED: {
         // The translation from layer to property trees is an intermediate
         // state. We will eventually get these data passed directly to the
         // compositor.
         if (should_measure_property_tree_performance) {
           TRACE_EVENT_BEGIN0(
               TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
               "LayerTreeHostCommon::ComputeVisibleRectsWithPropertyTrees");
         }
 
         BuildPropertyTreesAndComputeVisibleRects(
             inputs->root_layer, inputs->page_scale_layer,
             inputs->inner_viewport_scroll_layer,
             inputs->outer_viewport_scroll_layer, inputs->page_scale_factor,
             inputs->device_scale_factor,
             gfx::Rect(inputs->device_viewport_size), inputs->device_transform,
             inputs->can_render_to_separate_surface, inputs->property_trees,
-            &update_layer_list);
+            &visible_layer_list);
 
         if (should_measure_property_tree_performance) {
           TRACE_EVENT_END0(
               TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
               "LayerTreeHostCommon::ComputeVisibleRectsWithPropertyTrees");
         }
 
         break;
       }
       case DONT_BUILD_PROPERTY_TREES: {
@@ skipping 11 matching lines @@
         // Similarly, the device viewport and device transform are shared
         // by both trees.
         inputs->property_trees->clip_tree.SetViewportClip(
             gfx::RectF(gfx::SizeF(inputs->device_viewport_size)));
         inputs->property_trees->transform_tree.SetDeviceTransform(
             inputs->device_transform, inputs->root_layer->position());
         inputs->property_trees->transform_tree.SetDeviceTransformScaleFactor(
             inputs->device_transform);
         ComputeVisibleRectsUsingPropertyTrees(
             inputs->root_layer, inputs->property_trees,
-            inputs->can_render_to_separate_surface, &update_layer_list);
+            inputs->can_render_to_separate_surface, &visible_layer_list);
         break;
       }
     }
   }
 
   if (should_measure_property_tree_performance) {
     TRACE_EVENT_BEGIN0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
                        "LayerTreeHostCommon::CalculateDrawProperties");
   }
 
   std::vector<AccumulatedSurfaceState> accumulated_surface_state;
   CalculateRenderTarget(inputs);
-  CalculateDrawPropertiesInternal(inputs->root_layer, globals,
-                                  data_for_recursion,
-                                  &accumulated_surface_state);
+  if (inputs->use_property_trees) {
+    for (LayerImpl* layer : visible_layer_list) {
+      ComputeLayerDrawPropertiesUsingPropertyTrees(
+          layer, inputs->property_trees, inputs->layers_always_allowed_lcd_text,
+          inputs->can_use_lcd_text, &layer->draw_properties());
+      if (layer->mask_layer())
+        ComputeMaskLayerDrawProperties(layer, layer->mask_layer());
+      LayerImpl* replica_mask_layer = layer->replica_layer()
+                                          ? layer->replica_layer()->mask_layer()
+                                          : nullptr;
+      if (replica_mask_layer)
+        ComputeMaskLayerDrawProperties(layer, replica_mask_layer);
+    }
+  } else {
+    SubtreeGlobals globals;
+    DataForRecursion data_for_recursion;
+    ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion);
+    CalculateDrawPropertiesInternal(inputs->root_layer, globals,
+                                    data_for_recursion,
+                                    &accumulated_surface_state);
+  }
   CalculateRenderSurfaceLayerList(inputs);
 
   if (should_measure_property_tree_performance) {
     TRACE_EVENT_END0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
                      "LayerTreeHostCommon::CalculateDrawProperties");
   }
 
   if (inputs->verify_property_trees)
     VerifyPropertyTreeValues(inputs);
 
@@ skipping 30 matching lines @@
 
 PropertyTrees* GetPropertyTrees(Layer* layer) {
   return layer->layer_tree_host()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer) {
   return layer->layer_tree_impl()->property_trees();
 }
 
 }  // namespace cc