cc : Fix damage rect bug caused by deletion of render surface

cc/trees/damage_tracker.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/damage_tracker.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 135 matching lines @@
     damage_rect_for_this_update.Union(damage_from_leftover_rects);
 
     ExpandRectWithFilters(&damage_rect_for_this_update, filters);
   }
 
   // Damage accumulates until we are notified that we actually did draw on that
   // frame.
   current_damage_rect_.Union(damage_rect_for_this_update);
 }
 
-DamageTracker::RectMapData& DamageTracker::RectDataForLayer(
+DamageTracker::LayerRectMapData& DamageTracker::RectDataForLayer(
     int layer_id,
     bool* layer_is_new) {
+  LayerRectMapData data(layer_id);
 
-  RectMapData data(layer_id);
+  SortedRectMapForLayers::iterator it = std::lower_bound(
+      rect_history_for_layers_.begin(), rect_history_for_layers_.end(), data);
 
-  SortedRectMap::iterator it = std::lower_bound(rect_history_.begin(),
-    rect_history_.end(), data);
-
-  if (it == rect_history_.end() || it->layer_id_ != layer_id) {
+  if (it == rect_history_for_layers_.end() || it->layer_id_ != layer_id) {
     *layer_is_new = true;
-    it = rect_history_.insert(it, data);
+    it = rect_history_for_layers_.insert(it, data);
   }
 
   return *it;
+}
+
+DamageTracker::SurfaceRectMapData& DamageTracker::RectDataForSurface(
+    int surface_id,
+    bool* surface_is_new) {
+  SurfaceRectMapData data(surface_id);
+
+  SortedRectMapForSurfaces::iterator it =
+      std::lower_bound(rect_history_for_surfaces_.begin(),
+                       rect_history_for_surfaces_.end(), data);
+
+  if (it == rect_history_for_surfaces_.end() || it->surface_id_ != surface_id) {
+    *surface_is_new = true;
+    it = rect_history_for_surfaces_.insert(it, data);
+  }
+
+  return *it;
 }
 
 gfx::Rect DamageTracker::TrackDamageFromActiveLayers(
     const LayerImplList& layer_list,
     const RenderSurfaceImpl* target_surface) {
   gfx::Rect damage_rect;
 
   for (size_t layer_index = 0; layer_index < layer_list.size(); ++layer_index) {
     // Visit layers in back-to-front order.
     LayerImpl* layer = layer_list[layer_index];
@@ skipping 34 matching lines @@
 void DamageTracker::PrepareRectHistoryForUpdate() {
   mailboxId_++;
 }
 
 gfx::Rect DamageTracker::TrackDamageFromLeftoverRects() {
   // After computing damage for all active layers, any leftover items in the
   // current rect history correspond to layers/surfaces that no longer exist.
   // So, these regions are now exposed on the target surface.
 
   gfx::Rect damage_rect;
-  SortedRectMap::iterator cur_pos = rect_history_.begin();
-  SortedRectMap::iterator copy_pos = cur_pos;
+  SortedRectMapForLayers::iterator layer_cur_pos =
+      rect_history_for_layers_.begin();
+  SortedRectMapForLayers::iterator layer_copy_pos = layer_cur_pos;
+  SortedRectMapForSurfaces::iterator surface_cur_pos =
+      rect_history_for_surfaces_.begin();
+  SortedRectMapForSurfaces::iterator surface_copy_pos = surface_cur_pos;
 
   // Loop below basically implements std::remove_if loop with and extra
   // processing (adding deleted rect to damage_rect) for deleted items.
   // cur_pos iterator runs through all elements of the vector, but copy_pos
   // always points to the element after the last not deleted element. If new
   // not deleted element found then it is copied to the *copy_pos and copy_pos
   // moved to the next position.
   // If there are no deleted elements then copy_pos iterator is in sync with
   // cur_pos and no copy happens.
-  while (cur_pos < rect_history_.end()) {
-    if (cur_pos->mailboxId_ == mailboxId_) {
-      if (cur_pos != copy_pos)
-        *copy_pos = *cur_pos;
+  while (layer_cur_pos < rect_history_for_layers_.end()) {
+    if (layer_cur_pos->mailboxId_ == mailboxId_) {
+      if (layer_cur_pos != layer_copy_pos)
+        *layer_copy_pos = *layer_cur_pos;
 
-      ++copy_pos;
+      ++layer_copy_pos;
     } else {
-      damage_rect.Union(cur_pos->rect_);
+      damage_rect.Union(layer_cur_pos->rect_);
     }
 
-    ++cur_pos;
+    ++layer_cur_pos;
   }
 
-  if (copy_pos != rect_history_.end())
-    rect_history_.erase(copy_pos, rect_history_.end());
+  while (surface_cur_pos < rect_history_for_surfaces_.end()) {
+    if (surface_cur_pos->mailboxId_ == mailboxId_) {
+      if (surface_cur_pos != surface_copy_pos)
+        *surface_copy_pos = *surface_cur_pos;
+
+      ++surface_copy_pos;
+    } else {
+      damage_rect.Union(surface_cur_pos->rect_);
+    }
+
+    ++surface_cur_pos;
+  }
+
+  if (layer_copy_pos != rect_history_for_layers_.end())
+    rect_history_for_layers_.erase(layer_copy_pos,
+                                   rect_history_for_layers_.end());
+  if (surface_copy_pos != rect_history_for_surfaces_.end())
+    rect_history_for_surfaces_.erase(surface_copy_pos,
+                                     rect_history_for_surfaces_.end());
 
   // If the vector has excessive storage, shrink it
-  if (rect_history_.capacity() > rect_history_.size() * 4)
-    SortedRectMap(rect_history_).swap(rect_history_);
+  if (rect_history_for_layers_.capacity() > rect_history_for_layers_.size() * 4)
+    SortedRectMapForLayers(rect_history_for_layers_)
+        .swap(rect_history_for_layers_);
+  if (rect_history_for_surfaces_.capacity() >
+      rect_history_for_surfaces_.size() * 4)
+    SortedRectMapForSurfaces(rect_history_for_surfaces_)
+        .swap(rect_history_for_surfaces_);
 
   return damage_rect;
 }
 
 void DamageTracker::ExtendDamageForLayer(LayerImpl* layer,
                                          gfx::Rect* target_damage_rect) {
   // There are two ways that a layer can damage a region of the target surface:
   //   1. Property change (e.g. opacity, position, transforms):
   //        - the entire region of the layer itself damages the surface.
   //        - the old layer region also damages the surface, because this region
   //          is now exposed.
   //        - note that in many cases the old and new layer rects may overlap,
   //          which is fine.
   //
   //   2. Repaint/update: If a region of the layer that was repainted/updated,
   //      that region damages the surface.
   //
   // Property changes take priority over update rects.
   //
   // This method is called when we want to consider how a layer contributes to
   // its target RenderSurface, even if that layer owns the target RenderSurface
   // itself. To consider how a layer's target surface contributes to the
   // ancestor surface, ExtendDamageForRenderSurface() must be called instead.
 
   bool layer_is_new = false;
-  RectMapData& data = RectDataForLayer(layer->id(), &layer_is_new);
+  LayerRectMapData& data = RectDataForLayer(layer->id(), &layer_is_new);
   gfx::Rect old_rect_in_target_space = data.rect_;
 
   gfx::Rect rect_in_target_space = layer->GetEnclosingRectInTargetSpace();
   data.Update(rect_in_target_space, mailboxId_);
 
   if (layer_is_new || layer->LayerPropertyChanged()) {
     // If a layer is new or has changed, then its entire layer rect affects the
     // target surface.
     target_damage_rect->Union(rect_in_target_space);
 
@@ skipping 29 matching lines @@
   //        - just like layers, both the old surface rect and new surface rect
   //          will damage the target surface in this case.
   //
   //   2. Damage rect: This surface may have been damaged by its own layer_list
   //      as well, and that damage should propagate to the target surface.
   //
 
   RenderSurfaceImpl* render_surface = layer->render_surface();
 
   bool surface_is_new = false;
-  RectMapData& data = RectDataForLayer(layer->id(), &surface_is_new);
+  SurfaceRectMapData& data = RectDataForSurface(layer->id(), &surface_is_new);
   gfx::Rect old_surface_rect = data.rect_;
 
   // The drawableContextRect() already includes the replica if it exists.
   gfx::Rect surface_rect_in_target_space =
       gfx::ToEnclosingRect(render_surface->DrawableContentRect());
   data.Update(surface_rect_in_target_space, mailboxId_);
 
   if (surface_is_new || render_surface->SurfacePropertyChanged()) {
     // The entire surface contributes damage.
     target_damage_rect->Union(surface_rect_in_target_space);
@@ skipping 21 matching lines @@
       }
     }
   }
 
   // If there was damage on the replica's mask, then the target surface receives
   // that damage as well.
   if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {
     LayerImpl* replica_mask_layer = layer->replica_layer()->mask_layer();
 
     bool replica_is_new = false;
-    RectMapData& data =
+    LayerRectMapData& data =
         RectDataForLayer(replica_mask_layer->id(), &replica_is_new);
 
     const gfx::Transform& replica_draw_transform =
         render_surface->replica_draw_transform();
     gfx::Rect replica_mask_layer_rect = MathUtil::MapEnclosingClippedRect(
         replica_draw_transform, gfx::Rect(replica_mask_layer->bounds()));
     data.Update(replica_mask_layer_rect, mailboxId_);
 
     // In the current implementation, a change in the replica mask damages the
     // entire replica region.
@@ skipping 10 matching lines @@
   // one in them. This means we need to redraw any pixels in the surface being
   // used for the blur in this layer this frame.
   if (layer->background_filters().HasFilterThatMovesPixels()) {
     ExpandDamageRectInsideRectWithFilters(target_damage_rect,
                                           surface_rect_in_target_space,
                                           layer->background_filters());
   }
 }
 
 }  // namespace cc