cc: Make DamageTracker use the effect tree and layer list

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 689 matching lines @@
 
   return false;
 }
 
 void LayerTreeHostImpl::QueueSwapPromiseForMainThreadScrollUpdate(
     std::unique_ptr<SwapPromise> swap_promise) {
   swap_promises_for_main_thread_scroll_update_.push_back(
       std::move(swap_promise));
 }
 
-void LayerTreeHostImpl::TrackDamageForAllSurfaces(
-    const LayerImplList& render_surface_layer_list) {
-  // For now, we use damage tracking to compute a global scissor. To do this, we
-  // must compute all damage tracking before drawing anything, so that we know
-  // the root damage rect. The root damage rect is then used to scissor each
-  // surface.
-  size_t render_surface_layer_list_size = render_surface_layer_list.size();
-  for (size_t i = 0; i < render_surface_layer_list_size; ++i) {
-    size_t surface_index = render_surface_layer_list_size - 1 - i;
-    LayerImpl* render_surface_layer = render_surface_layer_list[surface_index];
-    RenderSurfaceImpl* render_surface =
-        render_surface_layer->GetRenderSurface();
-    DCHECK(render_surface);
-    render_surface->damage_tracker()->UpdateDamageTrackingState(
-        render_surface->layer_list(), render_surface,
-        render_surface->SurfacePropertyChangedOnlyFromDescendant(),
-        render_surface->content_rect(), render_surface->MaskLayer(),
-        render_surface->Filters());
-  }
-}
-
 void LayerTreeHostImpl::FrameData::AsValueInto(
     base::trace_event::TracedValue* value) const {
   value->SetBoolean("has_no_damage", has_no_damage);
 
   // Quad data can be quite large, so only dump render passes if we select
   // cc.debug.quads.
   bool quads_enabled;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"), &quads_enabled);
   if (quads_enabled) {
@@ skipping 59 matching lines @@
       list.begin(), list.end(),
       [id](const std::unique_ptr<RenderPass>& p) { return p->id == id; });
   return it == list.end() ? nullptr : it->get();
 }
 
 DrawResult LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
   DCHECK(frame->render_passes.empty());
   DCHECK(CanDraw());
   DCHECK(!active_tree_->LayerListIsEmpty());
 
-  TrackDamageForAllSurfaces(*frame->render_surface_layer_list);
+  // For now, we use damage tracking to compute a global scissor. To do this, we
+  // must compute all damage tracking before drawing anything, so that we know
+  // the root damage rect. The root damage rect is then used to scissor each
+  // surface.
+  DamageTracker::UpdateDamageTracking(active_tree_.get(),
+                                      active_tree_->RenderSurfaceLayerList());
 
   // If the root render surface has no visible damage, then don't generate a
   // frame at all.
   RenderSurfaceImpl* root_surface = active_tree_->RootRenderSurface();
   bool root_surface_has_no_visible_damage =
       !root_surface->GetDamageRect().Intersects(root_surface->content_rect());
   bool root_surface_has_contributing_layers =
       !root_surface->layer_list().empty();
   bool hud_wants_to_draw_ = active_tree_->hud_layer() &&
                             active_tree_->hud_layer()->IsAnimatingHUDContents();
@@ skipping 3478 matching lines @@
 }
 
 void LayerTreeHostImpl::UpdateScrollSourceInfo(bool is_wheel_scroll) {
   if (is_wheel_scroll)
     has_scrolled_by_wheel_ = true;
   else
     has_scrolled_by_touch_ = true;
 }
 
 }  // namespace cc