Mac Overlays: Remove OverlayStrategySandwich

This isn't being used anymore.

BUG=581526
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

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

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

3 files changed, 0 insertions, 558 deletions

diff --git a/cc/output/overlay_strategy_sandwich.cc b/cc/output/overlay_strategy_sandwich.cc
deleted file mode 100644
index ce590b9..0000000
--- a/cc/output/overlay_strategy_sandwich.cc
+++ /dev/null
@@ -1,183 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "cc/output/overlay_strategy_sandwich.h"
-
-#include "cc/base/math_util.h"
-#include "cc/base/region.h"
-#include "cc/output/overlay_candidate_validator.h"
-#include "cc/quads/draw_quad.h"
-#include "cc/quads/solid_color_draw_quad.h"
-
-namespace cc {
-
-namespace {
-
-void ClipDisplayAndUVRects(gfx::Rect* display_rect,
-                           gfx::RectF* uv_rect,
-                           const gfx::Rect& clip_rect) {
-  gfx::Rect display_cropped_rect =
-      gfx::IntersectRects(*display_rect, clip_rect);
-
-  gfx::RectF uv_cropped_rect = gfx::RectF(display_cropped_rect);
-  uv_cropped_rect -= gfx::Vector2dF(display_rect->x(), display_rect->y());
-  uv_cropped_rect.Scale(uv_rect->width() / display_rect->width(),
-                        uv_rect->height() / display_rect->height());
-  uv_cropped_rect += gfx::Vector2dF(uv_rect->x(), uv_rect->y());
-
-  *display_rect = display_cropped_rect;
-  *uv_rect = uv_cropped_rect;
-}
-
-}  // namespace
-
-OverlayStrategySandwich::OverlayStrategySandwich(
-    OverlayCandidateValidator* capability_checker)
-    : capability_checker_(capability_checker) {
-  DCHECK(capability_checker);
-}
-
-OverlayStrategySandwich::~OverlayStrategySandwich() {}
-
-bool OverlayStrategySandwich::Attempt(ResourceProvider* resource_provider,
-                                      RenderPassList* render_passes,
-                                      OverlayCandidateList* candidate_list) {
-  QuadList& quad_list = render_passes->back()->quad_list;
-  for (auto it = quad_list.begin(); it != quad_list.end();) {
-    OverlayCandidate candidate;
-    if (OverlayCandidate::FromDrawQuad(resource_provider, *it, &candidate)) {
-      it = TryOverlay(render_passes->back().get(), candidate_list, candidate,
-                      it);
-    } else {
-      ++it;
-    }
-  }
-
-  return candidate_list->size() > 1;
-}
-
-QuadList::Iterator OverlayStrategySandwich::TryOverlay(
-    RenderPass* render_pass,
-    OverlayCandidateList* candidate_list,
-    const OverlayCandidate& candidate,
-    QuadList::Iterator candidate_iter_in_quad_list) {
-  QuadList& quad_list = render_pass->quad_list;
-  gfx::Rect pixel_bounds = render_pass->output_rect;
-
-  const DrawQuad* candidate_quad = *candidate_iter_in_quad_list;
-  const gfx::Transform& candidate_transform =
-      candidate_quad->shared_quad_state->quad_to_target_transform;
-  gfx::Transform candidate_inverse_transform;
-  if (!candidate_transform.GetInverse(&candidate_inverse_transform))
-    return ++candidate_iter_in_quad_list;
-
-  // Compute the candidate's rect in display space (pixels on the screen).
-  gfx::Rect candidate_pixel_rect = candidate.quad_rect_in_target_space;
-  gfx::RectF candidate_uv_rect = candidate.uv_rect;
-  if (candidate.is_clipped &&
-      !candidate.clip_rect.Contains(candidate_pixel_rect)) {
-    ClipDisplayAndUVRects(&candidate_pixel_rect, &candidate_uv_rect,
-                          candidate.clip_rect);
-  }
-
-  // Don't allow overlapping overlays for now.
-  for (const OverlayCandidate& other_candidate : *candidate_list) {
-    if (other_candidate.display_rect.Intersects(candidate.display_rect) &&
-        other_candidate.plane_z_order == 1) {
-      return ++candidate_iter_in_quad_list;
-    }
-  }
-
-  // Iterate through the quads in front of |candidate|, and compute the region
-  // of |candidate| that is covered.
-  Region pixel_covered_region;
-  for (auto overlap_iter = quad_list.cbegin();
-       overlap_iter != candidate_iter_in_quad_list; ++overlap_iter) {
-    if (OverlayCandidate::IsInvisibleQuad(*overlap_iter))
-      continue;
-    // Compute the quad's bounds in display space.
-    gfx::Rect pixel_covered_rect = MathUtil::MapEnclosingClippedRect(
-        overlap_iter->shared_quad_state->quad_to_target_transform,
-        overlap_iter->rect);
-
-    // Include the intersection of that quad with the candidate's quad in the
-    // covered region.
-    pixel_covered_rect.Intersect(candidate_pixel_rect);
-    pixel_covered_region.Union(pixel_covered_rect);
-  }
-
-  // Add the candidate's overlay.
-  DCHECK(candidate.resource_id);
-  OverlayCandidateList new_candidate_list = *candidate_list;
-  new_candidate_list.push_back(candidate);
-  OverlayCandidate& new_candidate = new_candidate_list.back();
-  new_candidate.plane_z_order = 1;
-  new_candidate.display_rect = gfx::RectF(candidate_pixel_rect);
-  new_candidate.quad_rect_in_target_space = candidate_pixel_rect;
-  new_candidate.uv_rect = candidate_uv_rect;
-
-  // Add an overlay of the primary surface for any part of the candidate's
-  // quad that was covered.
-  std::vector<gfx::Rect> pixel_covered_rects;
-  for (Region::Iterator it(pixel_covered_region); it.has_rect(); it.next())
-    pixel_covered_rects.push_back(it.rect());
-  for (const gfx::Rect& pixel_covered_rect : pixel_covered_rects) {
-    OverlayCandidate main_image_on_top;
-    main_image_on_top.display_rect = gfx::RectF(pixel_covered_rect);
-    main_image_on_top.uv_rect = gfx::RectF(pixel_covered_rect);
-    main_image_on_top.uv_rect.Scale(1.f / pixel_bounds.width(),
-                                    1.f / pixel_bounds.height());
-    main_image_on_top.plane_z_order = 2;
-    main_image_on_top.transform = gfx::OVERLAY_TRANSFORM_NONE;
-    main_image_on_top.use_output_surface_for_resource = true;
-    new_candidate_list.push_back(main_image_on_top);
-  }
-
-  // Check for support.
-  capability_checker_->CheckOverlaySupport(&new_candidate_list);
-  for (const OverlayCandidate& candidate : new_candidate_list) {
-    if (!candidate.overlay_handled)
-      return ++candidate_iter_in_quad_list;
-  }
-
-  // Remove the quad for the overlay quad. Replace it with a transparent quad
-  // if we're putting a new overlay on top.
-  if (pixel_covered_rects.empty()) {
-    candidate_iter_in_quad_list =
-        quad_list.EraseAndInvalidateAllPointers(candidate_iter_in_quad_list);
-  } else {
-    // Cache the information from the candidate quad that we'll need to
-    // construct the solid color quads.
-    const SharedQuadState* candidate_shared_quad_state =
-        candidate_quad->shared_quad_state;
-    const gfx::Rect candidate_rect = candidate_quad->rect;
-
-    // Reserve space in the quad list for the transparent quads.
-    quad_list.ReplaceExistingElement<SolidColorDrawQuad>(
-        candidate_iter_in_quad_list);
-    candidate_iter_in_quad_list =
-        quad_list.InsertBeforeAndInvalidateAllPointers<SolidColorDrawQuad>(
-            candidate_iter_in_quad_list, pixel_covered_rects.size() - 1);
-
-    // Cover the region with transparent quads.
-    for (const gfx::Rect& pixel_covered_rect : pixel_covered_rects) {
-      gfx::Rect quad_space_covered_rect = MathUtil::MapEnclosingClippedRect(
-          candidate_inverse_transform, pixel_covered_rect);
-      quad_space_covered_rect.Intersect(candidate_rect);
-
-      SolidColorDrawQuad* transparent_quad =
-          static_cast<SolidColorDrawQuad*>(*candidate_iter_in_quad_list);
-      transparent_quad->SetAll(candidate_shared_quad_state,
-                               quad_space_covered_rect, quad_space_covered_rect,
-                               quad_space_covered_rect, false,
-                               SK_ColorTRANSPARENT, true);
-      ++candidate_iter_in_quad_list;
-    }
-  }
-
-  candidate_list->swap(new_candidate_list);
-  return candidate_iter_in_quad_list;
-}
-
-}  // namespace cc
diff --git a/cc/output/overlay_strategy_sandwich.h b/cc/output/overlay_strategy_sandwich.h
deleted file mode 100644
index f46dd03..0000000
--- a/cc/output/overlay_strategy_sandwich.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2015 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.
-
-#ifndef CC_OUTPUT_OVERLAY_STRATEGY_SANDWICH_H_
-#define CC_OUTPUT_OVERLAY_STRATEGY_SANDWICH_H_
-
-#include "base/macros.h"
-#include "cc/output/overlay_processor.h"
-
-namespace cc {
-
-class OverlayCandidateValidator;
-
-// The sandwich strategy looks for a video quad without regard to quads above
-// it. The video is "overlaid" on top of the scene, and then the non-empty
-// parts of the scene are "overlaid" on top of the video. This is only valid
-// for overlay contents that are fully opaque.
-class CC_EXPORT OverlayStrategySandwich : public OverlayProcessor::Strategy {
- public:
-  explicit OverlayStrategySandwich(
-      OverlayCandidateValidator* capability_checker);
-  ~OverlayStrategySandwich() override;
-
-  bool Attempt(ResourceProvider* resource_provider,
-               RenderPassList* render_passes,
-               OverlayCandidateList* candidate_list) override;
-
- private:
-  QuadList::Iterator TryOverlay(RenderPass* render_pass,
-                                OverlayCandidateList* candidate_list,
-                                const OverlayCandidate& candidate,
-                                QuadList::Iterator candidate_iterator);
-
-  OverlayCandidateValidator* capability_checker_;  // Weak.
-
-  DISALLOW_COPY_AND_ASSIGN(OverlayStrategySandwich);
-};
-
-}  // namespace cc
-
-#endif  // CC_OUTPUT_OVERLAY_STRATEGY_SANDWICH_H_
diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc
index 9b3bf97..bc5cf56 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -13,7 +13,6 @@
 #include "cc/output/output_surface_client.h"
 #include "cc/output/overlay_candidate_validator.h"
 #include "cc/output/overlay_processor.h"
