cc: Compute mask draw properties directly

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 <stddef.h>
 
 #include <algorithm>
 
@@ skipping 168 matching lines @@
   for (int i = 0; i < proto.scrolls_size(); ++i) {
     scrolls.push_back(LayerTreeHostCommon::ScrollUpdateInfo());
     scrolls[i].FromProtobuf(proto.scrolls(i));
   }
   page_scale_delta = proto.page_scale_delta();
   elastic_overscroll_delta = ProtoToVector2dF(proto.elastic_overscroll_delta());
   top_controls_delta = proto.top_controls_delta();
 }
 
 static inline void SetMaskLayersAreDrawnRenderSurfaceLayerListMembers(
-    LayerImpl* layer) {
-  if (layer->mask_layer())
+    LayerImpl* layer,
+    PropertyTrees* property_trees) {
+  if (layer->mask_layer()) {
     layer->mask_layer()->set_is_drawn_render_surface_layer_list_member(true);
+    draw_property_utils::ComputeMaskDrawProperties(layer->mask_layer(),
+                                                   property_trees);
+  }
   if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {
     layer->replica_layer()
         ->mask_layer()
         ->set_is_drawn_render_surface_layer_list_member(true);
+    draw_property_utils::ComputeMaskDrawProperties(
+        layer->replica_layer()->mask_layer(), property_trees);
   }
 }
 
 static inline void ClearLayerIsDrawnRenderSurfaceLayerListMember(
     LayerImpl* layer) {
   layer->set_is_drawn_render_surface_layer_list_member(false);
   if (layer->mask_layer())
     layer->mask_layer()->set_is_drawn_render_surface_layer_list_member(false);
   if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {
     layer->replica_layer()
@@ skipping 245 matching lines @@
           // root surface.
           DCHECK(!target_surface->layer_list().empty() ||
                  target_surface->render_target() == target_surface);
         } else {
           // This layer was removed when the target itself was cleared.
           DCHECK(target_surface->layer_list().empty());
         }
       }
       continue;
     }
-    SetMaskLayersAreDrawnRenderSurfaceLayerListMembers(layer);
+    SetMaskLayersAreDrawnRenderSurfaceLayerListMembers(layer, property_trees);
     final_surface_list->push_back(layer);
   }
 }
 
 static void CalculateRenderSurfaceLayerList(
     LayerTreeImpl* layer_tree_impl,
     PropertyTrees* property_trees,
     LayerImplList* render_surface_layer_list,
     const bool can_render_to_separate_surface,
     const int max_texture_size) {
@@ skipping 12 matching lines @@
   ComputeSurfaceContentRects(layer_tree_impl, property_trees,
                              &initial_render_surface_list, max_texture_size);
   ComputeListOfNonEmptySurfaces(layer_tree_impl, property_trees,
                                 &initial_render_surface_list,
                                 render_surface_layer_list);
 
   ComputeLayerScrollsDrawnDescendants(layer_tree_impl,
                                       &property_trees->scroll_tree);
 }
 
-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_properties().target_space_transform;

[ajuma, 2016/06/07 17:59:39]

Target space transform used to be needed to pick a contents scale, but now we're
using screen space transform for this, so masks no longer need a target space
transform.

-  mask_layer_draw_properties.screen_space_transform =
-      layer->draw_properties().screen_space_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;

[ajuma, 2016/06/07 17:59:39]

We were previously setting but never using animation contents scale (since we
were never setting screen_space_transform_is_animating), so in this patch
they're no longer computed at all for masks.

-}
-
 void CalculateDrawPropertiesInternal(
     LayerTreeHostCommon::CalcDrawPropsImplInputs* inputs,
     PropertyTreeOption property_tree_option) {
   inputs->render_surface_layer_list->clear();
 
   const bool should_measure_property_tree_performance =
       property_tree_option == BUILD_PROPERTY_TREES_IF_NEEDED;
 
   LayerImplList visible_layer_list;
   switch (property_tree_option) {
@@ skipping 65 matching lines @@
   if (should_measure_property_tree_performance) {
     TRACE_EVENT_BEGIN0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
                        "LayerTreeHostCommon::CalculateDrawProperties");
   }
 
   DCHECK(inputs->can_render_to_separate_surface ==
          inputs->property_trees->non_root_surfaces_enabled);
   for (LayerImpl* layer : visible_layer_list) {
     draw_property_utils::ComputeLayerDrawProperties(layer,
                                                     inputs->property_trees);
-    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);
   }
 
   CalculateRenderSurfaceLayerList(
       inputs->root_layer->layer_tree_impl(), inputs->property_trees,
       inputs->render_surface_layer_list, inputs->can_render_to_separate_surface,
       inputs->max_texture_size);
 
   if (inputs->verify_clip_tree_calculations)
     draw_property_utils::VerifyClipTreeCalculations(visible_layer_list,
                                                     inputs->property_trees);
@@ skipping 88 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