cc: Move main thread hierarchy dependencies into PropertyTreeBuilder

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 177 matching lines @@
   DCHECK_EQ(scrolls.size(), 0u);
   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 bool IsRootLayer(const Layer* layer) {
-  return !layer->parent();
-}
-
-static bool HasInvertibleOrAnimatedTransform(Layer* layer) {
-  return layer->transform_is_invertible() ||
-         layer->HasPotentiallyRunningTransformAnimation();
-}
-
-static bool HasInvertibleOrAnimatedTransformForTesting(LayerImpl* layer) {
-  return layer->transform().IsInvertible() ||
-         layer->HasPotentiallyRunningTransformAnimation();
-}
-
 static inline void MarkLayerWithRenderSurfaceLayerListId(
     LayerImpl* layer,
     int current_render_surface_layer_list_id) {
   layer->draw_properties().last_drawn_render_surface_layer_list_id =
       current_render_surface_layer_list_id;
 }
 
 static inline void MarkMasksWithRenderSurfaceLayerListId(
     LayerImpl* layer,
     int current_render_surface_layer_list_id) {
@@ skipping 18 matching lines @@
       scroll_tree->Node(layer->scroll_tree_index())
           ->data.num_drawn_descendants--;
     }
     MarkLayerWithRenderSurfaceLayerListId(layer,
                                           cleared_render_surface_layer_list_id);
     MarkMasksWithRenderSurfaceLayerListId(layer,
                                           cleared_render_surface_layer_list_id);
   }
 }
 
