Always set damage rect to output rect if 3D context was reshaped.

cc/output/overlay_unittest.cc

 // Copyright 2014 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 <stddef.h>
 
 #include <utility>
 #include <vector>
 
 #include "base/containers/flat_map.h"
@@ skipping 488 matching lines @@
 
   // Add something behind it.
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   ASSERT_EQ(1U, candidate_list.size());
 
   RenderPass* main_pass = pass.get();
   // Check that all the quads are gone.
   EXPECT_EQ(0U, main_pass->quad_list.size());
   // Check that we have only one overlay.
   EXPECT_EQ(1U, candidate_list.size());
   // Check that the right resource id got extracted.
   EXPECT_EQ(original_resource_id, candidate_list.front().resource_id);
 }
 
 TEST_F(FullscreenOverlayTest, AlphaFail) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   TextureDrawQuad* original_quad = CreateFullscreenCandidateQuad(
       resource_provider_.get(), pass->shared_quad_state_list.back(),
       pass.get());
   original_quad->opaque_rect = gfx::Rect(0, 0, 0, 0);
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
 
   RenderPass* main_pass = pass.get();
   // Check that all the quads are gone.
   EXPECT_EQ(1U, main_pass->quad_list.size());
   // Check that we have only one overlay.
   EXPECT_EQ(0U, candidate_list.size());
 }
 
 TEST_F(FullscreenOverlayTest, ResourceSizeInPixelsFail) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   TextureDrawQuad* original_quad = CreateFullscreenCandidateQuad(
       resource_provider_.get(), pass->shared_quad_state_list.back(),
       pass.get());
   original_quad->set_resource_size_in_pixels(gfx::Size(64, 64));
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   ASSERT_EQ(0U, candidate_list.size());
 
   RenderPass* main_pass = pass.get();
   // Check that the quad is not gone.
   EXPECT_EQ(1U, main_pass->quad_list.size());
 }
 
 TEST_F(FullscreenOverlayTest, OnTopFail) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
 
   // Add something in front of it.
   CreateOpaqueQuadAt(resource_provider_.get(),
                      pass->shared_quad_state_list.back(), pass.get(),
                      kOverlayTopLeftRect);
 
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   ASSERT_EQ(0U, candidate_list.size());
 
   RenderPass* main_pass = pass.get();
   // Check that the 2 quads are not gone.
   EXPECT_EQ(2U, main_pass->quad_list.size());
 }
 
 TEST_F(FullscreenOverlayTest, NotCoveringFullscreenFail) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   gfx::Rect inset_rect = pass->output_rect;
   inset_rect.Inset(0, 1, 0, 1);
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(),
                         inset_rect);
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   ASSERT_EQ(0U, candidate_list.size());
 
   RenderPass* main_pass = pass.get();
   // Check that the quad is not gone.
   EXPECT_EQ(1U, main_pass->quad_list.size());
 }
 
 TEST_F(FullscreenOverlayTest, RemoveFullscreenQuadFromQuadList) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
 
   // Add something in front of it that is fully transparent.
   pass->shared_quad_state_list.back()->opacity = 0.0f;
   CreateOpaqueQuadAt(resource_provider_.get(),
                      pass->shared_quad_state_list.back(), pass.get(),
                      kOverlayTopLeftRect);
 
   SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
   shared_state->opacity = 1.f;
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   ASSERT_EQ(1U, candidate_list.size());
 
   // Check that the fullscreen quad is gone.
   for (const DrawQuad* quad : pass->quad_list) {
     EXPECT_NE(pass->output_rect, quad->rect);
   }
 }
 
 TEST_F(SingleOverlayOnTopTest, SuccessfulOverlay) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   TextureDrawQuad* original_quad =
       CreateFullscreenCandidateQuad(resource_provider_.get(),
                                     pass->shared_quad_state_list.back(),
                                     pass.get());
   unsigned original_resource_id = original_quad->resource_id();
 
   // Add something behind it.
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   ASSERT_EQ(1U, candidate_list.size());
 
   RenderPass* main_pass = pass.get();
   // Check that the quad is gone.
   EXPECT_EQ(2U, main_pass->quad_list.size());
   const QuadList& quad_list = main_pass->quad_list;
   for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
        it != quad_list.BackToFrontEnd();
@@ skipping 27 matching lines @@
 
   // Add something behind it.
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   ASSERT_EQ(1U, candidate_list.size());
 
   RenderPass* main_pass = pass.get();
   // Check that one quad is gone.
   EXPECT_EQ(2U, main_pass->quad_list.size());
   // Check that we have only one overlay.
   EXPECT_EQ(1U, candidate_list.size());
   // Check that the right resource id (bigger quad) got extracted.
@@ skipping 20 matching lines @@
   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);
 
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_TRUE(damage_rect_.IsEmpty());
 }
 
 TEST_F(SingleOverlayOnTopTest, NoCandidates) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
 
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));
 
   RenderPassList original_pass_list;
   RenderPass::CopyAll(pass_list, &original_pass_list);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass_list.back().get(), render_pass_filters,
