DirectRenderer allows empty swap rects for CommitOverlayPlanes

cc/output/direct_renderer.cc

 // Copyright 2012 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/direct_renderer.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
@@ skipping 187 matching lines @@
       "Renderer4.renderPassCount",
       base::saturated_cast<int>(render_passes_in_draw_order->size()));
 
   const RenderPass* root_render_pass =
       render_passes_in_draw_order->back().get();
   DCHECK(root_render_pass);
 
   DrawingFrame frame;
   frame.render_passes_in_draw_order = render_passes_in_draw_order;
   frame.root_render_pass = root_render_pass;
-  frame.root_damage_rect = Capabilities().using_partial_swap
-                               ? root_render_pass->damage_rect
-                               : root_render_pass->output_rect;
+  frame.root_damage_rect = root_render_pass->damage_rect;
   frame.root_damage_rect.Union(overlay_processor_->GetAndResetOverlayDamage());
   frame.root_damage_rect.Intersect(gfx::Rect(device_viewport_rect.size()));
   frame.device_viewport_rect = device_viewport_rect;
   frame.device_clip_rect = device_clip_rect;
   frame.disable_picture_quad_image_filtering =
       disable_picture_quad_image_filtering;
 
   EnsureBackbuffer();
 
   // Only reshape when we know we are going to draw. Otherwise, the reshape
   // can leave the window at the wrong size if we never draw and the proper
   // viewport size is never set.
   output_surface_->Reshape(device_viewport_rect.size(), device_scale_factor);
 
   BeginDrawingFrame(&frame);
 
   if (output_surface_->IsDisplayedAsOverlayPlane()) {
     // Create the overlay candidate for the output surface, and mark it as
-    // always
-    // handled.
+    // always handled.
     OverlayCandidate output_surface_plane;
     output_surface_plane.display_rect =
         gfx::RectF(root_render_pass->output_rect);
     output_surface_plane.quad_rect_in_target_space =
         root_render_pass->output_rect;
     output_surface_plane.use_output_surface_for_resource = true;
     output_surface_plane.overlay_handled = true;
     frame.overlay_list.push_back(output_surface_plane);
   }
 
   // If we have any copy requests, we can't remove any quads for overlays or
   // CALayers because the framebuffer would be missing the removed quads'
   // contents.
   bool has_copy_requests = false;
   for (const auto& pass : *render_passes_in_draw_order) {
     if (!pass->copy_requests.empty()) {
       has_copy_requests = true;
       break;
     }
   }
   if (!has_copy_requests) {
     overlay_processor_->ProcessForOverlays(
         resource_provider_, render_passes_in_draw_order, &frame.overlay_list,
         &frame.ca_layer_overlay_list, &frame.root_damage_rect);
   }
 
+  // The damage rect might be empty now, but if empty swap isn't allowed we
+  // still have to draw.
+  bool should_draw = has_copy_requests || !frame.root_damage_rect.IsEmpty() ||
+                     !Capabilities().allow_empty_swap;
+  // If we have to draw but don't support partial swap the whole output should
+  // be considered damaged.
+  if (should_draw && !Capabilities().using_partial_swap)
+    frame.root_damage_rect = root_render_pass->output_rect;
+
   // If all damage is being drawn with overlays or CALayers then skip drawing
   // the render passes.
-  if (frame.root_damage_rect.IsEmpty() && !has_copy_requests) {
+  if (!should_draw) {
     BindFramebufferToOutputSurface(&frame);
   } else {
     for (const auto& pass : *render_passes_in_draw_order) {
       DrawRenderPass(&frame, pass.get());
 
       bool first_request = true;
       for (auto& copy_request : pass->copy_requests) {
         // Doing a readback is destructive of our state on Mac, so make sure
         // we restore the state between readbacks. http://crbug.com/99393.
         if (!first_request)
@@ skipping 280 matching lines @@
   ScopedResource* texture = render_pass_textures_.get(id);
   return texture && texture->id();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 }  // namespace cc