0

Rename gfx::OverlayTransform rotations

Bug: 1463980
Change-Id: I821cceb3e456040636b2c518b4d11202cc3cedef
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5107818
Reviewed-by: Mitsuru Oshima <oshima@chromium.org>
Reviewed-by: Chris Bookholt <bookholt@chromium.org>
Reviewed-by: Kenneth MacKay <kmackay@chromium.org>
Commit-Queue: Punith Nayak <npunith125@gmail.com>
Reviewed-by: Kyle Charbonneau <kylechar@chromium.org>
Reviewed-by: David Dorwin <ddorwin@chromium.org>
Reviewed-by: Bo Liu <boliu@chromium.org>
Reviewed-by: Ahmed Fakhry <afakhry@chromium.org>
Reviewed-by: Peng Huang <penghuang@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1237368}
This commit is contained in:
punithnayak
2023-12-14 04:03:26 +00:00
committed by Chromium LUCI CQ
parent 083ad62008
commit 316d5fb98d
29 changed files with 139 additions and 127 deletions

@ -3437,11 +3437,11 @@ TEST_F(DisplayManagerTest, UnifiedDesktopPrimarySizeWithRotatedDisplays) {
std::vector<display::Display> display_list =
display_manager()->software_mirroring_display_list();
EXPECT_EQ(gfx::Size(700, 1000), host_list[0]->window()->bounds().size());
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90,
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90,
host_list[0]->compositor()->display_transform_hint());
EXPECT_EQ(display::Display::ROTATE_90, display_list[0].panel_rotation());
EXPECT_EQ(gfx::Size(700, 1000), host_list[1]->window()->bounds().size());
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90,
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90,
host_list[1]->compositor()->display_transform_hint());
EXPECT_EQ(display::Display::ROTATE_90, display_list[1].panel_rotation());
@ -3453,11 +3453,11 @@ TEST_F(DisplayManagerTest, UnifiedDesktopPrimarySizeWithRotatedDisplays) {
host_list = test_api.GetHosts();
display_list = display_manager()->software_mirroring_display_list();
EXPECT_EQ(gfx::Size(700, 1000), host_list[0]->window()->bounds().size());
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90,
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90,
host_list[0]->compositor()->display_transform_hint());
EXPECT_EQ(display::Display::ROTATE_90, display_list[0].panel_rotation());
EXPECT_EQ(gfx::Size(700, 1000), host_list[1]->window()->bounds().size());
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_270,
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270,
host_list[1]->compositor()->display_transform_hint());
EXPECT_EQ(display::Display::ROTATE_270, display_list[1].panel_rotation());
@ -3469,7 +3469,7 @@ TEST_F(DisplayManagerTest, UnifiedDesktopPrimarySizeWithRotatedDisplays) {
host_list = test_api.GetHosts();
display_list = display_manager()->software_mirroring_display_list();
EXPECT_EQ(gfx::Size(700, 1000), host_list[0]->window()->bounds().size());
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90,
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90,
host_list[0]->compositor()->display_transform_hint());
EXPECT_EQ(display::Display::ROTATE_90, display_list[0].panel_rotation());
EXPECT_EQ(gfx::Size(1000, 700), host_list[1]->window()->bounds().size());
@ -3485,15 +3485,15 @@ TEST_F(DisplayManagerTest, UnifiedDesktopPrimarySizeWithRotatedDisplays) {
host_list = test_api.GetHosts();
display_list = display_manager()->software_mirroring_display_list();
EXPECT_EQ(gfx::Size(700, 1000), host_list[0]->window()->bounds().size());
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_270,
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270,
host_list[0]->compositor()->display_transform_hint());
EXPECT_EQ(display::Display::ROTATE_270, display_list[0].panel_rotation());
EXPECT_EQ(gfx::Size(700, 1000), host_list[1]->window()->bounds().size());
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90,
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90,
host_list[1]->compositor()->display_transform_hint());
EXPECT_EQ(display::Display::ROTATE_90, display_list[1].panel_rotation());
EXPECT_EQ(gfx::Size(700, 1000), host_list[2]->window()->bounds().size());
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_270,
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270,
host_list[2]->compositor()->display_transform_hint());
EXPECT_EQ(display::Display::ROTATE_270, display_list[2].panel_rotation());
}

