cc: Make all layer recursion use CallFunctionForSubtree

cc/trees/layer_tree_host_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_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/json/json_writer.h"
@@ skipping 1089 matching lines @@
   return metadata;
 }
 
 bool LayerTreeHostImpl::AllowPartialSwap() const {
   // We don't track damage on the HUD layer (it interacts with damage tracking
   // visualizations), so disable partial swaps to make the HUD layer display
   // properly.
   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) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
   DCHECK(CanDraw());
 
   if (frame->has_no_damage)
     return;
 
   DCHECK(!frame->render_passes.empty());
@@ skipping 21 matching lines @@
 
   if (!settings_.impl_side_painting && debug_state_.continuous_painting) {
     const RenderingStats& stats =
         rendering_stats_instrumentation_->GetRenderingStats();
     paint_time_counter_->SavePaintTime(stats.total_paint_time);
   }
 
   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(
       TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", this,
       TracedValue::FromValue(AsValue().release()));
 
   // Because the contents of the HUD depend on everything else in the frame, the
   // contents of its texture are updated as the last thing before the frame is
   // drawn.
   if (active_tree_->hud_layer())
@@ skipping 250 matching lines @@
     return managed_memory_policy_;
 
   ManagedMemoryPolicy actual = managed_memory_policy_;
   actual.priority_cutoff_when_not_visible =
       ManagedMemoryPolicy::CUTOFF_ALLOW_NOTHING;
   actual.priority_cutoff_when_visible =
       ManagedMemoryPolicy::CUTOFF_ALLOW_REQUIRED_ONLY;
   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
   // the old resources (i.e. render_surfaces and texture IDs). Clear them
   // 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();
 
   // Note: order is important here.
   renderer_.reset();
   tile_manager_.reset();
   resource_provider_.reset();
   output_surface_.reset();
 
   if (!output_surface->BindToClient(this))
@@ skipping 598 matching lines @@
   if (!events->empty()) {
     client_->PostAnimationEventsToMainThreadOnImplThread(events.Pass(),
                                                          last_animation_time_);
   }
 }
 
 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_)
     pending_tree_->ClearRenderSurfaces();
 }
 
 std::string LayerTreeHostImpl::LayerTreeAsText() const {
   std::string str;
   if (active_tree_->root_layer()) {
     str = active_tree_->root_layer()->LayerTreeAsText();
@@ skipping 186 matching lines @@
 }
 
 void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
   if (debug_state_.continuous_painting != debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = debug_state;
 }
 
 }  // namespace cc