cc : Compute visible rects dynamically (2)

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 540 matching lines @@
       }
 
       draw_property_utils::BuildPropertyTreesAndComputeVisibleRects(
           inputs->root_layer, inputs->page_scale_layer,
           inputs->inner_viewport_scroll_layer,
           inputs->outer_viewport_scroll_layer,
           inputs->elastic_overscroll_application_layer,
           inputs->elastic_overscroll, inputs->page_scale_factor,
           inputs->device_scale_factor, gfx::Rect(inputs->device_viewport_size),
           inputs->device_transform, inputs->can_render_to_separate_surface,
-          inputs->verify_visible_rect_calculations, inputs->property_trees,
-          &visible_layer_list);
+          inputs->property_trees, &visible_layer_list);
 
       // Property trees are normally constructed on the main thread and
       // passed to compositor thread. Source to parent updates on them are not
       // allowed in the compositor thread. Some tests build them on the
       // compositor thread, so we need to explicitly disallow source to parent
       // updates when they are built on compositor thread.
       inputs->property_trees->transform_tree
           .set_source_to_parent_updates_allowed(false);
       if (should_measure_property_tree_performance) {
         TRACE_EVENT_END0(
@@ skipping 21 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);
       draw_property_utils::ComputeVisibleRects(
           inputs->root_layer, inputs->property_trees,
-          inputs->can_render_to_separate_surface,
-          inputs->verify_visible_rect_calculations, &visible_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");
   }
 
   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);
   }
 
   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);
+  if (inputs->verify_visible_rect_calculations)
+    draw_property_utils::VerifyVisibleRectsCalculations(visible_layer_list,
+                                                        inputs->property_trees);
   if (inputs->verify_transform_tree_calculations)
     draw_property_utils::VerifyTransformTreeCalculations(
         visible_layer_list, inputs->property_trees);
 
   if (should_measure_property_tree_performance) {
     TRACE_EVENT_END0(TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
                      "LayerTreeHostCommon::CalculateDrawProperties");
   }
 
   // A root layer render_surface should always exist after
@@ skipping 81 matching lines @@
 
 PropertyTrees* GetPropertyTrees(Layer* layer) {
   return layer->GetLayerTree()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer) {
   return layer->layer_tree_impl()->property_trees();
 }
 
 }  // namespace cc