cc: Make all layer recursion use CallFunctionForSubtree

cc/trees/layer_tree_host.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.h"
 
 #include <algorithm>
-#include <stack>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_controller.h"
@@ skipping 412 matching lines @@
 void LayerTreeHost::FinishAllRendering() {
   proxy_->FinishAllRendering();
 }
 
 void LayerTreeHost::SetDeferCommits(bool defer_commits) {
   proxy_->SetDeferCommits(defer_commits);
 }
 
 void LayerTreeHost::DidDeferCommit() {}
 
+static void SetNeedsDisplay(Layer* layer) {
+  layer->SetNeedsDisplay();
+}
+
 void LayerTreeHost::SetNeedsDisplayOnAllLayers() {
-  std::stack<Layer*> layer_stack;
-  layer_stack.push(root_layer());
-  while (!layer_stack.empty()) {
-    Layer* current_layer = layer_stack.top();
-    layer_stack.pop();
-    current_layer->SetNeedsDisplay();
-    for (unsigned int i = 0; i < current_layer->children().size(); i++) {
-      layer_stack.push(current_layer->child_at(i));
-    }
-  }
+  if (root_layer())
+    LayerTreeHostCommon::CallFunctionForSubtree(SetNeedsDisplay, root_layer());
 }
 
 void LayerTreeHost::CollectRenderingStats(RenderingStats* stats) const {
   CHECK(debug_state_.RecordRenderingStats());
   *stats = rendering_stats_instrumentation_->GetRenderingStats();
 }
 
 const RendererCapabilities& LayerTreeHost::GetRendererCapabilities() const {
   return proxy_->GetRendererCapabilities();
 }
@@ skipping 203 matching lines @@
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     Layer* found = FindFirstScrollableLayer(layer->children()[i].get());
     if (found)
       return found;
   }
 
   return NULL;
 }
 
-class CalculateLCDTextMetricsFunctor {
- public:
-  void operator()(Layer* layer) {
-    LayerTreeHost* layer_tree_host = layer->layer_tree_host();
-    if (!layer_tree_host)
-      return;
+static void CalculateLCDTextMetrics(Layer* layer) {
+  LayerTreeHost* layer_tree_host = layer->layer_tree_host();
+  if (!layer_tree_host)
+    return;
 
-    if (!layer->SupportsLCDText())
-      return;
+  if (!layer->SupportsLCDText())
+    return;
 
-    bool update_total_num_cc_layers_can_use_lcd_text = false;
-    bool update_total_num_cc_layers_will_use_lcd_text = false;
-    if (layer->draw_properties().can_use_lcd_text) {
-      update_total_num_cc_layers_can_use_lcd_text = true;
-      if (layer->contents_opaque())
-        update_total_num_cc_layers_will_use_lcd_text = true;
-    }
+  bool update_total_num_cc_layers_can_use_lcd_text = false;
+  bool update_total_num_cc_layers_will_use_lcd_text = false;
+  if (layer->draw_properties().can_use_lcd_text) {
+    update_total_num_cc_layers_can_use_lcd_text = true;
+    if (layer->contents_opaque())
+      update_total_num_cc_layers_will_use_lcd_text = true;
+  }
 
-    layer_tree_host->IncrementLCDTextMetrics(
-        update_total_num_cc_layers_can_use_lcd_text,
-        update_total_num_cc_layers_will_use_lcd_text);
-  }
-};
+  layer_tree_host->IncrementLCDTextMetrics(
+      update_total_num_cc_layers_can_use_lcd_text,
+      update_total_num_cc_layers_will_use_lcd_text);
+}
 
 void LayerTreeHost::IncrementLCDTextMetrics(
     bool update_total_num_cc_layers_can_use_lcd_text,
     bool update_total_num_cc_layers_will_use_lcd_text) {
   lcd_text_metrics_.total_num_cc_layers++;
   if (update_total_num_cc_layers_can_use_lcd_text)
     lcd_text_metrics_.total_num_cc_layers_can_use_lcd_text++;
   if (update_total_num_cc_layers_will_use_lcd_text) {
     DCHECK(update_total_num_cc_layers_can_use_lcd_text);
     lcd_text_metrics_.total_num_cc_layers_will_use_lcd_text++;
@@ skipping 18 matching lines @@
         device_scale_factor_,
         page_scale_factor_,
         root_scroll,
         GetRendererCapabilities().max_texture_size,
         settings_.can_use_lcd_text,
         settings_.layer_transforms_should_scale_layer_contents,
         &update_list);
 
     if (total_frames_used_for_lcd_text_metrics_ <=
         kTotalFramesToUseForLCDTextMetrics) {
-      LayerTreeHostCommon::CallFunctionForSubtree<
-          CalculateLCDTextMetricsFunctor, Layer>(root_layer);
+      LayerTreeHostCommon::CallFunctionForSubtree(CalculateLCDTextMetrics,
+                                                  root_layer);
       total_frames_used_for_lcd_text_metrics_++;
     }
 
     if (total_frames_used_for_lcd_text_metrics_ ==
         kTotalFramesToUseForLCDTextMetrics) {
       total_frames_used_for_lcd_text_metrics_++;
 
       UMA_HISTOGRAM_PERCENTAGE(
           "Renderer4.LCDText.PercentageOfCandidateLayers",
           lcd_text_metrics_.total_num_cc_layers_can_use_lcd_text * 100.0 /
@@ skipping 22 matching lines @@
   for (size_t i = 0; i < update_list.size(); ++i)
     update_list[i]->ClearRenderSurface();
 }
 
 void LayerTreeHost::TriggerPrepaint() {
   prepaint_callback_.Cancel();
   TRACE_EVENT0("cc", "LayerTreeHost::TriggerPrepaint");
   SetNeedsCommit();
 }
 
-class LayerTreeHostReduceMemoryFunctor {
- public:
-  void operator()(Layer* layer) {
-    layer->ReduceMemoryUsage();
-  }
-};
+static void ReduceMemoryUsageForLayer(Layer* layer) {
+  layer->ReduceMemoryUsage();
+}
 
 void LayerTreeHost::ReduceMemoryUsage() {
-  if (!root_layer())
-    return;
-
-  LayerTreeHostCommon::CallFunctionForSubtree<
-      LayerTreeHostReduceMemoryFunctor, Layer>(root_layer());
+  if (root_layer())
+    LayerTreeHostCommon::CallFunctionForSubtree(ReduceMemoryUsageForLayer,
+                                                root_layer());
 }
 
 void LayerTreeHost::SetPrioritiesForSurfaces(size_t surface_memory_bytes) {
   DCHECK(surface_memory_placeholder_);
 
   // Surfaces have a place holder for their memory since they are managed
   // independantly but should still be tracked and reduce other memory usage.
   surface_memory_placeholder_->SetTextureManager(
       contents_texture_manager_.get());
   surface_memory_placeholder_->set_request_priority(
@@ skipping 276 matching lines @@
     bool start_ready_animations = true;
     (*iter).second->UpdateState(start_ready_animations, NULL);
   }
 }
 
 skia::RefPtr<SkPicture> LayerTreeHost::CapturePicture() {
   return proxy_->CapturePicture();
 }
 
 }  // namespace cc