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:

committed by
Chromium LUCI CQ

parent
083ad62008
commit
316d5fb98d
ash/display
cc/slim
chromecast/media/base
components/viz/service
display
display_unittest.ccoverlay_candidate_factory.ccoverlay_candidate_factory_unittest.ccoverlay_processor_surface_control_unittest.ccoverlay_unittest.ccsurface_aggregator_unittest.cc
display_embedder
gpu/vulkan
ui
android
java
src
org
chromium
aura
display
gfx
ozone
@ -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;
|
||||
|
Reference in New Issue
Block a user