cc: Make DamageTracker use the effect tree and layer list

cc/trees/damage_tracker.h

 // 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.
 
 #ifndef CC_TREES_DAMAGE_TRACKER_H_
 #define CC_TREES_DAMAGE_TRACKER_H_
 
 #include <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "cc/cc_export.h"
 #include "cc/layers/layer_collections.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace gfx {
 class Rect;
 }
 
 namespace cc {
 
 class FilterOperations;
 class LayerImpl;
+class LayerTreeImpl;
 class RenderSurfaceImpl;
 
 // Computes the region where pixels have actually changed on a
 // RenderSurfaceImpl. This region is used to scissor what is actually drawn to
 // the screen to save GPU computation and bandwidth.
 class CC_EXPORT DamageTracker {
  public:
   static std::unique_ptr<DamageTracker> Create();
   ~DamageTracker();
 
+  static void UpdateDamageTracking(LayerTreeImpl* layer_tree_impl,
+                                   const LayerImplList& render_surface_list);
+
   void DidDrawDamagedArea() { current_damage_ = DamageAccumulator(); }
   void AddDamageNextUpdate(const gfx::Rect& dmg) { current_damage_.Union(dmg); }
-  void UpdateDamageTrackingState(
-      const LayerImplList& layer_list,
-      const RenderSurfaceImpl* target_surface,
-      bool target_surface_property_changed_only_from_descendant,
-      const gfx::Rect& target_surface_content_rect,
-      LayerImpl* target_surface_mask_layer,
-      const FilterOperations& filters);
 
   bool GetDamageRectIfValid(gfx::Rect* rect);
 
  private:
   DamageTracker();
 
   class DamageAccumulator {
    public:
     template <typename Type>
     void Union(const Type& rect) {
@@ skipping 24 matching lines @@
     bool GetAsRect(gfx::Rect* rect);
 
    private:
     bool is_valid_rect_ = true;
     int x_ = 0;
     int y_ = 0;
     int right_ = 0;
     int bottom_ = 0;
   };
 
-  DamageAccumulator TrackDamageFromActiveLayers(
-      const LayerImplList& layer_list,
-      const RenderSurfaceImpl* target_surface);
   DamageAccumulator TrackDamageFromSurfaceMask(
       LayerImpl* target_surface_mask_layer);
   DamageAccumulator TrackDamageFromLeftoverRects();
-  void PrepareRectHistoryForUpdate();
 
-  // These helper functions are used only in TrackDamageFromActiveLayers().
-  void ExtendDamageForLayer(LayerImpl* layer, DamageAccumulator* target_damage);
-  void ExtendDamageForRenderSurface(RenderSurfaceImpl* render_surface,
-                                    DamageAccumulator* target_damage);
+  // These helper functions are used only during UpdateDamageTracking().
+  void PrepareForUpdate();
+  void AccumulateDamageFromLayer(LayerImpl* layer);
+  void AccumulateDamageFromRenderSurface(RenderSurfaceImpl* render_surface);
+  void ComputeSurfaceDamage(RenderSurfaceImpl* render_surface);
   void ExpandDamageInsideRectWithFilters(const gfx::Rect& pre_filter_rect,
-                                         const FilterOperations& filters,
-                                         DamageAccumulator* damage);
+                                         const FilterOperations& filters);
 
   struct LayerRectMapData {
     LayerRectMapData() : layer_id_(0), mailboxId_(0) {}
     explicit LayerRectMapData(int layer_id)
         : layer_id_(layer_id), mailboxId_(0) {}
     void Update(const gfx::Rect& rect, unsigned int mailboxId) {
       mailboxId_ = mailboxId;
       rect_ = rect;
     }
 
@@ skipping 28 matching lines @@
 
   LayerRectMapData& RectDataForLayer(int layer_id, bool* layer_is_new);
   SurfaceRectMapData& RectDataForSurface(int layer_id, bool* layer_is_new);
 
   SortedRectMapForLayers rect_history_for_layers_;
   SortedRectMapForSurfaces rect_history_for_surfaces_;
 
   unsigned int mailboxId_;
   DamageAccumulator current_damage_;
 
+  // Damage accumulated since the last call to PrepareForUpdate().
+  DamageAccumulator damage_for_this_update_;
+
   DISALLOW_COPY_AND_ASSIGN(DamageTracker);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_DAMAGE_TRACKER_H_