@ -154,7 +154,8 @@ TEST_F(SlimLayerTreeCompositorFrameTest, CompositorFrameMetadataBasics) {
layer_tree_->SetViewportRectAndScale(viewport_, /*device_scale_factor=*/2.0f,
local_surface_id_);
layer_tree_->set_background_color(SkColors::kBlue);
layer_tree_->set_display_transform_hint(gfx::OVERLAY_TRANSFORM_ROTATE_90);
layer_tree_->set_display_transform_hint(
gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90);
layer_tree_->UpdateTopControlsVisibleHeight(5.0f);
{
viz::CompositorFrame frame = ProduceFrame();
@ -164,7 +165,7 @@ TEST_F(SlimLayerTreeCompositorFrameTest, CompositorFrameMetadataBasics) {
EXPECT_EQ(sequence_id_, metadata.begin_frame_ack.frame_id.sequence_number);
EXPECT_EQ(2.0f, metadata.device_scale_factor);
EXPECT_EQ(SkColors::kBlue, metadata.root_background_color);
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90,
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90,
metadata.display_transform_hint);
EXPECT_EQ(5.0f, metadata.top_controls_visible_height);
}

@ -52,11 +52,11 @@ chromecast::media::VideoPlane::Transform ConvertTransform(
return chromecast::media::VideoPlane::FLIP_HORIZONTAL;
case gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL:
return chromecast::media::VideoPlane::FLIP_VERTICAL;
case gfx::OVERLAY_TRANSFORM_ROTATE_90:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90:
return chromecast::media::VideoPlane::ROTATE_90;
case gfx::OVERLAY_TRANSFORM_ROTATE_180:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180:
return chromecast::media::VideoPlane::ROTATE_180;
case gfx::OVERLAY_TRANSFORM_ROTATE_270:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270:
return chromecast::media::VideoPlane::ROTATE_270;
default:
NOTREACHED();

@ -4446,16 +4446,16 @@ TEST_F(DisplayTest, DisplayTransformHint) {
// Output size is always the display size when output surface does not
// support display transform hint.
{false, gfx::OVERLAY_TRANSFORM_NONE, kSize},
{false, gfx::OVERLAY_TRANSFORM_ROTATE_90, kSize},
{false, gfx::OVERLAY_TRANSFORM_ROTATE_180, kSize},
{false, gfx::OVERLAY_TRANSFORM_ROTATE_270, kSize},
{false, gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90, kSize},
{false, gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180, kSize},
{false, gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270, kSize},
// Output size is transposed on 90/270 degree rotation when output surface
// supports display transform hint.
{true, gfx::OVERLAY_TRANSFORM_NONE, kSize},
{true, gfx::OVERLAY_TRANSFORM_ROTATE_90, kTransposedSize},
{true, gfx::OVERLAY_TRANSFORM_ROTATE_180, kSize},
{true, gfx::OVERLAY_TRANSFORM_ROTATE_270, kTransposedSize},
{true, gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90, kTransposedSize},
{true, gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180, kSize},
{true, gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270, kTransposedSize},
};
size_t expected_frame_sent = 0u;

@ -76,11 +76,11 @@ gfx::OverlayTransform GetOverlayTransform(const gfx::Transform& quad_transform,
else if (x_to == AXIS_POS_X && y_to == AXIS_NEG_Y)
return gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL;
else if (x_to == AXIS_NEG_Y && y_to == AXIS_POS_X)
return gfx::OVERLAY_TRANSFORM_ROTATE_270;
return gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270;
else if (x_to == AXIS_NEG_X && y_to == AXIS_NEG_Y)
return gfx::OVERLAY_TRANSFORM_ROTATE_180;
return gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180;
else if (x_to == AXIS_POS_Y && y_to == AXIS_NEG_X)
return gfx::OVERLAY_TRANSFORM_ROTATE_90;
return gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90;
else
return gfx::OVERLAY_TRANSFORM_INVALID;
}

@ -761,32 +761,32 @@ TEST_F(TransformedOverlayClipRectTest, NoTransform) {
TEST_F(TransformedOverlayClipRectTest, Rotate90) {
// If the candidate is rotated by 90 degrees, the top-left corner of the quad
// corresponds to the bottom-left corner in UV space.
RunClipToTopLeftCornerTest(gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_90,
gfx::RectF(1, 1),
gfx::RectF(0.0f, 0.5f, 0.5f, 0.5f));
RunClipToTopLeftCornerTest(
gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90,
gfx::RectF(1, 1), gfx::RectF(0.0f, 0.5f, 0.5f, 0.5f));
}
TEST_F(TransformedOverlayClipRectTest, Rotate180) {
// If the candidate is rotated by 180 degrees, the top-left corner of the quad
// corresponds to the bottom-right corner in UV space.
RunClipToTopLeftCornerTest(
gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_180, gfx::RectF(1, 1),
gfx::RectF(0.5f, 0.5f, 0.5f, 0.5f));
gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180,
gfx::RectF(1, 1), gfx::RectF(0.5f, 0.5f, 0.5f, 0.5f));
}
TEST_F(TransformedOverlayClipRectTest, Rotate270) {
// If the candidate is rotated by 270 degrees, the top-left corner of the quad
// corresponds to the top-right corner in UV space.
RunClipToTopLeftCornerTest(
gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_270, gfx::RectF(1, 1),
gfx::RectF(0.5f, 0.0f, 0.5f, 0.5f));
gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270,
gfx::RectF(1, 1), gfx::RectF(0.5f, 0.0f, 0.5f, 0.5f));
}
TEST_F(TransformedOverlayClipRectTest, ClippedUvs) {
// Check that the clip is calculated correctly if the candidate's |uv_rect| is
// not full size, and offset from the origin.
RunClipToTopLeftCornerTest(
gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_180,
gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180,
gfx::RectF(0.1f, 0.2f, 0.4f, 0.4f), gfx::RectF(0.3f, 0.4f, 0.2f, 0.2f));
}

@ -88,7 +88,7 @@ TEST(OverlayProcessorSurfaceControlTest, DisplayTransformOverlay) {
OverlayProcessorSurfaceControl processor;
processor.SetViewportSize(gfx::Size(100, 200));
processor.SetDisplayTransformHint(gfx::OVERLAY_TRANSFORM_ROTATE_90);
processor.SetDisplayTransformHint(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90);
// First use a different transform than the display transform, the overlay is
// rejected.
@ -96,7 +96,7 @@ TEST(OverlayProcessorSurfaceControlTest, DisplayTransformOverlay) {
processor.CheckOverlaySupport(nullptr, &candidates);
EXPECT_FALSE(candidates.back().overlay_handled);
candidates.back().transform = gfx::OVERLAY_TRANSFORM_ROTATE_90;
candidates.back().transform = gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90;
processor.CheckOverlaySupport(nullptr, &candidates);
EXPECT_TRUE(candidates.back().overlay_handled);
EXPECT_EQ(absl::get<gfx::OverlayTransform>(candidates.back().transform),
@ -113,21 +113,22 @@ TEST(OverlayProcessorSurfaceControlTest, DisplayTransformOutputSurfaceOverlay) {
OverlayProcessorSurfaceControl processor;
processor.SetViewportSize(gfx::Size(100, 200));
processor.SetDisplayTransformHint(gfx::OVERLAY_TRANSFORM_ROTATE_90);
processor.SetDisplayTransformHint(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90);
processor.AdjustOutputSurfaceOverlay(&overlay_plane);
EXPECT_RECTF_EQ(overlay_plane.value().display_rect, gfx::RectF(200, 100));
EXPECT_EQ(overlay_plane.value().transform, gfx::OVERLAY_TRANSFORM_ROTATE_90);
EXPECT_EQ(overlay_plane.value().transform,
gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90);
}
TEST(OverlayCandidateValidatorTest, OverlayDamageRectForOutputSurface) {
OverlayCandidate candidate;
candidate.display_rect = gfx::RectF(10, 10, 50, 100);
candidate.transform = gfx::OVERLAY_TRANSFORM_ROTATE_90;
candidate.transform = gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90;
candidate.overlay_handled = false;
OverlayProcessorSurfaceControl processor;
processor.SetViewportSize(gfx::Size(100, 200));
processor.SetDisplayTransformHint(gfx::OVERLAY_TRANSFORM_ROTATE_90);
processor.SetDisplayTransformHint(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90);
OverlayCandidateList candidates;
candidates.push_back(candidate);

@ -2590,7 +2590,7 @@ TEST_F(UnderlayTest, Allow90DegreeRotation) {
std::move(surface_damage_rect_list), nullptr, &candidate_list,
&damage_rect_, &content_bounds_);
ASSERT_EQ(1U, candidate_list.size());
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90,
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90,
absl::get<gfx::OverlayTransform>(candidate_list.back().transform));
}
@ -2617,7 +2617,7 @@ TEST_F(UnderlayTest, Allow180DegreeRotation) {
std::move(surface_damage_rect_list), nullptr, &candidate_list,
&damage_rect_, &content_bounds_);
ASSERT_EQ(1U, candidate_list.size());
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_180,
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180,
absl::get<gfx::OverlayTransform>(candidate_list.back().transform));
}
@ -2644,7 +2644,7 @@ TEST_F(UnderlayTest, Allow270DegreeRotation) {
std::move(surface_damage_rect_list), nullptr, &candidate_list,
&damage_rect_, &content_bounds_);
ASSERT_EQ(1U, candidate_list.size());
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_270,
EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270,
absl::get<gfx::OverlayTransform>(candidate_list.back().transform));
}

