cc: Fix overlay damage tracking bug

Track the region that is covered by overlays and ensure that that is
included in the damage rect of future frames. This fixes bugs where
something that was previously an overlay becomes a non-overlay due to
reasons that didn't involve doing damage to the frame in that quad's
region (e.g, creating a slightly overlapping overlay quad).

Move the removal of overlays from the damage rect to being done in the
OverlayProcessor instead of being done in each individual strategy.

BUG=551861
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1452943002

Cr-Commit-Position: refs/heads/master@{#360513}

12 files changed, 227 insertions, 140 deletions

diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index 534b97e..4acd9c1 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -208,8 +208,7 @@ void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
   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;
@@ -239,59 +238,42 @@ void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
     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);
-
-      // 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 (!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);
-      }
+  // 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);
+  }
 
-  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;
+  // 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());
+
+      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();
 }
 
diff --git a/cc/output/direct_renderer.h b/cc/output/direct_renderer.h
index 6721e24..9c3db40 100644
--- a/cc/output/direct_renderer.h
+++ b/cc/output/direct_renderer.h
@@ -160,10 +160,6 @@ class CC_EXPORT DirectRenderer : public Renderer {
  private:
   gfx::Vector2d enlarge_pass_texture_amount_;
 
-  // Regions that must be drawn in the next frame because they were represented
-  // as CALayers in the current frame.
-  gfx::Rect next_root_damage_rect_;
-
   DISALLOW_COPY_AND_ASSIGN(DirectRenderer);
 };
 
