Reland "viz: Turn off or crop primary plane when possible"

This is a reland of I7946d7acab334bffdf2bb49a1d9c424cf46fc610 and
the following bug fixes as follows;
"viz: Fix wrong uv_rect calculation" 4bf9d01d
"viz: add unittests for CL:1291590" f8dfbe74

Additional fix:
- Fix the flickering issue because of primary |uv_rect| cropping even though
an overlay attemption fails mainly due to limited pixel rate (e.g. 4k video).
- Fix wrong |uv_rect| calculation which causes atomic page flip failures with
"No space left on device (28)" error.

Original change's description:
> viz: Turn off or crop primary plane when possible
>
> For many fullscreen cases, the rest of the renderpass quads are solid
> black quads. In that case, we can turn off the primary plane, and not
> having to scan out an full screen of black pixels saves a good deal of
> power. In other cases, we can crop down the primary plane down to the
> content rectangle (youtube channel logo, for example) and save power.
>
> Averaging battery draw measurement over about a minute of play back
> for a fullscreen youtube video, power savings for soraka is around
> 500mW (6.5W to 6.0W) and 300mW for kevin (4.4W to 4.1W), when we
> turn off the primary plane.
>
> Change-Id: I7946d7acab334bffdf2bb49a1d9c424cf46fc610
> Reviewed-on: https://chromium-review.googlesource.com/c/1045256
> Reviewed-by: Daniele Castagna <dcastagna@chromium.org>
> Reviewed-by: Dongseong Hwang <dongseong.hwang@intel.com>
> Commit-Queue: Kristian H. Kristensen <hoegsberg@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#600415}

TEST=SingleOverlayOnTopTest.AllowVideoNormalTransformWithOutputSurfaceOverlay

Bug: 896945, 900373
Change-Id: I88db118dbc3ca2fed8c8eaf1f9a4337cdae12990
Reviewed-on: https://chromium-review.googlesource.com/c/1346997
Commit-Queue: Dongseong Hwang <dongseong.hwang@intel.com>
Reviewed-by: Dongseong Hwang <dongseong.hwang@intel.com>
Reviewed-by: Kristian H. Kristensen <hoegsberg@chromium.org>
Reviewed-by: Daniele Castagna <dcastagna@chromium.org>
Cr-Commit-Position: refs/heads/master@{#611484}

components/viz/service/display/gl_renderer_unittest.cc

@@ -4152,10 +4152,6 @@ TEST_F(GLRendererWithGpuFenceTest, GpuFenceIdIsUsedWithoutRootRenderPass) {
       flipped, nearest_neighbor,
       /*secure_output_only=*/false, ui::ProtectedVideoType::kClear);
 
-  EXPECT_CALL(overlay_scheduler,
-              Schedule(0, gfx::OVERLAY_TRANSFORM_NONE, kSurfaceOverlayTextureId,
-                       gfx::Rect(viewport_size), _, _, kGpuFenceId))
-      .Times(1);
   EXPECT_CALL(overlay_scheduler,
               Schedule(1, gfx::OVERLAY_TRANSFORM_NONE, _,
                        gfx::Rect(viewport_size), _, _, kGpuFenceId))

components/viz/service/display/overlay_processor.cc

@@ -9,6 +9,7 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
+#include "components/viz/common/quads/solid_color_draw_quad.h"
 #include "components/viz/service/display/dc_layer_overlay.h"
 #include "components/viz/service/display/display_resource_provider.h"
 #include "components/viz/service/display/output_surface.h"
@@ -251,4 +252,61 @@ void OverlayProcessor::UpdateDamageRect(
   damage_rect->Union(output_surface_overlay_damage_rect);
 }
 
+namespace {
+
+bool DiscardableQuad(const DrawQuad* q) {
+  float opacity = q->shared_quad_state->opacity;
+  if (opacity < std::numeric_limits<float>::epsilon())
+    return true;
+
+  if (q->material == DrawQuad::SOLID_COLOR) {
+    if (SolidColorDrawQuad::MaterialCast(q)->color == SK_ColorBLACK ||
+        SolidColorDrawQuad::MaterialCast(q)->color == SK_ColorTRANSPARENT)
+      return true;
+
+    const SkColor color = SolidColorDrawQuad::MaterialCast(q)->color;
+    const float alpha = (SkColorGetA(color) * (1.0f / 255.0f)) * opacity;
+    return q->ShouldDrawWithBlending() &&
+           alpha < std::numeric_limits<float>::epsilon();
+  }
+
+  return false;
+}
+
+}  // namespace
+
+// static
+void OverlayProcessor::EliminateOrCropPrimary(
+    const QuadList& quad_list,
+    const QuadList::Iterator& candidate_iterator,
+    OverlayCandidate* primary,
+    OverlayCandidateList* candidate_list) {
+  gfx::RectF content_rect;
+
+  for (auto it = quad_list.begin(); it != quad_list.end(); ++it) {
+    if (it == candidate_iterator)
+      continue;
+    if (!DiscardableQuad(*it)) {
+      auto& transform = it->shared_quad_state->quad_to_target_transform;
+      gfx::RectF display_rect = gfx::RectF(it->rect);
+      transform.TransformRect(&display_rect);
+      content_rect.Union(display_rect);
+    }
+  }
+
+  if (!content_rect.IsEmpty()) {
+    // Sometimes the content quads extend past primary->display_rect, so first
+    // clip the content_rect to that.
+    content_rect.Intersect(primary->display_rect);
+    DCHECK_NE(0, primary->display_rect.width());
+    DCHECK_NE(0, primary->display_rect.height());
+    primary->uv_rect = gfx::ScaleRect(
+        content_rect, 1. / primary->resource_size_in_pixels.width(),
+        1. / primary->resource_size_in_pixels.height());
+    primary->display_rect = content_rect;
+
+    candidate_list->push_back(*primary);
+  }
+}
+
 }  // namespace viz

