Mac Overlays: Allow SolidColor and Tile quads to be candidates for overlays.

cc/output/overlay_strategy_sandwich.cc

 // 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"
@@ skipping 28 matching lines @@
 }
 
 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))
+    if (it->material == DrawQuad::IO_SURFACE_CONTENT &&
+        capability_checker_->IsSupportedQuad(*it) &&
+        OverlayCandidate::FromDrawQuad(resource_provider, *it, &candidate)) {
       it = TryOverlay(render_passes->back(), candidate_list, candidate, it);
-    else
+    } 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) {
@@ skipping 36 matching lines @@
         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);
+  DCHECK(candidate.resource.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;
+    main_image_on_top.resource_type = OverlayCandidate::USE_OUTPUT_SURFACE;
     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;
   }
 
@@ skipping 30 matching lines @@
                                SK_ColorTRANSPARENT, true);
       ++candidate_iter_in_quad_list;
     }
   }
 
   candidate_list->swap(new_candidate_list);
   return candidate_iter_in_quad_list;
 }
 
 }  // namespace cc