Display skips swapping if overlays draw the damage

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 170 matching lines @@
   for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i) {
     if (!render_pass_textures_.contains(render_passes_in_draw_order[i]->id)) {
       scoped_ptr<ScopedResource> texture =
           ScopedResource::Create(resource_provider_);
       render_pass_textures_.set(render_passes_in_draw_order[i]->id,
                                 std::move(texture));
     }
   }
 }
 
-void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
-                               float device_scale_factor,
-                               const gfx::Rect& device_viewport_rect,
-                               const gfx::Rect& device_clip_rect,
-                               bool disable_picture_quad_image_filtering) {
+DrawFrameResult DirectRenderer::DrawFrame(
+    RenderPassList* render_passes_in_draw_order,
+    float device_scale_factor,
+    const gfx::Rect& device_viewport_rect,
+    const gfx::Rect& device_clip_rect,
+    bool disable_picture_quad_image_filtering) {
   TRACE_EVENT0("cc", "DirectRenderer::DrawFrame");
   UMA_HISTOGRAM_COUNTS(
       "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
@@ skipping 20 matching lines @@
   // 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;
     }
   }
+  gfx::Rect damage_rect_minus_overlays = frame.root_damage_rect;
   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);
+        &frame.ca_layer_overlay_list, &damage_rect_minus_overlays);
+    frame.root_damage_rect = Capabilities().using_partial_swap
+                                 ? damage_rect_minus_overlays
+                                 : 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) {
+  DrawFrameResult draw_result = DrawFrameResult::DID_DRAW;
+  if (damage_rect_minus_overlays.IsEmpty() && !has_copy_requests) {
     BindFramebufferToOutputSurface(&frame);
+    draw_result = DrawFrameResult::DAMAGE_DRAWN_BY_OVERLAYS;
   } 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)
           UseRenderPass(&frame, pass.get());
         CopyCurrentRenderPassToBitmap(&frame, std::move(copy_request));
         first_request = false;
       }
     }
   }
   FinishDrawingFrame(&frame);
   render_passes_in_draw_order->clear();
+  return draw_result;
 }
 
 gfx::Rect DirectRenderer::ComputeScissorRectForRenderPass(
     const DrawingFrame* frame) {
   gfx::Rect render_pass_scissor = frame->current_render_pass->output_rect;
 
   if (frame->root_damage_rect == frame->root_render_pass->output_rect ||
       !frame->current_render_pass->copy_requests.empty())
     return render_pass_scissor;
 
@@ skipping 262 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