components/viz/service/display/overlay_processor.h

@@ -79,6 +79,15 @@ class VIZ_SERVICE_EXPORT OverlayProcessor {
       gfx::Rect* damage_rect,
       std::vector<gfx::Rect>* content_bounds);
 
+  // Determine if we can eliminate (all remaining quads are black or
+  // transparent) or crop (non-black content is a small sub-rectangle) the
+  // primary framebuffer.
+  static void EliminateOrCropPrimary(
+      const QuadList& quad_list,
+      const QuadList::Iterator& candidate_iterator,
+      OverlayCandidate* primary,
+      OverlayCandidateList* candidate_list);
+
  protected:
   StrategyList strategies_;
   OutputSurface* surface_;

components/viz/service/display/overlay_strategy_single_on_top.cc

@@ -44,29 +44,25 @@ bool OverlayStrategySingleOnTop::Attempt(
   if (best_quad_it == quad_list->end())
     return false;
 
-  if (TryOverlay(quad_list, candidate_list, best_candidate, best_quad_it))
-    return true;
-
-  return false;
-}
+  OverlayCandidateList new_candidate_list;
+  if (candidate_list->size() == 1) {
+    OverlayCandidate primary(candidate_list->back());
+    OverlayProcessor::EliminateOrCropPrimary(*quad_list, best_quad_it, &primary,
+                                             &new_candidate_list);
+  } else {
+    new_candidate_list = *candidate_list;
+  }
 
