cc: Ensure that large damage doesn't register as "frame has no damage"

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>
 
@@ skipping 13 matching lines @@
 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();
 
-  void DidDrawDamagedArea() { current_damage_rect_ = gfx::Rect(); }
-  void AddDamageNextUpdate(const gfx::Rect& dmg) {
-    current_damage_rect_.Union(dmg);
-  }
+  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);
 
-  gfx::Rect current_damage_rect() { return current_damage_rect_; }
+  bool ShouldDamageEverything();
+  gfx::Rect CurrentDamageRect();
 
  private:
   DamageTracker();
 
-  gfx::Rect TrackDamageFromActiveLayers(
+  class DamageAccumulator {
+   public:
+    template <typename Type>
+    void Union(const Type& rect) {
+      if (!is_valid_rect_)
+        return;
+
+      if (IsEmpty()) {
+        x_ = rect.x();
+        y_ = rect.y();
+        right_ = rect.right();
+        bottom_ = rect.bottom();
+        return;
+      }
+      if (rect.IsEmpty())

[danakj, 2017/01/13 23:17:58]

why is this below setting everything if we are already empty?

[vmpstr, 2017/01/19 23:08:27]

Moved it up.

+        return;
+
+      x_ = std::min(x_, rect.x());
+      y_ = std::min(y_, rect.y());
+      right_ = std::max(right_, rect.right());
+      bottom_ = std::max(bottom_, rect.bottom());
+    }
+
+    void SetInvalid() { is_valid_rect_ = false; }
+
+    int x() const { return x_; }
+    int y() const { return y_; }
+    int right() const { return right_; }
+    int bottom() const { return bottom_; }
+    bool IsEmpty() const { return x_ == right_ || y_ == bottom_; }
+
+    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);
-  gfx::Rect TrackDamageFromSurfaceMask(LayerImpl* target_surface_mask_layer);
-  gfx::Rect TrackDamageFromLeftoverRects();
+  DamageAccumulator TrackDamageFromSurfaceMask(
+      LayerImpl* target_surface_mask_layer);
+  DamageAccumulator TrackDamageFromLeftoverRects();
+  void ExpandDamageInsideRectWithFilters(DamageAccumulator* damage,
+                                         const gfx::Rect& pre_filter_rect,
+                                         const FilterOperations& filters);
 
   void PrepareRectHistoryForUpdate();
 
   // These helper functions are used only in TrackDamageFromActiveLayers().

[danakj, 2017/01/13 23:17:59]

ExpandDamageInsideRectWithFilters can be grouped with these? And maybe take
|damage| as last parameter, out params should be last.

[vmpstr, 2017/01/19 23:08:27]

Done.

-  void ExtendDamageForLayer(LayerImpl* layer, gfx::Rect* target_damage_rect);
+  void ExtendDamageForLayer(LayerImpl* layer, DamageAccumulator* target_damage);
   void ExtendDamageForRenderSurface(RenderSurfaceImpl* render_surface,
-                                    gfx::Rect* target_damage_rect);
+                                    DamageAccumulator* target_damage);
 
   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 26 matching lines @@
   typedef std::vector<LayerRectMapData> SortedRectMapForLayers;
   typedef std::vector<SurfaceRectMapData> SortedRectMapForSurfaces;
 
   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_;
-  gfx::Rect current_damage_rect_;
+  DamageAccumulator current_damage_;
 
   DISALLOW_COPY_AND_ASSIGN(DamageTracker);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_DAMAGE_TRACKER_H_