-struct PreCalculateMetaInformationRecursiveData {
-  size_t num_unclipped_descendants;
-  int num_layer_or_descendants_with_copy_request;
-  int num_layer_or_descendants_with_touch_handler;
-  int num_descendants_that_draw_content;
-
-  PreCalculateMetaInformationRecursiveData()
-      : num_unclipped_descendants(0),
-        num_layer_or_descendants_with_copy_request(0),
-        num_layer_or_descendants_with_touch_handler(0),
-        num_descendants_that_draw_content(0) {}
-
-  void Merge(const PreCalculateMetaInformationRecursiveData& data) {
-    num_layer_or_descendants_with_copy_request +=
-        data.num_layer_or_descendants_with_copy_request;
-    num_layer_or_descendants_with_touch_handler +=
-        data.num_layer_or_descendants_with_touch_handler;
-    num_unclipped_descendants += data.num_unclipped_descendants;
-    num_descendants_that_draw_content += data.num_descendants_that_draw_content;
-  }
-};
-
-static bool IsMetaInformationRecomputationNeeded(Layer* layer) {
-  return layer->layer_tree_host()->needs_meta_info_recomputation();
-}
-
-static void UpdateMetaInformationSequenceNumber(Layer* root_layer) {
-  root_layer->layer_tree_host()->IncrementMetaInformationSequenceNumber();
-}
-
-// Recursively walks the layer tree(if needed) to compute any information
-// that is needed before doing the main recursion.
-static void PreCalculateMetaInformationInternal(
-    Layer* layer,
-    PreCalculateMetaInformationRecursiveData* recursive_data) {
-  if (!IsMetaInformationRecomputationNeeded(layer)) {
-    DCHECK(IsRootLayer(layer));
-    return;
-  }
-
-  if (layer->clip_parent())
-    recursive_data->num_unclipped_descendants++;
-
-  if (!HasInvertibleOrAnimatedTransform(layer)) {
-    // Layers with singular transforms should not be drawn, the whole subtree
-    // can be skipped.
-    return;
-  }
-
-  for (size_t i = 0; i < layer->children().size(); ++i) {
-    Layer* child_layer = layer->child_at(i);
-
-    PreCalculateMetaInformationRecursiveData data_for_child;
-    PreCalculateMetaInformationInternal(child_layer, &data_for_child);
-    recursive_data->Merge(data_for_child);
-  }
-
-  if (layer->clip_children()) {
-    size_t num_clip_children = layer->clip_children()->size();
-    DCHECK_GE(recursive_data->num_unclipped_descendants, num_clip_children);
-    recursive_data->num_unclipped_descendants -= num_clip_children;
-  }
-
-  if (layer->HasCopyRequest())
-    recursive_data->num_layer_or_descendants_with_copy_request++;
-
-  if (!layer->touch_event_handler_region().IsEmpty())
-    recursive_data->num_layer_or_descendants_with_touch_handler++;
-
-  layer->set_num_unclipped_descendants(
-      recursive_data->num_unclipped_descendants);
-
-  if (IsRootLayer(layer))
-    layer->layer_tree_host()->SetNeedsMetaInfoRecomputation(false);
-}
-
-static void PreCalculateMetaInformationInternalForTesting(
-    LayerImpl* layer,
-    PreCalculateMetaInformationRecursiveData* recursive_data) {
-  if (layer->clip_parent())
-    recursive_data->num_unclipped_descendants++;
-
-  if (!HasInvertibleOrAnimatedTransformForTesting(layer)) {
-    // Layers with singular transforms should not be drawn, the whole subtree
-    // can be skipped.
-    return;
-  }
-
-  for (size_t i = 0; i < layer->children().size(); ++i) {
-    LayerImpl* child_layer = layer->child_at(i);
-
-    PreCalculateMetaInformationRecursiveData data_for_child;
-    PreCalculateMetaInformationInternalForTesting(child_layer, &data_for_child);
-    recursive_data->Merge(data_for_child);
-  }
-
-  if (layer->clip_children()) {
-    size_t num_clip_children = layer->clip_children()->size();
-    DCHECK_GE(recursive_data->num_unclipped_descendants, num_clip_children);
-    recursive_data->num_unclipped_descendants -= num_clip_children;
-  }
-
-  if (layer->HasCopyRequest())
-    recursive_data->num_layer_or_descendants_with_copy_request++;
-
-  if (!layer->touch_event_handler_region().IsEmpty())
-    recursive_data->num_layer_or_descendants_with_touch_handler++;
-
-  layer->draw_properties().num_unclipped_descendants =
-      recursive_data->num_unclipped_descendants;
-  layer->set_layer_or_descendant_has_touch_handler(
-      (recursive_data->num_layer_or_descendants_with_touch_handler != 0));
-  // TODO(enne): this should be synced from the main thread, so is only
-  // for tests constructing layers on the compositor thread.
-  layer->test_properties()->num_descendants_that_draw_content =
-      recursive_data->num_descendants_that_draw_content;
-
-  if (layer->DrawsContent())
-    recursive_data->num_descendants_that_draw_content++;
-}
-
-void LayerTreeHostCommon::PreCalculateMetaInformation(Layer* root_layer) {
-  PreCalculateMetaInformationRecursiveData recursive_data;
-  PreCalculateMetaInformationInternal(root_layer, &recursive_data);
-}
-
-void LayerTreeHostCommon::PreCalculateMetaInformationForTesting(
-    LayerImpl* root_layer) {
-  PreCalculateMetaInformationRecursiveData recursive_data;
-  PreCalculateMetaInformationInternalForTesting(root_layer, &recursive_data);
-}
-
-void LayerTreeHostCommon::PreCalculateMetaInformationForTesting(
-    Layer* root_layer) {
-  UpdateMetaInformationSequenceNumber(root_layer);
-  PreCalculateMetaInformationRecursiveData recursive_data;
-  PreCalculateMetaInformationInternal(root_layer, &recursive_data);
-}
-
 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) {
   LayerTreeImpl* layer_tree_impl = pending_tree_layer->layer_tree_impl();
   if (layer_tree_impl) {
@@ skipping 453 matching lines @@
       TRACE_EVENT_ASYNC_END1(
           "cdp.perf", "jitter",
           inputs->root_layer->layer_tree_impl()->source_frame_number(), "value",
           jitter);
     }
   }
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     CalcDrawPropsImplInputsForTesting* inputs) {
-  PreCalculateMetaInformationRecursiveData recursive_data;
-  PreCalculateMetaInformationInternalForTesting(inputs->root_layer,
-                                                &recursive_data);
+  PropertyTreeBuilder::PreCalculateMetaInformation(inputs->root_layer);
   CalculateDrawPropertiesInternal(inputs, BUILD_PROPERTY_TREES_IF_NEEDED);
 }
 
 PropertyTrees* GetPropertyTrees(Layer* layer) {
   return layer->layer_tree_host()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer) {
   return layer->layer_tree_impl()->property_trees();
 }
 
 }  // namespace cc