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

Video quad may be clipped.
We need to check that before use overlay

BUG=
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

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

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

cc/output/overlay_candidate.cc

@@ -38,6 +38,7 @@ OverlayCandidate::OverlayCandidate()
     : transform(gfx::OVERLAY_TRANSFORM_NONE),
       format(RGBA_8888),
       uv_rect(0.f, 0.f, 1.f, 1.f),
+      is_clipped(false),
       use_output_surface_for_resource(false),
       resource_id(0),
       plane_z_order(0),

cc/output/overlay_candidate.h

@@ -9,6 +9,7 @@
 
 #include "cc/base/cc_export.h"
 #include "cc/resources/resource_format.h"
+#include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/overlay_transform.h"
@@ -46,6 +47,12 @@ class CC_EXPORT OverlayCandidate {
   gfx::RectF display_rect;
   // Crop within the buffer to be placed inside |display_rect|.
   gfx::RectF uv_rect;
+  // Quad geometry rect after applying the quad_transform().
+  gfx::Rect quad_rect_in_target_space;
+  // Clip rect in the target content space after composition.
+  gfx::Rect clip_rect;
+  // If the quad is clipped after composition.
+  bool is_clipped;
   // True if the texture for this overlay should be the same one used by the
   // output surface's main overlay.
   bool use_output_surface_for_resource;

cc/output/overlay_strategy_common.cc

@@ -6,6 +6,7 @@
 
 #include <limits>
 
+#include "cc/base/math_util.h"
 #include "cc/quads/io_surface_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/stream_video_draw_quad.h"
@@ -100,6 +101,10 @@ bool OverlayStrategyCommon::GetTextureQuadInfo(const TextureDrawQuad& quad,
   quad_info->resource_size_in_pixels = quad.resource_size_in_pixels();
   quad_info->transform = overlay_transform;
   quad_info->uv_rect = BoundingRect(quad.uv_top_left, quad.uv_bottom_right);
+  quad_info->quad_rect_in_target_space = MathUtil::MapEnclosingClippedRect(
+      quad.shared_quad_state->quad_to_target_transform, quad.rect);
+  quad_info->clip_rect = quad.shared_quad_state->clip_rect;
+  quad_info->is_clipped = quad.shared_quad_state->is_clipped;
   return true;
 }
 
@@ -120,6 +125,10 @@ bool OverlayStrategyCommon::GetVideoQuadInfo(const StreamVideoDrawQuad& quad,
   quad_info->resource_id = quad.resource_id();
   quad_info->resource_size_in_pixels = quad.resource_size_in_pixels();
   quad_info->transform = overlay_transform;
+  quad_info->quad_rect_in_target_space = MathUtil::MapEnclosingClippedRect(
+      quad.shared_quad_state->quad_to_target_transform, quad.rect);
+  quad_info->clip_rect = quad.shared_quad_state->clip_rect;
+  quad_info->is_clipped = quad.shared_quad_state->is_clipped;
 
   gfx::Point3F uv0 = gfx::Point3F(0, 0, 0);
   gfx::Point3F uv1 = gfx::Point3F(1, 1, 0);
@@ -161,6 +170,10 @@ bool OverlayStrategyCommon::GetIOSurfaceQuadInfo(const IOSurfaceDrawQuad& quad,
   quad_info->resource_size_in_pixels = quad.io_surface_size;
   quad_info->transform = overlay_transform;
   quad_info->uv_rect = gfx::RectF(1.f, 1.f);
+  quad_info->quad_rect_in_target_space = MathUtil::MapEnclosingClippedRect(
+      quad.shared_quad_state->quad_to_target_transform, quad.rect);
+  quad_info->clip_rect = quad.shared_quad_state->clip_rect;
+  quad_info->is_clipped = quad.shared_quad_state->is_clipped;
   return true;
 }
 

cc/output/overlay_unittest.cc

@@ -38,6 +38,7 @@ const gfx::Size kDisplaySize(256, 256);
 const gfx::Rect kOverlayRect(0, 0, 128, 128);
 const gfx::Rect kOverlayTopLeftRect(0, 0, 64, 64);
 const gfx::Rect kOverlayBottomRightRect(64, 64, 64, 64);
+const gfx::Rect kOverlayClipRect(0, 0, 128, 128);
 const gfx::PointF kUVTopLeft(0.1f, 0.2f);
 const gfx::PointF kUVBottomRight(1.0f, 1.0f);
 const gfx::Transform kNormalTransform =
@@ -79,6 +80,10 @@ class SingleOverlayValidator : public OverlayCandidateValidator {
     }
     EXPECT_FLOAT_RECT_EQ(BoundingRect(kUVTopLeft, kUVBottomRight),
                          candidate.uv_rect);
+    if (!candidate.clip_rect.IsEmpty()) {
+      EXPECT_EQ(true, candidate.is_clipped);
+      EXPECT_EQ(kOverlayClipRect, candidate.clip_rect);
+    }
     candidate.overlay_handled = true;
   }
 };
