Mac Overlays: Clip display and UV rects

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"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/rect_conversions.h"

[Andre, 2015/09/29 04:18:05]

Don't need this include anymore.
Also dip_util.h.

[ccameron, 2015/09/29 06:58:53]

Done.

 
 namespace cc {
 
+namespace {
+
+void ClipDisplayAndUVRects(gfx::Rect* display_rect,
+                           gfx::RectF* uv_rect,
+                           const gfx::Rect& clip_rect) {
+  gfx::Rect display_cropped_rect = *display_rect;
+  display_cropped_rect.Intersect(clip_rect);

[Andre, 2015/09/29 04:11:14]

How about
gfx::Rect display_cropped_rect = gfx::IntersectRects(*display_rect, clip_rect)

[ccameron, 2015/09/29 06:58:53]

Yes, that's better. Done.

+
+  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() {}
 
 OverlayResult OverlayStrategySandwich::TryOverlay(
     OverlayCandidateValidator* capability_checker,
     RenderPassList* render_passes_in_draw_order,
     OverlayCandidateList* candidate_list,
     const OverlayCandidate& candidate,
     QuadList::Iterator* candidate_iter_in_quad_list,
     float device_scale_factor) {
   RenderPass* root_render_pass = render_passes_in_draw_order->back();
   QuadList& quad_list = root_render_pass->quad_list;
   gfx::Rect pixel_bounds = root_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 DID_NOT_CREATE_OVERLAY;
 
-  // Compute the candidate's rect in display space (pixels on the screen). The
-  // rect needs to be DIP-aligned, or we cannot use it.
-  const gfx::Rect candidate_pixel_rect =
-      gfx::ToNearestRect(candidate.display_rect);
+  // Compute the candidate's rect in display space (pixels on the screen).
+  gfx::Rect candidate_pixel_rect = candidate.quad_rect_in_target_space;

[ccameron, 2015/09/29 00:24:32]

Here I exploit that those display_rect and quad_rect_in_target_space are
(basically) the same.

+  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 DID_NOT_CREATE_OVERLAY;
     }
   }
 
   // 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 (OverlayStrategyCommon::IsInvisibleQuad(*overlap_iter))
       continue;
-    // Compute the quad's bounds in display space, and ensure that it is rounded
-    // up to be DIP-aligned.
+    // 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);
-  new_candidate_list.back().plane_z_order = 1;
+  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);
@@ skipping 45 matching lines @@
                                SK_ColorTRANSPARENT, true);
       ++(*candidate_iter_in_quad_list);
     }
   }
 
   candidate_list->swap(new_candidate_list);
   return CREATED_OVERLAY_KEEP_LOOKING;
 }
 
 }  // namespace cc