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 262 matching lines @@
   //
   // 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);
   gfx::Rect old_rect_in_target_space = data.rect_;
 
+  if (!layer_is_new && data.is_render_surface_) {
+    // This was a render surface in the previous frame. Since the surface is now
+    // removed, we need to add it the damage rect.
+    target_damage_rect->Union(data.rect_);
+  }
   gfx::Rect rect_in_target_space = layer->GetEnclosingRectInTargetSpace();
-  data.Update(rect_in_target_space, mailboxId_);
+  data.Update(rect_in_target_space, mailboxId_, false /*is_render_surface*/);
 
   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);
 
     // The layer's old region is now exposed on the target surface, too.
     // Note old_rect_in_target_space is already in target space.
     target_damage_rect->Union(old_rect_in_target_space);
     return;
@@ skipping 31 matching lines @@
 
   RenderSurfaceImpl* render_surface = layer->render_surface();
 
   bool surface_is_new = false;
   RectMapData& data = RectDataForLayer(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_);
+  data.Update(surface_rect_in_target_space, mailboxId_,
+              true /*is_render_surface*/);
 
   if (surface_is_new || render_surface->SurfacePropertyChanged()) {
     // The entire surface contributes damage.
     target_damage_rect->Union(surface_rect_in_target_space);
 
     // The surface's old region is now exposed on the target surface, too.
     target_damage_rect->Union(old_surface_rect);
   } else {
     // Only the surface's damage_rect will damage the target surface.
     gfx::Rect damage_rect_in_local_space =
@@ skipping 22 matching lines @@
     LayerImpl* replica_mask_layer = layer->replica_layer()->mask_layer();
 
     bool replica_is_new = false;
     RectMapData& 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_);
+    data.Update(replica_mask_layer_rect, mailboxId_,
+                false /*is_render_surface*/);
 
     // In the current implementation, a change in the replica mask damages the
     // entire replica region.
     if (replica_is_new ||
         replica_mask_layer->LayerPropertyChanged() ||
         !replica_mask_layer->update_rect().IsEmpty())
       target_damage_rect->Union(replica_mask_layer_rect);
   }
 
   // If the layer has a background filter, this may cause pixels in our surface
   // to be expanded, so we will need to expand any damage at or below this
   // layer. We expand the damage from this layer too, as we need to readback
   // those pixels from the surface with only the contents of layers below this
   // 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