-#include "cc/output/overlay_strategy_sandwich.h"
 #include "cc/output/overlay_strategy_single_on_top.h"
 #include "cc/output/overlay_strategy_underlay.h"
 #include "cc/quads/render_pass.h"
@@ -117,18 +116,6 @@ class UnderlayOverlayValidator : public SingleOverlayValidator {
   }
 };
 
-class SandwichOverlayValidator : public OverlayCandidateValidator {
- public:
-  void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
-    strategies->push_back(make_scoped_ptr(new OverlayStrategySandwich(this)));
-  }
-  bool AllowCALayerOverlays() override { return false; }
-  void CheckOverlaySupport(OverlayCandidateList* surfaces) override {
-    for (OverlayCandidate& candidate : *surfaces)
-      candidate.overlay_handled = true;
-  }
-};
-
 class DefaultOverlayProcessor : public OverlayProcessor {
  public:
   explicit DefaultOverlayProcessor(OutputSurface* surface);
@@ -373,7 +360,6 @@ class OverlayTest : public testing::Test {
 
 typedef OverlayTest<SingleOnTopOverlayValidator> SingleOverlayOnTopTest;
 typedef OverlayTest<UnderlayOverlayValidator> UnderlayTest;
-typedef OverlayTest<SandwichOverlayValidator> SandwichTest;
 typedef OverlayTest<CALayerValidator> CALayerOverlayTest;
 
 TEST(OverlayTest, NoOverlaysByDefault) {
@@ -403,325 +389,6 @@ TEST(OverlayTest, OverlaysProcessorHasStrategy) {
   EXPECT_GE(2U, overlay_processor->GetStrategyCount());
 }
 
-TEST_F(SandwichTest, SuccessfulSingleOverlay) {
-  scoped_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());
-
-  RenderPassList pass_list;
-  pass_list.push_back(std::move(pass));
-
-  // Check for potential candidates.
-  OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, nullptr,
-                                         &damage_rect_);
-
-  ASSERT_EQ(1U, pass_list.size());
-  ASSERT_EQ(1U, candidate_list.size());
-
-  RenderPass* main_pass = pass_list.back().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(); ++it) {
-    EXPECT_NE(DrawQuad::TEXTURE_CONTENT, it->material);
-  }
-
-  // Check that the right resource id got extracted.
-  EXPECT_EQ(original_resource_id, candidate_list.back().resource_id);
-}
-
-TEST_F(SandwichTest, CroppedSingleOverlay) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
-  pass->shared_quad_state_list.back()->is_clipped = true;
-  pass->shared_quad_state_list.back()->clip_rect = gfx::Rect(0, 32, 64, 64);
-
-  TextureDrawQuad* original_quad = CreateFullscreenCandidateQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back(),
-      pass.get());
-  original_quad->uv_top_left = gfx::PointF(0, 0);
-  original_quad->uv_bottom_right = gfx::PointF(1, 1);
-  unsigned candidate_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());
-
-  RenderPassList pass_list;
-  pass_list.push_back(std::move(pass));
-
-  // Check for potential candidates.
-  OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, nullptr,
-                                         &damage_rect_);
-
-  // Ensure that the display and uv rects have cropping applied to them.
-  ASSERT_EQ(1U, pass_list.size());
-  ASSERT_EQ(1U, candidate_list.size());
-  EXPECT_EQ(candidate_id, candidate_list[0].resource_id);
-  EXPECT_EQ(gfx::RectF(0.f, 32.f, 64.f, 64.f), candidate_list[0].display_rect);
-  EXPECT_EQ(gfx::RectF(0.f, 0.25f, 0.5f, 0.5f), candidate_list[0].uv_rect);
-}
-
-TEST_F(SandwichTest, SuccessfulTwoOverlays) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
-
-  // Add two non-overlapping candidates.
-  CreateCandidateQuadAt(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);
-
-  // Add something behind it.
-  CreateFullscreenOpaqueQuad(resource_provider_.get(),
-                             pass->shared_quad_state_list.back(), pass.get());
-
-  RenderPassList pass_list;
-  pass_list.push_back(std::move(pass));
-  OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, nullptr,
-                                         &damage_rect_);
-
-  // Both candidates should become overlays.
-  EXPECT_EQ(1u, pass_list.size());
-  EXPECT_EQ(2u, candidate_list.size());
-  EXPECT_EQ(gfx::RectF(kOverlayTopLeftRect), candidate_list[0].display_rect);
-  EXPECT_EQ(gfx::RectF(kOverlayBottomRightRect),
-            candidate_list[1].display_rect);
-
-  // The overlay quads should be gone.
-  const QuadList& quad_list = pass_list.back()->quad_list;
-  EXPECT_EQ(1u, quad_list.size());
-  EXPECT_EQ(DrawQuad::SOLID_COLOR, quad_list.front()->material);
-}
-
-TEST_F(SandwichTest, OverlappingOverlays) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
-
-  // Add two overlapping candidates.
-  CreateCandidateQuadAt(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);
-
-  // Add something behind it.
-  CreateFullscreenOpaqueQuad(resource_provider_.get(),
-                             pass->shared_quad_state_list.back(), pass.get());
-
-  RenderPassList pass_list;
-  pass_list.push_back(std::move(pass));
-  OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, nullptr,
-                                         &damage_rect_);
-
-  // Only one of the candidates should become an overlay.
-  EXPECT_EQ(1u, pass_list.size());
-  EXPECT_EQ(1u, candidate_list.size());
-  EXPECT_EQ(gfx::RectF(kOverlayTopLeftRect), candidate_list[0].display_rect);
-
-  // One of the overlay quads should be gone.
-  const QuadList& quad_list = pass_list.back()->quad_list;
-  EXPECT_EQ(2u, quad_list.size());
-  EXPECT_EQ(DrawQuad::TEXTURE_CONTENT, quad_list.front()->material);
-  EXPECT_EQ(DrawQuad::SOLID_COLOR, quad_list.back()->material);
-}
-
-TEST_F(SandwichTest, SuccessfulSandwichOverlay) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
-
-  CreateOpaqueQuadAt(resource_provider_.get(),
-                     pass->shared_quad_state_list.back(), pass.get(),
-                     gfx::Rect(16, 16, 32, 32));
-  unsigned candidate_id =
-      CreateCandidateQuadAt(resource_provider_.get(),
-                            pass->shared_quad_state_list.back(), pass.get(),
-                            gfx::Rect(32, 32, 32, 32))
-          ->resource_id();
-  CreateOpaqueQuadAt(resource_provider_.get(),
-                     pass->shared_quad_state_list.back(), pass.get(),
-                     gfx::Rect(kDisplaySize));
-
-  RenderPassList pass_list;
-  pass_list.push_back(std::move(pass));
-
-  // Check for potential candidates.
-  OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, nullptr,
-                                         &damage_rect_);
-  ASSERT_EQ(1U, pass_list.size());
-  ASSERT_EQ(2U, candidate_list.size());
-
-  RenderPass* main_pass = pass_list.back().get();
-  // Check that the quad is gone.
-  EXPECT_EQ(3U, main_pass->quad_list.size());
-  const QuadList& quad_list = main_pass->quad_list;
-  for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
-       it != quad_list.BackToFrontEnd(); ++it) {
-    EXPECT_NE(DrawQuad::TEXTURE_CONTENT, it->material);
-  }
-
-  EXPECT_EQ(candidate_id, candidate_list[0].resource_id);
-  EXPECT_EQ(gfx::RectF(32.f, 32.f, 32.f, 32.f), candidate_list[0].display_rect);
-  EXPECT_TRUE(candidate_list[1].use_output_surface_for_resource);
-  EXPECT_EQ(gfx::RectF(32.f, 32.f, 16.f, 16.f), candidate_list[1].display_rect);
-  EXPECT_EQ(gfx::RectF(32.f / 256.f, 32.f / 256.f, 16.f / 256.f, 16.f / 256.f),
-            candidate_list[1].uv_rect);
-}
-
-TEST_F(SandwichTest, MultiQuadOverlay) {
-  scoped_ptr<RenderPass> pass = CreateRenderPass();
-
-  // Put two non-intersecting quads on top.
-  const gfx::Rect rect1(gfx::Rect(0, 0, 32, 32));
-  const gfx::Rect rect2(gfx::Rect(32, 32, 32, 32));
-  Region covered_region;
-  covered_region.Union(rect1);
-  covered_region.Union(rect2);
-  CreateOpaqueQuadAt(resource_provider_.get(),
-                     pass->shared_quad_state_list.back(), pass.get(), rect1);
-  CreateOpaqueQuadAt(resource_provider_.get(),
-                     pass->shared_quad_state_list.back(), pass.get(), rect2);
-
-  // Then a candidate that we'll turn into an overlay.
-  unsigned candidate_id =
-      CreateCandidateQuadAt(resource_provider_.get(),
-                            pass->shared_quad_state_list.back(), pass.get(),
-                            gfx::Rect(0, 0, 64, 64))
-          ->resource_id();
-
-  // Then some opaque background.
-  CreateOpaqueQuadAt(resource_provider_.get(),
-                     pass->shared_quad_state_list.back(), pass.get(),
-                     gfx::Rect(kDisplaySize));
-
-  RenderPassList pass_list;
-  pass_list.push_back(std::move(pass));
-
-  // Run the overlay strategy on that input.
-  RenderPass* main_pass = pass_list.back().get();
-  OverlayCandidateList candidate_list;
-  EXPECT_EQ(4U, main_pass->quad_list.size());
-  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
-                                         &candidate_list, nullptr,
-                                         &damage_rect_);
-  ASSERT_EQ(1U, pass_list.size());
-  ASSERT_EQ(3U, candidate_list.size());
-
-  // Check that the candidate quad is gone and that we now have two transparent
-  // quads for the same region that was covered on the overlay.
-  EXPECT_EQ(5U, main_pass->quad_list.size());
-  const QuadList& quad_list = main_pass->quad_list;
-  Region transparent_quad_region;
-  for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
-       it != quad_list.BackToFrontEnd(); ++it) {
-    EXPECT_NE(DrawQuad::TEXTURE_CONTENT, it->material);
-    if (it->material == DrawQuad::SOLID_COLOR) {
-      const SolidColorDrawQuad* solid_color_quad =
-          SolidColorDrawQuad::MaterialCast(*it);
-      if (solid_color_quad->color == SK_ColorTRANSPARENT)
-        transparent_quad_region.Union(solid_color_quad->rect);
-    }
-  }
-  DCHECK(covered_region == transparent_quad_region);
-
-  // Check that overlays cover the same region that the quads covered.
-  EXPECT_EQ(candidate_id, candidate_list[0].resource_id);
-  EXPECT_EQ(gfx::RectF(64.f, 64.f), candidate_list[0].display_rect);
-  EXPECT_TRUE(candidate_list[1].use_output_surface_for_resource);
-  EXPECT_TRUE(candidate_list[2].use_output_surface_for_resource);
-  Region overlay_region;
-  overlay_region.Union(gfx::ToEnclosingRect(candidate_list[1].display_rect));
-  overlay_region.Union(gfx::ToEnclosingRect(candidate_list[2].display_rect));
-  DCHECK(covered_region == overlay_region);
-}
-
-TEST_F(SandwichTest, DamageRect) {
-  scoped_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());
-  CreateFullscreenOpaqueQuad(resource_provider_.get(),
-                             pass->shared_quad_state_list.back(), pass.get());
-
-  RenderPassList pass_list;
-  pass_list.push_back(std::move(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(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(std::move(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, SuccessfulOverlay) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   TextureDrawQuad* original_quad =