Always set damage rect to output rect if 3D context was reshaped.

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 99 matching lines @@
   overlay_shared_state->transform =
       quad->shared_quad_state->quad_to_target_transform.matrix();
 
   ca_layer_overlay->shared_state = overlay_shared_state;
   ca_layer_overlay->bounds_rect = gfx::RectF(quad->rect);
 
   return result;
 }
 
 void DCLayerOverlayProcessor::Process(ResourceProvider* resource_provider,
+                                      bool was_reshaped,
                                       const gfx::RectF& display_rect,
                                       QuadList* quad_list,
                                       gfx::Rect* overlay_damage_rect,
                                       gfx::Rect* damage_rect,
                                       DCLayerOverlayList* ca_layer_overlays) {

[ccameron, 2017/05/11 08:49:17]

This function is doing both the "overlay" strategy (which is pretty simple) and
the "underlay" strategy (which is pretty subtle).

Do you think we could internally split this into two functions -- bool
ProcessForOverlays and bool ProcessForUnderlays, and have this function do
  if (ProcessForOverlays(...))
    ProcessForUnderlays(...);

   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;
 
     if (!it->shared_quad_state->quad_to_target_transform
              .Preserves2dAxisAlignment() &&
         !base::FeatureList::IsEnabled(
             features::kDirectCompositionComplexOverlays)) {
       continue;
     }
 
     gfx::Rect quad_rectangle = gfx::ToEnclosingRect(ClippedQuadRectangle(*it));
     gfx::RectF occlusion_bounding_box =
         GetOcclusionBounds(gfx::RectF(quad_rectangle), quad_list->begin(), it);
     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() &&
-          !display_rect_changed && !it->ShouldDrawWithBlending()) {
+          !was_reshaped && !it->ShouldDrawWithBlending()) {
         damage_rect->Subtract(quad_rectangle);
       }
       quad_list->EraseAndInvalidateAllPointers(it);
     } else if (!base::FeatureList::IsEnabled(
                    features::kDirectCompositionUnderlays)) {
       continue;
     } 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() &&
-            !display_rect_changed) {
+            !was_reshaped) {

[ccameron, 2017/05/11 08:49:17]

Drive-by comment -- is this if missing a
  else {
    damage_rect->Union(quad_rectangle);
  }
?

           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);
         }
       } else {
         // Entire replacement quad must be redrawn.
         damage_rect->Union(quad_rectangle);
       }
       previous_occlusion_bounding_box_ =
           gfx::ToEnclosingRect(occlusion_bounding_box);
     }
     overlay_damage_rect->Union(quad_rectangle);
 
     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