DCLayerOverlay should damage entire frame on resize.

cc/output/dc_layer_overlay.cc

 // Copyright 2017 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/output/dc_layer_overlay.h"
 
 #include "cc/base/math_util.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
 #include "cc/resources/resource_provider.h"
@@ skipping 95 matching lines @@
   return result;
 }
 
 void DCLayerOverlayProcessor::Process(ResourceProvider* resource_provider,
                                       const gfx::RectF& display_rect,
                                       QuadList* quad_list,
                                       gfx::Rect* overlay_damage_rect,
                                       gfx::Rect* damage_rect,
                                       DCLayerOverlayList* ca_layer_overlays) {
   gfx::Rect this_frame_underlay_rect;
+  bool display_rect_changed = (display_rect != previous_display_rect_);
   for (auto it = quad_list->begin(); it != quad_list->end(); ++it) {
     DCLayerOverlay ca_layer;
     DCLayerResult result = FromDrawQuad(resource_provider, display_rect,
                                         quad_list->begin(), it, &ca_layer);
     if (result != DC_LAYER_SUCCESS)
       continue;
     gfx::Rect quad_rectangle = MathUtil::MapEnclosingClippedRect(
         it->shared_quad_state->quad_to_target_transform, it->rect);
     gfx::RectF occlusion_bounding_box =
         GetOcclusionBounds(gfx::RectF(quad_rectangle), quad_list->begin(), it);
+    overlay_damage_rect->Union(quad_rectangle);
 
     if (occlusion_bounding_box.IsEmpty()) {
       // The quad is on top, so promote it to an overlay and remove all damage
       // underneath it.
       if (it->shared_quad_state->quad_to_target_transform
-              .Preserves2dAxisAlignment()) {
+              .Preserves2dAxisAlignment() &&
+          !display_rect_changed) {
         damage_rect->Subtract(quad_rectangle);
-        overlay_damage_rect->Union(quad_rectangle);
       }
       quad_list->EraseAndInvalidateAllPointers(it);
     } else {
       // The quad is occluded, so replace it with a black solid color quad and
       // place the overlay itself under the quad.
       if (it->shared_quad_state->quad_to_target_transform
               .IsIdentityOrIntegerTranslation()) {
         this_frame_underlay_rect = quad_rectangle;
       }
       ca_layer.shared_state->z_order = -1;
       const SharedQuadState* shared_quad_state = it->shared_quad_state;
       gfx::Rect rect = it->visible_rect;
       SolidColorDrawQuad* replacement =
           quad_list->ReplaceExistingElement<SolidColorDrawQuad>(it);
       replacement->SetAll(shared_quad_state, rect, rect, rect, false,
                           SK_ColorTRANSPARENT, true);
 
       if (this_frame_underlay_rect == previous_frame_underlay_rect_) {
         // If this underlay rect is the same as for last frame, subtract its
         // area from the damage of the main surface, as the cleared area was
         // already cleared last frame. Add back the damage from the occluded
         // area for this and last frame, as that may have changed.
         if (it->shared_quad_state->quad_to_target_transform
-                .Preserves2dAxisAlignment()) {
+                .Preserves2dAxisAlignment() &&
+            !display_rect_changed) {
           gfx::Rect occluding_damage_rect = *damage_rect;
           occluding_damage_rect.Intersect(quad_rectangle);
           damage_rect->Subtract(quad_rectangle);
           gfx::Rect new_occlusion_bounding_box =
               gfx::ToEnclosingRect(occlusion_bounding_box);
           new_occlusion_bounding_box.Union(previous_occlusion_bounding_box_);
           occluding_damage_rect.Intersect(new_occlusion_bounding_box);
 
           damage_rect->Union(occluding_damage_rect);
-          overlay_damage_rect->Union(quad_rectangle);
         }
       } else {
         // Entire replacement quad must be redrawn.
         damage_rect->Union(quad_rectangle);
       }
       previous_occlusion_bounding_box_ =
           gfx::ToEnclosingRect(occlusion_bounding_box);
     }
 
     ca_layer_overlays->push_back(ca_layer);
     // Only allow one overlay for now.
     break;
   }
+  damage_rect->Intersect(gfx::ToEnclosingRect(display_rect));
   previous_frame_underlay_rect_ = this_frame_underlay_rect;
+  previous_display_rect_ = display_rect;
 }
 
 }  // namespace cc