diff --git a/cc/output/gl_renderer_unittest.cc b/cc/output/gl_renderer_unittest.cc
index 10095e9..d90e3e8 100644
--- a/cc/output/gl_renderer_unittest.cc
+++ b/cc/output/gl_renderer_unittest.cc
@@ -2024,11 +2024,10 @@ class TestOverlayProcessor : public OverlayProcessor {
    public:
     Strategy() {}
     ~Strategy() override {}
-    MOCK_METHOD4(Attempt,
+    MOCK_METHOD3(Attempt,
                  bool(ResourceProvider* resource_provider,
                       RenderPassList* render_passes,
-                      OverlayCandidateList* candidates,
-                      gfx::Rect* damage_rect));
+                      OverlayCandidateList* candidates));
   };
 
   class Validator : public OverlayCandidateValidator {
@@ -2125,7 +2124,7 @@ TEST_F(GLRendererTest, DontOverlayWithCopyRequests) {
   // added a fake strategy, so checking for Attempt calls checks if there was
   // any attempt to overlay, which there shouldn't be. We can't use the quad
   // list because the render pass is cleaned up by DrawFrame.
-  EXPECT_CALL(*processor->strategy_, Attempt(_, _, _, _)).Times(0);
+  EXPECT_CALL(*processor->strategy_, Attempt(_, _, _)).Times(0);
   EXPECT_CALL(*validator, AllowCALayerOverlays()).Times(0);
   renderer.DrawFrame(&render_passes_in_draw_order_, 1.f, viewport_rect,
                      viewport_rect, false);
@@ -2146,7 +2145,7 @@ TEST_F(GLRendererTest, DontOverlayWithCopyRequests) {
   EXPECT_CALL(*validator, AllowCALayerOverlays())
       .Times(1)
       .WillOnce(::testing::Return(false));
-  EXPECT_CALL(*processor->strategy_, Attempt(_, _, _, _)).Times(1);
+  EXPECT_CALL(*processor->strategy_, Attempt(_, _, _)).Times(1);
   renderer.DrawFrame(&render_passes_in_draw_order_, 1.f, viewport_rect,
                      viewport_rect, false);
 
@@ -2165,7 +2164,7 @@ TEST_F(GLRendererTest, DontOverlayWithCopyRequests) {
   EXPECT_CALL(*validator, AllowCALayerOverlays())
       .Times(1)
       .WillOnce(::testing::Return(true));
-  EXPECT_CALL(*processor->strategy_, Attempt(_, _, _, _)).Times(0);
+  EXPECT_CALL(*processor->strategy_, Attempt(_, _, _)).Times(0);
   renderer.DrawFrame(&render_passes_in_draw_order_, 1.f, viewport_rect,
                      viewport_rect, false);
 }
diff --git a/cc/output/overlay_processor.cc b/cc/output/overlay_processor.cc
index 43a064f..40d6da6 100644
--- a/cc/output/overlay_processor.cc
+++ b/cc/output/overlay_processor.cc
@@ -26,11 +26,18 @@ void OverlayProcessor::Initialize() {
 
 OverlayProcessor::~OverlayProcessor() {}
 
+gfx::Rect OverlayProcessor::GetAndResetOverlayDamage() {
+  gfx::Rect result = overlay_damage_rect_;
+  overlay_damage_rect_ = gfx::Rect();
+  return result;
+}
+
 bool OverlayProcessor::ProcessForCALayers(
     ResourceProvider* resource_provider,
     RenderPassList* render_passes,
+    OverlayCandidateList* overlay_candidates,
     CALayerOverlayList* ca_layer_overlays,
-    OverlayCandidateList* overlay_candidates) {
+    gfx::Rect* damage_rect) {
   RenderPass* root_render_pass = render_passes->back().get();
 
   OverlayCandidateValidator* overlay_validator =
@@ -48,18 +55,43 @@ bool OverlayProcessor::ProcessForCALayers(
   // list.
   overlay_candidates->clear();
   render_passes->back()->quad_list.clear();
+  overlay_damage_rect_ = root_render_pass->output_rect;
+  *damage_rect = gfx::Rect();
   return true;
 }
 
 void OverlayProcessor::ProcessForOverlays(ResourceProvider* resource_provider,
                                           RenderPassList* render_passes,
                                           OverlayCandidateList* candidates,
+                                          CALayerOverlayList* ca_layer_overlays,
                                           gfx::Rect* damage_rect) {
+  // First attempt to process for CALayers.
+  if (ProcessForCALayers(resource_provider, render_passes, candidates,
+                         ca_layer_overlays, damage_rect)) {
+    return;
+  }
+
+  // Only if that fails, attempt hardware overlay strategies.
   for (const auto& strategy : strategies_) {
-    if (strategy->Attempt(resource_provider, render_passes, candidates,
-                          damage_rect)) {
-      return;
+    if (!strategy->Attempt(resource_provider, render_passes, candidates))
+      continue;
+
+    // Subtract on-top overlays from the damage rect, unless the overlays use
+    // the backbuffer as their content (in which case, add their combined rect
+    // back to the damage at the end).
+    gfx::Rect output_surface_overlay_damage_rect;
+    for (const OverlayCandidate& overlay : *candidates) {
+      if (overlay.plane_z_order > 0) {
+        const gfx::Rect overlay_display_rect =
+            ToEnclosedRect(overlay.display_rect);
+        overlay_damage_rect_.Union(overlay_display_rect);
+        damage_rect->Subtract(overlay_display_rect);
+        if (overlay.use_output_surface_for_resource)
+          output_surface_overlay_damage_rect.Union(overlay_display_rect);
+      }
     }
+    damage_rect->Union(output_surface_overlay_damage_rect);
+    return;
   }
 }
 
diff --git a/cc/output/overlay_processor.h b/cc/output/overlay_processor.h
index 020c3c7..f348fb8 100644
--- a/cc/output/overlay_processor.h
+++ b/cc/output/overlay_processor.h
@@ -29,8 +29,7 @@ class CC_EXPORT OverlayProcessor {
     // overlays.
     virtual bool Attempt(ResourceProvider* resource_provider,
                          RenderPassList* render_passes,
-                         OverlayCandidateList* candidates,
-                         gfx::Rect* damage_rect) = 0;
+                         OverlayCandidateList* candidates) = 0;
   };
   using StrategyList = std::vector<scoped_ptr<Strategy>>;
 
@@ -39,21 +38,26 @@ class CC_EXPORT OverlayProcessor {
   // Virtual to allow testing different strategies.
   virtual void Initialize();
 
-  bool ProcessForCALayers(ResourceProvider* resource_provider,
-                          RenderPassList* render_passes,
-                          CALayerOverlayList* ca_layer_overlays,
-                          OverlayCandidateList* overlay_candidates);
+  gfx::Rect GetAndResetOverlayDamage();
 
   void ProcessForOverlays(ResourceProvider* resource_provider,
                           RenderPassList* render_passes,
-                          OverlayCandidateList* candidates,
+                          OverlayCandidateList* overlay_candidates,
+                          CALayerOverlayList* ca_layer_overlays,
                           gfx::Rect* damage_rect);
 
  protected:
   StrategyList strategies_;
   OutputSurface* surface_;
+  gfx::Rect overlay_damage_rect_;
 
  private:
+  bool ProcessForCALayers(ResourceProvider* resource_provider,
+                          RenderPassList* render_passes,
+                          OverlayCandidateList* overlay_candidates,
+                          CALayerOverlayList* ca_layer_overlays,
+                          gfx::Rect* damage_rect);
+
   DISALLOW_COPY_AND_ASSIGN(OverlayProcessor);
 };
 
diff --git a/cc/output/overlay_strategy_sandwich.cc b/cc/output/overlay_strategy_sandwich.cc
index 6aef45d..ce590b9 100644
--- a/cc/output/overlay_strategy_sandwich.cc
+++ b/cc/output/overlay_strategy_sandwich.cc
@@ -42,8 +42,7 @@ OverlayStrategySandwich::~OverlayStrategySandwich() {}
 
 bool OverlayStrategySandwich::Attempt(ResourceProvider* resource_provider,
                                       RenderPassList* render_passes,
-                                      OverlayCandidateList* candidate_list,
-                                      gfx::Rect* damage_rect) {
+                                      OverlayCandidateList* candidate_list) {
   QuadList& quad_list = render_passes->back()->quad_list;
   for (auto it = quad_list.begin(); it != quad_list.end();) {
     OverlayCandidate candidate;
diff --git a/cc/output/overlay_strategy_sandwich.h b/cc/output/overlay_strategy_sandwich.h
index 0bdd2d2..076ea9d 100644
--- a/cc/output/overlay_strategy_sandwich.h
+++ b/cc/output/overlay_strategy_sandwich.h
@@ -23,8 +23,7 @@ class CC_EXPORT OverlayStrategySandwich : public OverlayProcessor::Strategy {
 
   bool Attempt(ResourceProvider* resource_provider,
                RenderPassList* render_passes,
-               OverlayCandidateList* candidate_list,
-               gfx::Rect* damage_rect) override;
+               OverlayCandidateList* candidate_list) override;
 
  private:
   QuadList::Iterator TryOverlay(RenderPass* render_pass,
diff --git a/cc/output/overlay_strategy_single_on_top.cc b/cc/output/overlay_strategy_single_on_top.cc
index 7a35d1d..78e5bf9 100644
--- a/cc/output/overlay_strategy_single_on_top.cc
+++ b/cc/output/overlay_strategy_single_on_top.cc
@@ -21,13 +21,12 @@ OverlayStrategySingleOnTop::~OverlayStrategySingleOnTop() {}
 
 bool OverlayStrategySingleOnTop::Attempt(ResourceProvider* resource_provider,
                                          RenderPassList* render_passes,
-                                         OverlayCandidateList* candidate_list,
-                                         gfx::Rect* damage_rect) {
+                                         OverlayCandidateList* candidate_list) {
   QuadList* quad_list = &render_passes->back()->quad_list;
   for (auto it = quad_list->begin(); it != quad_list->end(); ++it) {
     OverlayCandidate candidate;
     if (OverlayCandidate::FromDrawQuad(resource_provider, *it, &candidate) &&
-        TryOverlay(quad_list, candidate_list, candidate, it, damage_rect)) {
+        TryOverlay(quad_list, candidate_list, candidate, it)) {
       return true;
     }
   }
@@ -39,8 +38,7 @@ bool OverlayStrategySingleOnTop::TryOverlay(
     QuadList* quad_list,
     OverlayCandidateList* candidate_list,
     const OverlayCandidate& candidate,
-    QuadList::Iterator candidate_iterator,
-    gfx::Rect* damage_rect) {
+    QuadList::Iterator candidate_iterator) {
   // Check that no prior quads overlap it.
   for (auto overlap_iter = quad_list->cbegin();
        overlap_iter != candidate_iterator; ++overlap_iter) {
@@ -65,7 +63,6 @@ bool OverlayStrategySingleOnTop::TryOverlay(
   if (overlay_candidate.overlay_handled) {
     quad_list->EraseAndInvalidateAllPointers(candidate_iterator);
     candidate_list->swap(new_candidate_list);
-    damage_rect->Subtract(ToEnclosedRect(overlay_candidate.display_rect));
     return true;
   }
 
diff --git a/cc/output/overlay_strategy_single_on_top.h b/cc/output/overlay_strategy_single_on_top.h
index 29d98de..bdf2cc2 100644
--- a/cc/output/overlay_strategy_single_on_top.h
+++ b/cc/output/overlay_strategy_single_on_top.h
@@ -19,15 +19,13 @@ class CC_EXPORT OverlayStrategySingleOnTop : public OverlayProcessor::Strategy {
 
   bool Attempt(ResourceProvider* resource_provider,
                RenderPassList* render_passes,
-               OverlayCandidateList* candidate_list,
-               gfx::Rect* damage_rect) override;
+               OverlayCandidateList* candidate_list) override;
 
  private:
   bool TryOverlay(QuadList* quad_list,
                   OverlayCandidateList* candidate_list,
                   const OverlayCandidate& candidate,
-                  QuadList::Iterator candidate_iterator,
-                  gfx::Rect* damage_rect);
+                  QuadList::Iterator candidate_iterator);
 
   OverlayCandidateValidator* capability_checker_;  // Weak.
 
diff --git a/cc/output/overlay_strategy_underlay.cc b/cc/output/overlay_strategy_underlay.cc
index 5f3f907..9a8a362 100644
--- a/cc/output/overlay_strategy_underlay.cc
+++ b/cc/output/overlay_strategy_underlay.cc
@@ -20,8 +20,7 @@ OverlayStrategyUnderlay::~OverlayStrategyUnderlay() {}
 
 bool OverlayStrategyUnderlay::Attempt(ResourceProvider* resource_provider,
                                       RenderPassList* render_passes,
-                                      OverlayCandidateList* candidate_list,
-                                      gfx::Rect* damage_rect) {
+                                      OverlayCandidateList* candidate_list) {
   QuadList& quad_list = render_passes->back()->quad_list;
   for (auto it = quad_list.begin(); it != quad_list.end(); ++it) {
     OverlayCandidate candidate;
diff --git a/cc/output/overlay_strategy_underlay.h b/cc/output/overlay_strategy_underlay.h
index ac20051..f276c1c 100644
--- a/cc/output/overlay_strategy_underlay.h
+++ b/cc/output/overlay_strategy_underlay.h
@@ -24,8 +24,7 @@ class CC_EXPORT OverlayStrategyUnderlay : public OverlayProcessor::Strategy {
 
   bool Attempt(ResourceProvider* resource_provider,
                RenderPassList* render_passes,
-               OverlayCandidateList* candidate_list,
-               gfx::Rect* damage_rect) override;
+               OverlayCandidateList* candidate_list) override;
 
  private:
   OverlayCandidateValidator* capability_checker_;  // Weak.
diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc
index a170cf9..1fbcff0 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -413,7 +413,8 @@ TEST_F(SandwichTest, SuccessfulSingleOverlay) {
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
 
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
@@ -455,7 +456,8 @@ TEST_F(SandwichTest, CroppedSingleOverlay) {
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
 
   // Ensure that the display and uv rects have cropping applied to them.
   ASSERT_EQ(1U, pass_list.size());
@@ -484,7 +486,8 @@ TEST_F(SandwichTest, SuccessfulTwoOverlays) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
 
   // Both candidates should become overlays.
   EXPECT_EQ(1u, pass_list.size());
@@ -518,7 +521,8 @@ TEST_F(SandwichTest, OverlappingOverlays) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
 
   // Only one of the candidates should become an overlay.
   EXPECT_EQ(1u, pass_list.size());
@@ -553,7 +557,8 @@ TEST_F(SandwichTest, SuccessfulSandwichOverlay) {
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(2U, candidate_list.size());
 
@@ -608,7 +613,8 @@ TEST_F(SandwichTest, MultiQuadOverlay) {
   OverlayCandidateList candidate_list;
   EXPECT_EQ(4U, main_pass->quad_list.size());
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(3U, candidate_list.size());
 
@@ -669,11 +675,45 @@ TEST_F(SandwichTest, DamageRect) {
   candidate_list.push_back(output_surface_plane);
 
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
-  DCHECK(!damage_rect_.IsEmpty());
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
+  EXPECT_EQ(2u, candidate_list.size());
+  EXPECT_TRUE(damage_rect_.IsEmpty());
+}
+
+TEST_F(SandwichTest, DamageRectNonEmpty) {
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  CreateFullscreenOpaqueQuad(resource_provider_.get(),
+                             pass->shared_quad_state_list.back(), pass.get());
+  CreateFullscreenCandidateQuad(resource_provider_.get(),
+                                pass->shared_quad_state_list.back(),
+                                pass.get());
+  CreateFullscreenOpaqueQuad(resource_provider_.get(),
+                             pass->shared_quad_state_list.back(), pass.get());
+  damage_rect_ = kOverlayRect;
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+
+  // Check for potential candidates.
+  OverlayCandidateList candidate_list;
+
+  // Primary plane.
+  OverlayCandidate output_surface_plane;
+  output_surface_plane.display_rect = gfx::RectF(kOverlayRect);
+  output_surface_plane.quad_rect_in_target_space = kOverlayRect;
+  output_surface_plane.use_output_surface_for_resource = true;
+  output_surface_plane.overlay_handled = true;
+  candidate_list.push_back(output_surface_plane);
+
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
+  EXPECT_EQ(3u, candidate_list.size());
+  EXPECT_EQ(damage_rect_, kOverlayRect);
 }
 
-TEST_F(SingleOverlayOnTopTest, SuccessfullOverlay) {
+TEST_F(SingleOverlayOnTopTest, SuccessfulOverlay) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   TextureDrawQuad* original_quad =
       CreateFullscreenCandidateQuad(resource_provider_.get(),
@@ -693,7 +733,8 @@ TEST_F(SingleOverlayOnTopTest, SuccessfullOverlay) {
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
 
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
@@ -740,7 +781,8 @@ TEST_F(SingleOverlayOnTopTest, DamageRect) {
   candidate_list.push_back(output_surface_plane);
 
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   DCHECK(damage_rect_.IsEmpty());
 }
 
@@ -759,7 +801,8 @@ TEST_F(SingleOverlayOnTopTest, NoCandidates) {
 
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   EXPECT_EQ(0U, candidate_list.size());
   // There should be nothing new here.
   CompareRenderPassLists(pass_list, original_pass_list);
@@ -784,7 +827,8 @@ TEST_F(SingleOverlayOnTopTest, OccludedCandidates) {
 
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   EXPECT_EQ(0U, candidate_list.size());
   // There should be nothing new here.
   CompareRenderPassLists(pass_list, original_pass_list);
@@ -814,7 +858,8 @@ TEST_F(SingleOverlayOnTopTest, MultipleRenderPasses) {
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   EXPECT_EQ(1U, candidate_list.size());
 
   // This should be the same.
@@ -833,7 +878,8 @@ TEST_F(SingleOverlayOnTopTest, RejectPremultipliedAlpha) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   EXPECT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -850,7 +896,8 @@ TEST_F(SingleOverlayOnTopTest, RejectBlending) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -867,7 +914,8 @@ TEST_F(SingleOverlayOnTopTest, RejectBackgroundColor) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -883,7 +931,8 @@ TEST_F(SingleOverlayOnTopTest, RejectBlendMode) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -899,7 +948,8 @@ TEST_F(SingleOverlayOnTopTest, RejectOpacity) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -916,7 +966,8 @@ TEST_F(SingleOverlayOnTopTest, RejectNonAxisAlignedTransform) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -933,7 +984,8 @@ TEST_F(SingleOverlayOnTopTest, AllowClipped) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -952,7 +1004,8 @@ TEST_F(SingleOverlayOnTopTest, AllowVerticalFlip) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL,
@@ -973,7 +1026,8 @@ TEST_F(SingleOverlayOnTopTest, AllowHorizontalFlip) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL,
@@ -993,7 +1047,8 @@ TEST_F(SingleOverlayOnTopTest, AllowPositiveScaleTransform) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -1011,7 +1066,8 @@ TEST_F(SingleOverlayOnTopTest, Allow90DegreeRotation) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90, candidate_list.back().transform);
@@ -1030,7 +1086,8 @@ TEST_F(SingleOverlayOnTopTest, Allow180DegreeRotation) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_180, candidate_list.back().transform);
@@ -1049,7 +1106,8 @@ TEST_F(SingleOverlayOnTopTest, Allow270DegreeRotation) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_270, candidate_list.back().transform);
@@ -1073,7 +1131,8 @@ TEST_F(SingleOverlayOnTopTest, AllowNotTopIfNotOccluded) {
 
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   EXPECT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -1097,7 +1156,8 @@ TEST_F(SingleOverlayOnTopTest, AllowTransparentOnTop) {
 
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   EXPECT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -1119,7 +1179,8 @@ TEST_F(SingleOverlayOnTopTest, AllowTransparentColorOnTop) {
 
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   EXPECT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -1143,7 +1204,8 @@ TEST_F(SingleOverlayOnTopTest, RejectOpaqueColorOnTop) {
 
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   EXPECT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -1165,7 +1227,8 @@ TEST_F(SingleOverlayOnTopTest, RejectTransparentColorOnTopWithoutBlending) {
 
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   EXPECT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -1180,7 +1243,8 @@ TEST_F(SingleOverlayOnTopTest, RejectVideoSwapTransform) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -1195,7 +1259,8 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoXMirrorTransform) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -1210,7 +1275,8 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoBothMirrorTransform) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -1225,7 +1291,8 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoNormalTransform) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -1240,7 +1307,8 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoYMirrorTransform) {
   pass_list.push_back(std::move(pass));
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -1258,7 +1326,8 @@ TEST_F(UnderlayTest, OverlayLayerUnderMainLayer) {
 
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   EXPECT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(-1, candidate_list[0].plane_z_order);
@@ -1281,7 +1350,8 @@ TEST_F(UnderlayTest, AllowOnTop) {
 
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   EXPECT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(-1, candidate_list[0].plane_z_order);
@@ -1318,7 +1388,8 @@ TEST_F(UnderlayTest, DamageRect) {
   candidate_list.push_back(output_surface_plane);
 
   overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, &damage_rect_);
+                                         &candidate_list, nullptr,
+                                         &damage_rect_);
   DCHECK(!damage_rect_.IsEmpty());
 }
 
@@ -1342,13 +1413,15 @@ TEST_F(CALayerOverlayTest, AllowNonAxisAlignedTransform) {
   pass->shared_quad_state_list.back()
       ->quad_to_target_transform.RotateAboutZAxis(45.f);
 
+  gfx::Rect damage_rect;
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));
   CALayerOverlayList ca_layer_list;
   OverlayCandidateList overlay_list(
       BackbufferOverlayList(pass_list.back().get()));
-  overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
-                                         &ca_layer_list, &overlay_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &overlay_list, &ca_layer_list,
+                                         &damage_rect);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, pass_list.back()->quad_list.size());
   EXPECT_EQ(0U, overlay_list.size());
@@ -1363,13 +1436,15 @@ TEST_F(CALayerOverlayTest, Disallow3DTransform) {
   pass->shared_quad_state_list.back()
       ->quad_to_target_transform.RotateAboutXAxis(45.f);
 
+  gfx::Rect damage_rect;
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));
   CALayerOverlayList ca_layer_list;
   OverlayCandidateList overlay_list(
       BackbufferOverlayList(pass_list.back().get()));
-  overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
-                                         &ca_layer_list, &overlay_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &overlay_list, &ca_layer_list,
+                                         &damage_rect);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, pass_list.back()->quad_list.size());
   EXPECT_EQ(1U, overlay_list.size());
@@ -1384,13 +1459,15 @@ TEST_F(CALayerOverlayTest, AllowContainingClip) {
   pass->shared_quad_state_list.back()->is_clipped = true;
   pass->shared_quad_state_list.back()->clip_rect = kOverlayRect;
 
+  gfx::Rect damage_rect;
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));
   CALayerOverlayList ca_layer_list;
   OverlayCandidateList overlay_list(
       BackbufferOverlayList(pass_list.back().get()));
-  overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
-                                         &ca_layer_list, &overlay_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &overlay_list, &ca_layer_list,
+                                         &damage_rect);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, pass_list.back()->quad_list.size());
   EXPECT_EQ(0U, overlay_list.size());
@@ -1406,13 +1483,15 @@ TEST_F(CALayerOverlayTest, SkipDisjointClip) {
   pass->shared_quad_state_list.back()->clip_rect =
       gfx::Rect(128, 128, 128, 128);
 
+  gfx::Rect damage_rect;
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));
   CALayerOverlayList ca_layer_list;
   OverlayCandidateList overlay_list(
       BackbufferOverlayList(pass_list.back().get()));
-  overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
-                                         &ca_layer_list, &overlay_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &overlay_list, &ca_layer_list,
+                                         &damage_rect);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, pass_list.back()->quad_list.size());
   EXPECT_EQ(0U, overlay_list.size());
@@ -1427,13 +1506,15 @@ TEST_F(CALayerOverlayTest, DisallowNontrivialClip) {
   pass->shared_quad_state_list.back()->is_clipped = true;
   pass->shared_quad_state_list.back()->clip_rect = gfx::Rect(64, 64, 128, 128);
 
+  gfx::Rect damage_rect;
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));
   CALayerOverlayList ca_layer_list;
   OverlayCandidateList overlay_list(
       BackbufferOverlayList(pass_list.back().get()));
-  overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
-                                         &ca_layer_list, &overlay_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &overlay_list, &ca_layer_list,
+                                         &damage_rect);
 
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, pass_list.back()->quad_list.size());
@@ -1448,13 +1529,15 @@ TEST_F(CALayerOverlayTest, SkipTransparent) {
                                 pass.get());
   pass->shared_quad_state_list.back()->opacity = 0;
 
+  gfx::Rect damage_rect;
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));
   CALayerOverlayList ca_layer_list;
   OverlayCandidateList overlay_list(
       BackbufferOverlayList(pass_list.back().get()));
-  overlay_processor_->ProcessForCALayers(resource_provider_.get(), &pass_list,
-                                         &ca_layer_list, &overlay_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &overlay_list, &ca_layer_list,
+                                         &damage_rect);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, pass_list.back()->quad_list.size());
   EXPECT_EQ(0U, overlay_list.size());