-      render_pass_background_filters, &candidate_list, nullptr, nullptr,
-      &damage_rect_, &content_bounds_);
+      resource_provider_.get(), pass_list.back().get(), false,
+      render_pass_filters, render_pass_background_filters, &candidate_list,
+      nullptr, nullptr, &damage_rect_, &content_bounds_);
   EXPECT_EQ(0U, candidate_list.size());
   // There should be nothing new here.
   CompareRenderPassLists(pass_list, original_pass_list);
 }
 
 TEST_F(SingleOverlayOnTopTest, OccludedCandidates) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
 
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
 
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));
 
   RenderPassList original_pass_list;
   RenderPass::CopyAll(pass_list, &original_pass_list);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass_list.back().get(), render_pass_filters,
-      render_pass_background_filters, &candidate_list, nullptr, nullptr,
-      &damage_rect_, &content_bounds_);
+      resource_provider_.get(), pass_list.back().get(), false,
+      render_pass_filters, render_pass_background_filters, &candidate_list,
+      nullptr, nullptr, &damage_rect_, &content_bounds_);
   EXPECT_EQ(0U, candidate_list.size());
   // There should be nothing new here.
   CompareRenderPassLists(pass_list, original_pass_list);
 }
 
 // Test with multiple render passes.
 TEST_F(SingleOverlayOnTopTest, MultipleRenderPasses) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
 
   // Add something behind it.
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, AcceptBlending) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   TextureDrawQuad* quad =
       CreateFullscreenCandidateQuad(resource_provider_.get(),
                                     pass->shared_quad_state_list.back(),
                                     pass.get());
   quad->needs_blending = true;
   quad->opaque_rect = gfx::Rect(0, 0, 0, 0);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   damage_rect_ = quad->rect;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(1U, candidate_list.size());
   EXPECT_FALSE(damage_rect_.IsEmpty());
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectBackgroundColor) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   TextureDrawQuad* quad =
       CreateFullscreenCandidateQuad(resource_provider_.get(),
                                     pass->shared_quad_state_list.back(),
                                     pass.get());
   quad->background_color = SK_ColorBLACK;
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(0U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectBlendMode) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
   pass->shared_quad_state_list.back()->blend_mode = SkBlendMode::kScreen;
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(0U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectOpacity) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
   pass->shared_quad_state_list.back()->opacity = 0.5f;
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(0U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectNonAxisAlignedTransform) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
   pass->shared_quad_state_list.back()
       ->quad_to_target_transform.RotateAboutXAxis(45.f);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(0U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowClipped) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
   pass->shared_quad_state_list.back()->is_clipped = true;
   pass->shared_quad_state_list.back()->clip_rect = kOverlayClipRect;
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(UnderlayTest, AllowVerticalFlip) {
   gfx::Rect rect = kOverlayRect;
   rect.set_width(rect.width() / 2);
   rect.Offset(0, -rect.height());
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(), rect);
   pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(2.0f,
                                                                       -1.0f);
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL,
             candidate_list.back().transform);
 }
 
 TEST_F(UnderlayTest, AllowHorizontalFlip) {
   gfx::Rect rect = kOverlayRect;
   rect.set_height(rect.height() / 2);
   rect.Offset(-rect.width(), 0);
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(), rect);
   pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(-1.0f,
                                                                       2.0f);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL,
             candidate_list.back().transform);
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowPositiveScaleTransform) {
   gfx::Rect rect = kOverlayRect;
   rect.set_width(rect.width() / 2);
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(), rect);
   pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(2.0f,
                                                                       1.0f);
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, AcceptMirrorYTransform) {
   gfx::Rect rect = kOverlayRect;
   rect.Offset(0, -rect.height());
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(), rect);
   pass->shared_quad_state_list.back()->quad_to_target_transform.Scale(1.f,
                                                                       -1.f);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   ASSERT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(UnderlayTest, Allow90DegreeRotation) {
   gfx::Rect rect = kOverlayRect;
   rect.Offset(0, -rect.height());
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(), rect);
   pass->shared_quad_state_list.back()
       ->quad_to_target_transform.RotateAboutZAxis(90.f);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90, candidate_list.back().transform);
 }
 
 TEST_F(UnderlayTest, Allow180DegreeRotation) {
   gfx::Rect rect = kOverlayRect;
   rect.Offset(-rect.width(), -rect.height());
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(), rect);
   pass->shared_quad_state_list.back()
       ->quad_to_target_transform.RotateAboutZAxis(180.f);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_180, candidate_list.back().transform);
 }
 
 TEST_F(UnderlayTest, Allow270DegreeRotation) {
   gfx::Rect rect = kOverlayRect;
   rect.Offset(-rect.width(), 0);
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(), rect);
   pass->shared_quad_state_list.back()
       ->quad_to_target_transform.RotateAboutZAxis(270.f);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_270, candidate_list.back().transform);
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowNotTopIfNotOccluded) {
   output_surface_->GetOverlayCandidateValidator()->AddExpectedRect(
       gfx::RectF(kOverlayBottomRightRect));
 
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateOpaqueQuadAt(resource_provider_.get(),
                      pass->shared_quad_state_list.back(), pass.get(),
                      kOverlayTopLeftRect);
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(),
                         pass.get(),
                         kOverlayBottomRightRect);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowTransparentOnTop) {
   output_surface_->GetOverlayCandidateValidator()->AddExpectedRect(
       gfx::RectF(kOverlayBottomRightRect));
 
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
   shared_state->opacity = 0.f;
   CreateSolidColorQuadAt(shared_state, SK_ColorBLACK, pass.get(),
                          kOverlayBottomRightRect);
   shared_state = pass->CreateAndAppendSharedQuadState();
   shared_state->opacity = 1.f;
   CreateCandidateQuadAt(resource_provider_.get(), shared_state, pass.get(),
                         kOverlayBottomRightRect);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowTransparentColorOnTop) {
   output_surface_->GetOverlayCandidateValidator()->AddExpectedRect(
       gfx::RectF(kOverlayBottomRightRect));
 
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateSolidColorQuadAt(pass->shared_quad_state_list.back(),
                          SK_ColorTRANSPARENT, pass.get(),
                          kOverlayBottomRightRect);
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(),
                         kOverlayBottomRightRect);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectOpaqueColorOnTop) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
   shared_state->opacity = 0.5f;
   CreateSolidColorQuadAt(shared_state, SK_ColorBLACK, pass.get(),
                          kOverlayBottomRightRect);
   shared_state = pass->CreateAndAppendSharedQuadState();
   shared_state->opacity = 1.f;
   CreateCandidateQuadAt(resource_provider_.get(), shared_state, pass.get(),
                         kOverlayBottomRightRect);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(0U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectTransparentColorOnTopWithoutBlending) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
   CreateSolidColorQuadAt(shared_state, SK_ColorTRANSPARENT, pass.get(),
                          kOverlayBottomRightRect)->opaque_rect =
       kOverlayBottomRightRect;
   CreateCandidateQuadAt(resource_provider_.get(), shared_state, pass.get(),
                         kOverlayBottomRightRect);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(0U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectVideoSwapTransform) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateVideoQuad(resource_provider_.get(),
                                      pass->shared_quad_state_list.back(),
                                      pass.get(), kSwapTransform);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(0U, candidate_list.size());
 }
 
 TEST_F(UnderlayTest, AllowVideoXMirrorTransform) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateVideoQuad(resource_provider_.get(),
                                      pass->shared_quad_state_list.back(),
                                      pass.get(), kXMirrorTransform);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(UnderlayTest, AllowVideoBothMirrorTransform) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateVideoQuad(resource_provider_.get(),
                                      pass->shared_quad_state_list.back(),
                                      pass.get(), kBothMirrorTransform);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(UnderlayTest, AllowVideoNormalTransform) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateVideoQuad(resource_provider_.get(),
                                      pass->shared_quad_state_list.back(),
                                      pass.get(), kNormalTransform);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowVideoYMirrorTransform) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateVideoQuad(resource_provider_.get(),
                                      pass->shared_quad_state_list.back(),
                                      pass.get(), kYMirrorTransform);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(1U, candidate_list.size());
 }
 
 TEST_F(UnderlayTest, OverlayLayerUnderMainLayer) {
   output_surface_->GetOverlayCandidateValidator()->AddExpectedRect(
       gfx::RectF(kOverlayBottomRightRect));
 
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(),
                         kOverlayBottomRightRect);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(-1, candidate_list[0].plane_z_order);
   EXPECT_EQ(2U, pass->quad_list.size());
   // The overlay quad should have changed to a SOLID_COLOR quad.
   EXPECT_EQ(pass->quad_list.back()->material, DrawQuad::SOLID_COLOR);
 }
 
 TEST_F(UnderlayTest, AllowOnTop) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
   pass->CreateAndAppendSharedQuadState()->opacity = 0.5f;
   CreateFullscreenOpaqueQuad(resource_provider_.get(),
                              pass->shared_quad_state_list.back(), pass.get());
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(-1, candidate_list[0].plane_z_order);
   // The overlay quad should have changed to a SOLID_COLOR quad.
   EXPECT_EQ(pass->quad_list.front()->material, DrawQuad::SOLID_COLOR);
 }
 
 // The first time an underlay is scheduled its damage must not be subtracted.
 TEST_F(UnderlayTest, InitialUnderlayDamageNotSubtracted) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
 
   damage_rect_ = kOverlayRect;
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
 
   EXPECT_EQ(kOverlayRect, damage_rect_);
 }
 
 // An identical underlay for two frames in a row means the damage can be
 // subtracted the second time.
 TEST_F(UnderlayTest, DamageSubtractedForConsecutiveIdenticalUnderlays) {
   for (int i = 0; i < 2; ++i) {
     std::unique_ptr<RenderPass> pass = CreateRenderPass();
     CreateFullscreenCandidateQuad(resource_provider_.get(),
                                   pass->shared_quad_state_list.back(),
                                   pass.get());
 
     damage_rect_ = kOverlayRect;
 
     // Add something behind it.
     CreateFullscreenOpaqueQuad(resource_provider_.get(),
                                pass->shared_quad_state_list.back(), pass.get());
 
     OverlayCandidateList candidate_list;
     base::flat_map<int, FilterOperations*> render_pass_filters;
     base::flat_map<int, FilterOperations*> render_pass_background_filters;
     overlay_processor_->ProcessForOverlays(
-        resource_provider_.get(), pass.get(), render_pass_filters,
+        resource_provider_.get(), pass.get(), false, render_pass_filters,
         render_pass_background_filters, &candidate_list, nullptr, nullptr,
         &damage_rect_, &content_bounds_);
   }
 
   // The second time the same overlay rect is scheduled it will be subtracted
   // from the damage rect.
   EXPECT_TRUE(damage_rect_.IsEmpty());
 }
 
 // Underlay damage can only be subtracted if the previous frame's underlay
 // was the same rect.
 TEST_F(UnderlayTest, DamageNotSubtractedForNonIdenticalConsecutiveUnderlays) {
   gfx::Rect overlay_rects[] = {kOverlayBottomRightRect, kOverlayRect};
   for (int i = 0; i < 2; ++i) {
     output_surface_->GetOverlayCandidateValidator()->AddExpectedRect(
         gfx::RectF(overlay_rects[i]));
 
     std::unique_ptr<RenderPass> pass = CreateRenderPass();
 
     CreateCandidateQuadAt(resource_provider_.get(),
                           pass->shared_quad_state_list.back(), pass.get(),
                           overlay_rects[i]);
 
     damage_rect_ = overlay_rects[i];
 
     OverlayCandidateList candidate_list;
     base::flat_map<int, FilterOperations*> render_pass_filters;
     base::flat_map<int, FilterOperations*> render_pass_background_filters;
     overlay_processor_->ProcessForOverlays(
-        resource_provider_.get(), pass.get(), render_pass_filters,
+        resource_provider_.get(), pass.get(), false, render_pass_filters,
         render_pass_background_filters, &candidate_list, nullptr, nullptr,
         &damage_rect_, &content_bounds_);
 
     EXPECT_EQ(overlay_rects[i], damage_rect_);
   }
 }
 
 // Underlay damage can only be subtracted if the previous frame's underlay
 // exists.
 TEST_F(UnderlayTest, DamageNotSubtractedForNonConsecutiveIdenticalUnderlays) {
@@ skipping 11 matching lines @@
     damage_rect_ = kOverlayRect;
 
     // Add something behind it.
     CreateFullscreenOpaqueQuad(resource_provider_.get(),
                                pass->shared_quad_state_list.back(), pass.get());
 
     OverlayCandidateList candidate_list;
     base::flat_map<int, FilterOperations*> render_pass_filters;
     base::flat_map<int, FilterOperations*> render_pass_background_filters;
     overlay_processor_->ProcessForOverlays(
-        resource_provider_.get(), pass.get(), render_pass_filters,
+        resource_provider_.get(), pass.get(), false, render_pass_filters,
         render_pass_background_filters, &candidate_list, nullptr, nullptr,
         &damage_rect_, &content_bounds_);
   }
 
   EXPECT_EQ(kOverlayRect, damage_rect_);
 }
 
 TEST_F(UnderlayTest, DamageNotSubtractedWhenQuadsAboveOverlap) {
   for (int i = 0; i < 2; ++i) {
     std::unique_ptr<RenderPass> pass = CreateRenderPass();
     // Add an overlapping quad above the candidate.
     CreateFullscreenOpaqueQuad(resource_provider_.get(),
                                pass->shared_quad_state_list.back(), pass.get());
     CreateFullscreenCandidateQuad(resource_provider_.get(),
                                   pass->shared_quad_state_list.back(),
                                   pass.get());
 
     damage_rect_ = kOverlayRect;
 
     OverlayCandidateList candidate_list;
     base::flat_map<int, FilterOperations*> render_pass_filters;
     base::flat_map<int, FilterOperations*> render_pass_background_filters;
     overlay_processor_->ProcessForOverlays(
-        resource_provider_.get(), pass.get(), render_pass_filters,
+        resource_provider_.get(), pass.get(), false, render_pass_filters,
         render_pass_background_filters, &candidate_list, nullptr, nullptr,
         &damage_rect_, &content_bounds_);
   }
 
   EXPECT_EQ(kOverlayRect, damage_rect_);
 }
 
 TEST_F(UnderlayTest, DamageSubtractedWhenQuadsAboveDontOverlap) {
   output_surface_->GetOverlayCandidateValidator()->AddExpectedRect(
       gfx::RectF(kOverlayBottomRightRect));
 
   for (int i = 0; i < 2; ++i) {
     std::unique_ptr<RenderPass> pass = CreateRenderPass();
     // Add a non-overlapping quad above the candidate.
     CreateOpaqueQuadAt(resource_provider_.get(),
                        pass->shared_quad_state_list.back(), pass.get(),
                        kOverlayTopLeftRect);
     CreateCandidateQuadAt(resource_provider_.get(),
                           pass->shared_quad_state_list.back(), pass.get(),
                           kOverlayBottomRightRect);
 
     damage_rect_ = kOverlayBottomRightRect;
 
     OverlayCandidateList candidate_list;
     base::flat_map<int, FilterOperations*> render_pass_filters;
     base::flat_map<int, FilterOperations*> render_pass_background_filters;
     overlay_processor_->ProcessForOverlays(
-        resource_provider_.get(), pass.get(), render_pass_filters,
+        resource_provider_.get(), pass.get(), false, render_pass_filters,
         render_pass_background_filters, &candidate_list, nullptr, nullptr,
         &damage_rect_, &content_bounds_);
   }
 
   EXPECT_TRUE(damage_rect_.IsEmpty());
 }
 
 TEST_F(UnderlayCastTest, NoOverlayContentBounds) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
 
   CreateOpaqueQuadAt(resource_provider_.get(),
                      pass->shared_quad_state_list.back(), pass.get(),
                      kOverlayTopLeftRect);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(0U, content_bounds_.size());
 }
 
 TEST_F(UnderlayCastTest, FullScreenOverlayContentBounds) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(),
                         kOverlayRect);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
 
   EXPECT_EQ(1U, content_bounds_.size());
   EXPECT_TRUE(content_bounds_[0].IsEmpty());
 }
 
 TEST_F(UnderlayCastTest, BlackOutsideOverlayContentBounds) {
   output_surface_->GetOverlayCandidateValidator()->AddExpectedRect(
       gfx::RectF(kOverlayBottomRightRect));
 
   const gfx::Rect kLeftSide(0, 0, 128, 256);
   const gfx::Rect kTopRight(128, 0, 128, 128);
 
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(),
                         kOverlayBottomRightRect);
   CreateOpaqueQuadAt(resource_provider_.get(),
                      pass->shared_quad_state_list.back(), pass.get(), kLeftSide,
                      SK_ColorBLACK);
   CreateOpaqueQuadAt(resource_provider_.get(),
                      pass->shared_quad_state_list.back(), pass.get(), kTopRight,
                      SK_ColorBLACK);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
 
   EXPECT_EQ(1U, content_bounds_.size());
   EXPECT_TRUE(content_bounds_[0].IsEmpty());
 }
 
 TEST_F(UnderlayCastTest, OverlayOccludedContentBounds) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateOpaqueQuadAt(resource_provider_.get(),
                      pass->shared_quad_state_list.back(), pass.get(),
                      kOverlayTopLeftRect);
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(),
                         kOverlayRect);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
 
   EXPECT_EQ(1U, content_bounds_.size());
   EXPECT_EQ(kOverlayTopLeftRect, content_bounds_[0]);
 }
 
 TEST_F(UnderlayCastTest, OverlayOccludedUnionContentBounds) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateOpaqueQuadAt(resource_provider_.get(),
                      pass->shared_quad_state_list.back(), pass.get(),
                      kOverlayTopLeftRect);
   CreateOpaqueQuadAt(resource_provider_.get(),
                      pass->shared_quad_state_list.back(), pass.get(),
                      kOverlayBottomRightRect);
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(),
                         kOverlayRect);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
 
   EXPECT_EQ(1U, content_bounds_.size());
   EXPECT_EQ(kOverlayRect, content_bounds_[0]);
 }
 
 TEST_F(UnderlayCastTest, RoundOverlayContentBounds) {
   // Check rounding behaviour on overlay quads.  Be conservative (content
   // potentially visible on boundary).
   const gfx::Rect overlay_rect(1, 1, 8, 8);
   output_surface_->GetOverlayCandidateValidator()->AddExpectedRect(
       gfx::RectF(1.5f, 1.5f, 8, 8));
 
   gfx::Transform transform;
   transform.Translate(0.5f, 0.5f);
 
   std::unique_ptr<RenderPass> pass = CreateRenderPassWithTransform(transform);
   CreateCandidateQuadAt(resource_provider_.get(),
                         pass->shared_quad_state_list.back(), pass.get(),
                         overlay_rect);
   CreateOpaqueQuadAt(resource_provider_.get(),
                      pass->shared_quad_state_list.back(), pass.get(),
                      gfx::Rect(0, 0, 10, 10), SK_ColorWHITE);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
 
   EXPECT_EQ(1U, content_bounds_.size());
   EXPECT_EQ(gfx::Rect(0, 0, 11, 11), content_bounds_[0]);
 }
 
 TEST_F(UnderlayCastTest, RoundContentBounds) {
   // Check rounding behaviour on content quads (bounds should be enclosing
   // rect).
@@ skipping 10 matching lines @@
                         pass->shared_quad_state_list.back(), pass.get(),
                         overlay_rect);
   CreateOpaqueQuadAt(resource_provider_.get(),
                      pass->shared_quad_state_list.back(), pass.get(),
                      gfx::Rect(0, 0, 255, 255), SK_ColorWHITE);
 
   OverlayCandidateList candidate_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &candidate_list, nullptr, nullptr,
       &damage_rect_, &content_bounds_);
 
   EXPECT_EQ(1U, content_bounds_.size());
   EXPECT_EQ(kOverlayRect, content_bounds_[0]);
 }
 
 OverlayCandidateList BackbufferOverlayList(const RenderPass* root_render_pass) {
   OverlayCandidateList list;
   OverlayCandidate output_surface_plane;
@@ skipping 13 matching lines @@
                                 pass.get());
   pass->shared_quad_state_list.back()
       ->quad_to_target_transform.RotateAboutZAxis(45.f);
 
   gfx::Rect damage_rect;
   CALayerOverlayList ca_layer_list;
   OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get()));
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &overlay_list, &ca_layer_list, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(gfx::Rect(), damage_rect);
   EXPECT_EQ(0U, overlay_list.size());
   EXPECT_EQ(1U, ca_layer_list.size());
   EXPECT_EQ(0U, output_surface_->bind_framebuffer_count());
 }
 
 TEST_F(CALayerOverlayTest, ThreeDTransform) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
   pass->shared_quad_state_list.back()
       ->quad_to_target_transform.RotateAboutXAxis(45.f);
 
   gfx::Rect damage_rect;
   CALayerOverlayList ca_layer_list;
   OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get()));
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &overlay_list, &ca_layer_list, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(0U, overlay_list.size());
   EXPECT_EQ(1U, ca_layer_list.size());
   gfx::Transform expected_transform;
   expected_transform.RotateAboutXAxis(45.f);
   gfx::Transform actual_transform(ca_layer_list.back().shared_state->transform);
   EXPECT_EQ(expected_transform.ToString(), actual_transform.ToString());
   EXPECT_EQ(0U, output_surface_->bind_framebuffer_count());
 }
 
 TEST_F(CALayerOverlayTest, AllowContainingClip) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
   pass->shared_quad_state_list.back()->is_clipped = true;
   pass->shared_quad_state_list.back()->clip_rect = kOverlayRect;
 
   gfx::Rect damage_rect;
   CALayerOverlayList ca_layer_list;
   OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get()));
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &overlay_list, &ca_layer_list, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(gfx::Rect(), damage_rect);
   EXPECT_EQ(0U, overlay_list.size());
   EXPECT_EQ(1U, ca_layer_list.size());
   EXPECT_EQ(0U, output_surface_->bind_framebuffer_count());
 }
 
 TEST_F(CALayerOverlayTest, NontrivialClip) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
   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;
   CALayerOverlayList ca_layer_list;
   OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get()));
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &overlay_list, &ca_layer_list, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(gfx::Rect(), damage_rect);
   EXPECT_EQ(0U, overlay_list.size());
   EXPECT_EQ(1U, ca_layer_list.size());
   EXPECT_TRUE(ca_layer_list.back().shared_state->is_clipped);
   EXPECT_EQ(gfx::RectF(64, 64, 128, 128),
             ca_layer_list.back().shared_state->clip_rect);
   EXPECT_EQ(0U, output_surface_->bind_framebuffer_count());
 }
 
 TEST_F(CALayerOverlayTest, SkipTransparent) {
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
                                 pass.get());
   pass->shared_quad_state_list.back()->opacity = 0;
 
   gfx::Rect damage_rect;
   CALayerOverlayList ca_layer_list;
   OverlayCandidateList overlay_list(BackbufferOverlayList(pass.get()));
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &overlay_list, &ca_layer_list, nullptr,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(gfx::Rect(), damage_rect);
   EXPECT_EQ(0U, overlay_list.size());
   EXPECT_EQ(0U, ca_layer_list.size());
   EXPECT_EQ(0U, output_surface_->bind_framebuffer_count());
 }
 
 TEST_F(DCLayerOverlayTest, AllowNonAxisAlignedTransform) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeature(
       features::kDirectCompositionComplexOverlays);
   std::unique_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateYUVVideoQuad(resource_provider_.get(),
                                         pass->shared_quad_state_list.back(),
                                         pass.get());
   pass->shared_quad_state_list.back()
       ->quad_to_target_transform.RotateAboutZAxis(45.f);
 
   gfx::Rect damage_rect;
   DCLayerOverlayList dc_layer_list;
   OverlayCandidateList overlay_list;
   base::flat_map<int, FilterOperations*> render_pass_filters;
   base::flat_map<int, FilterOperations*> render_pass_background_filters;
   damage_rect_ = gfx::Rect(1, 1, 10, 10);
   overlay_processor_->ProcessForOverlays(
-      resource_provider_.get(), pass.get(), render_pass_filters,
+      resource_provider_.get(), pass.get(), false, render_pass_filters,
       render_pass_background_filters, &overlay_list, nullptr, &dc_layer_list,
       &damage_rect_, &content_bounds_);
   EXPECT_EQ(gfx::Rect(), damage_rect);
   EXPECT_EQ(0U, overlay_list.size());
   EXPECT_EQ(1U, dc_layer_list.size());
   EXPECT_EQ(1, dc_layer_list.back().shared_state->z_order);
   EXPECT_EQ(0U, output_surface_->bind_framebuffer_count());
   EXPECT_EQ(gfx::Rect(1, 1, 10, 10), damage_rect_);
 }
 
 TEST_F(DCLayerOverlayTest, Occluded) {
   base::test::ScopedFeatureList feature_list;
   feature_list.InitAndEnableFeature(features::kDirectCompositionUnderlays);
   {
     std::unique_ptr<RenderPass> pass = CreateRenderPass();
     CreateOpaqueQuadAt(resource_provider_.get(),
                        pass->shared_quad_state_list.back(), pass.get(),
                        gfx::Rect(0, 2, 100, 100), SK_ColorWHITE);
     CreateFullscreenCandidateYUVVideoQuad(resource_provider_.get(),
                                           pass->shared_quad_state_list.back(),
                                           pass.get());
 
     gfx::Rect damage_rect;
     DCLayerOverlayList dc_layer_list;
     OverlayCandidateList overlay_list;
     base::flat_map<int, FilterOperations*> render_pass_filters;
     base::flat_map<int, FilterOperations*> render_pass_background_filters;
     damage_rect_ = gfx::Rect(1, 1, 10, 10);
     overlay_processor_->ProcessForOverlays(
-        resource_provider_.get(), pass.get(), render_pass_filters,
+        resource_provider_.get(), pass.get(), false, render_pass_filters,
         render_pass_background_filters, &overlay_list, nullptr, &dc_layer_list,
         &damage_rect_, &content_bounds_);
     EXPECT_EQ(gfx::Rect(), damage_rect);
     EXPECT_EQ(0U, overlay_list.size());
     EXPECT_EQ(1U, dc_layer_list.size());
     EXPECT_EQ(0U, output_surface_->bind_framebuffer_count());
     EXPECT_EQ(-1, dc_layer_list.back().shared_state->z_order);
     // Entire underlay rect must be redrawn.
     EXPECT_EQ(gfx::Rect(0, 0, 256, 256), damage_rect_);
   }
   {
     std::unique_ptr<RenderPass> pass = CreateRenderPass();
     CreateOpaqueQuadAt(resource_provider_.get(),
                        pass->shared_quad_state_list.back(), pass.get(),
                        gfx::Rect(2, 2, 100, 100), SK_ColorWHITE);
     CreateFullscreenCandidateYUVVideoQuad(resource_provider_.get(),
                                           pass->shared_quad_state_list.back(),
                                           pass.get());
 
     gfx::Rect damage_rect;
     DCLayerOverlayList dc_layer_list;
     OverlayCandidateList overlay_list;
     base::flat_map<int, FilterOperations*> render_pass_filters;
     base::flat_map<int, FilterOperations*> render_pass_background_filters;
     damage_rect_ = gfx::Rect(1, 1, 10, 10);
     overlay_processor_->ProcessForOverlays(
-        resource_provider_.get(), pass.get(), render_pass_filters,
+        resource_provider_.get(), pass.get(), false, render_pass_filters,
         render_pass_background_filters, &overlay_list, nullptr, &dc_layer_list,
         &damage_rect_, &content_bounds_);
     EXPECT_EQ(gfx::Rect(), damage_rect);
     EXPECT_EQ(0U, overlay_list.size());
     EXPECT_EQ(1U, dc_layer_list.size());
     EXPECT_EQ(0U, output_surface_->bind_framebuffer_count());
     EXPECT_EQ(-1, dc_layer_list.back().shared_state->z_order);
     // The underlay rectangle is the same, so the damage is contained within
     // the combined occluding rects for this and the last frame.
     EXPECT_EQ(gfx::Rect(1, 2, 10, 9), damage_rect_);
   }
 }
 
 TEST_F(DCLayerOverlayTest, DamageRect) {
   for (int i = 0; i < 2; i++) {
     std::unique_ptr<RenderPass> pass = CreateRenderPass();
     CreateFullscreenCandidateYUVVideoQuad(resource_provider_.get(),
                                           pass->shared_quad_state_list.back(),
                                           pass.get());
 
     gfx::Rect damage_rect;
     DCLayerOverlayList dc_layer_list;
     OverlayCandidateList overlay_list;
     base::flat_map<int, FilterOperations*> render_pass_filters;
     base::flat_map<int, FilterOperations*> render_pass_background_filters;
     damage_rect_ = gfx::Rect(1, 1, 10, 10);
     overlay_processor_->ProcessForOverlays(
-        resource_provider_.get(), pass.get(), render_pass_filters,
+        resource_provider_.get(), pass.get(), (i == 0), render_pass_filters,
         render_pass_background_filters, &overlay_list, nullptr, &dc_layer_list,
         &damage_rect_, &content_bounds_);
     EXPECT_EQ(gfx::Rect(), damage_rect);
     EXPECT_EQ(0U, overlay_list.size());
     EXPECT_EQ(1U, dc_layer_list.size());
     EXPECT_EQ(0U, output_surface_->bind_framebuffer_count());
     EXPECT_EQ(1, dc_layer_list.back().shared_state->z_order);
     // Damage rect should be unchanged on initial frame because of resize, but
     // should be empty on the second frame because everything was put in a
     // layer.
@@ skipping 25 matching lines @@
     shared_state->is_clipped = true;
     // Clipped rect shouldn't be overlapped by clipped opaque quad rect.
     shared_state->clip_rect = gfx::Rect(0, 0, 100, 3);
 
     DCLayerOverlayList dc_layer_list;
     OverlayCandidateList overlay_list;
     base::flat_map<int, FilterOperations*> render_pass_filters;
     base::flat_map<int, FilterOperations*> render_pass_background_filters;
     damage_rect_ = gfx::Rect(1, 1, 10, 10);
     overlay_processor_->ProcessForOverlays(
-        resource_provider_.get(), pass.get(), render_pass_filters,
+        resource_provider_.get(), pass.get(), false, render_pass_filters,
         render_pass_background_filters, &overlay_list, nullptr, &dc_layer_list,
         &damage_rect_, &content_bounds_);
     EXPECT_EQ(0U, overlay_list.size());
     EXPECT_EQ(1U, dc_layer_list.size());
     // Because of clip rects the overlay isn't occluded and shouldn't be an
     // underlay.
     EXPECT_EQ(1, dc_layer_list.back().shared_state->z_order);
     if (i == 1) {
       // The damage rect should only contain contents that aren't in the
       // clipped overlay rect.
@@ skipping 14 matching lines @@
                                           pass->shared_quad_state_list.back(),
                                           pass.get());
     pass->shared_quad_state_list.back()->opacity = 0.5f;
 
     DCLayerOverlayList dc_layer_list;
     OverlayCandidateList overlay_list;
     base::flat_map<int, FilterOperations*> render_pass_filters;
     base::flat_map<int, FilterOperations*> render_pass_background_filters;
     damage_rect_ = gfx::Rect(1, 1, 10, 10);
     overlay_processor_->ProcessForOverlays(
-        resource_provider_.get(), pass.get(), render_pass_filters,
+        resource_provider_.get(), pass.get(), false, render_pass_filters,
         render_pass_background_filters, &overlay_list, nullptr, &dc_layer_list,
         &damage_rect_, &content_bounds_);
     EXPECT_EQ(0U, overlay_list.size());
     EXPECT_EQ(1U, dc_layer_list.size());
     EXPECT_EQ(1, dc_layer_list.back().shared_state->z_order);
     // Quad isn't opaque, so underlying damage must remain the same.
     EXPECT_EQ(gfx::Rect(1, 1, 10, 10), damage_rect_);
   }
 }
 
