cc: Fix overlay damage tracking bug

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 190 matching lines @@
   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.Union(next_root_damage_rect_);
-  next_root_damage_rect_ = gfx::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.
     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,
-  // otherwise the framebuffer will be missing the overlay contents.
-  if (root_render_pass->copy_requests.empty()) {
-    if (overlay_processor_->ProcessForCALayers(
-            resource_provider_, render_passes_in_draw_order,
-            &frame.ca_layer_overlay_list, &frame.overlay_list)) {
-      // Ensure that the next frame to use the backbuffer will do a full redraw.
-      next_root_damage_rect_.Union(root_render_pass->output_rect);
-    } else {
-      overlay_processor_->ProcessForOverlays(
-          resource_provider_, render_passes_in_draw_order, &frame.overlay_list,
-          &frame.root_damage_rect);
+  // 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);
+  }
 
-      // No need to render in case the damage rect is completely composited
-      // using
-      // overlays and dont have any copy requests.
-      if (frame.root_damage_rect.IsEmpty()) {
-        bool handle_copy_requests = false;
-        for (const auto& pass : *render_passes_in_draw_order) {
-          if (!pass->copy_requests.empty()) {
-            handle_copy_requests = true;
-            break;
-          }
-        }
+  // 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) {
+    BindFramebufferToOutputSurface(&frame);
+  } else {
+    for (const auto& pass : *render_passes_in_draw_order) {
+      DrawRenderPass(&frame, pass.get());
 
-        if (!handle_copy_requests) {
-          BindFramebufferToOutputSurface(&frame);
-          FinishDrawingFrame(&frame);
-          render_passes_in_draw_order->clear();
-          return;
-        }
-        overlay_processor_->ProcessForOverlays(
-            resource_provider_, render_passes_in_draw_order,
-            &frame.overlay_list, &frame.root_damage_rect);
+      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;
       }
     }
   }
-
-  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();
 }
 
 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 263 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