@ -9242,7 +9242,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, DisplayTransformDamageCallback) {
auto frame =
aggregator_.Aggregate(root_surface_id_, GetNextDisplayTimeAndIncrement(),
gfx::OVERLAY_TRANSFORM_ROTATE_90);
gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90);
gfx::Rect transformed_rect(surface_size.height(), surface_size.width());
EXPECT_EQ(frame.render_pass_list.back()->output_rect, transformed_rect);
EXPECT_EQ(frame.render_pass_list.back()->damage_rect, transformed_rect);

@ -616,14 +616,14 @@ void SkiaOutputDeviceBufferQueue::DoFinishSwapBuffers(
gfx::Size SkiaOutputDeviceBufferQueue::GetSwapBuffersSize() {
switch (overlay_transform_) {
case gfx::OVERLAY_TRANSFORM_ROTATE_90:
case gfx::OVERLAY_TRANSFORM_ROTATE_270:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270:
return gfx::Size(image_size_.height(), image_size_.width());
case gfx::OVERLAY_TRANSFORM_INVALID:
case gfx::OVERLAY_TRANSFORM_NONE:
case gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL:
case gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL:
case gfx::OVERLAY_TRANSFORM_ROTATE_180:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180:
return image_size_;
}
}

@ -37,11 +37,11 @@ VkSurfaceTransformFlagBitsKHR ToVkSurfaceTransformFlag(
return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR;
case gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL:
return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR;
case gfx::OVERLAY_TRANSFORM_ROTATE_90:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90:
return VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR;
case gfx::OVERLAY_TRANSFORM_ROTATE_180:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180:
return VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR;
case gfx::OVERLAY_TRANSFORM_ROTATE_270:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270:
return VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR;
default:
NOTREACHED() << "transform:" << transform;
@ -59,11 +59,11 @@ gfx::OverlayTransform FromVkSurfaceTransformFlag(
case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
return gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL;
case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
return gfx::OVERLAY_TRANSFORM_ROTATE_90;
return gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90;
case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
return gfx::OVERLAY_TRANSFORM_ROTATE_180;
return gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180;
case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
return gfx::OVERLAY_TRANSFORM_ROTATE_270;
return gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270;
default:
NOTREACHED() << "transform:" << transform;
return gfx::OVERLAY_TRANSFORM_INVALID;
@ -285,8 +285,8 @@ bool VulkanSurface::CreateSwapChain(const gfx::Size& size,
image_size.SetSize(surface_caps.currentExtent.width,
surface_caps.currentExtent.height);
}
if (transform == gfx::OVERLAY_TRANSFORM_ROTATE_90 ||
transform == gfx::OVERLAY_TRANSFORM_ROTATE_270) {
if (transform == gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90 ||
transform == gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270) {
image_size.SetSize(image_size.height(), image_size.width());
}
}

@ -139,11 +139,11 @@ final class OverlayTransformApiHelper
case SurfaceControl.BUFFER_TRANSFORM_MIRROR_VERTICAL:
return OverlayTransform.FLIP_VERTICAL;
case SurfaceControl.BUFFER_TRANSFORM_ROTATE_90:
return OverlayTransform.ROTATE_90;
return OverlayTransform.ROTATE_CLOCKWISE_90;
case SurfaceControl.BUFFER_TRANSFORM_ROTATE_180:
return OverlayTransform.ROTATE_180;
return OverlayTransform.ROTATE_CLOCKWISE_180;
case SurfaceControl.BUFFER_TRANSFORM_ROTATE_270:
return OverlayTransform.ROTATE_270;
return OverlayTransform.ROTATE_CLOCKWISE_270;
// Combination cases between BUFFER_TRANSFORM_MIRROR_HORIZONTAL,
// BUFFER_TRANSFORM_MIRROR_VERTICAL, BUFFER_TRANSFORM_ROTATE_90 are not handled
// because expected behavior is under-specified by android APIs

@ -990,11 +990,11 @@ public class WindowAndroid implements AndroidPermissionDelegate, DisplayAndroidO
case Surface.ROTATION_0:
return OverlayTransform.NONE;
case Surface.ROTATION_90:
return OverlayTransform.ROTATE_90;
return OverlayTransform.ROTATE_CLOCKWISE_90;
case Surface.ROTATION_180:
return OverlayTransform.ROTATE_180;
return OverlayTransform.ROTATE_CLOCKWISE_180;
case Surface.ROTATION_270:
return OverlayTransform.ROTATE_270;
return OverlayTransform.ROTATE_CLOCKWISE_270;
default:
return OverlayTransform.NONE;
}

@ -255,9 +255,9 @@ void WindowTreeHost::UpdateCompositorScaleAndSize(
const gfx::Size& new_size_in_pixels) {
gfx::Rect new_bounds(new_size_in_pixels);
if (compositor_->display_transform_hint() ==
gfx::OVERLAY_TRANSFORM_ROTATE_90 ||
gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90 ||
compositor_->display_transform_hint() ==
gfx::OVERLAY_TRANSFORM_ROTATE_270) {
gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270) {
new_bounds.Transpose();
}

@ -624,8 +624,9 @@ TEST_F(WindowTest, WindowEmbeddingClientHasValidLocalSurfaceId) {
TEST_F(WindowTest, MoveCursorToWithTransformRootWindow) {
gfx::Transform transform;
transform.Translate(100.0, 100.0);
transform = transform * OverlayTransformToTransform(
gfx::OVERLAY_TRANSFORM_ROTATE_90, gfx::SizeF());
transform =
transform * OverlayTransformToTransform(
gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90, gfx::SizeF());
transform.Scale(2.0, 5.0);
host()->SetRootTransform(transform);
host()->MoveCursorToLocationInDIP(gfx::Point(10, 10));
@ -657,8 +658,9 @@ TEST_F(WindowTest, MoveCursorToWithTransformWindow) {
display::Screen::GetScreen()->GetCursorScreenPoint().ToString());
gfx::Transform transform3;
transform3 = transform3 * OverlayTransformToTransform(
gfx::OVERLAY_TRANSFORM_ROTATE_90, gfx::SizeF());
transform3 = transform3 *
OverlayTransformToTransform(
gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90, gfx::SizeF());
w1->SetTransform(transform3);
w1->MoveCursorTo(gfx::Point(5, 5));
EXPECT_EQ("5,15",
@ -666,8 +668,9 @@ TEST_F(WindowTest, MoveCursorToWithTransformWindow) {
gfx::Transform transform4;
transform4.Translate(100.0, 100.0);
transform4 = transform4 * OverlayTransformToTransform(
gfx::OVERLAY_TRANSFORM_ROTATE_90, gfx::SizeF());
transform4 = transform4 *
OverlayTransformToTransform(
gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90, gfx::SizeF());
transform4.Scale(2.0, 5.0);
w1->SetTransform(transform4);
w1->MoveCursorTo(gfx::Point(10, 10));
@ -692,8 +695,9 @@ TEST_F(WindowTest, MoveCursorToWithComplexTransform) {
gfx::Transform root_transform;
root_transform.Translate(60.0, 70.0);
root_transform =
root_transform * OverlayTransformToTransform(
gfx::OVERLAY_TRANSFORM_ROTATE_270, gfx::SizeF());
root_transform *
OverlayTransformToTransform(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270,
gfx::SizeF());
root_transform.Translate(-50.0, -50.0);
root_transform.Scale(2.0, 3.0);
@ -1834,7 +1838,7 @@ TEST_F(WindowTest, Transform) {
// Rotate it clock-wise 90 degrees.
host()->SetRootTransform(OverlayTransformToTransform(
gfx::OVERLAY_TRANSFORM_ROTATE_90, gfx::SizeF(size)));
gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90, gfx::SizeF(size)));
// The size should be the transformed size.
gfx::Size transformed_size(size.height(), size.width());
@ -1860,7 +1864,7 @@ TEST_F(WindowTest, TransformGesture) {
// Rotate the root-window clock-wise 90 degrees.
host()->SetRootTransform(OverlayTransformToTransform(
gfx::OVERLAY_TRANSFORM_ROTATE_90, gfx::SizeF(size)));
gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90, gfx::SizeF(size)));
ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(size.height() - 10, 10),
getTime(),

@ -32,11 +32,11 @@ gfx::OverlayTransform DisplayRotationToOverlayTransform(
case display::Display::ROTATE_0:
return gfx::OVERLAY_TRANSFORM_NONE;
case display::Display::ROTATE_90:
return gfx::OVERLAY_TRANSFORM_ROTATE_90;
return gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90;
case display::Display::ROTATE_180:
return gfx::OVERLAY_TRANSFORM_ROTATE_180;
return gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180;
case display::Display::ROTATE_270:
return gfx::OVERLAY_TRANSFORM_ROTATE_270;
return gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270;
}
NOTREACHED();
return gfx::OVERLAY_TRANSFORM_NONE;

@ -337,11 +337,11 @@ int32_t OverlayTransformToWindowTransform(gfx::OverlayTransform transform) {
return ANATIVEWINDOW_TRANSFORM_MIRROR_HORIZONTAL;
case gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL:
return ANATIVEWINDOW_TRANSFORM_MIRROR_VERTICAL;
case gfx::OVERLAY_TRANSFORM_ROTATE_90:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90:
return ANATIVEWINDOW_TRANSFORM_ROTATE_270;
case gfx::OVERLAY_TRANSFORM_ROTATE_180:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180:
return ANATIVEWINDOW_TRANSFORM_ROTATE_180;
case gfx::OVERLAY_TRANSFORM_ROTATE_270:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270:
return ANATIVEWINDOW_TRANSFORM_ROTATE_90;
};
NOTREACHED();

@ -10,8 +10,8 @@ enum OverlayTransform {
OVERLAY_TRANSFORM_NONE,
OVERLAY_TRANSFORM_FLIP_HORIZONTAL,
OVERLAY_TRANSFORM_FLIP_VERTICAL,
OVERLAY_TRANSFORM_ROTATE_90,
OVERLAY_TRANSFORM_ROTATE_180,
OVERLAY_TRANSFORM_ROTATE_270,
OVERLAY_TRANSFORM_LAST = OVERLAY_TRANSFORM_ROTATE_270
OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90,
OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180,
OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270,
OVERLAY_TRANSFORM_LAST = OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270
};

@ -23,12 +23,15 @@ struct EnumTraits<gfx::mojom::OverlayTransform, gfx::OverlayTransform> {
return gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_FLIP_HORIZONTAL;
case gfx::OverlayTransform::OVERLAY_TRANSFORM_FLIP_VERTICAL:
return gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_FLIP_VERTICAL;
case gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_90:
return gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_90;
case gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_180:
return gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_180;
case gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_270:
return gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_270;
case gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90:
return gfx::mojom::OverlayTransform::
OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90;
case gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180:
return gfx::mojom::OverlayTransform::
OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180;
case gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270:
return gfx::mojom::OverlayTransform::
OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270;
}
NOTREACHED();
return gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_INVALID;
@ -49,14 +52,14 @@ struct EnumTraits<gfx::mojom::OverlayTransform, gfx::OverlayTransform> {
case gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_FLIP_VERTICAL:
*out = gfx::OverlayTransform::OVERLAY_TRANSFORM_FLIP_VERTICAL;
return true;
case gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_90:
*out = gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_90;
case gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90:
*out = gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90;
return true;
case gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_180:
*out = gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_180;
case gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180:
*out = gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180;
return true;
case gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_270:
*out = gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_270;
case gfx::mojom::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270:
*out = gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270;
return true;
}
NOTREACHED();

@ -17,10 +17,10 @@ enum OverlayTransform : uint8_t {
OVERLAY_TRANSFORM_NONE,
OVERLAY_TRANSFORM_FLIP_HORIZONTAL,
OVERLAY_TRANSFORM_FLIP_VERTICAL,
OVERLAY_TRANSFORM_ROTATE_90,
OVERLAY_TRANSFORM_ROTATE_180,
OVERLAY_TRANSFORM_ROTATE_270,
OVERLAY_TRANSFORM_LAST = OVERLAY_TRANSFORM_ROTATE_270
OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90,
OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180,
OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270,
OVERLAY_TRANSFORM_LAST = OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270
};
} // namespace gfx

@ -21,12 +21,12 @@ Transform OverlayTransformToTransform(OverlayTransform overlay_transform,
return Transform::Affine(-1, 0, 0, 1, viewport_bounds.width(), 0);
case OVERLAY_TRANSFORM_FLIP_VERTICAL:
return Transform::Affine(1, 0, 0, -1, 0, viewport_bounds.height());
case OVERLAY_TRANSFORM_ROTATE_90:
case OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90:
return Transform::Affine(0, 1, -1, 0, viewport_bounds.height(), 0);
case OVERLAY_TRANSFORM_ROTATE_180:
case OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180:
return Transform::Affine(-1, 0, 0, -1, viewport_bounds.width(),
viewport_bounds.height());
case OVERLAY_TRANSFORM_ROTATE_270:
case OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270:
return Transform::Affine(0, -1, 1, 0, 0, viewport_bounds.width());
}
@ -45,12 +45,12 @@ OverlayTransform InvertOverlayTransform(OverlayTransform transform) {
return OVERLAY_TRANSFORM_FLIP_HORIZONTAL;
case OVERLAY_TRANSFORM_FLIP_VERTICAL:
return OVERLAY_TRANSFORM_FLIP_VERTICAL;
case OVERLAY_TRANSFORM_ROTATE_90:
return OVERLAY_TRANSFORM_ROTATE_270;
case OVERLAY_TRANSFORM_ROTATE_180:
return OVERLAY_TRANSFORM_ROTATE_180;
case OVERLAY_TRANSFORM_ROTATE_270:
return OVERLAY_TRANSFORM_ROTATE_90;
case OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90:
return OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270;
case OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180:
return OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180;
case OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270:
return OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90;
}
NOTREACHED();
return OVERLAY_TRANSFORM_NONE;

@ -23,9 +23,9 @@ TEST(OverlayTransformUtilTest, All) {
{OVERLAY_TRANSFORM_NONE, Rect(10, 10, 50, 100)},
{OVERLAY_TRANSFORM_FLIP_HORIZONTAL, Rect(40, 10, 50, 100)},
{OVERLAY_TRANSFORM_FLIP_VERTICAL, Rect(10, 90, 50, 100)},
{OVERLAY_TRANSFORM_ROTATE_90, Rect(90, 10, 100, 50)},
{OVERLAY_TRANSFORM_ROTATE_180, Rect(40, 90, 50, 100)},
{OVERLAY_TRANSFORM_ROTATE_270, Rect(10, 40, 100, 50)},
{OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90, Rect(90, 10, 100, 50)},
{OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180, Rect(40, 90, 50, 100)},
{OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270, Rect(10, 40, 100, 50)},
};
for (const auto& test_case : test_cases) {

@ -30,11 +30,11 @@ uint32_t OverlayTransformToDrmRotationPropertyValue(
// Driver code swaps 90 and 270 to be compliant with how xrandr uses these
// values, so we need to invert them here as well to get them back to the
// proper value.
case gfx::OVERLAY_TRANSFORM_ROTATE_90:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90:
return DRM_MODE_ROTATE_270;
case gfx::OVERLAY_TRANSFORM_ROTATE_180:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180:
return DRM_MODE_ROTATE_180;
case gfx::OVERLAY_TRANSFORM_ROTATE_270:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270:
return DRM_MODE_ROTATE_90;
default:
NOTREACHED();
@ -53,8 +53,8 @@ uint32_t OverlayTransformToDrmRotationPropertyValue(
bool IsRotationTransformSupported(gfx::OverlayTransform transform,
uint32_t format_fourcc,
bool is_original_buffer) {
if ((transform == gfx::OVERLAY_TRANSFORM_ROTATE_90) ||
(transform == gfx::OVERLAY_TRANSFORM_ROTATE_270) ||
if ((transform == gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90) ||
(transform == gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270) ||
(transform == gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL)) {
if (is_original_buffer && (format_fourcc == DRM_FORMAT_NV12 ||
format_fourcc == DRM_FORMAT_P010)) {

@ -1604,7 +1604,8 @@ TEST_P(HardwareDisplayPlaneManagerAtomicTest, OriginalModifiersSupportOnly) {
DrmFramebuffer::AddFramebuffer(fake_drm_, buffer.get(),
kDefaultBufferSize, {}, true);
assigns.emplace_back(framebuffer_original, nullptr);
assigns.back().plane_transform = gfx::OVERLAY_TRANSFORM_ROTATE_270;
assigns.back().plane_transform =
gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270;
fake_drm_->plane_manager()->BeginFrame(&state_);
// Rotation should be supported for this buffer as it is the original buffer
@ -1631,7 +1632,8 @@ TEST_P(HardwareDisplayPlaneManagerAtomicTest, OriginalModifiersSupportOnly) {
DrmFramebuffer::AddFramebuffer(fake_drm_, buffer.get(),
kDefaultBufferSize, {}, false);
assigns.emplace_back(framebuffer_non_original, nullptr);
assigns.back().plane_transform = gfx::OVERLAY_TRANSFORM_ROTATE_270;
assigns.back().plane_transform =
gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270;
EXPECT_FALSE(fake_drm_->plane_manager()->AssignOverlayPlanes(
&state_, assigns, fake_drm_->crtc_property(0).id));
}

@ -59,19 +59,19 @@ OverlayTransformFlatlandProperties OverlayTransformToFlatlandProperties(
.image_flip = fuchsia::ui::composition::ImageFlip::NONE};
// gfx::OverlayTransform and Flatland rotate in opposite directions relative
// to each other, so swap 90 and 270.
case gfx::OVERLAY_TRANSFORM_ROTATE_90:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90:
return {
.translation = {rounded_bounds.x() + rounded_bounds.width(),
rounded_bounds.y()},
.orientation = fuchsia::ui::composition::Orientation::CCW_270_DEGREES,
.image_flip = fuchsia::ui::composition::ImageFlip::NONE};
case gfx::OVERLAY_TRANSFORM_ROTATE_180:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180:
return {
.translation = {rounded_bounds.x() + rounded_bounds.width(),
rounded_bounds.y() + rounded_bounds.height()},
.orientation = fuchsia::ui::composition::Orientation::CCW_180_DEGREES,
.image_flip = fuchsia::ui::composition::ImageFlip::NONE};
case gfx::OVERLAY_TRANSFORM_ROTATE_270:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270:
return {
.translation = {rounded_bounds.x(),
rounded_bounds.y() + rounded_bounds.height()},
@ -104,8 +104,8 @@ OverlayTransformFlatlandProperties OverlayTransformToFlatlandProperties(
fuchsia::math::SizeU GfxSizeToFuchsiaSize(
const gfx::Size& size,
gfx::OverlayTransform plane_transform = gfx::OVERLAY_TRANSFORM_NONE) {
if (plane_transform == gfx::OVERLAY_TRANSFORM_ROTATE_90 ||
plane_transform == gfx::OVERLAY_TRANSFORM_ROTATE_270) {
if (plane_transform == gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90 ||
plane_transform == gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270) {
return fuchsia::math::SizeU{static_cast<uint32_t>(size.height()),
static_cast<uint32_t>(size.width())};
}

@ -322,17 +322,17 @@ INSTANTIATE_TEST_SUITE_P(
ImageFlip::NONE,
Vec{10, 20},
SizeU{120U, 115U}),
std::make_tuple(gfx::OVERLAY_TRANSFORM_ROTATE_90,
std::make_tuple(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90,
Orientation::CCW_270_DEGREES,
ImageFlip::NONE,
Vec{130, 20},
SizeU{115U, 120U}),
std::make_tuple(gfx::OVERLAY_TRANSFORM_ROTATE_180,
std::make_tuple(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180,
Orientation::CCW_180_DEGREES,
ImageFlip::NONE,
Vec{130, 135},
SizeU{120U, 115U}),
std::make_tuple(gfx::OVERLAY_TRANSFORM_ROTATE_270,
std::make_tuple(gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270,
Orientation::CCW_90_DEGREES,
ImageFlip::NONE,
Vec{10, 135},

@ -132,11 +132,11 @@ wl_output_transform ToWaylandTransform(gfx::OverlayTransform transform) {
// directions relative to each other, so swap 90 and 270.
// TODO(rivr): Currently all wl_buffers are created without y inverted, so
// this may need to be revisited if that changes.
case gfx::OVERLAY_TRANSFORM_ROTATE_90:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90:
return WL_OUTPUT_TRANSFORM_270;
case gfx::OVERLAY_TRANSFORM_ROTATE_180:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_180:
return WL_OUTPUT_TRANSFORM_180;
case gfx::OVERLAY_TRANSFORM_ROTATE_270:
case gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270:
return WL_OUTPUT_TRANSFORM_90;
default:
break;

@ -1374,7 +1374,8 @@ TEST_P(WaylandSurfaceFactoryCompositorV3, SurfaceDamageTest) {
presenter->ScheduleOverlayPlane(
fake_overlay_image[0]->GetNativePixmap(), nullptr,
gfx::OverlayPlaneData(
INT32_MIN, gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_270,
INT32_MIN,
gfx::OverlayTransform::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_270,
gfx::RectF(window_->GetBoundsInPixels()), crop_uv, false,
surface_damage_rect, 1.0f, gfx::OverlayPriorityHint::kNone,
gfx::RRectF(), gfx::ColorSpace::CreateSRGB(), absl::nullopt));

@ -48,7 +48,7 @@ class WaylandOverlayConfigStructTraitsTest
} // namespace
TEST_F(WaylandOverlayConfigStructTraitsTest, OverlayTransform) {
const gfx::OverlayTransform t = gfx::OVERLAY_TRANSFORM_ROTATE_90;
const gfx::OverlayTransform t = gfx::OVERLAY_TRANSFORM_ROTATE_CLOCKWISE_90;
absl::variant<gfx::OverlayTransform, gfx::Transform> input(t);
mojo::Remote<mojom::ConfigTraitsTestService> remote = GetTraitsTestRemote();
absl::variant<gfx::OverlayTransform, gfx::Transform> output;