cc: Make all layer recursion use CallFunctionForSubtree

This is mostly a cleanup that I noticed while doing other code.

The behavior change here is that SetNeedsDisplay and DidBecomeActive is
now called for all mask and replica layers.

Also, refactor CallFunctionForSubtree so that both functors and
functions can be passed to it.  As no uses in the codebase actually
needed function objects with state, turn them all into simpler static
functions.

R=danakj@chromium.org
BUG=239614

Review URL: https://chromiumcodereview.appspot.com/15959012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@204221 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 68 insertions, 88 deletions

diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index 913ca1b..108a711 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -5,7 +5,6 @@
 #include "cc/trees/layer_tree_host.h"
 
 #include <algorithm>
-#include <stack>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ -438,17 +437,13 @@ void LayerTreeHost::SetDeferCommits(bool 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 {
@@ -672,29 +667,26 @@ static Layer* FindFirstScrollableLayer(Layer* layer) {
   return NULL;
 }
 
-class CalculateLCDTextMetricsFunctor {
- public:
-  void operator()(Layer* layer) {
-    LayerTreeHost* layer_tree_host = layer->layer_tree_host();
-    if (!layer_tree_host)
-      return;
-
-    if (!layer->SupportsLCDText())
-      return;
+static void CalculateLCDTextMetrics(Layer* layer) {
+  LayerTreeHost* layer_tree_host = layer->layer_tree_host();
+  if (!layer_tree_host)
+    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;
-    }
+  if (!layer->SupportsLCDText())
+    return;
 
-    layer_tree_host->IncrementLCDTextMetrics(
-        update_total_num_cc_layers_can_use_lcd_text,
-        update_total_num_cc_layers_will_use_lcd_text);
+  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);
+}
 
 void LayerTreeHost::IncrementLCDTextMetrics(
     bool update_total_num_cc_layers_can_use_lcd_text,
@@ -733,8 +725,8 @@ void LayerTreeHost::UpdateLayers(Layer* root_layer,
 
     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_++;
     }
 
@@ -777,19 +769,14 @@ void 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) {
diff --git a/cc/trees/layer_tree_host_common.h b/cc/trees/layer_tree_host_common.h
index cecb793..7712db2 100644
--- a/cc/trees/layer_tree_host_common.h
+++ b/cc/trees/layer_tree_host_common.h
@@ -64,7 +64,7 @@ class CC_EXPORT LayerTreeHostCommon {
                                                int target_surface_layer_id);
 
   template <class Function, typename LayerType>
-  static void CallFunctionForSubtree(LayerType* root_layer);
+  static void CallFunctionForSubtree(Function function, LayerType* root_layer);
 
   // Returns a layer with the given id if one exists in the subtree starting
   // from the given root layer (including mask and replica layers).
@@ -133,21 +133,22 @@ LayerType* LayerTreeHostCommon::FindLayerInSubtree(LayerType* root_layer,
   return NULL;
 }
 
-template <class Function, typename LayerType>
-void LayerTreeHostCommon::CallFunctionForSubtree(LayerType* root_layer) {
-  Function()(root_layer);
+template <typename Function, typename LayerType>
+void LayerTreeHostCommon::CallFunctionForSubtree(Function function,
+                                                 LayerType* root_layer) {
+  function(root_layer);
 
   if (LayerType* mask_layer = root_layer->mask_layer())
-    Function()(mask_layer);
+    function(mask_layer);
   if (LayerType* replica_layer = root_layer->replica_layer()) {
-    Function()(replica_layer);
+    function(replica_layer);
     if (LayerType* mask_layer = replica_layer->mask_layer())
-      Function()(mask_layer);
+      function(mask_layer);
   }
 
   for (size_t i = 0; i < root_layer->children().size(); ++i) {
-    CallFunctionForSubtree<Function>(
-        get_child_as_raw_ptr(root_layer->children(), i));
+    CallFunctionForSubtree(function,
+                           get_child_as_raw_ptr(root_layer->children(), i));
   }
 }
 
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index ef2b53d..d89460a 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -1107,12 +1107,9 @@ bool LayerTreeHostImpl::AllowPartialSwap() const {
   return !debug_state_.ShowHudRects();
 }
 
-class DidBeginTracingFunctor {
- public:
-  void operator()(LayerImpl* layer) {
-    layer->DidBeginTracing();
-  }
-};
+void DidBeginTracing(LayerImpl* layer) {
+  layer->DidBeginTracing();
+}
 
 void LayerTreeHostImpl::DrawLayers(FrameData* frame,
                                    base::TimeTicks frame_begin_time) {
@@ -1154,13 +1151,12 @@ void LayerTreeHostImpl::DrawLayers(FrameData* frame,
   bool is_new_trace;
   TRACE_EVENT_IS_NEW_TRACE(&is_new_trace);
   if (is_new_trace) {
-    if (pending_tree_)
-      LayerTreeHostCommon::CallFunctionForSubtree<
-          DidBeginTracingFunctor, LayerImpl>(
-              pending_tree_->root_layer());
-    LayerTreeHostCommon::CallFunctionForSubtree<
-        DidBeginTracingFunctor, LayerImpl>(
-            active_tree_->root_layer());
+    if (pending_tree_) {
+      LayerTreeHostCommon::CallFunctionForSubtree(DidBeginTracing,
+                                                  pending_tree_->root_layer());
+    }
+    LayerTreeHostCommon::CallFunctionForSubtree(DidBeginTracing,
+                                                active_tree_->root_layer());
   }
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
@@ -1431,6 +1427,10 @@ ManagedMemoryPolicy LayerTreeHostImpl::ActualManagedMemoryPolicy() const {
   return actual;
 }
 
+static void LostOutputSurface(LayerImpl* layer) {
+  layer->DidLoseOutputSurface();
+}
+
 bool LayerTreeHostImpl::InitializeRenderer(
     scoped_ptr<OutputSurface> output_surface) {
   // Since we will create a new resource provider, we cannot continue to use
@@ -1438,12 +1438,18 @@ bool LayerTreeHostImpl::InitializeRenderer(
   // before we destroy the old resource provider.
   if (active_tree_->root_layer())
     ClearRenderSurfaces();
-  if (active_tree_->root_layer())
-    SendDidLoseOutputSurfaceRecursive(active_tree_->root_layer());
-  if (pending_tree_ && pending_tree_->root_layer())
-    SendDidLoseOutputSurfaceRecursive(pending_tree_->root_layer());
-  if (recycle_tree_ && recycle_tree_->root_layer())
-    SendDidLoseOutputSurfaceRecursive(recycle_tree_->root_layer());
+  if (active_tree_->root_layer()) {
+    LayerTreeHostCommon::CallFunctionForSubtree(LostOutputSurface,
+                                                active_tree_->root_layer());
+  }
+  if (pending_tree_ && pending_tree_->root_layer()) {
+    LayerTreeHostCommon::CallFunctionForSubtree(LostOutputSurface,
+                                                pending_tree_->root_layer());
+  }
+  if (recycle_tree_ && recycle_tree_->root_layer()) {
+    LayerTreeHostCommon::CallFunctionForSubtree(LostOutputSurface,
+                                                recycle_tree_->root_layer());
+  }
   if (resource_provider_)
     resource_provider_->DidLoseOutputSurface();
 
@@ -2062,17 +2068,6 @@ base::TimeDelta LayerTreeHostImpl::LowFrequencyAnimationInterval() const {
   return base::TimeDelta::FromSeconds(1);
 }
 
-void LayerTreeHostImpl::SendDidLoseOutputSurfaceRecursive(LayerImpl* current) {
-  DCHECK(current);
-  current->DidLoseOutputSurface();
-  if (current->mask_layer())
-    SendDidLoseOutputSurfaceRecursive(current->mask_layer());
-  if (current->replica_layer())
-    SendDidLoseOutputSurfaceRecursive(current->replica_layer());
-  for (size_t i = 0; i < current->children().size(); ++i)
-    SendDidLoseOutputSurfaceRecursive(current->children()[i]);
-}
-
 void LayerTreeHostImpl::ClearRenderSurfaces() {
   active_tree_->ClearRenderSurfaces();
   if (pending_tree_)
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 02c0a90..f785b97 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -419,7 +419,6 @@ class CC_EXPORT LayerTreeHostImpl
   // if this helper function is called.
   bool CalculateRenderPasses(FrameData* frame);
 
-  void SendDidLoseOutputSurfaceRecursive(LayerImpl* current);
   void ClearRenderSurfaces();
   bool EnsureRenderSurfaceLayerList();
   void ClearCurrentlyScrollingLayer();
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 3a33441..f006032 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -350,15 +350,13 @@ void LayerTreeImpl::PushPersistedState(LayerTreeImpl* pending_tree) {
   pending_tree->SetCurrentlyScrollingLayer(pending_scrolling_layer_twin);
 }
 
-static void DidBecomeActiveRecursive(LayerImpl* layer) {
+static void MarkActive(LayerImpl* layer) {
   layer->DidBecomeActive();
-  for (size_t i = 0; i < layer->children().size(); ++i)
-    DidBecomeActiveRecursive(layer->children()[i]);
 }
 
 void LayerTreeImpl::DidBecomeActive() {
   if (root_layer())
-    DidBecomeActiveRecursive(root_layer());
+    LayerTreeHostCommon::CallFunctionForSubtree(MarkActive, root_layer());
   FindRootScrollLayer();
   UpdateMaxScrollOffset();
 }