cc : Make CallFunctionForSubtree on impl use layer iterator

cc/trees/layer_tree_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_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 87 matching lines @@
 }
 
 void LayerTreeImpl::Shutdown() {
   if (root_layer_)
     RemoveLayer(root_layer_->id());
   root_layer_ = nullptr;
 }
 
 void LayerTreeImpl::ReleaseResources() {
   if (root_layer_) {
-    LayerTreeHostCommon::CallFunctionForSubtree(
-        root_layer_, [](LayerImpl* layer) { layer->ReleaseResources(); });
+    LayerTreeHostCommon::CallFunctionForEveryLayer(
+        this, [](LayerImpl* layer) { layer->ReleaseResources(); });
   }
 }
 
 void LayerTreeImpl::RecreateResources() {
   if (root_layer_) {
-    LayerTreeHostCommon::CallFunctionForSubtree(
-        root_layer_, [](LayerImpl* layer) { layer->RecreateResources(); });
+    LayerTreeHostCommon::CallFunctionForEveryLayer(
+        this, [](LayerImpl* layer) { layer->RecreateResources(); });
   }
 }
 
 void LayerTreeImpl::GatherFrameTimingRequestIds(
     std::vector<int64_t>* request_ids) {
   if (!root_layer_)
     return;
 
   // TODO(vmpstr): Early out if there are no requests on any of the layers. For
   // that, we need to inform LayerTreeImpl whenever there are requests when we
   // get them.
-  LayerTreeHostCommon::CallFunctionForSubtree(
-      root_layer_, [request_ids](LayerImpl* layer) {
+  LayerTreeHostCommon::CallFunctionForEveryLayer(
+      this, [request_ids](LayerImpl* layer) {
         layer->GatherFrameTimingRequestIds(request_ids);
       });
 }
 
 bool LayerTreeImpl::IsViewportLayerId(int id) const {
   if (id == inner_viewport_scroll_layer_id_ ||
       id == outer_viewport_scroll_layer_id_)
     return true;
   if (InnerViewportContainerLayer() &&
       id == InnerViewportContainerLayer()->id())
@@ skipping 417 matching lines @@
 
 void LayerTreeImpl::UpdatePropertyTreeScrollingAndAnimationFromMainThread() {
   // TODO(enne): This should get replaced by pulling out scrolling and
   // animations into their own trees.  Then scrolls and animations would have
   // their own ways of synchronizing across commits.  This occurs to push
   // updates from scrolling deltas on the compositor thread that have occurred
   // after begin frame and updates from animations that have ticked since begin
   // frame to a newly-committed property tree.
   if (!root_layer())
     return;
-  LayerTreeHostCommon::CallFunctionForSubtree(
-      root_layer(), [](LayerImpl* layer) {
-        layer->UpdatePropertyTreeForScrollingAndAnimationIfNeeded();
-      });
+  LayerTreeHostCommon::CallFunctionForEveryLayer(this, [](LayerImpl* layer) {
+    layer->UpdatePropertyTreeForScrollingAndAnimationIfNeeded();
+  });
 }
 
 void LayerTreeImpl::SetPageScaleOnActiveTree(float active_page_scale) {
   DCHECK(IsActiveTree());
   if (page_scale_factor()->SetCurrent(
           ClampPageScaleFactorToLimits(active_page_scale))) {
     DidUpdatePageScale();
     if (PageScaleLayer()) {
       draw_property_utils::UpdatePageScaleFactor(
           property_trees(), PageScaleLayer(), current_page_scale_factor(),
@@ skipping 265 matching lines @@
 
   {
     TRACE_EVENT2("cc", "LayerTreeImpl::UpdateDrawProperties::Occlusion",
                  "IsActive", IsActiveTree(), "SourceFrameNumber",
                  source_frame_number_);
     OcclusionTracker occlusion_tracker(
         root_layer()->render_surface()->content_rect());
     occlusion_tracker.set_minimum_tracking_size(
         settings().minimum_occlusion_tracking_size);
 
-    // LayerIterator is used here instead of CallFunctionForSubtree to only
+    // LayerIterator is used here instead of CallFunctionForEveryLayer to only
     // UpdateTilePriorities on layers that will be visible (and thus have valid
     // draw properties) and not because any ordering is required.
     LayerIterator end = LayerIterator::End(&render_surface_layer_list_);
     for (LayerIterator it = LayerIterator::Begin(&render_surface_layer_list_);
          it != end; ++it) {
       occlusion_tracker.EnterLayer(it);
 
       bool inside_replica = it->render_target()->InsideReplica();
 
       // Don't use occlusion if a layer will appear in a replica, since the
@@ skipping 203 matching lines @@
   if (next_activation_forces_redraw_) {
     layer_tree_host_impl_->SetFullRootLayerDamage();
     next_activation_forces_redraw_ = false;
   }
 
   // Always reset this flag on activation, as we would only have activated
   // if we were in a good state.
   layer_tree_host_impl_->ResetRequiresHighResToDraw();
 
   if (root_layer()) {
-    LayerTreeHostCommon::CallFunctionForSubtree(
-        root_layer(), [](LayerImpl* layer) { layer->DidBecomeActive(); });
+    LayerTreeHostCommon::CallFunctionForEveryLayer(
+        this, [](LayerImpl* layer) { layer->DidBecomeActive(); });
   }
 
   for (const auto& swap_promise : swap_promise_list_)
     swap_promise->DidActivate();
   devtools_instrumentation::DidActivateLayerTree(layer_tree_host_impl_->id(),
                                                  source_frame_number_);
 }
 
 bool LayerTreeImpl::RequiresHighResToDraw() const {
   return layer_tree_host_impl_->RequiresHighResToDraw();
@@ skipping 1003 matching lines @@
 }
 
 void LayerTreeImpl::ResetAllChangeTracking(PropertyTrees::ResetFlags flag) {
   layers_that_should_push_properties_.clear();
   for (auto* layer : *this)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking(flag);
 }
 
 }  // namespace cc