@@ skipping 526 matching lines @@
     CALayerOverlayTest::SetUp();
     pass_ = CreateRenderPass();
     quad_ = pass_->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
     render_pass_id_ = 3;
   }
 
   void ProcessForOverlays() {
     gfx::Rect damage_rect;
     overlay_list_ = BackbufferOverlayList(pass_.get());
     overlay_processor_->ProcessForOverlays(
-        resource_provider_.get(), pass_.get(), render_pass_filters_,
+        resource_provider_.get(), pass_.get(), false, render_pass_filters_,
         render_pass_background_filters_, &overlay_list_, &ca_layer_list_,
         nullptr, &damage_rect_, &content_bounds_);
   }
   std::unique_ptr<RenderPass> pass_;
   RenderPassDrawQuad* quad_;
   int render_pass_id_;
   FilterOperations filters_;
   FilterOperations background_filters_;
   base::flat_map<int, FilterOperations*> render_pass_filters_;
   base::flat_map<int, FilterOperations*> render_pass_background_filters_;
@@ skipping 101 matching lines @@
                  kOverlayRect, render_pass_id_, 2, gfx::RectF(), gfx::Size(),
                  gfx::Vector2dF(1, 1), gfx::PointF(), gfx::RectF());
   }
 
   ProcessForOverlays();
   EXPECT_EQ(0U, ca_layer_list_.size());
 }
 
 }  // namespace
 }  // namespace cc