diff --git a/components/viz/service/display/DEPS b/components/viz/service/display/DEPS
index 2e7a97a885a27..efe3b8e5c1993 100644
--- a/components/viz/service/display/DEPS
+++ b/components/viz/service/display/DEPS
@@ -35,7 +35,7 @@ include_rules = [
   "+ui/gfx/hdr_metadata.h",
   "+ui/gfx/video_types.h",
   "+ui/gl/ca_renderer_layer_params.h",
-  "+ui/gl/dc_renderer_layer_params.h",
+  "+ui/gl/dc_layer_overlay_params.h",
   "+ui/gl/direct_composition_support.h",
   "+ui/gl/gl_fence.h",
   "+ui/gl/gl_utils.h",
diff --git a/components/viz/service/display/dc_layer_overlay.cc b/components/viz/service/display/dc_layer_overlay.cc
index f013ae509f0de..e0e4b2aaea45e 100644
--- a/components/viz/service/display/dc_layer_overlay.cc
+++ b/components/viz/service/display/dc_layer_overlay.cc
@@ -138,7 +138,7 @@ DCLayerResult ValidateYUVQuad(
 
 void FromYUVQuad(const YUVVideoDrawQuad* quad,
                  const gfx::Transform& transform_to_root_target,
-                 DCLayerOverlay* dc_layer) {
+                 DCLayerOverlayCandidate* dc_layer) {
   // Direct composition path only supports single NV12 buffer, or two buffers
   // one each for Y and UV planes.
   DCHECK(quad->y_plane_resource_id() && quad->u_plane_resource_id());
@@ -200,7 +200,7 @@ DCLayerResult ValidateTextureQuad(
 
 void FromTextureQuad(const TextureDrawQuad* quad,
                      const gfx::Transform& transform_to_root_target,
-                     DCLayerOverlay* dc_layer) {
+                     DCLayerOverlayCandidate* dc_layer) {
   dc_layer->resources[kTextureResourceIndex] = quad->resource_id();
   dc_layer->z_order = 1;
   dc_layer->content_rect = gfx::Rect(quad->resource_size_in_pixels());
@@ -422,9 +422,10 @@ void RecordDCLayerResult(DCLayerResult result, QuadList::ConstIterator it) {
 }
 
 // This function records the damage rect rect of the current frame.
-void RecordOverlayHistograms(DCLayerOverlayList* dc_layer_overlays,
-                             bool has_occluding_surface_damage,
-                             const gfx::Rect* damage_rect) {
+void RecordOverlayHistograms(
+    std::vector<DCLayerOverlayCandidate>* dc_layer_overlays,
+    bool has_occluding_surface_damage,
+    const gfx::Rect* damage_rect) {
   // If an underlay is found, we record the damage rect of this frame as an
   // underlay.
   bool is_overlay = true;
@@ -472,11 +473,12 @@ bool IsClearVideoQuad(const QuadList::ConstIterator& it) {
 
 }  // namespace
 
-DCLayerOverlay::DCLayerOverlay() = default;
-DCLayerOverlay::DCLayerOverlay(const DCLayerOverlay& other) = default;
-DCLayerOverlay& DCLayerOverlay::operator=(const DCLayerOverlay& other) =
-    default;
-DCLayerOverlay::~DCLayerOverlay() = default;
+DCLayerOverlayCandidate::DCLayerOverlayCandidate() = default;
+DCLayerOverlayCandidate::DCLayerOverlayCandidate(
+    const DCLayerOverlayCandidate& other) = default;
+DCLayerOverlayCandidate& DCLayerOverlayCandidate::operator=(
+    const DCLayerOverlayCandidate& other) = default;
+DCLayerOverlayCandidate::~DCLayerOverlayCandidate() = default;
 
 DCLayerOverlayProcessor::DCLayerOverlayProcessor(
     const DebugRendererSettings* debug_settings,
@@ -614,7 +616,7 @@ void DCLayerOverlayProcessor::UpdateRootDamageRect(
 }
 
 void DCLayerOverlayProcessor::InsertDebugBorderDrawQuad(
-    const DCLayerOverlayList* dc_layer_overlays,
+    const std::vector<DCLayerOverlayCandidate>* dc_layer_overlays,
     AggregatedRenderPass* render_pass,
     const gfx::RectF& display_rect,
     gfx::Rect* damage_rect) {
@@ -732,7 +734,7 @@ void DCLayerOverlayProcessor::Process(
     AggregatedRenderPass* render_pass,
     gfx::Rect* damage_rect,
     SurfaceDamageRectList surface_damage_rect_list,
-    DCLayerOverlayList* dc_layer_overlays,
+    std::vector<DCLayerOverlayCandidate>* dc_layer_overlays,
     bool is_video_capture_enabled,
     bool is_page_fullscreen_mode) {
   bool this_frame_has_occluding_damage_rect = false;
@@ -1055,12 +1057,12 @@ void DCLayerOverlayProcessor::UpdateDCLayerOverlays(
     QuadList::Iterator* new_it,
     size_t* new_index,
     gfx::Rect* damage_rect,
-    DCLayerOverlayList* dc_layer_overlays,
+    std::vector<DCLayerOverlayCandidate>* dc_layer_overlays,
     bool is_page_fullscreen_mode) {
   // Record the result first before ProcessForOverlay().
   RecordDCLayerResult(DC_LAYER_SUCCESS, it);
 
-  DCLayerOverlay dc_layer;
+  DCLayerOverlayCandidate dc_layer;
   dc_layer.is_video_fullscreen_letterboxing =
       is_page_fullscreen_mode
           ? IsFullScreenLetterboxing(it, render_pass->quad_list.end(),
@@ -1133,7 +1135,7 @@ void DCLayerOverlayProcessor::ProcessForUnderlay(
     const QuadList::Iterator& it,
     size_t processed_overlay_count,
     gfx::Rect* damage_rect,
-    DCLayerOverlay* dc_layer) {
+    DCLayerOverlayCandidate* dc_layer) {
   // Assign decreasing z-order so that underlays processed earlier, and hence
   // which are above the subsequent underlays, are placed above in the direct
   // composition visual tree.
diff --git a/components/viz/service/display/dc_layer_overlay.h b/components/viz/service/display/dc_layer_overlay.h
index 13f0b07aefaa8..82c6908c1b69a 100644
--- a/components/viz/service/display/dc_layer_overlay.h
+++ b/components/viz/service/display/dc_layer_overlay.h
@@ -26,14 +26,14 @@ class DisplayResourceProvider;
 
 // TODO(weiliangc): Eventually fold this into OverlayProcessorWin and
 // OverlayCandidate class.
-// Holds all information necessary to construct a
-// DCLayer from a DrawQuad.
-class VIZ_SERVICE_EXPORT DCLayerOverlay {
+// Holds all information necessary to construct a direct composition overlay
+// from a DrawQuad.
+class VIZ_SERVICE_EXPORT DCLayerOverlayCandidate {
  public:
-  DCLayerOverlay();
-  DCLayerOverlay(const DCLayerOverlay& other);
-  DCLayerOverlay& operator=(const DCLayerOverlay& other);
-  ~DCLayerOverlay();
+  DCLayerOverlayCandidate();
+  DCLayerOverlayCandidate(const DCLayerOverlayCandidate& other);
+  DCLayerOverlayCandidate& operator=(const DCLayerOverlayCandidate& other);
+  ~DCLayerOverlayCandidate();
 
   // Resource ids for video Y and UV planes, a single NV12 image, or a swap
   // chain image. See DirectCompositionSurfaceWin for details.
@@ -73,8 +73,6 @@ class VIZ_SERVICE_EXPORT DCLayerOverlay {
   bool is_video_fullscreen_letterboxing = false;
 };
 
-typedef std::vector<DCLayerOverlay> DCLayerOverlayList;
-
 class VIZ_SERVICE_EXPORT DCLayerOverlayProcessor final
     : public gl::DirectCompositionOverlayCapsObserver {
  public:
@@ -100,7 +98,7 @@ class VIZ_SERVICE_EXPORT DCLayerOverlayProcessor final
                        AggregatedRenderPass* render_pass,
                        gfx::Rect* damage_rect,
                        SurfaceDamageRectList surface_damage_rect_list,
-                       DCLayerOverlayList* dc_layer_overlays,
+                       std::vector<DCLayerOverlayCandidate>* dc_layer_overlays,
                        bool is_video_capture_enabled,
                        bool is_page_fullscreen_mode);
   void ClearOverlayState();
@@ -124,17 +122,18 @@ class VIZ_SERVICE_EXPORT DCLayerOverlayProcessor final
 
   // UpdateDCLayerOverlays() adds the quad at |it| to the overlay list
   // |dc_layer_overlays|.
-  void UpdateDCLayerOverlays(const gfx::RectF& display_rect,
-                             AggregatedRenderPass* render_pass,
-                             const QuadList::Iterator& it,
-                             const gfx::Rect& quad_rectangle_in_target_space,
-                             const gfx::Rect& occluding_damage_rect,
-                             bool is_overlay,
-                             QuadList::Iterator* new_it,
-                             size_t* new_index,
-                             gfx::Rect* damage_rect,
-                             DCLayerOverlayList* dc_layer_overlays,
-                             bool is_page_fullscreen_mode);
+  void UpdateDCLayerOverlays(
+      const gfx::RectF& display_rect,
+      AggregatedRenderPass* render_pass,
+      const QuadList::Iterator& it,
+      const gfx::Rect& quad_rectangle_in_target_space,
+      const gfx::Rect& occluding_damage_rect,
+      bool is_overlay,
+      QuadList::Iterator* new_it,
+      size_t* new_index,
+      gfx::Rect* damage_rect,
+      std::vector<DCLayerOverlayCandidate>* dc_layer_overlays,
+      bool is_page_fullscreen_mode);
 
   // Returns an iterator to the element after |it|.
   QuadList::Iterator ProcessForOverlay(const gfx::RectF& display_rect,
@@ -149,7 +148,7 @@ class VIZ_SERVICE_EXPORT DCLayerOverlayProcessor final
                           const QuadList::Iterator& it,
                           size_t processed_overlay_count,
                           gfx::Rect* damage_rect,
-                          DCLayerOverlay* dc_layer);
+                          DCLayerOverlayCandidate* dc_layer);
 
   void UpdateRootDamageRect(const gfx::RectF& display_rect,
                             gfx::Rect* damage_rect);
@@ -159,10 +158,11 @@ class VIZ_SERVICE_EXPORT DCLayerOverlayProcessor final
                                const gfx::Rect& occluding_damage_rect,
                                gfx::Rect* damage_rect);
 
-  void InsertDebugBorderDrawQuad(const DCLayerOverlayList* dc_layer_overlays,
-                                 AggregatedRenderPass* render_pass,
-                                 const gfx::RectF& display_rect,
-                                 gfx::Rect* damage_rect);
+  void InsertDebugBorderDrawQuad(
+      const std::vector<DCLayerOverlayCandidate>* dc_layer_overlays,
+      AggregatedRenderPass* render_pass,
+      const gfx::RectF& display_rect,
+      gfx::Rect* damage_rect);
   bool IsPreviousFrameUnderlayRect(const gfx::Rect& quad_rectangle,
                                    size_t index);
 
diff --git a/components/viz/service/display/overlay_dc_unittest.cc b/components/viz/service/display/overlay_dc_unittest.cc
index 541fc24a46941..795bf637ce0c6 100644
--- a/components/viz/service/display/overlay_dc_unittest.cc
+++ b/components/viz/service/display/overlay_dc_unittest.cc
@@ -260,7 +260,7 @@ TEST_F(DCLayerOverlayTest, DisableVideoOverlayIfMovingFeature) {
         video_quad->rect = gfx::Rect(0, 0, 10, 10) + video_rect_offset;
         video_quad->visible_rect = gfx::Rect(0, 0, 10, 10) + video_rect_offset;
 
-        DCLayerOverlayList dc_layer_list;
+        std::vector<DCLayerOverlayCandidate> dc_layer_list;
         OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
         OverlayProcessorInterface::FilterOperationsMap
             render_pass_backdrop_filters;
@@ -319,7 +319,8 @@ TEST_F(DCLayerOverlayTest, Occluded) {
     auto* first_video_quad = CreateFullscreenCandidateYUVVideoQuad(
         resource_provider_.get(), child_resource_provider_.get(),
         child_provider_.get(), pass->shared_quad_state_list.back(), pass.get());
-    // Set the protected video flag will force DCLayerOverlay to use hw overlay
+    // Set the protected video flag will force DCLayerOverlayCandidate to use hw
+    // overlay
     first_video_quad->protected_video_type =
         gfx::ProtectedVideoType::kHardwareProtected;
 
@@ -329,13 +330,14 @@ TEST_F(DCLayerOverlayTest, Occluded) {
     auto* second_video_quad = CreateFullscreenCandidateYUVVideoQuad(
         resource_provider_.get(), child_resource_provider_.get(),
         child_provider_.get(), pass->shared_quad_state_list.back(), pass.get());
-    // Set the protected video flag will force DCLayerOverlay to use hw overlay
+    // Set the protected video flag will force DCLayerOverlayCandidate to use hw
+    // overlay
     second_video_quad->protected_video_type =
         gfx::ProtectedVideoType::kHardwareProtected;
     second_video_quad->rect.set_origin(gfx::Point(2, 2));
     second_video_quad->visible_rect.set_origin(gfx::Point(2, 2));
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
     damage_rect_ = gfx::Rect(1, 1, 10, 10);
@@ -370,7 +372,8 @@ TEST_F(DCLayerOverlayTest, Occluded) {
     auto* video_quad = CreateFullscreenCandidateYUVVideoQuad(
         resource_provider_.get(), child_resource_provider_.get(),
         child_provider_.get(), pass->shared_quad_state_list.back(), pass.get());
-    // Set the protected video flag will force DCLayerOverlay to use hw overlay
+    // Set the protected video flag will force DCLayerOverlayCandidate to use hw
+    // overlay
     video_quad->protected_video_type =
         gfx::ProtectedVideoType::kHardwareProtected;
 
@@ -385,7 +388,7 @@ TEST_F(DCLayerOverlayTest, Occluded) {
     second_video_quad->rect.set_origin(gfx::Point(2, 2));
     second_video_quad->visible_rect.set_origin(gfx::Point(2, 2));
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
     damage_rect_ = gfx::Rect(1, 1, 10, 10);
@@ -435,7 +438,7 @@ TEST_F(DCLayerOverlayTest, DamageRectWithoutVideoDamage) {
     video_quad->rect = gfx::Rect(0, 0, 200, 200);
     video_quad->visible_rect = video_quad->rect;
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
     // Damage rect fully outside video quad
@@ -478,7 +481,7 @@ TEST_F(DCLayerOverlayTest, DamageRectWithoutVideoDamage) {
     video_quad->rect = gfx::Rect(0, 0, 200, 200);
     video_quad->visible_rect = video_quad->rect;
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
     // Damage rect fully outside video quad
@@ -509,7 +512,7 @@ TEST_F(DCLayerOverlayTest, DamageRect) {
         resource_provider_.get(), child_resource_provider_.get(),
         child_provider_.get(), pass->shared_quad_state_list.back(), pass.get());
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
     damage_rect_ = gfx::Rect(1, 1, 10, 10);
@@ -555,7 +558,7 @@ TEST_F(DCLayerOverlayTest, ClipRect) {
     // Clipped rect shouldn't be overlapped by clipped opaque quad rect.
     shared_state->clip_rect = gfx::Rect(0, 0, 100, 3);
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
     AggregatedRenderPassList pass_list;
@@ -594,7 +597,7 @@ TEST_F(DCLayerOverlayTest, TransparentOnTop) {
         child_provider_.get(), pass->shared_quad_state_list.back(), pass.get());
     pass->shared_quad_state_list.back()->opacity = 0.5f;
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
     damage_rect_ = gfx::Rect(1, 1, 10, 10);
@@ -628,7 +631,7 @@ TEST_F(DCLayerOverlayTest, UnderlayDamageRectWithQuadOnTopUnchanged) {
         resource_provider_.get(), child_resource_provider_.get(),
         child_provider_.get(), shared_state, pass.get());
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
     AggregatedRenderPassList pass_list;
@@ -679,7 +682,7 @@ TEST_F(DCLayerOverlayTest, RoundedCorners) {
     pass->shared_quad_state_list.back()->mask_filter_info =
         gfx::MaskFilterInfo(gfx::RRectF(gfx::RectF(0.f, 0.f, 20.f, 30.f), 5.f));
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
     damage_rect_ = gfx::Rect(0, 0, 256, 256);
@@ -737,7 +740,7 @@ TEST_F(DCLayerOverlayTest, RoundedCorners) {
     pass->shared_quad_state_list.back()->mask_filter_info =
         gfx::MaskFilterInfo(gfx::RRectF(gfx::RectF(0.f, 0.f, 20.f, 30.f), 5.f));
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
     damage_rect_ = gfx::Rect(0, 0, 256, 256);
@@ -795,7 +798,7 @@ TEST_F(DCLayerOverlayTest, RoundedCorners) {
     pass->shared_quad_state_list.back()->mask_filter_info =
         gfx::MaskFilterInfo(gfx::RRectF(gfx::RectF(0.f, 0.f, 20.f, 30.f), 5.f));
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
     damage_rect_ = gfx::Rect(0, 0, 256, 256);
@@ -862,7 +865,7 @@ TEST_F(DCLayerOverlayTest, MultipleYUVOverlays) {
     second_video_quad->visible_rect = second_rect;
     pass->shared_quad_state_list.back()->overlay_damage_index = 2;
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
     damage_rect_ = gfx::Rect(0, 0, 220, 220);
@@ -905,7 +908,7 @@ TEST_F(DCLayerOverlayTest, SetEnableDCLayers) {
     AggregatedRenderPassList pass_list;
     pass_list.push_back(std::move(pass));
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
     SurfaceDamageRectList surface_damage_rect_list;
@@ -943,7 +946,7 @@ TEST_F(DCLayerOverlayTest, SetEnableDCLayers) {
     quad->SetNew(pass->CreateAndAppendSharedQuadState(), damage_rect_,
                  damage_rect_, SkColors::kRed, false);
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
 
@@ -1024,7 +1027,7 @@ TEST_F(DCLayerOverlayTest, PixelMovingForegroundFilter) {
   // 100, 100).
   pass->output_rect = gfx::Rect(0, 0, 512, 512);
 
-  DCLayerOverlayList dc_layer_list;
+  std::vector<DCLayerOverlayCandidate> dc_layer_list;
   OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
   OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
   render_pass_filters[filter_render_pass_id] = &blur_filter;
@@ -1094,7 +1097,7 @@ TEST_F(DCLayerOverlayTest, BackdropFilter) {
   // 100, 100).
   pass->output_rect = gfx::Rect(0, 0, 512, 512);
 
-  DCLayerOverlayList dc_layer_list;
+  std::vector<DCLayerOverlayCandidate> dc_layer_list;
   OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
   OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
   render_pass_backdrop_filters[backdrop_filter_render_pass_id] =
@@ -1140,7 +1143,7 @@ TEST_F(DCLayerOverlayTest, VideoCapture) {
     video_quad->visible_rect = rect;
     pass->shared_quad_state_list.back()->overlay_damage_index = 1;
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
     damage_rect_ = gfx::Rect(0, 0, 256, 256);
@@ -1178,7 +1181,7 @@ TEST_F(DCLayerOverlayTest, VideoCapture) {
     video_quad->visible_rect = rect;
     pass->shared_quad_state_list.back()->overlay_damage_index = 0;
 
-    DCLayerOverlayList dc_layer_list;
+    std::vector<DCLayerOverlayCandidate> dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;
     OverlayProcessorInterface::FilterOperationsMap render_pass_backdrop_filters;
     damage_rect_ = gfx::Rect(0, 0, 256, 256);
diff --git a/components/viz/service/display/overlay_processor_interface.h b/components/viz/service/display/overlay_processor_interface.h
index 136d1ea5c907c..41ccab8514eab 100644
--- a/components/viz/service/display/overlay_processor_interface.h
+++ b/components/viz/service/display/overlay_processor_interface.h
@@ -53,8 +53,8 @@ class VIZ_SERVICE_EXPORT OverlayProcessorInterface {
   using PlatformOverlayCandidate = CALayerOverlay;
   using CandidateList = CALayerOverlayList;
 #elif BUILDFLAG(IS_WIN)
-  using PlatformOverlayCandidate = DCLayerOverlay;
-  using CandidateList = DCLayerOverlayList;
+  using PlatformOverlayCandidate = DCLayerOverlayCandidate;
+  using CandidateList = std::vector<DCLayerOverlayCandidate>;
 #else
   // Default.
   using PlatformOverlayCandidate = OverlayCandidate;
@@ -66,7 +66,8 @@ class VIZ_SERVICE_EXPORT OverlayProcessorInterface {
 
   virtual bool DisableSplittingQuads() const;
 
-  // Used by Window's DCLayerOverlay system and OverlayProcessorUsingStrategy.
+  // Used by Window's DCLayerOverlayCandidate system and
+  // OverlayProcessorUsingStrategy.
   static void RecordOverlayDamageRectHistograms(
       bool is_overlay,
       bool has_occluding_surface_damage,
diff --git a/components/viz/service/display/overlay_processor_on_gpu.h b/components/viz/service/display/overlay_processor_on_gpu.h
index 10b766af5f5d8..3be8131f89b4b 100644
--- a/components/viz/service/display/overlay_processor_on_gpu.h
+++ b/components/viz/service/display/overlay_processor_on_gpu.h
@@ -35,7 +35,7 @@ class VIZ_SERVICE_EXPORT OverlayProcessorOnGpu {
 #if BUILDFLAG(IS_APPLE)
   using CandidateList = CALayerOverlayList;
 #elif BUILDFLAG(IS_WIN)
-  using CandidateList = DCLayerOverlayList;
+  using CandidateList = std::vector<DCLayerOverlayCandidate>;
 #else
   // Default.
   using CandidateList = OverlayCandidateList;
diff --git a/components/viz/service/display/overlay_processor_win.h b/components/viz/service/display/overlay_processor_win.h
index 932613bf9fc79..bf6c9715985b3 100644
--- a/components/viz/service/display/overlay_processor_win.h
+++ b/components/viz/service/display/overlay_processor_win.h
@@ -26,7 +26,7 @@ namespace viz {
 class VIZ_SERVICE_EXPORT OverlayProcessorWin
     : public OverlayProcessorInterface {
  public:
-  using CandidateList = DCLayerOverlayList;
+  using CandidateList = std::vector<DCLayerOverlayCandidate>;
 
   OverlayProcessorWin(
       OutputSurface* output_surface,
diff --git a/components/viz/service/display/skia_output_surface.h b/components/viz/service/display/skia_output_surface.h
index 7501f8d41a38e..880530a0ad7c0 100644
--- a/components/viz/service/display/skia_output_surface.h
+++ b/components/viz/service/display/skia_output_surface.h
@@ -56,7 +56,7 @@ class VIZ_SERVICE_EXPORT SkiaOutputSurface : public OutputSurface,
 #elif BUILDFLAG(IS_APPLE)
   using OverlayList = CALayerOverlayList;
 #elif BUILDFLAG(IS_WIN)
-  using OverlayList = DCLayerOverlayList;
+  using OverlayList = std::vector<DCLayerOverlayCandidate>;
 #elif BUILDFLAG(IS_OZONE)
   using OverlayList = std::vector<OverlayCandidate>;
 #else
diff --git a/components/viz/service/display/skia_renderer.cc b/components/viz/service/display/skia_renderer.cc
index 7fb2f06ffa051..c356971cc78a2 100644
--- a/components/viz/service/display/skia_renderer.cc
+++ b/components/viz/service/display/skia_renderer.cc
@@ -2681,7 +2681,7 @@ void SkiaRenderer::ScheduleOverlays() {
   }
 #elif BUILDFLAG(IS_WIN)
   for (auto& dc_layer_overlay : current_frame()->overlay_list) {
-    for (size_t i = 0; i < DCLayerOverlay::kNumResources; ++i) {
+    for (size_t i = 0; i < DCLayerOverlayCandidate::kNumResources; ++i) {
       ResourceId resource_id = dc_layer_overlay.resources[i];
       if (resource_id == kInvalidResourceId)
         break;
diff --git a/components/viz/service/display_embedder/output_presenter.h b/components/viz/service/display_embedder/output_presenter.h
index 773a6f14ad418..dbfc9d460df2c 100644
--- a/components/viz/service/display_embedder/output_presenter.h
+++ b/components/viz/service/display_embedder/output_presenter.h
@@ -135,7 +135,7 @@ class VIZ_SERVICE_EXPORT OutputPresenter {
 #elif BUILDFLAG(IS_APPLE)
   using OverlayPlaneCandidate = CALayerOverlay;
 #elif BUILDFLAG(IS_WIN)
-  using OverlayPlaneCandidate = DCLayerOverlay;
+  using OverlayPlaneCandidate = DCLayerOverlayCandidate;
 #else
   // Default.
   using OverlayPlaneCandidate = OverlayCandidate;
diff --git a/components/viz/service/display_embedder/output_presenter_gl.cc b/components/viz/service/display_embedder/output_presenter_gl.cc
index c4cac8b517072..6f49d47781e9e 100644
--- a/components/viz/service/display_embedder/output_presenter_gl.cc
+++ b/components/viz/service/display_embedder/output_presenter_gl.cc
@@ -313,7 +313,7 @@ void OutputPresenterGL::ScheduleOverlayPlane(
     std::unique_ptr<gfx::GpuFence> acquire_fence) {
   // Note that |overlay_plane_candidate| has different types on different
   // platforms. On Android and Ozone it is an OverlayCandidate, on Windows it is
-  // a DCLayerOverlay, and on macOS it is a CALayeroverlay.
+  // a DCLayerOverlayCandidate, and on macOS it is a CALayeroverlay.
 #if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_OZONE)
 #if BUILDFLAG(IS_OZONE)
   // TODO(crbug.com/1366808): Add ScopedOverlayAccess::GetOverlayImage() that
diff --git a/components/viz/service/display_embedder/skia_output_device_dcomp.cc b/components/viz/service/display_embedder/skia_output_device_dcomp.cc
index 907d0c71c4e20..eb592dcaf43fa 100644
--- a/components/viz/service/display_embedder/skia_output_device_dcomp.cc
+++ b/components/viz/service/display_embedder/skia_output_device_dcomp.cc
@@ -30,7 +30,7 @@
 #include "third_party/skia/include/gpu/GrDirectContext.h"
 #include "third_party/skia/include/gpu/gl/GrGLTypes.h"
 #include "ui/gfx/buffer_format_util.h"
-#include "ui/gl/dc_renderer_layer_params.h"
+#include "ui/gl/dc_layer_overlay_params.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface.h"
@@ -207,7 +207,7 @@ void SkiaOutputDeviceDComp::ScheduleOverlays(
       continue;
     }
 
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<gl::DCLayerOverlayParams>();
     params->overlay_image = std::move(overlay_image);
     params->z_order = dc_layer.z_order;
     params->content_rect = dc_layer.content_rect;
@@ -369,7 +369,7 @@ SkSurface* SkiaOutputDeviceDCompGLSurface::BeginPaint(
 void SkiaOutputDeviceDCompGLSurface::EndPaint() {}
 
 bool SkiaOutputDeviceDCompGLSurface::ScheduleDCLayer(
-    std::unique_ptr<ui::DCRendererLayerParams> params) {
+    std::unique_ptr<gl::DCLayerOverlayParams> params) {
   return gl_surface_->ScheduleDCLayer(std::move(params));
 }
 
diff --git a/components/viz/service/display_embedder/skia_output_device_dcomp.h b/components/viz/service/display_embedder/skia_output_device_dcomp.h
index 32a54f455064b..5bd984ef8f4ba 100644
--- a/components/viz/service/display_embedder/skia_output_device_dcomp.h
+++ b/components/viz/service/display_embedder/skia_output_device_dcomp.h
@@ -18,6 +18,7 @@
 
 namespace gl {
 class DCLayerOverlayImage;
+struct DCLayerOverlayParams;
 class GLSurface;
 }  // namespace gl
 
@@ -31,10 +32,6 @@ class FeatureInfo;
 }  // namespace gles2
 }  // namespace gpu
 
-namespace ui {
-struct DCRendererLayerParams;
-}  // namespace ui
-
 namespace viz {
 
 // Base class for DComp-backed OutputDevices.
@@ -72,7 +69,7 @@ class SkiaOutputDeviceDComp : public SkiaOutputDevice {
   void CreateSkSurface();
 
   virtual bool ScheduleDCLayer(
-      std::unique_ptr<ui::DCRendererLayerParams> params) = 0;
+      std::unique_ptr<gl::DCLayerOverlayParams> params) = 0;
 
   virtual gfx::Size GetRootSurfaceSize() const = 0;
 
@@ -126,7 +123,7 @@ class VIZ_SERVICE_EXPORT SkiaOutputDeviceDCompGLSurface final
 
  protected:
   bool ScheduleDCLayer(
-      std::unique_ptr<ui::DCRendererLayerParams> params) override;
+      std::unique_ptr<gl::DCLayerOverlayParams> params) override;
   gfx::Size GetRootSurfaceSize() const override;
   gfx::SwapResult DoPostSubBuffer(const gfx::Rect& rect,
                                   BufferPresentedCallback feedback,
diff --git a/components/viz/service/display_embedder/skia_output_device_gl.cc b/components/viz/service/display_embedder/skia_output_device_gl.cc
index 4d778a153f60c..0db864ca878b9 100644
--- a/components/viz/service/display_embedder/skia_output_device_gl.cc
+++ b/components/viz/service/display_embedder/skia_output_device_gl.cc
@@ -72,7 +72,6 @@ SkiaOutputDeviceGL::SkiaOutputDeviceGL(
   capabilities_.supports_commit_overlay_planes =
       gl_surface_->SupportsCommitOverlayPlanes();
   capabilities_.supports_gpu_vsync = gl_surface_->SupportsGpuVSync();
-  capabilities_.supports_dc_layers = gl_surface_->SupportsDCLayers();
 #if BUILDFLAG(IS_ANDROID)
   // TODO(weiliangc): This capability is used to check whether we should do
   // overlay. Since currently none of the other overlay system is implemented,
diff --git a/ui/gl/BUILD.gn b/ui/gl/BUILD.gn
index c66c07ab333d9..79eefcb04f605 100644
--- a/ui/gl/BUILD.gn
+++ b/ui/gl/BUILD.gn
@@ -50,8 +50,6 @@ component("gl") {
   sources = [
     "buffer_format_utils.cc",
     "buffer_format_utils.h",
-    "dc_renderer_layer_params.cc",
-    "dc_renderer_layer_params.h",
     "dual_gpu_state.cc",
     "dual_gpu_state.h",
     "egl_timestamps.h",
@@ -299,6 +297,8 @@ component("gl") {
       "child_window_win.h",
       "dc_layer_overlay_image.cc",
       "dc_layer_overlay_image.h",
+      "dc_layer_overlay_params.cc",
+      "dc_layer_overlay_params.h",
       "dc_layer_tree.cc",
       "dc_layer_tree.h",
       "dcomp_presenter.cc",
diff --git a/ui/gl/dc_layer_overlay_params.cc b/ui/gl/dc_layer_overlay_params.cc
new file mode 100644
index 0000000000000..74ca138300044
--- /dev/null
+++ b/ui/gl/dc_layer_overlay_params.cc
@@ -0,0 +1,12 @@
+// Copyright 2017 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/gl/dc_layer_overlay_params.h"
+
+namespace gl {
+
+DCLayerOverlayParams::DCLayerOverlayParams() = default;
+DCLayerOverlayParams::~DCLayerOverlayParams() = default;
+
+}  // namespace gl
diff --git a/ui/gl/dc_renderer_layer_params.h b/ui/gl/dc_layer_overlay_params.h
similarity index 76%
rename from ui/gl/dc_renderer_layer_params.h
rename to ui/gl/dc_layer_overlay_params.h
index aff8c06bde2c7..3dfac358ffb17 100644
--- a/ui/gl/dc_renderer_layer_params.h
+++ b/ui/gl/dc_layer_overlay_params.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef UI_GL_DC_RENDERER_LAYER_PARAMS_H_
-#define UI_GL_DC_RENDERER_LAYER_PARAMS_H_
+#ifndef UI_GL_DC_LAYER_OVERLAY_PARAMS_H_
+#define UI_GL_DC_LAYER_OVERLAY_PARAMS_H_
 
 #include "base/callback.h"
 #include "base/memory/scoped_refptr.h"
@@ -16,24 +16,18 @@
 #include "ui/gfx/geometry/transform.h"
 #include "ui/gfx/hdr_metadata.h"
 #include "ui/gfx/video_types.h"
-#include "ui/gl/gl_export.h"
-
-#if BUILDFLAG(IS_WIN)
 #include "ui/gl/dc_layer_overlay_image.h"
-#endif
+#include "ui/gl/gl_export.h"
 
-// TODO(sunnyps): Move this to gl namespace and compile on Windows only.
-namespace ui {
+namespace gl {
 
-struct GL_EXPORT DCRendererLayerParams {
-  DCRendererLayerParams();
-  ~DCRendererLayerParams();
+struct GL_EXPORT DCLayerOverlayParams {
+  DCLayerOverlayParams();
+  ~DCLayerOverlayParams();
 
-#if BUILDFLAG(IS_WIN)
   // Image to display in overlay - could be hardware or software video frame,
   // swap chain, or dcomp surface.
-  absl::optional<gl::DCLayerOverlayImage> overlay_image;
-#endif
+  absl::optional<DCLayerOverlayImage> overlay_image;
 
   // Stacking order relative to backbuffer which has z-order 0.
   int z_order = 1;
@@ -61,6 +55,6 @@ struct GL_EXPORT DCRendererLayerParams {
   bool is_video_fullscreen_letterboxing = false;
 };
 
-}  // namespace ui
+}  // namespace gl
 
-#endif  // UI_GL_DC_RENDERER_LAYER_PARAMS_H_
+#endif  // UI_GL_DC_LAYER_OVERLAY_PARAMS_H_
diff --git a/ui/gl/dc_layer_tree.cc b/ui/gl/dc_layer_tree.cc
index 38c682ba71c20..c7e87fc6e32a9 100644
--- a/ui/gl/dc_layer_tree.cc
+++ b/ui/gl/dc_layer_tree.cc
@@ -314,7 +314,7 @@ bool DCLayerTree::CommitAndClearPendingOverlays(
     }
   }
 
-  std::vector<std::unique_ptr<ui::DCRendererLayerParams>> overlays;
+  std::vector<std::unique_ptr<DCLayerOverlayParams>> overlays;
   std::swap(pending_overlays_, overlays);
 
   // Grow or shrink list of swap chain presenters to match pending overlays.
@@ -335,7 +335,7 @@ bool DCLayerTree::CommitAndClearPendingOverlays(
       root_visual_content = root_dcomp_surface_;
     }
     // Add a placeholder overlay for the root surface, at a z-order of 0.
-    auto root_params = std::make_unique<ui::DCRendererLayerParams>();
+    auto root_params = std::make_unique<DCLayerOverlayParams>();
     root_params->z_order = 0;
     root_params->overlay_image = DCLayerOverlayImage(
         root_surface->GetSize(), std::move(root_visual_content),
@@ -391,7 +391,7 @@ bool DCLayerTree::CommitAndClearPendingOverlays(
 }
 
 bool DCLayerTree::BuildVisualTreeHelper(
-    const std::vector<std::unique_ptr<ui::DCRendererLayerParams>>& overlays,
+    const std::vector<std::unique_ptr<DCLayerOverlayParams>>& overlays,
     bool needs_rebuild_visual_tree) {
   // Grow or shrink list of visual subtrees to match pending overlays.
   size_t old_visual_subtrees_size = visual_subtrees_.size();
@@ -486,7 +486,7 @@ bool DCLayerTree::BuildVisualTreeHelper(
 }
 
 bool DCLayerTree::ScheduleDCLayer(
-    std::unique_ptr<ui::DCRendererLayerParams> params) {
+    std::unique_ptr<DCLayerOverlayParams> params) {
   pending_overlays_.push_back(std::move(params));
   return true;
 }
diff --git a/ui/gl/dc_layer_tree.h b/ui/gl/dc_layer_tree.h
index 325d11eae567e..aac91bf056870 100644
--- a/ui/gl/dc_layer_tree.h
+++ b/ui/gl/dc_layer_tree.h
@@ -16,7 +16,7 @@
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "ui/gfx/color_space_win.h"
 #include "ui/gfx/geometry/size.h"
-#include "ui/gl/dc_renderer_layer_params.h"
+#include "ui/gl/dc_layer_overlay_params.h"
 #include "ui/gl/delegated_ink_point_renderer_gpu.h"
 #include "ui/gl/hdr_metadata_helper_win.h"
 
@@ -88,7 +88,7 @@ class DCLayerTree {
       DirectCompositionChildSurfaceWin* root_surface);
 
   // Schedule an overlay layer for the next CommitAndClearPendingOverlays call.
-  bool ScheduleDCLayer(std::unique_ptr<ui::DCRendererLayerParams> params);
+  bool ScheduleDCLayer(std::unique_ptr<DCLayerOverlayParams> params);
 
   // Called by SwapChainPresenter to initialize video processor that can handle
   // at least given input and output size.  The video processor is shared across
@@ -209,7 +209,7 @@ class DCLayerTree {
   // Given pending overlays, builds or updates visual tree.
   // Returns true if commit succeeded.
   bool BuildVisualTreeHelper(
-      const std::vector<std::unique_ptr<ui::DCRendererLayerParams>>& overlays,
+      const std::vector<std::unique_ptr<DCLayerOverlayParams>>& overlays,
       // True if the caller determined that rebuilding the tree is required.
       bool needs_rebuild_visual_tree);
 
@@ -260,7 +260,7 @@ class DCLayerTree {
   Microsoft::WRL::ComPtr<IDCompositionVisual2> dcomp_root_visual_;
 
   // List of pending overlay layers from ScheduleDCLayer().
-  std::vector<std::unique_ptr<ui::DCRendererLayerParams>> pending_overlays_;
+  std::vector<std::unique_ptr<DCLayerOverlayParams>> pending_overlays_;
 
   // List of swap chain presenters for previous frame.
   std::vector<std::unique_ptr<SwapChainPresenter>> video_swap_chains_;
diff --git a/ui/gl/dc_renderer_layer_params.cc b/ui/gl/dc_renderer_layer_params.cc
deleted file mode 100644
index 8a7f86898cfef..0000000000000
--- a/ui/gl/dc_renderer_layer_params.cc
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright 2017 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "ui/gl/dc_renderer_layer_params.h"
-
-#include "ui/gl/gl_image.h"
-
-namespace ui {
-
-DCRendererLayerParams::DCRendererLayerParams() = default;
-DCRendererLayerParams::~DCRendererLayerParams() = default;
-
-}  // namespace ui
diff --git a/ui/gl/dcomp_presenter.cc b/ui/gl/dcomp_presenter.cc
index e102e7586d709..c6e1917c2c4c1 100644
--- a/ui/gl/dcomp_presenter.cc
+++ b/ui/gl/dcomp_presenter.cc
@@ -165,7 +165,7 @@ void DCompPresenter::OnVSync(base::TimeTicks vsync_time,
 }
 
 bool DCompPresenter::ScheduleDCLayer(
-    std::unique_ptr<ui::DCRendererLayerParams> params) {
+    std::unique_ptr<DCLayerOverlayParams> params) {
   return layer_tree_->ScheduleDCLayer(std::move(params));
 }
 
diff --git a/ui/gl/dcomp_presenter.h b/ui/gl/dcomp_presenter.h
index 8579f1965d014..5191cb0684948 100644
--- a/ui/gl/dcomp_presenter.h
+++ b/ui/gl/dcomp_presenter.h
@@ -84,8 +84,7 @@ class GL_EXPORT DCompPresenter : public SurfacelessEGL, public VSyncObserver {
   // to remain in the layer tree. This surface's backbuffer doesn't have to be
   // scheduled with ScheduleDCLayer, as it's automatically placed in the layer
   // tree at z-order 0.
-  bool ScheduleDCLayer(
-      std::unique_ptr<ui::DCRendererLayerParams> params) override;
+  bool ScheduleDCLayer(std::unique_ptr<DCLayerOverlayParams> params) override;
   void SetFrameRate(float frame_rate) override;
 
   // VSyncObserver implementation.
diff --git a/ui/gl/dcomp_presenter_unittest.cc b/ui/gl/dcomp_presenter_unittest.cc
index 76e4f851cddd7..b6c2d5abb0762 100644
--- a/ui/gl/dcomp_presenter_unittest.cc
+++ b/ui/gl/dcomp_presenter_unittest.cc
@@ -22,7 +22,7 @@
 #include "ui/gfx/frame_data.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/transform.h"
-#include "ui/gl/dc_renderer_layer_params.h"
+#include "ui/gl/dc_layer_overlay_params.h"
 #include "ui/gl/direct_composition_child_surface_win.h"
 #include "ui/gl/direct_composition_support.h"
 #include "ui/gl/direct_composition_surface_win.h"
@@ -196,7 +196,7 @@ TEST_F(DCompPresenterTest, NoPresentTwice) {
   EXPECT_NE(texture, nullptr);
 
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = gfx::Rect(100, 100);
@@ -222,7 +222,7 @@ TEST_F(DCompPresenterTest, NoPresentTwice) {
   EXPECT_EQ(2u, last_present_count);
 
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = gfx::Rect(100, 100);
@@ -246,7 +246,7 @@ TEST_F(DCompPresenterTest, NoPresentTwice) {
   EXPECT_NE(texture, nullptr);
 
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = gfx::Rect(100, 100);
@@ -285,7 +285,7 @@ TEST_F(DCompPresenterTest, SwapchainSizeWithScaledOverlays) {
   gfx::Rect quad_rect = gfx::Rect(100, 100);
 
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = quad_rect;
@@ -315,7 +315,7 @@ TEST_F(DCompPresenterTest, SwapchainSizeWithScaledOverlays) {
   quad_rect = gfx::Rect(32, 48);
 
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = quad_rect;
@@ -352,7 +352,7 @@ TEST_F(DCompPresenterTest, SwapchainSizeWithoutScaledOverlays) {
   gfx::Rect quad_rect = gfx::Rect(42, 42);
 
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = quad_rect;
@@ -376,7 +376,7 @@ TEST_F(DCompPresenterTest, SwapchainSizeWithoutScaledOverlays) {
   quad_rect = gfx::Rect(124, 136);
 
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = quad_rect;
@@ -413,7 +413,7 @@ TEST_F(DCompPresenterTest, ProtectedVideos) {
 
   // Clear video
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->quad_rect = gfx::Rect(window_size);
     params->content_rect = gfx::Rect(texture_size);
@@ -437,7 +437,7 @@ TEST_F(DCompPresenterTest, ProtectedVideos) {
 
   // Software protected video
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->quad_rect = gfx::Rect(window_size);
     params->content_rect = gfx::Rect(texture_size);
@@ -517,8 +517,8 @@ class DCompPresenterPixelTest : public DCompPresenterTest {
     ASSERT_HRESULT_SUCCEEDED(root_surface->EndDraw());
 
     // Schedule the root surface as a normal overlay
-    std::unique_ptr<ui::DCRendererLayerParams> params =
-        std::make_unique<ui::DCRendererLayerParams>();
+    std::unique_ptr<DCLayerOverlayParams> params =
+        std::make_unique<DCLayerOverlayParams>();
     params->z_order = 0;
     params->quad_rect = gfx::Rect(window_size);
     params->content_rect = params->quad_rect;
@@ -541,7 +541,7 @@ class DCompPresenterPixelTest : public DCompPresenterTest {
     Microsoft::WRL::ComPtr<ID3D11Texture2D> texture =
         CreateNV12Texture(d3d11_device, texture_size);
 
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = content_rect;
     params->quad_rect = quad_rect;
@@ -577,7 +577,7 @@ class DCompPresenterVideoPixelTest : public DCompPresenterPixelTest {
         CreateNV12Texture(d3d11_device, texture_size);
 
     {
-      auto params = std::make_unique<ui::DCRendererLayerParams>();
+      auto params = std::make_unique<DCLayerOverlayParams>();
       params->overlay_image.emplace(texture_size, texture);
       params->content_rect = gfx::Rect(texture_size);
       params->quad_rect = gfx::Rect(texture_size);
@@ -591,7 +591,7 @@ class DCompPresenterVideoPixelTest : public DCompPresenterPixelTest {
     // Scaling up the swapchain with the same image should cause it to be
     // transformed again, but not presented again.
     {
-      auto params = std::make_unique<ui::DCRendererLayerParams>();
+      auto params = std::make_unique<DCLayerOverlayParams>();
       params->overlay_image.emplace(texture_size, texture);
       params->content_rect = gfx::Rect(texture_size);
       params->quad_rect = gfx::Rect(window_size);
@@ -653,7 +653,7 @@ TEST_F(DCompPresenterPixelTest, SoftwareVideoSwapchain) {
 
   std::vector<uint8_t> nv12_pixmap(stride * 3 * y_size.height() / 2, 0xff);
 
-  auto params = std::make_unique<ui::DCRendererLayerParams>();
+  auto params = std::make_unique<DCLayerOverlayParams>();
   params->overlay_image =
       DCLayerOverlayImage(y_size, nv12_pixmap.data(), stride);
   params->content_rect = gfx::Rect(y_size);
@@ -732,7 +732,7 @@ TEST_F(DCompPresenterPixelTest, SkipVideoLayerEmptyContentsRect) {
       CreateNV12Texture(d3d11_device, texture_size);
 
   // Layer with empty content rect.
-  auto params = std::make_unique<ui::DCRendererLayerParams>();
+  auto params = std::make_unique<DCLayerOverlayParams>();
   params->overlay_image.emplace(texture_size, texture);
   params->quad_rect = gfx::Rect(window_size);
   params->color_space = gfx::ColorSpace::CreateREC709();
@@ -890,7 +890,7 @@ TEST_F(DCompPresenterPixelTest, ResizeVideoLayer) {
 
   // (1) Test if swap chain is overridden to window size (100, 100).
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = gfx::Rect(window_size);
@@ -913,7 +913,7 @@ TEST_F(DCompPresenterPixelTest, ResizeVideoLayer) {
 
   // (2) Test if swap chain is overridden to window size (100, 100).
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(30, 30);
     params->quad_rect = gfx::Rect(window_size);
@@ -938,7 +938,7 @@ TEST_F(DCompPresenterPixelTest, ResizeVideoLayer) {
   gfx::Rect on_screen_rect =
       gfx::Rect(0, 0, monitor_size.width() - 2, monitor_size.height() - 2);
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(50, 50);
     params->quad_rect = on_screen_rect;
@@ -971,7 +971,7 @@ TEST_F(DCompPresenterPixelTest, ResizeVideoLayer) {
   on_screen_rect =
       gfx::Rect(0, 0, monitor_size.width() + 2, monitor_size.height() + 2);
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(50, 50);
     params->quad_rect = on_screen_rect;
@@ -1072,7 +1072,7 @@ TEST_F(DCompPresenterPixelTest, SwapChainImage) {
 
     ASSERT_TRUE(SUCCEEDED(swap_chain->Present1(0, 0, &present_params)));
 
-    auto dc_layer_params = std::make_unique<ui::DCRendererLayerParams>();
+    auto dc_layer_params = std::make_unique<DCLayerOverlayParams>();
     dc_layer_params->overlay_image =
         DCLayerOverlayImage(swap_chain_size, swap_chain);
     dc_layer_params->content_rect = gfx::Rect(swap_chain_size);
@@ -1098,7 +1098,7 @@ TEST_F(DCompPresenterPixelTest, SwapChainImage) {
 
     ASSERT_TRUE(SUCCEEDED(swap_chain->Present1(0, 0, &present_params)));
 
-    auto dc_layer_params = std::make_unique<ui::DCRendererLayerParams>();
+    auto dc_layer_params = std::make_unique<DCLayerOverlayParams>();
     dc_layer_params->overlay_image =
         DCLayerOverlayImage(swap_chain_size, swap_chain);
     dc_layer_params->content_rect = gfx::Rect(swap_chain_size);
@@ -1122,7 +1122,7 @@ TEST_F(DCompPresenterPixelTest, SwapChainImage) {
   {
     ASSERT_TRUE(SUCCEEDED(swap_chain->Present1(0, 0, &present_params)));
 
-    auto dc_layer_params = std::make_unique<ui::DCRendererLayerParams>();
+    auto dc_layer_params = std::make_unique<DCLayerOverlayParams>();
     dc_layer_params->overlay_image =
         DCLayerOverlayImage(swap_chain_size, swap_chain);
     dc_layer_params->content_rect = gfx::Rect(swap_chain_size);
@@ -1146,7 +1146,7 @@ TEST_F(DCompPresenterPixelTest, SwapChainImage) {
     float clear_color[] = {0.0, 0.0, 1.0, 1.0};
     context->ClearRenderTargetView(rtv.Get(), clear_color);
 
-    auto dc_layer_params = std::make_unique<ui::DCRendererLayerParams>();
+    auto dc_layer_params = std::make_unique<DCLayerOverlayParams>();
     dc_layer_params->overlay_image =
         DCLayerOverlayImage(swap_chain_size, swap_chain);
     dc_layer_params->content_rect = gfx::Rect(swap_chain_size);
@@ -1209,7 +1209,7 @@ TEST_P(DCompPresenterBufferCountTest, VideoSwapChainBufferCount) {
   Microsoft::WRL::ComPtr<ID3D11Texture2D> texture =
       CreateNV12Texture(d3d11_device, texture_size);
 
-  auto params = std::make_unique<ui::DCRendererLayerParams>();
+  auto params = std::make_unique<DCLayerOverlayParams>();
   params->overlay_image.emplace(texture_size, texture);
   params->content_rect = gfx::Rect(texture_size);
   params->quad_rect = gfx::Rect(window_size);
diff --git a/ui/gl/direct_composition_surface_win.cc b/ui/gl/direct_composition_surface_win.cc
index e1956d7f321dc..3ca2d38cc9168 100644
--- a/ui/gl/direct_composition_surface_win.cc
+++ b/ui/gl/direct_composition_surface_win.cc
@@ -187,7 +187,7 @@ void DirectCompositionSurfaceWin::OnVSync(base::TimeTicks vsync_time,
 }
 
 bool DirectCompositionSurfaceWin::ScheduleDCLayer(
-    std::unique_ptr<ui::DCRendererLayerParams> params) {
+    std::unique_ptr<DCLayerOverlayParams> params) {
   return layer_tree_->ScheduleDCLayer(std::move(params));
 }
 
diff --git a/ui/gl/direct_composition_surface_win.h b/ui/gl/direct_composition_surface_win.h
index 6dcfd714da263..446f50dd161f3 100644
--- a/ui/gl/direct_composition_surface_win.h
+++ b/ui/gl/direct_composition_surface_win.h
@@ -100,8 +100,7 @@ class GL_EXPORT DirectCompositionSurfaceWin : public GLSurfaceEGL,
   // to remain in the layer tree. This surface's backbuffer doesn't have to be
   // scheduled with ScheduleDCLayer, as it's automatically placed in the layer
   // tree at z-order 0.
-  bool ScheduleDCLayer(
-      std::unique_ptr<ui::DCRendererLayerParams> params) override;
+  bool ScheduleDCLayer(std::unique_ptr<DCLayerOverlayParams> params) override;
   void SetFrameRate(float frame_rate) override;
 
   // VSyncObserver implementation.
diff --git a/ui/gl/direct_composition_surface_win_unittest.cc b/ui/gl/direct_composition_surface_win_unittest.cc
index 952062f88f7b2..072ae86e4c47d 100644
--- a/ui/gl/direct_composition_surface_win_unittest.cc
+++ b/ui/gl/direct_composition_surface_win_unittest.cc
@@ -22,7 +22,7 @@
 #include "ui/gfx/frame_data.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/transform.h"
-#include "ui/gl/dc_renderer_layer_params.h"
+#include "ui/gl/dc_layer_overlay_params.h"
 #include "ui/gl/direct_composition_child_surface_win.h"
 #include "ui/gl/direct_composition_support.h"
 #include "ui/gl/gl_angle_util_win.h"
@@ -325,7 +325,7 @@ TEST_F(DirectCompositionSurfaceTest, NoPresentTwice) {
   EXPECT_NE(texture, nullptr);
 
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = gfx::Rect(100, 100);
@@ -351,7 +351,7 @@ TEST_F(DirectCompositionSurfaceTest, NoPresentTwice) {
   EXPECT_EQ(2u, last_present_count);
 
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = gfx::Rect(100, 100);
@@ -375,7 +375,7 @@ TEST_F(DirectCompositionSurfaceTest, NoPresentTwice) {
   EXPECT_NE(texture, nullptr);
 
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = gfx::Rect(100, 100);
@@ -414,7 +414,7 @@ TEST_F(DirectCompositionSurfaceTest, SwapchainSizeWithScaledOverlays) {
   gfx::Rect quad_rect = gfx::Rect(100, 100);
 
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = quad_rect;
@@ -444,7 +444,7 @@ TEST_F(DirectCompositionSurfaceTest, SwapchainSizeWithScaledOverlays) {
   quad_rect = gfx::Rect(32, 48);
 
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = quad_rect;
@@ -481,7 +481,7 @@ TEST_F(DirectCompositionSurfaceTest, SwapchainSizeWithoutScaledOverlays) {
   gfx::Rect quad_rect = gfx::Rect(42, 42);
 
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = quad_rect;
@@ -505,7 +505,7 @@ TEST_F(DirectCompositionSurfaceTest, SwapchainSizeWithoutScaledOverlays) {
   quad_rect = gfx::Rect(124, 136);
 
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = quad_rect;
@@ -542,7 +542,7 @@ TEST_F(DirectCompositionSurfaceTest, ProtectedVideos) {
 
   // Clear video
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->quad_rect = gfx::Rect(window_size);
     params->content_rect = gfx::Rect(texture_size);
@@ -566,7 +566,7 @@ TEST_F(DirectCompositionSurfaceTest, ProtectedVideos) {
 
   // Software protected video
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->quad_rect = gfx::Rect(window_size);
     params->content_rect = gfx::Rect(texture_size);
@@ -628,7 +628,7 @@ class DirectCompositionPixelTest : public DirectCompositionSurfaceTest {
     Microsoft::WRL::ComPtr<ID3D11Texture2D> texture =
         CreateNV12Texture(d3d11_device, texture_size);
 
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = content_rect;
     params->quad_rect = quad_rect;
@@ -701,7 +701,7 @@ class DirectCompositionVideoPixelTest : public DirectCompositionPixelTest {
         CreateNV12Texture(d3d11_device, texture_size);
 
     {
-      auto params = std::make_unique<ui::DCRendererLayerParams>();
+      auto params = std::make_unique<DCLayerOverlayParams>();
       params->overlay_image.emplace(texture_size, texture);
       params->content_rect = gfx::Rect(texture_size);
       params->quad_rect = gfx::Rect(texture_size);
@@ -715,7 +715,7 @@ class DirectCompositionVideoPixelTest : public DirectCompositionPixelTest {
     // Scaling up the swapchain with the same image should cause it to be
     // transformed again, but not presented again.
     {
-      auto params = std::make_unique<ui::DCRendererLayerParams>();
+      auto params = std::make_unique<DCLayerOverlayParams>();
       params->overlay_image.emplace(texture_size, texture);
       params->content_rect = gfx::Rect(texture_size);
       params->quad_rect = gfx::Rect(window_size);
@@ -777,7 +777,7 @@ TEST_F(DirectCompositionPixelTest, SoftwareVideoSwapchain) {
 
   std::vector<uint8_t> nv12_pixmap(stride * 3 * y_size.height() / 2, 0xff);
 
-  auto params = std::make_unique<ui::DCRendererLayerParams>();
+  auto params = std::make_unique<DCLayerOverlayParams>();
   params->overlay_image =
       DCLayerOverlayImage(y_size, nv12_pixmap.data(), stride);
   params->content_rect = gfx::Rect(y_size);
@@ -857,7 +857,7 @@ TEST_F(DirectCompositionPixelTest, SkipVideoLayerEmptyContentsRect) {
       CreateNV12Texture(d3d11_device, texture_size);
 
   // Layer with empty content rect.
-  auto params = std::make_unique<ui::DCRendererLayerParams>();
+  auto params = std::make_unique<DCLayerOverlayParams>();
   params->overlay_image.emplace(texture_size, texture);
   params->quad_rect = gfx::Rect(window_size);
   params->color_space = gfx::ColorSpace::CreateREC709();
@@ -1016,7 +1016,7 @@ TEST_F(DirectCompositionPixelTest, ResizeVideoLayer) {
 
   // (1) Test if swap chain is overridden to window size (100, 100).
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = gfx::Rect(window_size);
@@ -1039,7 +1039,7 @@ TEST_F(DirectCompositionPixelTest, ResizeVideoLayer) {
 
   // (2) Test if swap chain is overridden to window size (100, 100).
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(30, 30);
     params->quad_rect = gfx::Rect(window_size);
@@ -1064,7 +1064,7 @@ TEST_F(DirectCompositionPixelTest, ResizeVideoLayer) {
   gfx::Rect on_screen_rect =
       gfx::Rect(0, 0, monitor_size.width() - 2, monitor_size.height() - 2);
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(50, 50);
     params->quad_rect = on_screen_rect;
@@ -1097,7 +1097,7 @@ TEST_F(DirectCompositionPixelTest, ResizeVideoLayer) {
   on_screen_rect =
       gfx::Rect(0, 0, monitor_size.width() + 2, monitor_size.height() + 2);
   {
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(50, 50);
     params->quad_rect = on_screen_rect;
@@ -1199,7 +1199,7 @@ TEST_F(DirectCompositionPixelTest, SwapChainImage) {
 
     ASSERT_TRUE(SUCCEEDED(swap_chain->Present1(0, 0, &present_params)));
 
-    auto dc_layer_params = std::make_unique<ui::DCRendererLayerParams>();
+    auto dc_layer_params = std::make_unique<DCLayerOverlayParams>();
     dc_layer_params->overlay_image =
         DCLayerOverlayImage(swap_chain_size, swap_chain);
     dc_layer_params->content_rect = gfx::Rect(swap_chain_size);
@@ -1225,7 +1225,7 @@ TEST_F(DirectCompositionPixelTest, SwapChainImage) {
 
     ASSERT_TRUE(SUCCEEDED(swap_chain->Present1(0, 0, &present_params)));
 
-    auto dc_layer_params = std::make_unique<ui::DCRendererLayerParams>();
+    auto dc_layer_params = std::make_unique<DCLayerOverlayParams>();
     dc_layer_params->overlay_image =
         DCLayerOverlayImage(swap_chain_size, swap_chain);
     dc_layer_params->content_rect = gfx::Rect(swap_chain_size);
@@ -1249,7 +1249,7 @@ TEST_F(DirectCompositionPixelTest, SwapChainImage) {
   {
     ASSERT_TRUE(SUCCEEDED(swap_chain->Present1(0, 0, &present_params)));
 
-    auto dc_layer_params = std::make_unique<ui::DCRendererLayerParams>();
+    auto dc_layer_params = std::make_unique<DCLayerOverlayParams>();
     dc_layer_params->overlay_image =
         DCLayerOverlayImage(swap_chain_size, swap_chain);
     dc_layer_params->content_rect = gfx::Rect(swap_chain_size);
@@ -1273,7 +1273,7 @@ TEST_F(DirectCompositionPixelTest, SwapChainImage) {
     float clear_color[] = {0.0, 0.0, 1.0, 1.0};
     context->ClearRenderTargetView(rtv.Get(), clear_color);
 
-    auto dc_layer_params = std::make_unique<ui::DCRendererLayerParams>();
+    auto dc_layer_params = std::make_unique<DCLayerOverlayParams>();
     dc_layer_params->overlay_image =
         DCLayerOverlayImage(swap_chain_size, swap_chain);
     dc_layer_params->content_rect = gfx::Rect(swap_chain_size);
@@ -1415,7 +1415,7 @@ void RunBufferCountTest(scoped_refptr<DirectCompositionSurfaceWin> surface,
     Microsoft::WRL::ComPtr<ID3D11Texture2D> texture =
         CreateNV12Texture(d3d11_device, texture_size);
 
-    auto params = std::make_unique<ui::DCRendererLayerParams>();
+    auto params = std::make_unique<DCLayerOverlayParams>();
     params->overlay_image.emplace(texture_size, texture);
     params->content_rect = gfx::Rect(texture_size);
     params->quad_rect = gfx::Rect(window_size);
diff --git a/ui/gl/gl_surface.cc b/ui/gl/gl_surface.cc
index f65de74cbea91..0e9057c69587d 100644
--- a/ui/gl/gl_surface.cc
+++ b/ui/gl/gl_surface.cc
@@ -14,12 +14,19 @@
 #include "base/trace_event/trace_event.h"
 #include "ui/gfx/gpu_fence.h"
 #include "ui/gfx/swap_result.h"
-#include "ui/gl/dc_renderer_layer_params.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_format.h"
 #include "ui/gl/gl_switches.h"
 
+#if BUILDFLAG(IS_WIN)
+#include "ui/gl/dc_layer_overlay_params.h"
+#else
+namespace gl {
+struct DCLayerOverlayParams {};
+}  // namespace gl
+#endif
+
 namespace gl {
 
 namespace {
@@ -169,8 +176,7 @@ bool GLSurface::ScheduleCALayer(const ui::CARendererLayerParams& params) {
   return false;
 }
 
-bool GLSurface::ScheduleDCLayer(
-    std::unique_ptr<ui::DCRendererLayerParams> params) {
+bool GLSurface::ScheduleDCLayer(std::unique_ptr<DCLayerOverlayParams> params) {
   NOTIMPLEMENTED();
   return false;
 }
@@ -485,7 +491,7 @@ bool GLSurfaceAdapter::ScheduleOverlayPlane(
 }
 
 bool GLSurfaceAdapter::ScheduleDCLayer(
-    std::unique_ptr<ui::DCRendererLayerParams> params) {
+    std::unique_ptr<DCLayerOverlayParams> params) {
   return surface_->ScheduleDCLayer(std::move(params));
 }
 
diff --git a/ui/gl/gl_surface.h b/ui/gl/gl_surface.h
index 3bf9c2a35e769..7524af518a767 100644
--- a/ui/gl/gl_surface.h
+++ b/ui/gl/gl_surface.h
@@ -55,11 +55,11 @@ class VSyncProvider;
 
 namespace ui {
 struct CARendererLayerParams;
-struct DCRendererLayerParams;
 }  // namespace ui
 
 namespace gl {
 
+struct DCLayerOverlayParams;
 class GLContext;
 class GLImage;
 class EGLTimestampClient;
@@ -276,8 +276,7 @@ class GL_EXPORT GLSurface : public base::RefCounted<GLSurface>,
   // All arguments correspond to their CALayer properties.
   virtual bool ScheduleCALayer(const ui::CARendererLayerParams& params);
 
-  virtual bool ScheduleDCLayer(
-      std::unique_ptr<ui::DCRendererLayerParams> params);
+  virtual bool ScheduleDCLayer(std::unique_ptr<DCLayerOverlayParams> params);
 
   // Enables or disables DC layers, returning success. If failed, it is possible
   // that the context is no longer current.
@@ -440,8 +439,7 @@ class GL_EXPORT GLSurfaceAdapter : public GLSurface {
       OverlayImage image,
       std::unique_ptr<gfx::GpuFence> gpu_fence,
       const gfx::OverlayPlaneData& overlay_plane_data) override;
-  bool ScheduleDCLayer(
-      std::unique_ptr<ui::DCRendererLayerParams> params) override;
+  bool ScheduleDCLayer(std::unique_ptr<DCLayerOverlayParams> params) override;
   bool SetEnableDCLayers(bool enable) override;
   bool IsSurfaceless() const override;
   bool SupportsViewporter() const override;
diff --git a/ui/gl/swap_chain_presenter.cc b/ui/gl/swap_chain_presenter.cc
index bbab02db7c878..31180909548a7 100644
--- a/ui/gl/swap_chain_presenter.cc
+++ b/ui/gl/swap_chain_presenter.cc
@@ -540,7 +540,7 @@ gfx::Size SwapChainPresenter::GetMonitorSize() {
 }
 
 void SwapChainPresenter::AdjustTargetToOptimalSizeIfNeeded(
-    const ui::DCRendererLayerParams& params,
+    const DCLayerOverlayParams& params,
     const gfx::Rect& overlay_onscreen_rect,
     gfx::Size* swap_chain_size,
     gfx::Transform* visual_transform,
@@ -561,7 +561,7 @@ void SwapChainPresenter::AdjustTargetToOptimalSizeIfNeeded(
 
 bool SwapChainPresenter::AdjustTargetToFullScreenSizeIfNeeded(
     const gfx::Size& monitor_size,
-    const ui::DCRendererLayerParams& params,
+    const DCLayerOverlayParams& params,
     const gfx::Rect& overlay_onscreen_rect,
     gfx::Size* swap_chain_size,
     gfx::Transform* visual_transform,
@@ -653,7 +653,7 @@ bool SwapChainPresenter::AdjustTargetToFullScreenSizeIfNeeded(
 
 void SwapChainPresenter::AdjustTargetForFullScreenLetterboxing(
     const gfx::Size& monitor_size,
-    const ui::DCRendererLayerParams& params,
+    const DCLayerOverlayParams& params,
     const gfx::Rect& overlay_onscreen_rect,
     gfx::Size* swap_chain_size,
     gfx::Transform* visual_transform,
@@ -816,7 +816,7 @@ void SwapChainPresenter::AdjustTargetForFullScreenLetterboxing(
 }
 
 gfx::Size SwapChainPresenter::CalculateSwapChainSize(
-    const ui::DCRendererLayerParams& params,
+    const DCLayerOverlayParams& params,
     gfx::Transform* visual_transform,
     gfx::Rect* visual_clip_rect) {
   // Swap chain size is the minimum of the on-screen size and the source size so
@@ -1062,7 +1062,7 @@ bool SwapChainPresenter::PresentToDecodeSwapChain(
   return true;
 }
 
-bool SwapChainPresenter::PresentToSwapChain(ui::DCRendererLayerParams& params,
+bool SwapChainPresenter::PresentToSwapChain(DCLayerOverlayParams& params,
                                             gfx::Transform* visual_transform,
                                             gfx::Rect* visual_clip_rect) {
   DCHECK(params.overlay_image);
@@ -1332,7 +1332,7 @@ void SwapChainPresenter::RecordPresentationStatistics() {
   }
 }
 
-bool SwapChainPresenter::PresentDCOMPSurface(ui::DCRendererLayerParams& params,
+bool SwapChainPresenter::PresentDCOMPSurface(DCLayerOverlayParams& params,
                                              gfx::Transform* visual_transform,
                                              gfx::Rect* visual_clip_rect) {
   // TODO(crbug.com/999747): Include an early out path in case the same dcomp
diff --git a/ui/gl/swap_chain_presenter.h b/ui/gl/swap_chain_presenter.h
index 8018b42f45322..b27e4b432c11a 100644
--- a/ui/gl/swap_chain_presenter.h
+++ b/ui/gl/swap_chain_presenter.h
@@ -16,8 +16,8 @@
 #include "base/time/time.h"
 #include "base/win/scoped_handle.h"
 #include "ui/gfx/color_space.h"
+#include "ui/gl/dc_layer_overlay_params.h"
 #include "ui/gl/dc_layer_tree.h"
-#include "ui/gl/dc_renderer_layer_params.h"
 
 namespace gl {
 
@@ -41,7 +41,7 @@ class SwapChainPresenter : public base::PowerStateObserver {
   // returns a modified |visual_transform| and |visual_clip_rect| that should be
   // used instead of the ones on |overlay|.
   // Returns true on success.
-  bool PresentToSwapChain(ui::DCRendererLayerParams& overlay,
+  bool PresentToSwapChain(DCLayerOverlayParams& overlay,
                           gfx::Transform* visual_transform,
                           gfx::Rect* visual_clip_rect);
 
@@ -134,19 +134,18 @@ class SwapChainPresenter : public base::PowerStateObserver {
   // needed to scale the swap chain backbuffer to the monitor size.
   // The visual_clip_rect will be adjusted to the monitor size for fullscreen
   // mode, and to the video overlay quad for letterboxing mode.
-  void AdjustTargetToOptimalSizeIfNeeded(
-      const ui::DCRendererLayerParams& params,
-      const gfx::Rect& overlay_onscreen_rect,
-      gfx::Size* swap_chain_size,
-      gfx::Transform* visual_transform,
-      gfx::Rect* visual_clip_rect);
+  void AdjustTargetToOptimalSizeIfNeeded(const DCLayerOverlayParams& params,
+                                         const gfx::Rect& overlay_onscreen_rect,
+                                         gfx::Size* swap_chain_size,
+                                         gfx::Transform* visual_transform,
+                                         gfx::Rect* visual_clip_rect);
 
   // If the swap chain size is very close to the screen size but not exactly the
   // same, the swap chain should be adjusted to fit the screen size in order to
   // get the fullscreen DWM optimizations.
   bool AdjustTargetToFullScreenSizeIfNeeded(
       const gfx::Size& monitor_size,
-      const ui::DCRendererLayerParams& params,
+      const DCLayerOverlayParams& params,
       const gfx::Rect& overlay_onscreen_rect,
       gfx::Size* swap_chain_size,
       gfx::Transform* visual_transform,
@@ -154,14 +153,14 @@ class SwapChainPresenter : public base::PowerStateObserver {
 
   void AdjustTargetForFullScreenLetterboxing(
       const gfx::Size& monitor_size,
-      const ui::DCRendererLayerParams& params,
+      const DCLayerOverlayParams& params,
       const gfx::Rect& overlay_onscreen_rect,
       gfx::Size* swap_chain_size,
       gfx::Transform* visual_transform,
       gfx::Rect* visual_clip_rect);
 
   // Returns optimal swap chain size for given layer.
-  gfx::Size CalculateSwapChainSize(const ui::DCRendererLayerParams& params,
+  gfx::Size CalculateSwapChainSize(const DCLayerOverlayParams& params,
                                    gfx::Transform* visual_transform,
                                    gfx::Rect* visual_clip_rect);
 
@@ -207,7 +206,7 @@ class SwapChainPresenter : public base::PowerStateObserver {
   Microsoft::WRL::ComPtr<IDXGISwapChainMedia> GetSwapChainMedia() const;
 
   // Present the Direct Composition surface from MediaFoundationRenderer.
-  bool PresentDCOMPSurface(ui::DCRendererLayerParams& overlay,
+  bool PresentDCOMPSurface(DCLayerOverlayParams& overlay,
                            gfx::Transform* visual_transform,
                            gfx::Rect* visual_clip_rect);