[Ozone] Fix SingleOnTop issue by checking if the quad is clipped.

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/output/overlay_candidate_validator.h"
 #include "cc/quads/draw_quad.h"
@@ skipping 11 matching lines @@
     RenderPassList* render_passes_in_draw_order,
     OverlayCandidateList* candidate_list,
     const OverlayCandidate& candidate,
     QuadList::Iterator candidate_iterator) {
   RenderPass* root_render_pass = render_passes_in_draw_order->back();
   QuadList& quad_list = root_render_pass->quad_list;
   const DrawQuad* draw_quad = *candidate_iterator;
   gfx::RectF rect = draw_quad->rect;
   draw_quad->shared_quad_state->quad_to_target_transform.TransformRect(&rect);
 
+  // Check if the quad is clipped.
+  if (draw_quad->shared_quad_state->visible_quad_layer_rect.size() !=

[alexst (slow to review), 2015/08/27 12:42:36]

I don't think this is the right place to check for it. For example, this would
work fine on MacOS.

OverlayCandidate should already contain enough info in it to figure out this
scenario (if not, we should add what's missing), and instead of rejecting it
here,we need to reject it as part of line 58  
capability_checker->CheckOverlaySupport(&candidates);

Which on ChromeOS will go to

https://code.google.com/p/chromium/codesearch#chromium/src/ui/ozone/platform/...

and some place else on other platforms.

+      draw_quad->shared_quad_state->quad_layer_bounds)

[danakj, 2015/08/27 17:37:54]

Can you just use the draw_quad->shared_quad_state->is_clipped bool?

[william.xie1, 2015/08/28 00:00:46]

Hi Dana, I tried it, but is_clipped was always true, it maybe used for other
purpose?

[danakj, 2015/08/28 22:55:05]

Ah, ok well even if it's always true, it won't always clip something.

To determine if a quad is clipped the correct method would be to map the quad's
|rect| with the quad_to_target_transform and verify if the clip_rect.Contains()
that mapped rect. If not, then it will get clipped.

And if is_clipped is false you don't need to do any of that.

+    return false;
+
   // Check that no prior quads overlap it.
   for (auto overlap_iter = quad_list.cbegin();
        overlap_iter != candidate_iterator; ++overlap_iter) {
     gfx::RectF overlap_rect = overlap_iter->rect;
     overlap_iter->shared_quad_state->quad_to_target_transform.TransformRect(
         &overlap_rect);
     if (rect.Intersects(overlap_rect) && !IsInvisibleQuad(*overlap_iter))
       return false;
   }
 
@@ skipping 13 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