@@ -880,6 +885,22 @@ TEST_F(SingleOverlayOnTopTest, RejectNonAxisAlignedTransform) {
   EXPECT_EQ(0U, candidate_list.size());
 }
 
+TEST_F(SingleOverlayOnTopTest, AllowClipped) {
+  scoped_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;
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+  OverlayCandidateList candidate_list;
+  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  ASSERT_EQ(1U, pass_list.size());
+  EXPECT_EQ(2U, candidate_list.size());
+}
+
 TEST_F(SingleOverlayOnTopTest, AllowVerticalFlip) {
   gfx::Rect rect = kOverlayRect;
   rect.set_width(rect.width() / 2);

content/browser/compositor/browser_compositor_overlay_candidate_validator_ozone.cc

@@ -59,6 +59,10 @@ void BrowserCompositorOverlayCandidateValidatorOzone::CheckOverlaySupport(
     ozone_surface_list.at(i).format = GetBufferFormat(surfaces->at(i).format);
     ozone_surface_list.at(i).display_rect = surfaces->at(i).display_rect;
     ozone_surface_list.at(i).crop_rect = surfaces->at(i).uv_rect;
+    ozone_surface_list.at(i).quad_rect_in_target_space =
+        surfaces->at(i).quad_rect_in_target_space;
+    ozone_surface_list.at(i).clip_rect = surfaces->at(i).clip_rect;
+    ozone_surface_list.at(i).is_clipped = surfaces->at(i).is_clipped;
     ozone_surface_list.at(i).plane_z_order = surfaces->at(i).plane_z_order;
     ozone_surface_list.at(i).buffer_size =
         surfaces->at(i).resource_size_in_pixels;

ui/ozone/platform/drm/host/drm_overlay_candidates_host.cc

@@ -79,6 +79,9 @@ void DrmOverlayCandidatesHost::CheckSingleOverlay(
     return;
   if (overlay->transform == gfx::OVERLAY_TRANSFORM_INVALID)
     return;
+  if (overlay->is_clipped &&
+      !overlay->clip_rect.Contains(overlay->quad_rect_in_target_space))
+    return;
 
   OverlayCheck_Params lookup(*overlay);
   auto iter = cache_.Get(lookup);

ui/ozone/public/overlay_candidates_ozone.cc

@@ -8,8 +8,8 @@
 
 namespace ui {
 
-OverlayCandidatesOzone::OverlaySurfaceCandidate::OverlaySurfaceCandidate() {
-}
+OverlayCandidatesOzone::OverlaySurfaceCandidate::OverlaySurfaceCandidate()
+    : is_clipped(false) {}
 
 OverlayCandidatesOzone::OverlaySurfaceCandidate::~OverlaySurfaceCandidate() {
 }

ui/ozone/public/overlay_candidates_ozone.h

@@ -35,6 +35,12 @@ class OZONE_BASE_EXPORT OverlayCandidatesOzone {
     gfx::RectF display_rect;
     // Crop within the buffer to be placed inside |display_rect|.
     gfx::RectF crop_rect;
+    // Quad geometry rect after applying the quad_transform().
+    gfx::Rect quad_rect_in_target_space;
+    // Clip rect in the target content space after composition.
+    gfx::Rect clip_rect;
+    // If the quad is clipped after composition.
+    bool is_clipped;
     // Stacking order of the overlay plane relative to the main surface,
     // which is 0. Signed to allow for "underlays".
     int plane_z_order = 0;