cc: Ignore certain quads that would otherwise block overlays

cc/output/overlay_strategy_single_on_top.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 "cc/output/overlay_strategy_single_on_top.h"
 
 #include <limits>
 
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
@@ skipping 101 matching lines @@
     if (!GetVideoQuadInfo(quad, quad_info))
       return false;
   }
 
   quad_info->format = RGBA_8888;
   quad_info->display_rect = OverlayCandidate::GetOverlayRect(
       draw_quad.quadTransform(), draw_quad.rect);
   return true;
 }
 
+bool OverlayStrategySingleOnTop::IsInvisibleQuad(const DrawQuad* draw_quad) {
+  if (draw_quad->material == DrawQuad::SOLID_COLOR) {
+    const SolidColorDrawQuad* solid_quad =
+        SolidColorDrawQuad::MaterialCast(draw_quad);
+    SkColor color = solid_quad->color;
+    float opacity = solid_quad->opacity();
+    float alpha = (SkColorGetA(color) * (1.0f / 255.0f)) * opacity;
+    // Ignore transparent solid color quads.
+    return solid_quad->ShouldDrawWithBlending() &&
+           alpha < std::numeric_limits<float>::epsilon();
+  }
+  return false;
+}
+
 bool OverlayStrategySingleOnTop::Attempt(
     RenderPassList* render_passes_in_draw_order,
     OverlayCandidateList* candidate_list) {
   // Only attempt to handle very simple case for now.
   if (!capability_checker_)
     return false;
 
   RenderPass* root_render_pass = render_passes_in_draw_order->back();
   DCHECK(root_render_pass);
 
   OverlayCandidate candidate;
   QuadList& quad_list = root_render_pass->quad_list;
   auto candidate_iterator = quad_list.end();
   for (auto it = quad_list.begin(); it != quad_list.end(); ++it) {
     const DrawQuad* draw_quad = *it;
     if (IsOverlayQuad(draw_quad)) {
       // Check that no prior quads overlap it.
       bool intersects = false;
       gfx::RectF rect = draw_quad->rect;
       draw_quad->quadTransform().TransformRect(&rect);
       for (auto overlap_iter = quad_list.cbegin(); overlap_iter != it;
            ++overlap_iter) {
         gfx::RectF overlap_rect = overlap_iter->rect;
         overlap_iter->quadTransform().TransformRect(&overlap_rect);
-        if (rect.Intersects(overlap_rect)) {
+        if (rect.Intersects(overlap_rect) && !IsInvisibleQuad(*overlap_iter)) {
           intersects = true;
           break;
         }
       }
       if (intersects || !GetCandidateQuadInfo(*draw_quad, &candidate))
         continue;
       candidate_iterator = it;
       break;
     }
   }
@@ skipping 16 matching lines @@
   // If the candidate can be handled by an overlay, create a pass for it.
   if (candidates[1].overlay_handled) {
     quad_list.EraseAndInvalidateAllPointers(candidate_iterator);
     candidate_list->swap(candidates);
     return true;
   }
   return false;
 }
 
 }  // namespace cc