-bool OverlayStrategySingleOnTop::TryOverlay(
-    QuadList* quad_list,
-    OverlayCandidateList* candidate_list,
-    const OverlayCandidate& candidate,
-    QuadList::Iterator candidate_iterator) {
   // Add the overlay.
-  OverlayCandidateList new_candidate_list = *candidate_list;
-  new_candidate_list.push_back(candidate);
+  new_candidate_list.push_back(best_candidate);
   new_candidate_list.back().plane_z_order = 1;
 
   // Check for support.
   capability_checker_->CheckOverlaySupport(&new_candidate_list);
 
-  const OverlayCandidate& overlay_candidate = new_candidate_list.back();
   // If the candidate can be handled by an overlay, create a pass for it.
-  if (overlay_candidate.overlay_handled) {
-    quad_list->EraseAndInvalidateAllPointers(candidate_iterator);
+  if (new_candidate_list.back().overlay_handled) {
+    quad_list->EraseAndInvalidateAllPointers(best_quad_it);
     candidate_list->swap(new_candidate_list);
     return true;
   }

components/viz/service/display/overlay_strategy_underlay.cc

@@ -57,11 +57,19 @@ bool OverlayStrategyUnderlay::Attempt(
       continue;
     }
 
+    OverlayCandidateList new_candidate_list;
+    if (candidate_list->size() == 1) {
+      OverlayCandidate primary(candidate_list->back());
+      primary.is_opaque = false;
+      OverlayProcessor::EliminateOrCropPrimary(quad_list, it, &primary,
+                                               &new_candidate_list);
+    } else {
+      new_candidate_list = *candidate_list;
+    }
+
     // Add the overlay.
-    OverlayCandidateList new_candidate_list = *candidate_list;
     new_candidate_list.push_back(candidate);
     new_candidate_list.back().plane_z_order = -1;
-    new_candidate_list.front().is_opaque = false;
 
     // Check for support.
     capability_checker_->CheckOverlaySupport(&new_candidate_list);

components/viz/service/display/overlay_unittest.cc

@@ -583,6 +583,18 @@ class OverlayTest : public testing::Test {
   std::vector<gfx::Rect> content_bounds_;
 };
 
+OverlayCandidateList BackbufferOverlayList(const RenderPass* root_render_pass) {
+  OverlayCandidateList list;
+  OverlayCandidate output_surface_plane;
+  output_surface_plane.display_rect = gfx::RectF(root_render_pass->output_rect);
+  output_surface_plane.resource_size_in_pixels =
+      root_render_pass->output_rect.size();
+  output_surface_plane.use_output_surface_for_resource = true;
+  output_surface_plane.overlay_handled = true;
+  list.push_back(output_surface_plane);
+  return list;
+}
+
 using FullscreenOverlayTest = OverlayTest<FullscreenOverlayValidator>;
 using SingleOverlayOnTopTest = OverlayTest<SingleOnTopOverlayValidator>;
 using UnderlayTest = OverlayTest<UnderlayOverlayValidator>;
@@ -1544,6 +1556,25 @@ TEST_F(SingleOverlayOnTopTest, RejectTransparentColorOnTopWithoutBlending) {
   EXPECT_EQ(0U, candidate_list.size());
 }
 
+TEST_F(SingleOverlayOnTopTest, AllowVideoNormalTransform) {
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
+  CreateFullscreenCandidateVideoQuad(
+      resource_provider_.get(), child_resource_provider_.get(),
+      child_provider_.get(), pass->shared_quad_state_list.back(), pass.get(),
+      kNormalTransform);
+
+  OverlayCandidateList candidate_list;
+  OverlayProcessor::FilterOperationsMap render_pass_filters;
+  OverlayProcessor::FilterOperationsMap render_pass_background_filters;
+  RenderPassList pass_list;
+  pass_list.push_back(std::move(pass));
+  overlay_processor_->ProcessForOverlays(
+      resource_provider_.get(), &pass_list, GetIdentityColorMatrix(),
+      render_pass_filters, render_pass_background_filters, &candidate_list,
+      nullptr, nullptr, &damage_rect_, &content_bounds_);
+  EXPECT_EQ(1U, candidate_list.size());
+}
+
 TEST_F(SingleOverlayOnTopTest, RejectVideoSwapTransform) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateVideoQuad(
@@ -1563,6 +1594,33 @@ TEST_F(SingleOverlayOnTopTest, RejectVideoSwapTransform) {
   EXPECT_EQ(0U, candidate_list.size());
 }
 
+TEST_F(SingleOverlayOnTopTest,
+       AllowVideoNormalTransformWithOutputSurfaceOverlay) {
+  std::unique_ptr<RenderPass> pass = CreateRenderPass();
+  CreateFullscreenCandidateQuad(
+      resource_provider_.get(), child_resource_provider_.get(),
+      child_provider_.get(), pass->shared_quad_state_list.back(), pass.get());
+
+  gfx::Rect video_rect = gfx::ScaleToEnclosingRect(pass->output_rect, .5);
+  CreateCandidateVideoQuadAt(
+      resource_provider_.get(), child_resource_provider_.get(),
+      child_provider_.get(), pass->shared_quad_state_list.back(), pass.get(),
+      video_rect, kNormalTransform);
+
+  OverlayCandidateList candidate_list(BackbufferOverlayList(pass.get()));
+  OverlayProcessor::FilterOperationsMap render_pass_filters;
+  OverlayProcessor::FilterOperationsMap render_pass_background_filters;
+  RenderPassList pass_list;
+  pass_list.push_back(std::move(pass));
+  overlay_processor_->ProcessForOverlays(
+      resource_provider_.get(), &pass_list, GetIdentityColorMatrix(),
+      render_pass_filters, render_pass_background_filters, &candidate_list,
+      nullptr, nullptr, &damage_rect_, &content_bounds_);
+  ASSERT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(candidate_list[0].uv_rect, gfx::RectF(.5, .5));
+  EXPECT_EQ(candidate_list[1].uv_rect, gfx::RectF(.1, .2, .9, .8));
+}
+
 TEST_F(UnderlayTest, AllowVideoXMirrorTransform) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateVideoQuad(
@@ -1928,6 +1986,7 @@ TEST_F(UnderlayTest, PrimaryPlaneOverlayIsTransparentWithUnderlay) {
 
   OverlayCandidateList candidate_list;
   OverlayCandidate candidate;
+  candidate.display_rect = gfx::RectF(pass->output_rect);
   candidate.use_output_surface_for_resource = true;
   candidate.is_opaque = true;
   candidate_list.push_back(candidate);
@@ -2226,6 +2285,7 @@ TEST_F(UnderlayCastTest, PrimaryPlaneOverlayIsTransparentWithUnderlay) {
 
   OverlayCandidateList candidate_list;
   OverlayCandidate candidate;
+  candidate.display_rect = gfx::RectF(pass->output_rect);
   candidate.use_output_surface_for_resource = true;
   candidate.is_opaque = true;
   candidate_list.push_back(candidate);
@@ -2265,16 +2325,6 @@ TEST_F(UnderlayCastTest, NoOverlayPromotionWithoutProtectedContent) {
   EXPECT_TRUE(content_bounds_.empty());
 }
 
-OverlayCandidateList BackbufferOverlayList(const RenderPass* root_render_pass) {
-  OverlayCandidateList list;
-  OverlayCandidate output_surface_plane;
-  output_surface_plane.display_rect = gfx::RectF(root_render_pass->output_rect);
-  output_surface_plane.use_output_surface_for_resource = true;
-  output_surface_plane.overlay_handled = true;
-  list.push_back(output_surface_plane);
-  return list;
-}
-
 TEST_F(CALayerOverlayTest, AllowNonAxisAlignedTransform) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(
@@ -2808,7 +2858,7 @@ class OverlayInfoRendererGL : public GLRenderer {
                         OutputSurface* output_surface,
                         DisplayResourceProvider* resource_provider)
       : GLRenderer(settings, output_surface, resource_provider, nullptr),
-        expect_overlays_(false) {}
+        expected_overlay_count_(0) {}
 
   MOCK_METHOD2(DoDrawQuad,
                void(const DrawQuad* quad, const gfx::QuadF* draw_region));
@@ -2822,21 +2872,17 @@ class OverlayInfoRendererGL : public GLRenderer {
   void FinishDrawingFrame() override {
     GLRenderer::FinishDrawingFrame();
 
-    if (!expect_overlays_) {
-      EXPECT_EQ(0U, current_frame()->overlay_list.size());
-      return;
-    }
-
-    ASSERT_EQ(2U, current_frame()->overlay_list.size());
+    ASSERT_EQ(expected_overlay_count_, current_frame()->overlay_list.size());
+    if (expected_overlay_count_ > 0)
       EXPECT_GE(current_frame()->overlay_list.back().resource_id, 0U);
   }
 
-  void set_expect_overlays(bool expect_overlays) {
-    expect_overlays_ = expect_overlays;
+  void set_expected_overlay_count(unsigned int overlay_count) {
+    expected_overlay_count_ = overlay_count;
   }
 
  private:
-  bool expect_overlays_;
+  unsigned int expected_overlay_count_;
 };
 
 class MockOverlayScheduler {
@@ -2921,7 +2967,7 @@ class GLRendererWithOverlaysTest : public testing::Test {
 TEST_F(GLRendererWithOverlaysTest, OverlayQuadNotDrawn) {
   bool use_validator = true;
   Init(use_validator);
-  renderer_->set_expect_overlays(true);
+  renderer_->set_expected_overlay_count(1);
   output_surface_->GetOverlayCandidateValidator()->AddExpectedRect(
       gfx::RectF(kOverlayBottomRightRect));
 
@@ -2942,10 +2988,6 @@ TEST_F(GLRendererWithOverlaysTest, OverlayQuadNotDrawn) {
   // Candidate pass was taken out and extra skipped pass added,
   // so only draw 2 quads.
   EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(2);
-  EXPECT_CALL(scheduler_,
-              Schedule(0, gfx::OVERLAY_TRANSFORM_NONE, _,
-                       gfx::Rect(kDisplaySize), gfx::RectF(0, 0, 1, 1), _, _))
-      .Times(1);
   EXPECT_CALL(
       scheduler_,
       Schedule(1, gfx::OVERLAY_TRANSFORM_NONE, _, kOverlayBottomRightRect,
@@ -2963,7 +3005,7 @@ TEST_F(GLRendererWithOverlaysTest, OverlayQuadNotDrawn) {
 TEST_F(GLRendererWithOverlaysTest, OccludedQuadInUnderlay) {
   bool use_validator = true;
   Init(use_validator);
-  renderer_->set_expect_overlays(true);
+  renderer_->set_expected_overlay_count(1);
 
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
 
@@ -2982,10 +3024,6 @@ TEST_F(GLRendererWithOverlaysTest, OccludedQuadInUnderlay) {
   // Candidate quad should fail to be overlaid on top because of occlusion.
   // Expect to be replaced with transparent hole quad and placed in underlay.
   EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(3);
-  EXPECT_CALL(scheduler_,
-              Schedule(0, gfx::OVERLAY_TRANSFORM_NONE, _,
-                       gfx::Rect(kDisplaySize), gfx::RectF(0, 0, 1, 1), _, _))
-      .Times(1);
   EXPECT_CALL(scheduler_,
               Schedule(-1, gfx::OVERLAY_TRANSFORM_NONE, _, kOverlayRect,
                        BoundingRect(kUVTopLeft, kUVBottomRight), _, _))
@@ -3002,7 +3040,7 @@ TEST_F(GLRendererWithOverlaysTest, OccludedQuadInUnderlay) {
 TEST_F(GLRendererWithOverlaysTest, NoValidatorNoOverlay) {
   bool use_validator = false;
   Init(use_validator);
-  renderer_->set_expect_overlays(false);
+  renderer_->set_expected_overlay_count(0);
 
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
 
@@ -3029,13 +3067,14 @@ TEST_F(GLRendererWithOverlaysTest, NoValidatorNoOverlay) {
   Mock::VerifyAndClearExpectations(&scheduler_);
 }
 
-// GLRenderer skips drawing occluded quads when partial swap is enabled.
+// GLRenderer skips drawing occluded quads when partial swap is enabled and
+// turns off primary plane.
 TEST_F(GLRendererWithOverlaysTest, OccludedQuadNotDrawnWhenPartialSwapEnabled) {
   provider_->TestContextGL()->set_have_post_sub_buffer(true);
   settings_.partial_swap_enabled = true;
   bool use_validator = true;
   Init(use_validator);
-  renderer_->set_expect_overlays(true);
+  renderer_->set_expected_overlay_count(1);
 
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
 
@@ -3052,7 +3091,8 @@ TEST_F(GLRendererWithOverlaysTest, OccludedQuadNotDrawnWhenPartialSwapEnabled) {
 
   output_surface_->set_is_displayed_as_overlay_plane(true);
   EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(0);
-  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _, _, _)).Times(2);
+  // Only the candidate quad gets scheduled
+  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _, _, _)).Times(1);
   DrawFrame(&pass_list, kDisplaySize);
   EXPECT_EQ(0U, output_surface_->bind_framebuffer_count());
   SwapBuffers();
@@ -3060,12 +3100,13 @@ TEST_F(GLRendererWithOverlaysTest, OccludedQuadNotDrawnWhenPartialSwapEnabled) {
   Mock::VerifyAndClearExpectations(&scheduler_);
 }
 
-// GLRenderer skips drawing occluded quads when empty swap is enabled.
+// GLRenderer skips drawing occluded quads when empty swap is enabled and
+// turns off primary plane.
 TEST_F(GLRendererWithOverlaysTest, OccludedQuadNotDrawnWhenEmptySwapAllowed) {
   provider_->TestContextGL()->set_have_commit_overlay_planes(true);
   bool use_validator = true;
   Init(use_validator);
-  renderer_->set_expect_overlays(true);
+  renderer_->set_expected_overlay_count(1);
 
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
 
@@ -3083,7 +3124,8 @@ TEST_F(GLRendererWithOverlaysTest, OccludedQuadNotDrawnWhenEmptySwapAllowed) {
 
   output_surface_->set_is_displayed_as_overlay_plane(true);
   EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(0);
-  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _, _, _)).Times(2);
+  // Only the candidate quad gets scheduled
+  EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _, _, _)).Times(1);
   DrawFrame(&pass_list, kDisplaySize);
   EXPECT_EQ(0U, output_surface_->bind_framebuffer_count());
   SwapBuffers();
@@ -3094,7 +3136,7 @@ TEST_F(GLRendererWithOverlaysTest, OccludedQuadNotDrawnWhenEmptySwapAllowed) {
 TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturnedWithDelay) {
   bool use_validator = true;
   Init(use_validator);
-  renderer_->set_expect_overlays(true);
+  renderer_->set_expected_overlay_count(2);
 
   ResourceId resource1 = CreateResourceInLayerTree(
       child_resource_provider_.get(), gfx::Size(32, 32), true);
@@ -3202,7 +3244,7 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturnedWithDelay) {
   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _, _, _)).Times(0);
   DirectRenderer::DrawingFrame frame_no_overlays;
   frame_no_overlays.render_passes_in_draw_order = &pass_list;
-  renderer_->set_expect_overlays(false);
+  renderer_->set_expected_overlay_count(0);
   renderer_->SetCurrentFrame(frame_no_overlays);
   renderer_->BeginDrawingFrame();
   renderer_->FinishDrawingFrame();
@@ -3221,7 +3263,7 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturnedWithDelay) {
   EXPECT_FALSE(resource_provider_->InUse(mapped_resource3));
 
   // Use the same buffer twice.
-  renderer_->set_expect_overlays(true);
+  renderer_->set_expected_overlay_count(2);
   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _, _, _)).Times(2);
   renderer_->SetCurrentFrame(frame1);
   renderer_->BeginDrawingFrame();
@@ -3259,7 +3301,7 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturnedWithDelay) {
   EXPECT_FALSE(resource_provider_->InUse(mapped_resource3));
 
   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _, _, _)).Times(0);
-  renderer_->set_expect_overlays(false);
+  renderer_->set_expected_overlay_count(0);
   renderer_->SetCurrentFrame(frame_no_overlays);
   renderer_->BeginDrawingFrame();
   renderer_->FinishDrawingFrame();
@@ -3283,7 +3325,7 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturnedAfterGpuQuery) {
   bool use_validator = true;
   settings_.release_overlay_resources_after_gpu_query = true;
   Init(use_validator);
-  renderer_->set_expect_overlays(true);
+  renderer_->set_expected_overlay_count(2);
 
   ResourceId resource1 = CreateResourceInLayerTree(
       child_resource_provider_.get(), gfx::Size(32, 32), true);