Make all scrollable layers visible to hit testing.

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 194 matching lines @@
 static inline void ClearMaskLayersAreDrawnRenderSurfaceLayerListMembers(
     RenderSurfaceImpl* surface) {
   LayerImpl* mask_layer = surface->MaskLayer();
   if (mask_layer)
     mask_layer->set_is_drawn_render_surface_layer_list_member(false);
 }
 
 static inline void ClearIsDrawnRenderSurfaceLayerListMember(
     LayerImplList* layer_list,
     ScrollTree* scroll_tree) {
-  for (LayerImpl* layer : *layer_list) {
-    if (layer->is_drawn_render_surface_layer_list_member()) {
-      DCHECK_GT(
-          scroll_tree->Node(layer->scroll_tree_index())->num_drawn_descendants,
-          0);
-      scroll_tree->Node(layer->scroll_tree_index())->num_drawn_descendants--;
-    }
+  for (LayerImpl* layer : *layer_list)
     layer->set_is_drawn_render_surface_layer_list_member(false);
-  }
 }
 
 static bool CdpPerfTracingEnabled() {
   bool tracing_enabled;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED("cdp.perf", &tracing_enabled);
   return tracing_enabled;
 }
 
 static float TranslationFromActiveTreeLayerScreenSpaceTransform(
     LayerImpl* pending_tree_layer) {
@@ skipping 52 matching lines @@
     }
   }
   return jitter;
 }
 
 enum PropertyTreeOption {
   BUILD_PROPERTY_TREES_IF_NEEDED,
   DONT_BUILD_PROPERTY_TREES
 };
 
-static void ComputeLayerScrollsDrawnDescendants(LayerTreeImpl* layer_tree_impl,
-                                                ScrollTree* scroll_tree) {
-  for (int i = static_cast<int>(scroll_tree->size()) - 1; i > 0; --i) {
-    ScrollNode* node = scroll_tree->Node(i);
-    scroll_tree->parent(node)->num_drawn_descendants +=
-        node->num_drawn_descendants;
-  }
-  for (LayerImpl* layer : *layer_tree_impl) {
-    bool scrolls_drawn_descendant = false;
-    if (layer->scrollable()) {
-      ScrollNode* node = scroll_tree->Node(layer->scroll_tree_index());
-      if (node->num_drawn_descendants > 0)
-        scrolls_drawn_descendant = true;
-    }
-    layer->set_scrolls_drawn_descendant(scrolls_drawn_descendant);
-  }
-}
-
 static void ComputeInitialRenderSurfaceLayerList(
     LayerTreeImpl* layer_tree_impl,
     PropertyTrees* property_trees,
     LayerImplList* render_surface_layer_list,
     bool can_render_to_separate_surface) {
-  ScrollTree* scroll_tree = &property_trees->scroll_tree;
-  for (int i = 0; i < static_cast<int>(scroll_tree->size()); ++i)
-    scroll_tree->Node(i)->num_drawn_descendants = 0;
-
   // Add all non-skipped surfaces to the initial render surface layer list. Add
   // all non-skipped layers to the layer list of their target surface, and
   // add their content rect to their target surface's accumulated content rect.
   for (LayerImpl* layer : *layer_tree_impl) {
     if (layer->render_surface()) {
       layer->ClearRenderSurfaceLayerList();
       ClearMaskLayersAreDrawnRenderSurfaceLayerListMembers(
           layer->render_surface());
     }
     layer->set_is_drawn_render_surface_layer_list_member(false);
@@ skipping 51 matching lines @@
       }
     }
     bool layer_is_drawn =
         property_trees->effect_tree.Node(layer->effect_tree_index())->is_drawn;
     bool layer_should_be_drawn = draw_property_utils::LayerNeedsUpdate(
         layer, layer_is_drawn, property_trees);
     if (!layer_should_be_drawn)
       continue;
 
     layer->set_is_drawn_render_surface_layer_list_member(true);
-    scroll_tree->Node(layer->scroll_tree_index())->num_drawn_descendants++;
     layer->render_target()->layer_list().push_back(layer);
 
     // The layer contributes its drawable content rect to its render target.
     layer->render_target()->AccumulateContentRectFromContributingLayer(layer);
   }
 }
 
 static void ComputeSurfaceContentRects(LayerTreeImpl* layer_tree_impl,
                                        PropertyTrees* property_trees,
                                        LayerImplList* render_surface_layer_list,
@@ skipping 75 matching lines @@
   // have an empty content rect. After surface content rects are computed,
   // produce a final RSLL that omits empty surfaces.
   ComputeInitialRenderSurfaceLayerList(layer_tree_impl, property_trees,
                                        &initial_render_surface_list,
                                        can_render_to_separate_surface);
   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);
 }
 
 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;
 
@@ skipping 181 matching lines @@
 
 PropertyTrees* GetPropertyTrees(Layer* layer) {
   return layer->GetLayerTree()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer) {
   return layer->layer_tree_impl()->property_trees();
 }
 
 }  // namespace cc