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}

ash/display/display_manager_unittest.cc

@@ -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());
 }

cc/slim/slim_layer_tree_compositor_frame_unittest.cc

@@ -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);
   }

chromecast/media/base/video_plane_controller.cc

@@ -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();

components/viz/service/display/display_unittest.cc

@@ -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;

components/viz/service/display/overlay_candidate_factory.cc

@@ -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;
 }

components/viz/service/display/overlay_candidate_factory_unittest.cc

@@ -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));
 }
 

components/viz/service/display/overlay_processor_surface_control_unittest.cc

@@ -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);

components/viz/service/display/overlay_unittest.cc

@@ -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));
 }
 

components/viz/service/display/surface_aggregator_unittest.cc

@@ -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);

components/viz/service/display_embedder/skia_output_device_buffer_queue.cc

@@ -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_;
   }
 }

gpu/vulkan/vulkan_surface.cc

@@ -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());
     }
   }

ui/android/java/src/org/chromium/ui/base/OverlayTransformApiHelper.java

@@ -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

ui/android/java/src/org/chromium/ui/base/WindowAndroid.java

@@ -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;
             }

ui/aura/window_tree_host.cc

@@ -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();
   }
 

ui/aura/window_unittest.cc

@@ -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(),

ui/display/display_transform.cc

@@ -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;

ui/gfx/android/android_surface_control_compat.cc

@@ -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();

ui/gfx/mojom/overlay_transform.mojom

@@ -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
 };

ui/gfx/mojom/overlay_transform_mojom_traits.h

@@ -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();

ui/gfx/overlay_transform.h

@@ -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

ui/gfx/overlay_transform_utils.cc

@@ -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;

ui/gfx/overlay_transform_utils_unittest.cc

@@ -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) {

ui/ozone/platform/drm/gpu/hardware_display_plane_atomic.cc

@@ -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)) {

ui/ozone/platform/drm/gpu/hardware_display_plane_manager_unittest.cc

@@ -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));
   }

ui/ozone/platform/flatland/flatland_surface.cc

@@ -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())};
   }

ui/ozone/platform/flatland/flatland_surface_unittest.cc

@@ -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},

ui/ozone/platform/wayland/common/wayland_util.cc

@@ -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;

ui/ozone/platform/wayland/gpu/wayland_surface_factory_unittest.cc

@@ -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));

ui/ozone/platform/wayland/mojom/wayland_overlay_config_mojom_traits_unittest.cc

@@ -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;