[NOT FOR REVIEW]

cc/trees/layer_tree_impl.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_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 942 matching lines @@
   layer->SetElementId(LayerIdToElementIdForTesting(layer->id()));
 }
 
 void LayerTreeImpl::SetElementIdsForTesting() {
   LayerListIterator<LayerImpl> it(root_layer_for_testing_);
   for (; it != LayerListIterator<LayerImpl>(nullptr); ++it) {
     SetElementIdForTesting(*it);
   }
 }
 
-bool LayerTreeImpl::UpdateDrawProperties(
-    bool update_lcd_text,
-    bool force_skip_verify_visible_rect_calculations) {
+bool LayerTreeImpl::UpdateDrawProperties(bool update_lcd_text) {
   if (!needs_update_draw_properties_)
     return true;
 
   // Calling UpdateDrawProperties must clear this flag, so there can be no
   // early outs before this.
   needs_update_draw_properties_ = false;
 
   // For max_texture_size. When a new output surface is received the needs
   // update draw properties flag is set again.
   if (!layer_tree_host_impl_->compositor_frame_sink())
@@ skipping 10 matching lines @@
     base::ElapsedTimer timer;
     TRACE_EVENT2(
         "cc", "LayerTreeImpl::UpdateDrawProperties::CalculateDrawProperties",
         "IsActive", IsActiveTree(), "SourceFrameNumber", source_frame_number_);
     bool can_render_to_separate_surface =
         (!is_in_resourceless_software_draw_mode());
 
     // We verify visible rect calculations whenever we verify clip tree
     // calculations except when this function is explicitly passed a flag asking
     // us to skip it.
-    bool verify_visible_rect_calculations =
-        force_skip_verify_visible_rect_calculations
-            ? false
-            : settings().verify_clip_tree_calculations;
     LayerTreeHostCommon::CalcDrawPropsImplInputs inputs(
         layer_list_[0], DrawViewportSize(),
         layer_tree_host_impl_->DrawTransform(), device_scale_factor(),
         current_page_scale_factor(), PageScaleLayer(),
         InnerViewportScrollLayer(), OuterViewportScrollLayer(),
         elastic_overscroll()->Current(IsActiveTree()),
         OverscrollElasticityLayer(), resource_provider()->max_texture_size(),
         can_render_to_separate_surface,
         settings().layer_transforms_should_scale_layer_contents,
-        settings().verify_clip_tree_calculations,
-        verify_visible_rect_calculations,
         &render_surface_layer_list_, &property_trees_);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     if (const char* client_name = GetClientNameForMetrics()) {
       UMA_HISTOGRAM_COUNTS(
           base::StringPrintf(
               "Compositing.%s.LayerTreeImpl.CalculateDrawPropertiesUs",
               client_name),
           timer.Elapsed().InMicroseconds());
       UMA_HISTOGRAM_COUNTS_100(
           base::StringPrintf("Compositing.%s.NumRenderSurfaces", client_name),
@@ skipping 760 matching lines @@
     const gfx::PointF& screen_space_point,
     const LayerImpl* layer) {
   // We need to visit all ancestor clip nodes to check this. Checking with just
   // the combined clip stored at a clip node is not enough because parent
   // combined clip can sometimes be smaller than current combined clip. This can
   // happen when we have transforms like rotation that inflate the combined
   // clip's bounds. Also, the point can be clipped by the content rect of an
   // ancestor render surface.
 
   // We first check if the point is clipped by viewport.
-  const PropertyTrees* property_trees =
-      layer->layer_tree_impl()->property_trees();
+  PropertyTrees* property_trees = layer->layer_tree_impl()->property_trees();
   const ClipTree& clip_tree = property_trees->clip_tree;
   const TransformTree& transform_tree = property_trees->transform_tree;
   const ClipNode* clip_node = clip_tree.Node(1);
-  gfx::Rect combined_clip_in_target_space =
-      gfx::ToEnclosingRect(clip_node->combined_clip_in_target_space);
-  if (!PointHitsRect(screen_space_point, gfx::Transform(),
-                     combined_clip_in_target_space, NULL))
+  gfx::Rect clip = gfx::ToEnclosingRect(clip_node->clip);
+  if (!PointHitsRect(screen_space_point, gfx::Transform(), clip, NULL))
     return true;
 
   for (const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index());
        clip_node->id > ClipTree::kViewportNodeId;
        clip_node = clip_tree.parent(clip_node)) {
     if (clip_node->clip_type == ClipNode::ClipType::APPLIES_LOCAL_CLIP) {
-      const TransformNode* transform_node =
-          transform_tree.Node(clip_node->target_transform_id);
-      gfx::Rect combined_clip_in_target_space =
-          gfx::ToEnclosingRect(clip_node->combined_clip_in_target_space);
+      gfx::Rect clip = gfx::ToEnclosingRect(clip_node->clip);
 
-      const LayerImpl* target_layer =
-          layer->layer_tree_impl()->LayerById(transform_node->owning_layer_id);
-      DCHECK(transform_node->id == TransformTree::kRootNodeId ||
-             target_layer->render_surface() ||
-             layer->layer_tree_impl()->is_in_resourceless_software_draw_mode());
-      gfx::Transform surface_screen_space_transform =
-          transform_node->id == TransformTree::kRootNodeId ||
-                  (layer->layer_tree_impl()
-                       ->is_in_resourceless_software_draw_mode())
-              ? gfx::Transform()
-              : SurfaceScreenSpaceTransform(target_layer);
-      if (!PointHitsRect(screen_space_point, surface_screen_space_transform,
-                         combined_clip_in_target_space, NULL)) {
+      gfx::Transform screen_space_transform =
+          transform_tree.ToScreen(clip_node->transform_id);
+      if (!PointHitsRect(screen_space_point, screen_space_transform, clip,
+                         NULL)) {
         return true;
       }
     }
     const LayerImpl* clip_node_owner =
         layer->layer_tree_impl()->LayerById(clip_node->owning_layer_id);
     if (clip_node_owner->render_surface() &&
         !PointHitsRect(
             screen_space_point, SurfaceScreenSpaceTransform(clip_node_owner),
             clip_node_owner->render_surface()->content_rect(), NULL)) {
       return true;
@@ skipping 268 matching lines @@
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   // Iterate over all layers, including masks.
   for (auto& layer : *layers_)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc