Compute if a layer is clipped outside CalcDrawProps

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 168 matching lines @@
     clip_parent = layer->clip_parent();
 
   if (!clip_parent || clip_parent == layer->parent())
     return;
 
   // The root layer is never a clip child.
   DCHECK(layer->parent());
 
   // Grab the cached values.
   *clip_rect_in_parent_target_space = clip_parent->clip_rect();
-  *subtree_should_be_clipped = clip_parent->is_clipped();
+  *subtree_should_be_clipped = clip_parent->is_clipped_from_property_tree();
 
   // We may have to project the clip rect into our parent's target space. Note,
   // it must be our parent's target space, not ours. For one, we haven't
   // computed our transforms, so we couldn't put it in our space yet even if we
   // wanted to. But more importantly, this matches the expectations of
   // CalculateDrawPropertiesInternal. If we, say, create a render surface, these
   // clip rects will want to be in its target space, not ours.
   if (clip_parent == layer->clip_parent()) {
     *clip_rect_in_parent_target_space = TranslateRectToTargetSpace<LayerType>(
         *clip_parent, *layer->parent(), *clip_rect_in_parent_target_space,
@@ skipping 54 matching lines @@
 
   // 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.
   gfx::Rect target_rect = drawable_content_rect;
   if (layer->render_surface()) {
     target_rect =
         gfx::ToEnclosedRect(layer->render_surface()->DrawableContentRect());
   }
 
-  if (render_target->is_clipped()) {
+  if (render_target->is_clipped_from_property_tree()) {
     gfx::Rect clip_rect = render_target->clip_rect();
     // If the layer has a clip parent, the clip rect may be in the wrong space,
     // so we'll need to transform it before it is applied.
     if (layer->clip_parent()) {
       clip_rect = TranslateRectToTargetSpace<LayerType>(
           *layer->clip_parent(), *layer, clip_rect,
           TRANSLATE_RECT_DIRECTION_TO_DESCENDANT);
     }
     target_rect.Intersect(clip_rect);
   }
@@ skipping 1779 matching lines @@
     } else {
       clip_rect_in_target_space = rect_in_target_space;
     }
   }
 
   // Tell the layer the rect that it's clipped by. In theory we could use a
   // tighter clip rect here (drawable_content_rect), but that actually does not
   // reduce how much would be drawn, and instead it would create unnecessary
   // changes to scissor state affecting GPU performance. Our clip information
   // is used in the recursion below, so we must set it beforehand.
-  layer_draw_properties.is_clipped = layer_or_ancestor_clips_descendants;
+  CHECK_EQ(layer_or_ancestor_clips_descendants,
+           layer->is_clipped_from_property_tree());
   if (layer_or_ancestor_clips_descendants) {
     layer_draw_properties.clip_rect = clip_rect_in_target_space;
   } else {
     // Initialize the clip rect to a safe value that will not clip the
     // layer, just in case clipping is still accidentally used.
     layer_draw_properties.clip_rect = rect_in_target_space;
   }
 
   typename LayerType::LayerListType& descendants =
       (render_to_separate_surface ? layer->render_surface()->layer_list()
@@ skipping 419 matching lines @@
       << DrawTransformFromPropertyTrees(
              current_layer, property_trees->transform_tree).ToString();
 
   const bool draw_opacities_match =
       current_layer->draw_opacity() ==
       DrawOpacityFromPropertyTrees(current_layer, property_trees->opacity_tree);
   CHECK(draw_opacities_match)
       << "expected: " << current_layer->draw_opacity()
       << " actual: " << DrawOpacityFromPropertyTrees(
                             current_layer, property_trees->opacity_tree);
+

[Ian Vollick, 2015/07/09 14:26:27]

nit: spurious ws.

[jaydasika, 2015/07/09 15:11:49]

Done.

   const bool can_use_lcd_text_match =
       CanUseLcdTextFromPropertyTrees(
           current_layer, layers_always_allowed_lcd_text, can_use_lcd_text,
           property_trees) == current_layer->can_use_lcd_text();
   CHECK(can_use_lcd_text_match);
 }
 
 void VerifyPropertyTreeValues(
     LayerTreeHostCommon::CalcDrawPropsMainInputs* inputs) {
 }
@@ skipping 32 matching lines @@
   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 (should_measure_property_tree_performance) {
     TRACE_EVENT_BEGIN0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
                        "LayerTreeHostCommon::CalculateDrawProperties");
   }

[Ian Vollick, 2015/07/09 14:26:27]

This TRACE_EVENT_BEGIN0 and TRACE_EVENT_END0 here are used for measuring the
performance of CDP. If you're going to move CDP (and it's awesome that you are),
you'll need to move these, too.

[jaydasika, 2015/07/09 15:11:49]

Done.

 
-  std::vector<AccumulatedSurfaceState<LayerType>> accumulated_surface_state;
-  CalculateDrawPropertiesInternal<LayerType>(
-      inputs->root_layer, globals, data_for_recursion,
-      inputs->render_surface_layer_list, &dummy_layer_list,
-      &accumulated_surface_state, inputs->current_render_surface_layer_list_id);
-
   if (should_measure_property_tree_performance) {
     TRACE_EVENT_END0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
                      "LayerTreeHostCommon::CalculateDrawProperties");
   }
 
   if (inputs->verify_property_trees) {
     typename LayerType::LayerListType update_layer_list;
 
     // For testing purposes, sometimes property trees need to be built on the
     // compositor thread, so this can't just switch on Layer vs LayerImpl,
@@ skipping 27 matching lines @@
       }
       case DONT_BUILD_PROPERTY_TREES: {
         TRACE_EVENT0(
             TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
             "LayerTreeHostCommon::ComputeJustVisibleRectsWithPropertyTrees");
         ComputeVisibleRectsUsingPropertyTrees(
             inputs->root_layer, inputs->property_trees, &update_layer_list);
         break;
       }
     }
+  }
 
+  std::vector<AccumulatedSurfaceState<LayerType>> accumulated_surface_state;
+  CalculateDrawPropertiesInternal<LayerType>(
+      inputs->root_layer, globals, data_for_recursion,
+      inputs->render_surface_layer_list, &dummy_layer_list,
+      &accumulated_surface_state, inputs->current_render_surface_layer_list_id);
+
+  if (inputs->verify_property_trees)
     VerifyPropertyTreeValues(inputs);
-  }
 
   // The dummy layer list should not have been used.
   DCHECK_EQ(0u, dummy_layer_list.size());
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
   DCHECK(inputs->root_layer->render_surface());
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     CalcDrawPropsMainInputs* inputs) {
@@ skipping 15 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