Move draw quad interfaces to SkColor4f

All GetAll and SetAll methods for quad classes in components/viz/common/quads now use SkColor4f directly.

Next move will be to clear up the classes marked in TODOs in this CL, after that I believe that the viz folder will be almost entirely moved to float color.

After a rebase all tests with internals.useMockOverlayScrollbars() are
now failing due to float rounding errors when comparing a float color
with an integer color. Once this color changes in blink to float the tests can be reenabled:

https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/scroll/scrollbar_theme_overlay_mock.h;l=48

Bug: 1308932
Change-Id: I682f5cb1f959634373b89bf4fb378b3b967b1d79
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3700159
Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
Reviewed-by: Vasiliy Telezhnikov <vasilyt@chromium.org>
Reviewed-by: Mitsuru Oshima <oshima@chromium.org>
Commit-Queue: Aaron Krajeski <aaronhk@chromium.org>
Reviewed-by: Juanmi Huertas <juanmihd@chromium.org>
Reviewed-by: ccameron chromium <ccameron@chromium.org>
Reviewed-by: Piotr Bialecki <bialpio@chromium.org>
Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1018567}

android_webview/browser/gfx/hardware_renderer_viz.cc

@@ -227,7 +227,8 @@ void HardwareRendererViz::OnViz::DrawAndSwapOnViz(
   surface_quad->SetNew(quad_state, gfx::Rect(quad_state->quad_layer_rect),
                        gfx::Rect(quad_state->quad_layer_rect),
                        viz::SurfaceRange(absl::nullopt, child_id),
-                       SK_ColorWHITE, /*stretch_content_to_fill_bounds=*/false);
+                       SkColors::kWhite,
+                       /*stretch_content_to_fill_bounds=*/false);
 
   viz::CompositorFrame frame;
   // We draw synchronously, so acknowledge a manual BeginFrame.

android_webview/browser/gfx/test/invalidate_test.cc

@@ -46,7 +46,8 @@ void AppendSurfaceDrawQuad(viz::CompositorRenderPass& render_pass,
   surface_quad->SetNew(quad_state, gfx::Rect(quad_state->quad_layer_rect),
                        gfx::Rect(quad_state->quad_layer_rect),
                        viz::SurfaceRange(absl::nullopt, child_id),
-                       SK_ColorWHITE, /*stretch_content_to_fill_bounds=*/false);
+                       SkColors::kWhite,
+                       /*stretch_content_to_fill_bounds=*/false);
 }
 
 void AppendSolidColorDrawQuad(viz::CompositorRenderPass& render_pass) {
@@ -63,7 +64,7 @@ void AppendSolidColorDrawQuad(viz::CompositorRenderPass& render_pass) {
       render_pass.CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
   solid_color_quad->SetNew(quad_state, gfx::Rect(quad_state->quad_layer_rect),
                            gfx::Rect(quad_state->quad_layer_rect),
-                           SK_ColorWHITE, /*force_anti_aliasing_off=*/false);
+                           SkColors::kWhite, /*force_anti_aliasing_off=*/false);
 }
 
 class VizClient : public viz::mojom::CompositorFrameSinkClient {

ash/fast_ink/fast_ink_host.cc

@@ -430,7 +430,7 @@ void FastInkHost::SubmitCompositorFrame() {
       quad_state, quad_rect, quad_rect,
       /*needs_blending=*/true, transferable_resource.id,
       /*premultiplied_alpha=*/true, uv_crop.origin(), uv_crop.bottom_right(),
-      /*background_color=*/SK_ColorTRANSPARENT, vertex_opacity,
+      /*background_color=*/SkColors::kTransparent, vertex_opacity,
       /*y_flipped=*/false,
       /*nearest_neighbor=*/false,
       /*secure_output_only=*/false, gfx::ProtectedVideoType::kClear);

ash/fast_ink/view_tree_host_root_view.cc

@@ -490,7 +490,7 @@ void ViewTreeHostRootView::SubmitCompositorFrame() {
       quad_state, quad_rect, quad_rect,
       /*needs_blending=*/true, transferable_resource.id,
       /*premultiplied_alpha=*/true, uv_crop.origin(), uv_crop.bottom_right(),
-      SK_ColorTRANSPARENT, vertex_opacity,
+      SkColors::kTransparent, vertex_opacity,
       /*y_flipped=*/false,
       /*nearest_neighbor=*/false,
       /*secure_output_only=*/false, gfx::ProtectedVideoType::kClear);

cc/layers/heads_up_display_layer_impl.cc

@@ -223,7 +223,7 @@ void HeadsUpDisplayLayerImpl::AppendQuads(
   // layers.
   gfx::Rect quad_rect(internal_content_bounds_);
   auto* quad = render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
-  quad->SetNew(shared_quad_state, quad_rect, quad_rect, SK_ColorTRANSPARENT,
+  quad->SetNew(shared_quad_state, quad_rect, quad_rect, SkColors::kTransparent,
                false);
   ValidateQuadResources(quad);
   current_quad_ = quad;
@@ -491,7 +491,7 @@ void HeadsUpDisplayLayerImpl::UpdateHudTexture(
                    resource_id, /*premultiplied_alpha=*/true,
                    /*uv_top_left=*/gfx::PointF(),
                    /*uv_bottom_right=*/uv_bottom_right,
-                   /*background_color=*/SK_ColorTRANSPARENT, vertex_opacity,
+                   /*background_color=*/SkColors::kTransparent, vertex_opacity,
                    /*flipped=*/false,
                    /*nearest_neighbor=*/false, /*secure_output_only=*/false,
                    gfx::ProtectedVideoType::kClear);

cc/layers/layer_impl.cc

@@ -273,15 +273,14 @@ void LayerImpl::AppendDebugBorderQuad(
   gfx::Rect visible_quad_rect(quad_rect);
   auto* debug_border_quad =
       render_pass->CreateAndAppendDrawQuad<viz::DebugBorderDrawQuad>();
-  // TODO(crbug/1308932): Remove toSkColor and make all SkColor4f.
   debug_border_quad->SetNew(shared_quad_state, quad_rect, visible_quad_rect,
-                            color.toSkColor(), width);
+                            color, width);
   if (contents_opaque()) {
     // When opaque, draw a second inner border that is thicker than the outer
     // border, but more transparent.
     static const float kFillOpacity = 0.3f;
     SkColor4f fill_color = color;
-    color.fA *= kFillOpacity;
+    fill_color.fA *= kFillOpacity;
     float fill_width = width * 3;
     gfx::Rect fill_rect = quad_rect;
     fill_rect.Inset(fill_width / 2.f);
@@ -289,11 +288,10 @@ void LayerImpl::AppendDebugBorderQuad(
       return;
     gfx::Rect visible_fill_rect =
         gfx::IntersectRects(visible_quad_rect, fill_rect);
-    // TODO(crbug/1308932): Remove toSkColor and make all SkColor4f.
     auto* fill_quad =
         render_pass->CreateAndAppendDrawQuad<viz::DebugBorderDrawQuad>();
     fill_quad->SetNew(shared_quad_state, fill_rect, visible_fill_rect,
-                      fill_color.toSkColor(), fill_width);
+                      fill_color, fill_width);
   }
 }
 

cc/layers/nine_patch_generator.cc

@@ -361,7 +361,7 @@ void NinePatchGenerator::AppendQuads(LayerImpl* layer_impl,
       auto* quad = render_pass->CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
       quad->SetNew(shared_quad_state, output_rect, visible_rect, needs_blending,
                    resource, premultiplied_alpha, image_rect.origin(),
-                   image_rect.bottom_right(), SK_ColorTRANSPARENT,
+                   image_rect.bottom_right(), SkColors::kTransparent,
                    vertex_opacity, flipped, nearest_neighbor_,
                    /*secure_output_only=*/false,
                    gfx::ProtectedVideoType::kClear);

cc/layers/painted_overlay_scrollbar_layer_impl.cc

@@ -162,11 +162,12 @@ void PaintedOverlayScrollbarLayerImpl::AppendTrackQuads(
   float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
   viz::TextureDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
-  quad->SetNew(
-      shared_quad_state, scaled_track_quad_rect, scaled_visible_track_quad_rect,
-      needs_blending, track_resource_id, premultipled_alpha, uv_top_left,
-      uv_bottom_right, SK_ColorTRANSPARENT, opacity, flipped, nearest_neighbor,
-      /*secure_output_only=*/false, gfx::ProtectedVideoType::kClear);
+  quad->SetNew(shared_quad_state, scaled_track_quad_rect,
+               scaled_visible_track_quad_rect, needs_blending,
+               track_resource_id, premultipled_alpha, uv_top_left,
+               uv_bottom_right, SkColors::kTransparent, opacity, flipped,
+               nearest_neighbor,
+               /*secure_output_only=*/false, gfx::ProtectedVideoType::kClear);
   ValidateQuadResources(quad);
 }
 

cc/layers/painted_scrollbar_layer_impl.cc

@@ -130,7 +130,7 @@ void PaintedScrollbarLayerImpl::AppendQuads(
     quad->SetNew(shared_quad_state, scaled_thumb_quad_rect,
                  scaled_visible_thumb_quad_rect, needs_blending,
                  thumb_resource_id, premultipled_alpha, uv_top_left,
-                 uv_bottom_right, SK_ColorTRANSPARENT, opacity, flipped,
+                 uv_bottom_right, SkColors::kTransparent, opacity, flipped,
                  nearest_neighbor, /*secure_output_only=*/false,
                  gfx::ProtectedVideoType::kClear);
     ValidateQuadResources(quad);
@@ -150,7 +150,7 @@ void PaintedScrollbarLayerImpl::AppendQuads(
     quad->SetNew(shared_quad_state, scaled_track_quad_rect,
                  scaled_visible_track_quad_rect, needs_blending,
                  track_resource_id, premultipled_alpha, uv_top_left,
-                 uv_bottom_right, SK_ColorTRANSPARENT, opacity, flipped,
+                 uv_bottom_right, SkColors::kTransparent, opacity, flipped,
                  nearest_neighbor, /*secure_output_only=*/false,
                  gfx::ProtectedVideoType::kClear);
     ValidateQuadResources(quad);

cc/layers/picture_layer_impl.cc

@@ -400,24 +400,20 @@ void PictureLayerImpl::AppendQuads(viz::CompositorRenderPass* render_pass,
       gfx::Rect geometry_rect = iter.geometry_rect();
       geometry_rect.Offset(quad_offset);
       gfx::Rect visible_geometry_rect = geometry_rect;
-      // TODO(crbug/1308932): Remove  toSkColor  and make all SkColor4f.
       debug_border_quad->SetNew(shared_quad_state, geometry_rect,
-                                visible_geometry_rect, color.toSkColor(),
-                                width);
+                                visible_geometry_rect, color, width);
     }
   }
 
   if (layer_tree_impl()->debug_state().highlight_non_lcd_text_layers) {
-    // TODO(crbug/1308932): Remove all instances of toSkColor below and make all
-    // SkColor4f.
     SkColor4f color =
         DebugColors::NonLCDTextHighlightColor(lcd_text_disallowed_reason());
     if (color != SkColors::kTransparent &&
         GetRasterSource()->GetDisplayItemList()->AreaOfDrawText(
             gfx::Rect(bounds()))) {
       render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>()->SetNew(
-          shared_quad_state, debug_border_rect, debug_border_rect,
-          color.toSkColor(), append_quads_data);
+          shared_quad_state, debug_border_rect, debug_border_rect, color,
+          append_quads_data);
     }
   }
 
@@ -499,9 +495,11 @@ void PictureLayerImpl::AppendQuads(viz::CompositorRenderPass* render_pass,
           if (alpha >= std::numeric_limits<float>::epsilon()) {
             auto* quad =
                 render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
+            // TODO(crbug.com/1308932): draw_info.solid_color to SkColor4f
             quad->SetNew(
                 shared_quad_state, offset_geometry_rect,
-                offset_visible_geometry_rect, draw_info.solid_color(),
+                offset_visible_geometry_rect,
+                SkColor4f::FromColor(draw_info.solid_color()),
                 !layer_tree_impl()->settings().enable_edge_anti_aliasing);
             ValidateQuadResources(quad);
           }
@@ -522,9 +520,8 @@ void PictureLayerImpl::AppendQuads(viz::CompositorRenderPass* render_pass,
       }
       auto* quad =
           render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
-      // TODO(crbug/1308932): Remove toSkColor and make all SkColor4f.
       quad->SetNew(shared_quad_state, offset_geometry_rect,
-                   offset_visible_geometry_rect, color.toSkColor(), false);
+                   offset_visible_geometry_rect, color, false);
       ValidateQuadResources(quad);
 
       if (geometry_rect.Intersects(scaled_viewport_for_tile_priority)) {

cc/layers/render_surface_impl.cc

@@ -110,9 +110,8 @@ SkBlendMode RenderSurfaceImpl::BlendMode() const {
   return OwningEffectNode()->blend_mode;
 }
 
-SkColor RenderSurfaceImpl::GetDebugBorderColor() const {
-  // TODO(crbug/1308932): Remove toSkColor and make all SkColor4f.
-  return DebugColors::SurfaceBorderColor().toSkColor();
+SkColor4f RenderSurfaceImpl::GetDebugBorderColor() const {
+  return DebugColors::SurfaceBorderColor();
 }
 
 float RenderSurfaceImpl::GetDebugBorderWidth() const {

cc/layers/render_surface_impl.h

@@ -90,7 +90,7 @@ class CC_EXPORT RenderSurfaceImpl {
     return nearest_occlusion_immune_ancestor_;
   }
 
-  SkColor GetDebugBorderColor() const;
+  SkColor4f GetDebugBorderColor() const;
   float GetDebugBorderWidth() const;
 
   void SetDrawTransform(const gfx::Transform& draw_transform) {

cc/layers/solid_color_layer_impl.cc

@@ -57,9 +57,8 @@ void SolidColorLayerImpl::AppendSolidQuads(
     return;
 
   auto* quad = render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
-  // TODO(crbug/1308932): Remove toSkColor and make all SkColor4f.
-  quad->SetNew(shared_quad_state, visible_layer_rect, visible_quad_rect,
-               color.toSkColor(), force_anti_aliasing_off);
+  quad->SetNew(shared_quad_state, visible_layer_rect, visible_quad_rect, color,
+               force_anti_aliasing_off);
 }
 
 void SolidColorLayerImpl::AppendQuads(viz::CompositorRenderPass* render_pass,

cc/layers/solid_color_scrollbar_layer_impl.cc

@@ -106,9 +106,8 @@ void SolidColorScrollbarLayerImpl::AppendQuads(
     return;
 
   auto* quad = render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
-  // TODO(crbug/1308932): Remove toSkColor and make all SkColor4f.
-  quad->SetNew(shared_quad_state, thumb_quad_rect, visible_quad_rect,
-               color_.toSkColor(), false);
+  quad->SetNew(shared_quad_state, thumb_quad_rect, visible_quad_rect, color_,
+               false);
 }
 
 const char* SolidColorScrollbarLayerImpl::LayerTypeAsString() const {

cc/layers/surface_layer_impl.cc

@@ -182,9 +182,8 @@ void SurfaceLayerImpl::AppendQuads(viz::CompositorRenderPass* render_pass,
 
   if (surface_range_.IsValid()) {
     auto* quad = render_pass->CreateAndAppendDrawQuad<viz::SurfaceDrawQuad>();
-    // TODO(crbug/1308932): Remove toSkColor and make all SkColor4f.
     quad->SetNew(shared_quad_state, quad_rect, visible_quad_rect,
-                 surface_range_, background_color().toSkColor(),
+                 surface_range_, background_color(),
                  stretch_content_to_fill_bounds_);
     quad->is_reflection = is_reflection_;
     // Add the primary surface ID as a dependency.
@@ -200,10 +199,8 @@ void SurfaceLayerImpl::AppendQuads(viz::CompositorRenderPass* render_pass,
   } else {
     auto* quad =
         render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
-    // TODO(crbug/1308932): Remove toSkColor and make all SkColor4f.
     quad->SetNew(shared_quad_state, quad_rect, visible_quad_rect,
-                 background_color().toSkColor(),
-                 false /* force_anti_aliasing_off */);
+                 background_color(), false /* force_anti_aliasing_off */);
   }
 
   // Unless the client explicitly specifies otherwise, don't block on
@@ -236,10 +233,10 @@ void SurfaceLayerImpl::AppendRainbowDebugBorder(
       render_pass->CreateAndAppendSharedQuadState();
   PopulateSharedQuadState(shared_quad_state, contents_opaque());
 
-  SkColor4f color;
   float border_width;
-  GetDebugBorderProperties(&color, &border_width);
+  GetDebugBorderProperties(nullptr, &border_width);
 
+  // TODO(crbug.com/1308932) Make these SkColor4fs
   SkColor colors[] = {
       0x80ff0000,  // Red.
       0x80ffa500,  // Orange.
@@ -274,14 +271,16 @@ void SurfaceLayerImpl::AppendRainbowDebugBorder(
       bool force_anti_aliasing_off = false;
       auto* top_quad =
           render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
-      top_quad->SetNew(shared_quad_state, top, top, colors[i % kNumColors],
+      top_quad->SetNew(shared_quad_state, top, top,
+                       SkColor4f::FromColor(colors[i % kNumColors]),
                        force_anti_aliasing_off);
 
       auto* bottom_quad =
           render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
-      bottom_quad->SetNew(shared_quad_state, bottom, bottom,
-                          colors[kNumColors - 1 - (i % kNumColors)],
-                          force_anti_aliasing_off);
+      bottom_quad->SetNew(
+          shared_quad_state, bottom, bottom,
+          SkColor4f::FromColor(colors[kNumColors - 1 - (i % kNumColors)]),
+          force_anti_aliasing_off);
 
       if (contents_opaque()) {
         // Draws a stripe filling the layer vertically with the same color and
@@ -295,7 +294,8 @@ void SurfaceLayerImpl::AppendRainbowDebugBorder(
             static_cast<uint8_t>(SkColorGetA(colors[i % kNumColors]) *
                                  kFillOpacity));
         gfx::Rect fill_rect(x, 0, width, bounds().height());
-        solid_quad->SetNew(shared_quad_state, fill_rect, fill_rect, fill_color,
+        solid_quad->SetNew(shared_quad_state, fill_rect, fill_rect,
+                           SkColor4f::FromColor(fill_color),
                            force_anti_aliasing_off);
       }
     }
@@ -303,14 +303,16 @@ void SurfaceLayerImpl::AppendRainbowDebugBorder(
       bool force_anti_aliasing_off = false;
       auto* left_quad =
           render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
-      left_quad->SetNew(shared_quad_state, left, left,
-                        colors[kNumColors - 1 - (i % kNumColors)],
-                        force_anti_aliasing_off);
+      left_quad->SetNew(
+          shared_quad_state, left, left,
+          SkColor4f::FromColor(colors[kNumColors - 1 - (i % kNumColors)]),
+          force_anti_aliasing_off);
 
       auto* right_quad =
           render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
       right_quad->SetNew(shared_quad_state, right, right,
-                         colors[i % kNumColors], force_anti_aliasing_off);
+                         SkColor4f::FromColor(colors[i % kNumColors]),
+                         force_anti_aliasing_off);
     }
   }
 }

cc/layers/texture_layer_impl.cc

@@ -147,11 +147,10 @@ void TextureLayerImpl::AppendQuads(viz::CompositorRenderPass* render_pass,
     return;
 
   float vertex_opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
-  // TODO(crbug/1308932): Remove toSkColor and make all SkColor4f.
   auto* quad = render_pass->CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
   quad->SetNew(shared_quad_state, quad_rect, visible_quad_rect, needs_blending,
                resource_id_, premultiplied_alpha_, uv_top_left_,
-               uv_bottom_right_, bg_color.toSkColor(), vertex_opacity, flipped_,
+               uv_bottom_right_, bg_color, vertex_opacity, flipped_,
                nearest_neighbor_, /*secure_output=*/false,
                gfx::ProtectedVideoType::kClear);
   quad->set_resource_size_in_pixels(transferable_resource_.size);

cc/layers/ui_resource_layer_impl.cc

@@ -130,7 +130,8 @@ void UIResourceLayerImpl::AppendQuads(viz::CompositorRenderPass* render_pass,
   auto* quad = render_pass->CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
   quad->SetNew(shared_quad_state, quad_rect, visible_quad_rect, needs_blending,
                resource, premultiplied_alpha, uv_top_left_, uv_bottom_right_,
-               SK_ColorTRANSPARENT, vertex_opacity_, flipped, nearest_neighbor,
+               SkColors::kTransparent, vertex_opacity_, flipped,
+               nearest_neighbor,
                /*secure_output_only=*/false, gfx::ProtectedVideoType::kClear);
   ValidateQuadResources(quad);
 }

cc/test/render_pass_test_utils.cc

@@ -110,7 +110,7 @@ viz::AggregatedRenderPass* AddRenderPassWithDamage(
 
 viz::SolidColorDrawQuad* AddClippedQuad(viz::AggregatedRenderPass* pass,
                                         const gfx::Rect& rect,
-                                        SkColor color) {
+                                        SkColor4f color) {
   viz::SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
   shared_state->SetAll(gfx::Transform(), rect, rect, gfx::MaskFilterInfo(),
                        rect, false, 1, SkBlendMode::kSrcOver, 0);
@@ -121,7 +121,7 @@ viz::SolidColorDrawQuad* AddClippedQuad(viz::AggregatedRenderPass* pass,
 
 viz::SolidColorDrawQuad* AddTransformedQuad(viz::AggregatedRenderPass* pass,
                                             const gfx::Rect& rect,
-                                            SkColor color,
+                                            SkColor4f color,
                                             const gfx::Transform& transform) {
   viz::SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
   shared_state->SetAll(transform, rect, rect, gfx::MaskFilterInfo(),
@@ -223,7 +223,8 @@ std::vector<viz::ResourceId> AddOneOfEveryQuadType(
 
   auto* debug_border_quad =
       to_pass->CreateAndAppendDrawQuad<viz::DebugBorderDrawQuad>();
-  debug_border_quad->SetNew(shared_state, rect, visible_rect, SK_ColorRED, 1);
+  debug_border_quad->SetNew(shared_state, rect, visible_rect, SkColors::kRed,
+                            1);
 
   if (child_pass_id) {
     auto* render_pass_quad =
@@ -236,7 +237,7 @@ std::vector<viz::ResourceId> AddOneOfEveryQuadType(
 
   auto* solid_color_quad =
       to_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
-  solid_color_quad->SetNew(shared_state, rect, visible_rect, SK_ColorRED,
+  solid_color_quad->SetNew(shared_state, rect, visible_rect, SkColors::kRed,
                            false);
 
   auto* stream_video_quad =
@@ -248,14 +249,14 @@ std::vector<viz::ResourceId> AddOneOfEveryQuadType(
   auto* texture_quad = to_pass->CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
   texture_quad->SetNew(
       shared_state, rect, visible_rect, needs_blending, resource1, false,
-      gfx::PointF(0.f, 0.f), gfx::PointF(1.f, 1.f), SK_ColorTRANSPARENT,
+      gfx::PointF(0.f, 0.f), gfx::PointF(1.f, 1.f), SkColors::kTransparent,
       vertex_opacity, false, false, false, gfx::ProtectedVideoType::kClear);
 
   auto* external_resource_texture_quad =
       to_pass->CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
   external_resource_texture_quad->SetNew(
       shared_state, rect, visible_rect, needs_blending, resource8, false,
-      gfx::PointF(0.f, 0.f), gfx::PointF(1.f, 1.f), SK_ColorTRANSPARENT,
+      gfx::PointF(0.f, 0.f), gfx::PointF(1.f, 1.f), SkColors::kTransparent,
       vertex_opacity, false, false, false, gfx::ProtectedVideoType::kClear);
 
   auto* scaled_tile_quad =
@@ -400,7 +401,8 @@ void AddOneOfEveryQuadTypeInDisplayResourceProvider(
 
   viz::DebugBorderDrawQuad* debug_border_quad =
       to_pass->CreateAndAppendDrawQuad<viz::DebugBorderDrawQuad>();
-  debug_border_quad->SetNew(shared_state, rect, visible_rect, SK_ColorRED, 1);
+  debug_border_quad->SetNew(shared_state, rect, visible_rect, SkColors::kRed,
+                            1);
   if (child_pass_id) {
     auto* render_pass_quad =
         to_pass->CreateAndAppendDrawQuad<viz::AggregatedRenderPassDrawQuad>();
@@ -412,7 +414,7 @@ void AddOneOfEveryQuadTypeInDisplayResourceProvider(
 
   viz::SolidColorDrawQuad* solid_color_quad =
       to_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
-  solid_color_quad->SetNew(shared_state, rect, visible_rect, SK_ColorRED,
+  solid_color_quad->SetNew(shared_state, rect, visible_rect, SkColors::kRed,
                            false);
 
   viz::StreamVideoDrawQuad* stream_video_quad =
@@ -425,14 +427,14 @@ void AddOneOfEveryQuadTypeInDisplayResourceProvider(
       to_pass->CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
   texture_quad->SetNew(
       shared_state, rect, visible_rect, needs_blending, mapped_resource1, false,
-      gfx::PointF(0.f, 0.f), gfx::PointF(1.f, 1.f), SK_ColorTRANSPARENT,
+      gfx::PointF(0.f, 0.f), gfx::PointF(1.f, 1.f), SkColors::kTransparent,
       vertex_opacity, false, false, false, gfx::ProtectedVideoType::kClear);
 
   viz::TextureDrawQuad* external_resource_texture_quad =
       to_pass->CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
   external_resource_texture_quad->SetNew(
       shared_state, rect, visible_rect, needs_blending, mapped_resource8, false,
-      gfx::PointF(0.f, 0.f), gfx::PointF(1.f, 1.f), SK_ColorTRANSPARENT,
+      gfx::PointF(0.f, 0.f), gfx::PointF(1.f, 1.f), SkColors::kTransparent,
       vertex_opacity, false, false, false, gfx::ProtectedVideoType::kClear);
 
   viz::TileDrawQuad* scaled_tile_quad =

cc/test/render_pass_test_utils.h

@@ -70,7 +70,7 @@ viz::AggregatedRenderPass* AddRenderPassWithDamage(
 template <typename RenderPassType>
 inline viz::SolidColorDrawQuad* AddQuad(RenderPassType* pass,
                                         const gfx::Rect& rect,
-                                        SkColor color) {
+                                        SkColor4f color) {
   viz::SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
   shared_state->SetAll(gfx::Transform(), rect, rect, gfx::MaskFilterInfo(),
                        absl::nullopt, false, 1, SkBlendMode::kSrcOver, 0);

cc/trees/layer_tree_host_impl.cc

@@ -1145,8 +1145,10 @@ static void AppendQuadsToFillScreen(
     // occlusion checks.
     auto* quad =
         target_render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
+    // TODO(crbug.com/1308932): Call this function with SkColor4f
     quad->SetNew(shared_quad_state, screen_space_rect,
-                 visible_screen_space_rect, screen_background_color, false);
+                 visible_screen_space_rect,
+                 SkColor4f::FromColor(screen_background_color), false);
   }
 }
 

cc/trees/layer_tree_host_impl_unittest.cc

@@ -11099,7 +11099,7 @@ class FakeLayerWithQuads : public LayerImpl {
         render_pass->CreateAndAppendSharedQuadState();
     PopulateSharedQuadState(shared_quad_state, contents_opaque());
 
-    SkColor gray = SkColorSetRGB(100, 100, 100);
+    SkColor4f gray = SkColors::kGray;
     gfx::Rect quad_rect(bounds());
     gfx::Rect visible_quad_rect(quad_rect);
     auto* my_quad =

components/exo/surface.cc

@@ -1421,11 +1421,12 @@ void Surface::AppendContentsToFrame(const gfx::PointF& origin,
       buffer_transform_.TransformRectReverse(&uv_crop);
     }
 
-    SkColor background_color = SK_ColorTRANSPARENT;
+    SkColor4f background_color = SkColors::kTransparent;
     if (state_.basic_state.background_color.has_value())
-      background_color = state_.basic_state.background_color.value();
+      background_color =
+          SkColor4f::FromColor(state_.basic_state.background_color.value());
     else if (current_resource_has_alpha_ && are_contents_opaque)
-      background_color = SK_ColorBLACK;  // Avoid writing alpha < 1
+      background_color = SkColors::kBlack;  // Avoid writing alpha < 1
 
     // If this surface is being replaced by a SurfaceId emit a SurfaceDrawQuad.
     if (get_current_surface_id_) {
@@ -1528,7 +1529,8 @@ void Surface::AppendContentsToFrame(const gfx::PointF& origin,
                         : SK_ColorBLACK;
     viz::SolidColorDrawQuad* solid_quad =
         render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
-    solid_quad->SetNew(quad_state, quad_rect, quad_rect, color,
+    solid_quad->SetNew(quad_state, quad_rect, quad_rect,
+                       SkColor4f::FromColor(color),
                        false /* force_anti_aliasing_off */);
   }
 

components/exo/surface_tree_host.cc

@@ -330,7 +330,7 @@ void SurfaceTreeHost::SubmitEmptyCompositorFrame() {
 
   viz::SolidColorDrawQuad* solid_quad =
       render_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
-  solid_quad->SetNew(quad_state, quad_rect, quad_rect, SK_ColorBLACK,
+  solid_quad->SetNew(quad_state, quad_rect, quad_rect, SkColors::kBlack,
                      /*force_anti_aliasing_off=*/false);
   layer_tree_frame_sink_holder_->SubmitCompositorFrame(std::move(frame));
 }

components/viz/common/quads/compositor_render_pass_unittest.cc

@@ -91,7 +91,7 @@ TEST(CompositorRenderPassTest,
 
   auto* color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   color_quad->SetNew(pass->shared_quad_state_list.back(), gfx::Rect(),
-                     gfx::Rect(), SkColor(), false);
+                     gfx::Rect(), SkColor4f(), false);
 
   AggregatedRenderPassId new_render_pass_id{63u};
 
@@ -153,12 +153,12 @@ TEST(CompositorRenderPassTest, CopyAllShouldBeIdentical) {
 
   auto* color_quad1 = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   color_quad1->SetNew(pass->shared_quad_state_list.back(),
-                      gfx::Rect(1, 1, 1, 1), gfx::Rect(1, 1, 1, 1), SkColor(),
+                      gfx::Rect(1, 1, 1, 1), gfx::Rect(1, 1, 1, 1), SkColor4f(),
                       false);
 
   auto* color_quad2 = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   color_quad2->SetNew(pass->shared_quad_state_list.back(),
-                      gfx::Rect(2, 2, 2, 2), gfx::Rect(2, 2, 2, 2), SkColor(),
+                      gfx::Rect(2, 2, 2, 2), gfx::Rect(2, 2, 2, 2), SkColor4f(),
                       false);
 
   // And two quads using another shared state.
@@ -169,12 +169,12 @@ TEST(CompositorRenderPassTest, CopyAllShouldBeIdentical) {
 
   auto* color_quad3 = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   color_quad3->SetNew(pass->shared_quad_state_list.back(),
-                      gfx::Rect(3, 3, 3, 3), gfx::Rect(3, 3, 3, 3), SkColor(),
+                      gfx::Rect(3, 3, 3, 3), gfx::Rect(3, 3, 3, 3), SkColor4f(),
                       false);
 
   auto* color_quad4 = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   color_quad4->SetNew(pass->shared_quad_state_list.back(),
-                      gfx::Rect(4, 4, 4, 4), gfx::Rect(4, 4, 4, 4), SkColor(),
+                      gfx::Rect(4, 4, 4, 4), gfx::Rect(4, 4, 4, 4), SkColor4f(),
                       false);
 
   // A second render pass with a quad.
@@ -213,8 +213,8 @@ TEST(CompositorRenderPassTest, CopyAllShouldBeIdentical) {
 
   auto* contrib_quad = contrib->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   contrib_quad->SetNew(contrib->shared_quad_state_list.back(),
-                       gfx::Rect(3, 3, 3, 3), gfx::Rect(3, 3, 3, 3), SkColor(),
-                       false);
+                       gfx::Rect(3, 3, 3, 3), gfx::Rect(3, 3, 3, 3),
+                       SkColor4f(), false);
 
   // And a CompositorRenderPassDrawQuad for the contributing pass.
   auto pass_quad = std::make_unique<CompositorRenderPassDrawQuad>();
@@ -268,7 +268,7 @@ TEST(CompositorRenderPassTest, CopyAllWithCulledQuads) {
 
   auto* color_quad1 = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   color_quad1->SetNew(pass->shared_quad_state_list.back(),
-                      gfx::Rect(1, 1, 1, 1), gfx::Rect(1, 1, 1, 1), SkColor(),
+                      gfx::Rect(1, 1, 1, 1), gfx::Rect(1, 1, 1, 1), SkColor4f(),
                       false);
 
   // A shared state with no quads, they were culled.
@@ -291,7 +291,7 @@ TEST(CompositorRenderPassTest, CopyAllWithCulledQuads) {
 
   auto* color_quad2 = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   color_quad2->SetNew(pass->shared_quad_state_list.back(),
-                      gfx::Rect(3, 3, 3, 3), gfx::Rect(3, 3, 3, 3), SkColor(),
+                      gfx::Rect(3, 3, 3, 3), gfx::Rect(3, 3, 3, 3), SkColor4f(),
                       false);
 
   pass_list.push_back(std::move(pass));
@@ -308,8 +308,8 @@ TEST(CompositorRenderPassTest, ReplacedQuadsShouldntMove) {
   SharedQuadState* quad_state = pass->CreateAndAppendSharedQuadState();
   auto* quad = pass->quad_list.AllocateAndConstruct<SolidColorDrawQuad>();
   gfx::Rect quad_rect(1, 2, 3, 4);
-  quad->SetNew(quad_state, quad_rect, quad_rect, SkColor(), false);
-  pass->ReplaceExistingQuadWithSolidColor(pass->quad_list.begin(), SkColor(),
+  quad->SetNew(quad_state, quad_rect, quad_rect, SkColor4f(), false);
+  pass->ReplaceExistingQuadWithSolidColor(pass->quad_list.begin(), SkColor4f(),
                                           SkBlendMode::kSrcOver);
   EXPECT_EQ(pass->quad_list.begin()->rect, quad_rect);
 }
@@ -319,8 +319,8 @@ TEST(CompositorRenderPassTest, ReplacedQuadsShouldntBeOpaque) {
   SharedQuadState* quad_state = pass->CreateAndAppendSharedQuadState();
   auto* quad = pass->quad_list.AllocateAndConstruct<SolidColorDrawQuad>();
   gfx::Rect quad_rect(1, 2, 3, 4);
-  quad->SetNew(quad_state, quad_rect, quad_rect, SkColor(), false);
-  pass->ReplaceExistingQuadWithSolidColor(pass->quad_list.begin(), SkColor(),
+  quad->SetNew(quad_state, quad_rect, quad_rect, SkColor4f(), false);
+  pass->ReplaceExistingQuadWithSolidColor(pass->quad_list.begin(), SkColor4f(),
                                           SkBlendMode::kSrcOver);
   EXPECT_FALSE(pass->quad_list.begin()->shared_quad_state->are_contents_opaque);
 }
@@ -330,9 +330,9 @@ TEST(CompositorRenderPassTest, ReplacedQuadsGetColor) {
   const SharedQuadState* quad_state = pass->CreateAndAppendSharedQuadState();
   auto* quad = pass->quad_list.AllocateAndConstruct<SolidColorDrawQuad>();
   const gfx::Rect quad_rect(1, 2, 3, 4);
-  quad->SetNew(quad_state, quad_rect, quad_rect, SK_ColorRED, false);
-  pass->ReplaceExistingQuadWithSolidColor(pass->quad_list.begin(),
-                                          SK_ColorGREEN, SkBlendMode::kSrcOver);
+  quad->SetNew(quad_state, quad_rect, quad_rect, SkColors::kRed, false);
+  pass->ReplaceExistingQuadWithSolidColor(
+      pass->quad_list.begin(), SkColors::kGreen, SkBlendMode::kSrcOver);
   EXPECT_EQ(SkColors::kGreen, quad->color);
 }
 
@@ -344,8 +344,8 @@ TEST(CompositorRenderPassTest, ReplacedQuadsGetBlendMode) {
   quad_state->are_contents_opaque = false;
   auto* quad = pass->quad_list.AllocateAndConstruct<SolidColorDrawQuad>();
   const gfx::Rect quad_rect(1, 2, 3, 4);
-  quad->SetNew(quad_state, quad_rect, quad_rect, SkColor(), false);
-  pass->ReplaceExistingQuadWithSolidColor(pass->quad_list.begin(), SkColor(),
+  quad->SetNew(quad_state, quad_rect, quad_rect, SkColor4f(), false);
+  pass->ReplaceExistingQuadWithSolidColor(pass->quad_list.begin(), SkColor4f(),
                                           SkBlendMode::kDstOut);
   EXPECT_EQ(SkBlendMode::kDstOut, quad->shared_quad_state->blend_mode);
 }
@@ -358,9 +358,9 @@ TEST(CompositorRenderPassTest,
   quad_state->blend_mode = SkBlendMode::kSoftLight;
   auto* quad = pass->quad_list.AllocateAndConstruct<SolidColorDrawQuad>();
   const gfx::Rect quad_rect(1, 2, 3, 4);
-  quad->SetNew(quad_state, quad_rect, quad_rect, SK_ColorRED, false);
+  quad->SetNew(quad_state, quad_rect, quad_rect, SkColors::kRed, false);
   pass->ReplaceExistingQuadWithSolidColor(
-      pass->quad_list.begin(), SK_ColorGREEN, SkBlendMode::kSoftLight);
+      pass->quad_list.begin(), SkColors::kGreen, SkBlendMode::kSoftLight);
   EXPECT_EQ(quad_state, quad->shared_quad_state);
 }
 

components/viz/common/quads/debug_border_draw_quad.cc

@@ -15,13 +15,12 @@ DebugBorderDrawQuad::DebugBorderDrawQuad() = default;
 void DebugBorderDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
                                  const gfx::Rect& rect,
                                  const gfx::Rect& visible_rect,
-                                 SkColor c,
+                                 SkColor4f c,
                                  int w) {
-  bool needs_blending = SkColorGetA(c) < 255;
+  bool needs_blending = c.fA < 1.0f;
   DrawQuad::SetAll(shared_quad_state, DrawQuad::Material::kDebugBorder, rect,
                    visible_rect, needs_blending);
-  // TODO(crbug/1308932) remove FromColor and make all SkColor4f
-  color = SkColor4f::FromColor(c);
+  color = c;
   width = w;
 }
 
@@ -29,12 +28,11 @@ void DebugBorderDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                                  const gfx::Rect& rect,
                                  const gfx::Rect& visible_rect,
                                  bool needs_blending,
-                                 SkColor c,
+                                 SkColor4f c,
                                  int w) {
   DrawQuad::SetAll(shared_quad_state, DrawQuad::Material::kDebugBorder, rect,
                    visible_rect, needs_blending);
-  // TODO(crbug/1308932) remove FromColor and make all SkColor4f
-  color = SkColor4f::FromColor(c);
+  color = c;
   width = w;
 }
 

components/viz/common/quads/debug_border_draw_quad.h

@@ -18,14 +18,14 @@ class VIZ_COMMON_EXPORT DebugBorderDrawQuad : public DrawQuad {
   void SetNew(const SharedQuadState* shared_quad_state,
               const gfx::Rect& rect,
               const gfx::Rect& visible_rect,
-              SkColor c,
+              SkColor4f c,
               int w);
 
   void SetAll(const SharedQuadState* shared_quad_state,
               const gfx::Rect& rect,
               const gfx::Rect& visible_rect,
               bool needs_blending,
-              SkColor c,
+              SkColor4f c,
               int w);
 
   SkColor4f color = SkColors::kTransparent;

components/viz/common/quads/draw_quad_perftest.cc

@@ -80,7 +80,7 @@ class DrawQuadPerfTest : public testing::Test {
       bool premultiplied_alpha = true;
       gfx::PointF uv_top_left(0, 0);
       gfx::PointF uv_bottom_right(1, 1);
-      SkColor background_color = SK_ColorRED;
+      SkColor4f background_color = SkColors::kRed;
       float vertex_opacity[4] = {1.f, 1.f, 1.f, 1.f};
       bool y_flipped = false;
       bool nearest_neighbor = true;

components/viz/common/quads/draw_quad_unittest.cc

@@ -172,19 +172,19 @@ void CompareDrawQuad(DrawQuad* quad, DrawQuad* copy) {
 
 TEST(DrawQuadTest, CopyDebugBorderDrawQuad) {
   gfx::Rect visible_rect(40, 50, 30, 20);
-  SkColor color = 0xfabb0011;
+  SkColor4f color = {0.7, 0.0, 0.1, 0.9};
   int width = 99;
   CREATE_SHARED_STATE();
 
   CREATE_QUAD_NEW(DebugBorderDrawQuad, visible_rect, color, width);
   EXPECT_EQ(DrawQuad::Material::kDebugBorder, copy_quad->material);
   EXPECT_EQ(visible_rect, copy_quad->visible_rect);
-  EXPECT_EQ(SkColor4f::FromColor(color), copy_quad->color);
+  EXPECT_EQ(color, copy_quad->color);
   EXPECT_EQ(width, copy_quad->width);
 
   CREATE_QUAD_ALL(DebugBorderDrawQuad, color, width);
   EXPECT_EQ(DrawQuad::Material::kDebugBorder, copy_quad->material);
-  EXPECT_EQ(SkColor4f::FromColor(color), copy_quad->color);
+  EXPECT_EQ(color, copy_quad->color);
   EXPECT_EQ(width, copy_quad->width);
 }
 
@@ -226,8 +226,7 @@ TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
 
 TEST(DrawQuadTest, CopySolidColorDrawQuad) {
   gfx::Rect visible_rect(40, 50, 30, 20);
-  // TODO(crbug.com/1308932): Use SkColor4f here
-  SkColor color = 0x49494949;
+  SkColor4f color = {0.28, 0.28, 0.28, 0.28};
   bool force_anti_aliasing_off = false;
   CREATE_SHARED_STATE();
 
@@ -235,12 +234,12 @@ TEST(DrawQuadTest, CopySolidColorDrawQuad) {
                   force_anti_aliasing_off);
   EXPECT_EQ(DrawQuad::Material::kSolidColor, copy_quad->material);
   EXPECT_EQ(visible_rect, copy_quad->visible_rect);
-  EXPECT_EQ(SkColor4f::FromColor(color), copy_quad->color);
+  EXPECT_EQ(color, copy_quad->color);
   EXPECT_EQ(force_anti_aliasing_off, copy_quad->force_anti_aliasing_off);
 
   CREATE_QUAD_ALL(SolidColorDrawQuad, color, force_anti_aliasing_off);
   EXPECT_EQ(DrawQuad::Material::kSolidColor, copy_quad->material);
-  EXPECT_EQ(SkColor4f::FromColor(color), copy_quad->color);
+  EXPECT_EQ(color, copy_quad->color);
   EXPECT_EQ(force_anti_aliasing_off, copy_quad->force_anti_aliasing_off);
 }
 
@@ -284,7 +283,7 @@ TEST(DrawQuadTest, CopySurfaceDrawQuad) {
 
   CREATE_QUAD_NEW(SurfaceDrawQuad, visible_rect,
                   SurfaceRange(fallback_surface_id, primary_surface_id),
-                  SK_ColorWHITE, /*stretch_content_to_fill_bounds=*/true);
+                  SkColors::kWhite, /*stretch_content_to_fill_bounds=*/true);
   EXPECT_EQ(DrawQuad::Material::kSurfaceContent, copy_quad->material);
   EXPECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_EQ(primary_surface_id, copy_quad->surface_range.end());
@@ -293,7 +292,7 @@ TEST(DrawQuadTest, CopySurfaceDrawQuad) {
 
   CREATE_QUAD_ALL(SurfaceDrawQuad,
                   SurfaceRange(fallback_surface_id, primary_surface_id),
-                  SK_ColorWHITE, /*stretch_content_to_fill_bounds=*/false,
+                  SkColors::kWhite, /*stretch_content_to_fill_bounds=*/false,
                   /*is_reflection=*/false, /*allow_merge=*/true);
   EXPECT_EQ(DrawQuad::Material::kSurfaceContent, copy_quad->material);
   EXPECT_EQ(primary_surface_id, copy_quad->surface_range.end());
@@ -320,7 +319,7 @@ TEST(DrawQuadTest, CopyTextureDrawQuad) {
 
   CREATE_QUAD_NEW(TextureDrawQuad, visible_rect, blending, resource_id,
                   premultiplied_alpha, uv_top_left, uv_bottom_right,
-                  SK_ColorTRANSPARENT, vertex_opacity, y_flipped,
+                  SkColors::kTransparent, vertex_opacity, y_flipped,
                   nearest_neighbor, secure_output_only, protected_video_type);
   EXPECT_EQ(DrawQuad::Material::kTextureContent, copy_quad->material);
   EXPECT_EQ(visible_rect, copy_quad->visible_rect);
@@ -337,7 +336,7 @@ TEST(DrawQuadTest, CopyTextureDrawQuad) {
 
   CREATE_QUAD_ALL(TextureDrawQuad, resource_id, resource_size_in_pixels,
                   premultiplied_alpha, uv_top_left, uv_bottom_right,
-                  SK_ColorTRANSPARENT, vertex_opacity, y_flipped,
+                  SkColors::kTransparent, vertex_opacity, y_flipped,
                   nearest_neighbor, secure_output_only, protected_video_type);
   EXPECT_EQ(DrawQuad::Material::kTextureContent, copy_quad->material);
   EXPECT_EQ(resource_id, copy_quad->resource_id());
@@ -523,7 +522,7 @@ class DrawQuadIteratorTest : public testing::Test {
 
 TEST_F(DrawQuadIteratorTest, DebugBorderDrawQuad) {
   gfx::Rect visible_rect(40, 50, 30, 20);
-  SkColor color = 0xfabb0011;
+  SkColor4f color = {0.7, 0.0, 0.1, 0.9};
   int width = 99;
 
   CREATE_SHARED_STATE();
@@ -566,7 +565,7 @@ TEST_F(DrawQuadIteratorTest, CompositorRenderPassDrawQuad) {
 
 TEST_F(DrawQuadIteratorTest, SolidColorDrawQuad) {
   gfx::Rect visible_rect(40, 50, 30, 20);
-  SkColor color = 0x49494949;
+  SkColor4f color = {0.28, 0.28, 0.28, 0.28};
   bool force_anti_aliasing_off = false;
 
   CREATE_SHARED_STATE();
@@ -599,7 +598,7 @@ TEST_F(DrawQuadIteratorTest, SurfaceDrawQuad) {
 
   CREATE_SHARED_STATE();
   CREATE_QUAD_NEW(SurfaceDrawQuad, visible_rect,
-                  SurfaceRange(absl::nullopt, surface_id), SK_ColorWHITE,
+                  SurfaceRange(absl::nullopt, surface_id), SkColors::kWhite,
                   /*stretch_content_to_fill_bounds=*/false);
   EXPECT_EQ(0, IterateAndCount(quad_new));
 }
@@ -620,7 +619,7 @@ TEST_F(DrawQuadIteratorTest, TextureDrawQuad) {
   CREATE_SHARED_STATE();
   CREATE_QUAD_NEW(TextureDrawQuad, visible_rect, needs_blending, resource_id,
                   premultiplied_alpha, uv_top_left, uv_bottom_right,
-                  SK_ColorTRANSPARENT, vertex_opacity, y_flipped,
+                  SkColors::kTransparent, vertex_opacity, y_flipped,
                   nearest_neighbor, secure_output_only, protected_video_type);
   EXPECT_EQ(resource_id, quad_new->resource_id());
   EXPECT_EQ(1, IterateAndCount(quad_new));

components/viz/common/quads/render_pass_internal.cc

@@ -40,7 +40,7 @@ SharedQuadState* RenderPassInternal::CreateAndAppendSharedQuadState() {
 
 void RenderPassInternal::ReplaceExistingQuadWithSolidColor(
     QuadList::Iterator at,
-    SkColor color,
+    SkColor4f color,
     SkBlendMode blend_mode) {
   const SharedQuadState* shared_quad_state = at->shared_quad_state;
   if (shared_quad_state->are_contents_opaque ||
@@ -53,6 +53,7 @@ void RenderPassInternal::ReplaceExistingQuadWithSolidColor(
   }
 
   const gfx::Rect rect = at->rect;
+  // TODO(crbug.com/1308932) This function should be called with an SkColor4f
   quad_list.ReplaceExistingElement<SolidColorDrawQuad>(at)->SetAll(
       shared_quad_state, rect, /*visible_rect=*/rect,
       /*needs_blending=*/false, color,

components/viz/common/quads/render_pass_internal.h

@@ -36,7 +36,7 @@ class VIZ_COMMON_EXPORT RenderPassInternal {
 
   // Replaces a quad in |quad_list| with a |SolidColorDrawQuad|.
   void ReplaceExistingQuadWithSolidColor(QuadList::Iterator at,
-                                         SkColor color,
+                                         SkColor4f color,
                                          SkBlendMode blend_mode);
 
   // These are in the space of the render pass' physical pixels.

components/viz/common/quads/render_pass_io.cc

@@ -190,17 +190,19 @@ bool SkColor4fFromDict(const base::Value& dict, SkColor4f* color) {
 // SkColors (which are ints). For backward compatibility's sake, read either.
 bool ColorFromDict(const base::Value& dict,
                    base::StringPiece key,
-                   SkColor& output_color) {
+                   SkColor4f* output_color) {
   const base::Value* color_key = dict.FindDictKey(key);
   SkColor4f color_4f;
   if (!color_key || !SkColor4fFromDict(*color_key, &color_4f)) {
     absl::optional<int> color_int = dict.FindIntKey(key);
     if (!color_int)
       return false;
-    output_color = static_cast<SkColor>(color_int.value());
-    return true;
+    color_4f = SkColor4f::FromColor(static_cast<SkColor>(color_int.value()));
   }
-  output_color = color_4f.toSkColor();
+  output_color->fR = color_4f.fR;
+  output_color->fG = color_4f.fG;
+  output_color->fB = color_4f.fB;
+  output_color->fA = color_4f.fA;
   return true;
 }
 
@@ -1406,8 +1408,8 @@ bool SolidColorDrawQuadFromDict(const base::Value& dict,
   if (!force_anti_aliasing_off)
     return false;
 
-  SkColor t_color;
-  if (!ColorFromDict(dict, "color", t_color))
+  SkColor4f t_color;
+  if (!ColorFromDict(dict, "color", &t_color))
     return false;
 
   draw_quad->SetAll(common.shared_quad_state, common.rect, common.visible_rect,
@@ -1469,9 +1471,9 @@ bool SurfaceDrawQuadFromDict(const base::Value& dict,
   if (!surface_range || !stretch_content || !is_reflection || !allow_merge)
     return false;
 
-  SkColor t_default_background_color;
+  SkColor4f t_default_background_color;
   if (!ColorFromDict(dict, "default_background_color",
-                     t_default_background_color))
+                     &t_default_background_color))
     return false;
 
   draw_quad->SetAll(common.shared_quad_state, common.rect, common.visible_rect,
@@ -1517,11 +1519,11 @@ bool TextureDrawQuadFromDict(const base::Value& dict,
     return false;
   gfx::PointF t_uv_top_left, t_uv_bottom_right;
   gfx::Size t_resource_size_in_pixels;
-  SkColor t_background_color;
+  SkColor4f t_background_color;
   if (!PointFFromDict(*uv_top_left, &t_uv_top_left) ||
       !PointFFromDict(*uv_bottom_right, &t_uv_bottom_right) ||
       !SizeFromDict(*resource_size_in_pixels, &t_resource_size_in_pixels) ||
-      !ColorFromDict(dict, "background_color", t_background_color)) {
+      !ColorFromDict(dict, "background_color", &t_background_color)) {
     return false;
   }
   float t_vertex_opacity[4];

components/viz/common/quads/render_pass_io_unittest.cc

@@ -209,7 +209,7 @@ TEST(RenderPassIOTest, QuadList) {
           render_pass0->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
       quad->SetAll(render_pass0->shared_quad_state_list.ElementAt(sqs_index),
                    gfx::Rect(0, 0, 30, 40), gfx::Rect(1, 2, 20, 30), true,
-                   SK_ColorRED, false);
+                   SkColors::kRed, false);
       ++quad_count;
     }
     {
@@ -260,8 +260,8 @@ TEST(RenderPassIOTest, QuadList) {
       quad->SetAll(render_pass0->shared_quad_state_list.ElementAt(sqs_index),
                    gfx::Rect(0, 0, 100, 50), gfx::Rect(0, 0, 100, 50), false,
                    ResourceId(9u), gfx::Size(100, 50), false,
-                   gfx::PointF(0.f, 0.f), gfx::PointF(1.f, 1.f), SK_ColorBLUE,
-                   vertex_opacity, false, true, false,
+                   gfx::PointF(0.f, 0.f), gfx::PointF(1.f, 1.f),
+                   SkColors::kBlue, vertex_opacity, false, true, false,
                    gfx::ProtectedVideoType::kHardwareProtected);
       ++sqs_index;
       ++quad_count;
@@ -295,8 +295,8 @@ TEST(RenderPassIOTest, QuadList) {
           render_pass0->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
       quad->SetAll(render_pass0->shared_quad_state_list.ElementAt(sqs_index),
                    gfx::Rect(0, 0, 512, 256), gfx::Rect(2, 2, 500, 250), true,
-                   SurfaceRange(kSurfaceId1, kSurfaceId2), SK_ColorWHITE, false,
-                   false, true);
+                   SurfaceRange(kSurfaceId1, kSurfaceId2), SkColors::kWhite,
+                   false, false, true);
       ++quad_count;
     }
     {
@@ -306,7 +306,7 @@ TEST(RenderPassIOTest, QuadList) {
       quad->SetAll(render_pass0->shared_quad_state_list.ElementAt(sqs_index),
                    gfx::Rect(10, 10, 512, 256), gfx::Rect(12, 12, 500, 250),
                    true, SurfaceRange(absl::nullopt, kSurfaceId1),
-                   SK_ColorBLACK, true, true, false);
+                   SkColors::kBlack, true, true, false);
       ++quad_count;
     }
     DCHECK_EQ(kSharedQuadStateCount, sqs_index + 1);

components/viz/common/quads/solid_color_draw_quad.cc

@@ -16,12 +16,12 @@ SolidColorDrawQuad::SolidColorDrawQuad()
 void SolidColorDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
                                 const gfx::Rect& rect,
                                 const gfx::Rect& visible_rect,
-                                SkColor c,
+                                SkColor4f c,
                                 bool anti_aliasing_off) {
-  bool needs_blending = SkColorGetA(c) != 255;
+  bool needs_blending = !c.isOpaque();
   DrawQuad::SetAll(shared_quad_state, DrawQuad::Material::kSolidColor, rect,
                    visible_rect, needs_blending);
-  color = SkColor4f::FromColor(c);
+  color = c;
   force_anti_aliasing_off = anti_aliasing_off;
 }
 
@@ -29,11 +29,11 @@ void SolidColorDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                                 const gfx::Rect& rect,
                                 const gfx::Rect& visible_rect,
                                 bool needs_blending,
-                                SkColor c,
+                                SkColor4f c,
                                 bool anti_aliasing_off) {
   DrawQuad::SetAll(shared_quad_state, DrawQuad::Material::kSolidColor, rect,
                    visible_rect, needs_blending);
-  color = SkColor4f::FromColor(c);
+  color = c;
   force_anti_aliasing_off = anti_aliasing_off;
 }
 

components/viz/common/quads/solid_color_draw_quad.h

@@ -18,14 +18,14 @@ class VIZ_COMMON_EXPORT SolidColorDrawQuad : public DrawQuad {
   void SetNew(const SharedQuadState* shared_quad_state,
               const gfx::Rect& rect,
               const gfx::Rect& visible_rect,
-              SkColor c,
+              SkColor4f c,
               bool anti_aliasing_off);
 
   void SetAll(const SharedQuadState* shared_quad_state,
               const gfx::Rect& rect,
               const gfx::Rect& visible_rect,
               bool needs_blending,
-              SkColor c,
+              SkColor4f c,
               bool anti_aliasing_off);
 
   SkColor4f color;

components/viz/common/quads/surface_draw_quad.cc

@@ -24,14 +24,13 @@ void SurfaceDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
                              const gfx::Rect& rect,
                              const gfx::Rect& visible_rect,
                              const SurfaceRange& range,
-                             SkColor background_color,
+                             SkColor4f background_color,
                              bool stretch_content) {
   bool needs_blending = true;
   DrawQuad::SetAll(shared_quad_state, DrawQuad::Material::kSurfaceContent, rect,
                    visible_rect, needs_blending);
   surface_range = range;
-  // TODO(crbug/1308932) remove FromColor and make all SkColor4f
-  default_background_color = SkColor4f::FromColor(background_color);
+  default_background_color = background_color;
   stretch_content_to_fill_bounds = stretch_content;
 }
 
@@ -40,15 +39,14 @@ void SurfaceDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                              const gfx::Rect& visible_rect,
                              bool needs_blending,
                              const SurfaceRange& range,
-                             SkColor background_color,
+                             SkColor4f background_color,
                              bool stretch_content,
                              bool reflection,
                              bool merge) {
   DrawQuad::SetAll(shared_quad_state, DrawQuad::Material::kSurfaceContent, rect,
                    visible_rect, needs_blending);
   surface_range = range;
-  // TODO(crbug/1308932) remove FromColor and make all SkColor4f
-  default_background_color = SkColor4f::FromColor(background_color);
+  default_background_color = background_color;
   stretch_content_to_fill_bounds = stretch_content;
   is_reflection = reflection;
   allow_merge = merge;

components/viz/common/quads/surface_draw_quad.h

@@ -24,7 +24,7 @@ class VIZ_COMMON_EXPORT SurfaceDrawQuad : public DrawQuad {
               const gfx::Rect& rect,
               const gfx::Rect& visible_rect,
               const SurfaceRange& range,
-              SkColor background_color,
+              SkColor4f background_color,
               bool stretch_content);
 
   void SetAll(const SharedQuadState* shared_quad_state,
@@ -32,7 +32,7 @@ class VIZ_COMMON_EXPORT SurfaceDrawQuad : public DrawQuad {
               const gfx::Rect& visible_rect,
               bool needs_blending,
               const SurfaceRange& range,
-              SkColor background_color,
+              SkColor4f background_color,
               bool stretch_content,
               bool reflection,
               bool merge);

components/viz/common/quads/texture_draw_quad.cc

@@ -38,7 +38,7 @@ void TextureDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
                              bool premultiplied,
                              const gfx::PointF& top_left,
                              const gfx::PointF& bottom_right,
-                             SkColor background,
+                             SkColor4f background,
                              const float opacity[4],
                              bool flipped,
                              bool nearest,
@@ -53,7 +53,7 @@ void TextureDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
   premultiplied_alpha = premultiplied;
   uv_top_left = top_left;
   uv_bottom_right = bottom_right;
-  background_color = SkColor4f::FromColor(background);
+  background_color = background;
   vertex_opacity[0] = opacity[0];
   vertex_opacity[1] = opacity[1];
   vertex_opacity[2] = opacity[2];
@@ -73,7 +73,7 @@ void TextureDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                              bool premultiplied,
                              const gfx::PointF& top_left,
                              const gfx::PointF& bottom_right,
-                             SkColor background,
+                             SkColor4f background,
                              const float opacity[4],
                              bool flipped,
                              bool nearest,
@@ -87,7 +87,7 @@ void TextureDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
   premultiplied_alpha = premultiplied;
   uv_top_left = top_left;
   uv_bottom_right = bottom_right;
-  background_color = SkColor4f::FromColor(background);
+  background_color = background;
   vertex_opacity[0] = opacity[0];
   vertex_opacity[1] = opacity[1];
   vertex_opacity[2] = opacity[2];

components/viz/common/quads/texture_draw_quad.h

@@ -36,7 +36,7 @@ class VIZ_COMMON_EXPORT TextureDrawQuad : public DrawQuad {
               bool premultiplied,
               const gfx::PointF& top_left,
               const gfx::PointF& bottom_right,
-              SkColor background,
+              SkColor4f background,
               const float opacity[4],
               bool flipped,
               bool nearest,
@@ -52,7 +52,7 @@ class VIZ_COMMON_EXPORT TextureDrawQuad : public DrawQuad {
               bool premultiplied,
               const gfx::PointF& top_left,
               const gfx::PointF& bottom_right,
-              SkColor background,
+              SkColor4f background,
               const float opacity[4],
               bool flipped,
               bool nearest,

components/viz/demo/client/demo_client.cc

@@ -66,7 +66,8 @@ void DemoClient::Resize(const gfx::Size& size,
 }
 
 viz::CompositorFrame DemoClient::CreateFrame(const viz::BeginFrameArgs& args) {
-  constexpr SkColor colors[] = {SK_ColorRED, SK_ColorGREEN, SK_ColorYELLOW};
+  constexpr SkColor4f colors[] = {SkColors::kRed, SkColors::kGreen,
+                                  SkColors::kYellow};
   viz::CompositorFrame frame;
 
   frame.metadata.begin_frame_ack = viz::BeginFrameAck(args, true);
@@ -115,7 +116,7 @@ viz::CompositorFrame DemoClient::CreateFrame(const viz::BeginFrameArgs& args) {
     embed->SetNew(quad_state,
                   /*rect=*/gfx::Rect(child_bounds.size()),
                   /*visible_rect=*/gfx::Rect(child_bounds.size()),
-                  viz::SurfaceRange(surface_id), SK_ColorGRAY,
+                  viz::SurfaceRange(surface_id), SkColors::kGray,
                   /*stretch_content_to_fill_bounds=*/false);
   }
 

components/viz/service/compositor_frame_fuzzer/compositor_frame_fuzzer_util.cc

@@ -233,6 +233,7 @@ CompositorRenderPassId FuzzedCompositorFrameBuilder::AddRenderPass(
   return data_.frame.render_pass_list.back()->id;
 }
 
+// TODO(crbug.com/1308932): Move proto::DrawQuad to SkColor4f
 void FuzzedCompositorFrameBuilder::AddSolidColorDrawQuad(
     CompositorRenderPass* pass,
     const gfx::Rect& rect,
@@ -242,7 +243,7 @@ void FuzzedCompositorFrameBuilder::AddSolidColorDrawQuad(
   ConfigureSharedQuadState(shared_quad_state, quad_spec);
   auto* quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   quad->SetNew(shared_quad_state, rect, visible_rect,
-               quad_spec.solid_color_quad().color(),
+               SkColor4f::FromColor(quad_spec.solid_color_quad().color()),
                quad_spec.solid_color_quad().force_anti_aliasing_off());
 }
 

components/viz/service/compositor_frame_fuzzer/fuzzer_browser_process.cc

@@ -142,7 +142,7 @@ CompositorFrame FuzzerBrowserProcess::BuildBrowserUICompositorFrame(
   surface_quad->SetNew(renderer_sqs, gfx::Rect(kRendererFrameSize),
                        gfx::Rect(kRendererFrameSize),
                        SurfaceRange(absl::nullopt, renderer_surface_id),
-                       SK_ColorWHITE,
+                       SkColors::kWhite,
                        /*stretch_content_to_fill_bounds=*/false);
 
   auto* toolbar_sqs = pass->CreateAndAppendSharedQuadState();
@@ -153,7 +153,7 @@ CompositorFrame FuzzerBrowserProcess::BuildBrowserUICompositorFrame(
       /*sorting_context_id=*/0);
   auto* color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   color_quad->SetNew(toolbar_sqs, gfx::Rect(kTopBarSize),
-                     gfx::Rect(kTopBarSize), SK_ColorLTGRAY,
+                     gfx::Rect(kTopBarSize), SkColors::kLtGray,
                      /*force_antialiasing_off=*/false);
   frame.render_pass_list.push_back(std::move(pass));
 

components/viz/service/display/ca_layer_overlay.cc

@@ -639,7 +639,7 @@ bool CALayerOverlayProcessor::PutQuadInSeparateOverlay(
     return true;
 
   ca_layer.protected_video_type = protected_video_type;
-  render_pass->ReplaceExistingQuadWithSolidColor(at, SK_ColorTRANSPARENT,
+  render_pass->ReplaceExistingQuadWithSolidColor(at, SkColors::kTransparent,
                                                  SkBlendMode::kSrcOver);
   ca_layer_overlays->push_back(ca_layer);
   return true;

components/viz/service/display/copy_output_scaling_pixeltest.cc

@@ -92,9 +92,9 @@ class CopyOutputScalingPixelTest
     constexpr gfx::Size viewport_size = gfx::Size(48, 20);
     constexpr int x_block = 8;
     constexpr int y_block = 4;
-    constexpr SkColor smaller_pass_colors[4] = {SK_ColorRED, SK_ColorGREEN,
-                                                SK_ColorBLUE, SK_ColorYELLOW};
-    constexpr SkColor root_pass_color = SK_ColorWHITE;
+    constexpr SkColor4f smaller_pass_colors[4] = {
+        SkColors::kRed, SkColors::kGreen, SkColors::kBlue, SkColors::kYellow};
+    constexpr SkColor4f root_pass_color = SkColors::kWhite;
 
     AggregatedRenderPassList list;
 
@@ -214,8 +214,9 @@ class CopyOutputScalingPixelTest
     for (int i = 0; i < 4; ++i) {
       gfx::Rect rect = smaller_pass_rects[i] - copy_rect.OffsetFromOrigin();
       rect = copy_output::ComputeResultRect(rect, scale_from_, scale_to_);
+      // TODO(crbug.com/1308932): Make this function use SkColor4f
       expected_bitmap.erase(
-          smaller_pass_colors[i],
+          smaller_pass_colors[i].toSkColor(),
           SkIRect{rect.x(), rect.y(), rect.right(), rect.bottom()});
     }
 

components/viz/service/display/damage_frame_annotator.cc

@@ -58,8 +58,10 @@ void DamageFrameAnnotator::AnnotateRootRenderPass(
 
     DebugBorderDrawQuad* new_quad =
         static_cast<DebugBorderDrawQuad*>(*quad_iter);
+    // TODO(crbug.com/1308932) SkColor4f for annotation highlights
     new_quad->SetNew(new_sqs, annotation.rect, annotation.rect,
-                     annotation.highlight.color, annotation.highlight.width);
+                     SkColor4f::FromColor(annotation.highlight.color),
+                     annotation.highlight.width);
 
     ++quad_iter;
   }

components/viz/service/display/dc_layer_overlay.cc

@@ -605,7 +605,7 @@ void DCLayerOverlayProcessor::InsertDebugBorderDrawQuad(
 
   // Add debug borders for the root damage rect after overlay promotion.
   {
-    SkColor border_color = SK_ColorGREEN;
+    SkColor4f border_color = SkColors::kGreen;
     auto it =
         quad_list.InsertBeforeAndInvalidateAllPointers<DebugBorderDrawQuad>(
             quad_list.begin(), 1u);
@@ -625,7 +625,8 @@ void DCLayerOverlayProcessor::InsertDebugBorderDrawQuad(
       overlay_rect.Intersect(gfx::RectF(*dc_layer.clip_rect));
 
     // Overlay:red, Underlay:blue.
-    SkColor border_color = dc_layer.z_order > 0 ? SK_ColorRED : SK_ColorBLUE;
+    SkColor4f border_color =
+        dc_layer.z_order > 0 ? SkColors::kRed : SkColors::kBlue;
     auto it =
         quad_list.InsertBeforeAndInvalidateAllPointers<DebugBorderDrawQuad>(
             quad_list.begin(), 1u);
@@ -1073,13 +1074,13 @@ void DCLayerOverlayProcessor::ProcessForUnderlay(
 
   if (it->ShouldDrawWithBlending() &&
       it->shared_quad_state->blend_mode == SkBlendMode::kSrcOver) {
-    render_pass->ReplaceExistingQuadWithSolidColor(it, SK_ColorBLACK,
+    render_pass->ReplaceExistingQuadWithSolidColor(it, SkColors::kBlack,
                                                    SkBlendMode::kDstOut);
   } else {
     // When the opacity == 1.0, drawing with transparent will be done without
     // blending and will have the proper effect of completely clearing the
     // layer.
-    render_pass->ReplaceExistingQuadWithSolidColor(it, SK_ColorTRANSPARENT,
+    render_pass->ReplaceExistingQuadWithSolidColor(it, SkColors::kTransparent,
                                                    SkBlendMode::kSrcOver);
     is_opaque = true;
   }

components/viz/service/display/delegated_ink_point_pixel_test_helper.cc

@@ -37,12 +37,13 @@ void DelegatedInkPointPixelTestHelper::CreateInkRenderer() {
 void DelegatedInkPointPixelTestHelper::CreateAndSendMetadata(
     const gfx::PointF& point,
     float diameter,
-    SkColor color,
+    SkColor4f color,
     base::TimeTicks timestamp,
     const gfx::RectF& presentation_area) {
   DCHECK(renderer_);
+  // TODO(crbug.com/1308932): Make this function use SkColor4f
   metadata_ = gfx::DelegatedInkMetadata(
-      point, diameter, color, timestamp, presentation_area,
+      point, diameter, color.toSkColor(), timestamp, presentation_area,
       base::TimeTicks::Now(), /*hovering*/ false);
   ink_renderer_->SetDelegatedInkMetadata(
       std::make_unique<gfx::DelegatedInkMetadata>(metadata_));
@@ -56,8 +57,10 @@ void DelegatedInkPointPixelTestHelper::CreateAndSendMetadataFromLastPoint() {
 void DelegatedInkPointPixelTestHelper::CreateAndSendMetadataFromLastPoint(
     int32_t pointer_id) {
   DCHECK(ink_points_.find(pointer_id) != ink_points_.end());
+  // TODO(crbug.com/1308932): Make this function use SkColor4f
   CreateAndSendMetadata(ink_points_[pointer_id].back().point(),
-                        metadata_.diameter(), metadata_.color(),
+                        metadata_.diameter(),
+                        SkColor4f::FromColor(metadata_.color()),
                         ink_points_[pointer_id].back().timestamp(),
                         metadata_.presentation_area());
 }

components/viz/service/display/delegated_ink_point_pixel_test_helper.h

@@ -38,7 +38,7 @@ class DelegatedInkPointPixelTestHelper {
 
   void CreateAndSendMetadata(const gfx::PointF& point,
                              float diameter,
-                             SkColor color,
+                             SkColor4f color,
                              base::TimeTicks timestamp,
                              const gfx::RectF& presentation_area);
 

components/viz/service/display/direct_renderer.cc

@@ -669,7 +669,7 @@ void DirectRenderer::DrawRenderPass(const AggregatedRenderPass* render_pass) {
       // We cannot composite this quad properly, replace it with solid black.
       SolidColorDrawQuad solid_black;
       solid_black.SetAll(quad.shared_quad_state, quad.rect, quad.rect,
-                         /*needs_blending=*/false, SK_ColorBLACK,
+                         /*needs_blending=*/false, SkColors::kBlack,
                          /*force_anti_aliasing_off=*/true);
       DoDrawQuad(&solid_black, nullptr);
       continue;

components/viz/service/display/display_perftest.cc

@@ -112,7 +112,7 @@ class RemoveOverdrawQuadPerfTest : public testing::Test {
     bool premultiplied_alpha = true;
     gfx::PointF uv_top_left(0, 0);
     gfx::PointF uv_bottom_right(1, 1);
-    SkColor background_color = SK_ColorRED;
+    SkColor4f background_color = SkColors::kRed;
     float vertex_opacity[4] = {1.f, 1.f, 1.f, 1.f};
     bool y_flipped = false;
     bool nearest_neighbor = true;

components/viz/service/display/display_unittest.cc

@@ -793,7 +793,8 @@ TEST_F(DisplayTest, BackdropFilterTest) {
       auto* quad1 = pass->quad_list.AllocateAndConstruct<SurfaceDrawQuad>();
       quad1->SetNew(shared_quad_state1, /*rect=*/sub_surface_rect,
                     /*visible_rect=*/sub_surface_rect,
-                    SurfaceRange(absl::nullopt, sub_surface_id1), SK_ColorBLACK,
+                    SurfaceRange(absl::nullopt, sub_surface_id1),
+                    SkColors::kBlack,
                     /*stretch_content_to_fill_bounds=*/false);
       quad1->allow_merge = false;
 
@@ -810,7 +811,8 @@ TEST_F(DisplayTest, BackdropFilterTest) {
       auto* quad2 = pass->quad_list.AllocateAndConstruct<SurfaceDrawQuad>();
       quad2->SetNew(shared_quad_state2, /*rect=*/rect1,
                     /*visible_rect=*/rect1,
-                    SurfaceRange(absl::nullopt, sub_surface_id2), SK_ColorBLACK,
+                    SurfaceRange(absl::nullopt, sub_surface_id2),
+                    SkColors::kBlack,
                     /*stretch_content_to_fill_bounds=*/false);
       quad2->allow_merge = false;
 
@@ -925,10 +927,10 @@ TEST_F(DisplayTest, DrawOcclusionWithBlending) {
         is_root_render_pass ? SkBlendMode::kSrcOver : SkBlendMode::kDstIn, 0);
     auto* src_quad =
         render_pass->quad_list.AllocateAndConstruct<SolidColorDrawQuad>();
-    src_quad->SetNew(src_sqs, src_rect, src_rect, SK_ColorBLACK, false);
+    src_quad->SetNew(src_sqs, src_rect, src_rect, SkColors::kBlack, false);
     auto* dest_quad =
         render_pass->quad_list.AllocateAndConstruct<SolidColorDrawQuad>();
-    dest_quad->SetNew(dest_sqs, dest_rect, dest_rect, SK_ColorRED, false);
+    dest_quad->SetNew(dest_sqs, dest_rect, dest_rect, SkColors::kRed, false);
   }
 
   EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
@@ -995,8 +997,8 @@ TEST_F(DisplayTest, DrawOcclusionWithIntersectingBackdropFilter) {
     } else {
       auto* new_quad = root_render_pass->quad_list
                            .AllocateAndConstruct<SolidColorDrawQuad>();
-      new_quad->SetNew(shared_quad_states[i], rects[i], rects[i], SK_ColorBLACK,
-                       false);
+      new_quad->SetNew(shared_quad_states[i], rects[i], rects[i],
+                       SkColors::kBlack, false);
       quads[i] = new_quad;
     }
   }
@@ -1048,7 +1050,7 @@ TEST_F(DisplayTest, DrawOcclusionWithNonCoveringDrawQuad) {
         gfx::Transform(), rect1, rect1, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
     EXPECT_EQ(1u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // This is a base case, the compositor frame contains only one
@@ -1077,8 +1079,8 @@ TEST_F(DisplayTest, DrawOcclusionWithNonCoveringDrawQuad) {
         gfx::Transform(), rect2, rect2, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
 
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -1112,8 +1114,8 @@ TEST_F(DisplayTest, DrawOcclusionWithNonCoveringDrawQuad) {
         gfx::Transform(), rect3, rect3, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect3, rect3, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect3, rect3, SkColors::kBlack, false);
 
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -1145,8 +1147,8 @@ TEST_F(DisplayTest, DrawOcclusionWithNonCoveringDrawQuad) {
         gfx::Transform(), rect6, rect6, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect7, rect7, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect6, rect6, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect7, rect7, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect6, rect6, SkColors::kBlack, false);
 
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -1178,8 +1180,8 @@ TEST_F(DisplayTest, DrawOcclusionWithNonCoveringDrawQuad) {
         gfx::Transform(), rect4, rect4, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect4, rect4, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect4, rect4, SkColors::kBlack, false);
 
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -1209,8 +1211,8 @@ TEST_F(DisplayTest, DrawOcclusionWithNonCoveringDrawQuad) {
         gfx::Transform(), rect5, rect5, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect5, rect5, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect5, rect5, SkColors::kBlack, false);
 
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -1261,7 +1263,7 @@ TEST_F(DisplayTest, DrawOcclusionWithSingleOverlapBehindDisjointedDrawQuads) {
     shared_quad_state->SetAll(
         gfx::Transform(), rect, rect, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect, rect, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect, rect, SkColors::kBlack, false);
   }
 
   //              +-------+
@@ -1316,7 +1318,7 @@ TEST_F(DisplayTest, DrawOcclusionWithMultipleOverlapBehindDisjointedDrawQuads) {
     shared_quad_state->SetAll(
         gfx::Transform(), rect, rect, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect, rect, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect, rect, SkColors::kBlack, false);
   }
 
   //              +-------+
@@ -1378,8 +1380,8 @@ TEST_F(DisplayTest, CompositorFrameWithOverlapDrawQuad) {
         gfx::Transform(), rect1, rect1, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect1, rect1, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect1, rect1, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // |quad2| overlaps |quad1|, so |quad2| is removed from the |quad_list|.
@@ -1402,8 +1404,8 @@ TEST_F(DisplayTest, CompositorFrameWithOverlapDrawQuad) {
         gfx::Transform(), rect2, rect2, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // |quad2| is hiding behind |quad1|, so |quad2| is removed from the
@@ -1428,8 +1430,8 @@ TEST_F(DisplayTest, CompositorFrameWithOverlapDrawQuad) {
         gfx::Transform(), rect3, rect3, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect3, rect3, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect3, rect3, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // |quad2| is behind |quad1| and aligns with the edge of |quad1|, so |quad2|
@@ -1455,8 +1457,8 @@ TEST_F(DisplayTest, CompositorFrameWithOverlapDrawQuad) {
         gfx::Transform(), rect4, rect4, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect4, rect4, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect4, rect4, SkColors::kBlack, false);
 
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -1518,8 +1520,8 @@ TEST_F(DisplayTest, CompositorFrameWithTransformer) {
                                absl::nullopt, are_contents_opaque, opacity,
                                SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // |rect2| becomes (12, 12, 50x50) after applying half scale transform,
@@ -1541,8 +1543,8 @@ TEST_F(DisplayTest, CompositorFrameWithTransformer) {
                                absl::nullopt, are_contents_opaque, opacity,
                                SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect3, rect3, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect3, rect3, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // |rect3| becomes (25, 25, 50x25) after applying half scale transform,
@@ -1565,8 +1567,8 @@ TEST_F(DisplayTest, CompositorFrameWithTransformer) {
                                absl::nullopt, are_contents_opaque, opacity,
                                SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect4, rect4, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect4, rect4, SkColors::kBlack, false);
 
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -1584,7 +1586,7 @@ TEST_F(DisplayTest, CompositorFrameWithTransformer) {
                               absl::nullopt, are_contents_opaque, opacity,
                               SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
     EXPECT_EQ(1u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // The compositor frame contains only one quad, so |quad_list| remains 1
@@ -1606,8 +1608,8 @@ TEST_F(DisplayTest, CompositorFrameWithTransformer) {
         double_scale, rect5, rect5, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect5, rect5, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect5, rect5, SkColors::kBlack, false);
 
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -1634,8 +1636,8 @@ TEST_F(DisplayTest, CompositorFrameWithTransformer) {
         double_scale, rect6, rect6, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect6, rect6, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect6, rect6, SkColors::kBlack, false);
 
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -1662,8 +1664,8 @@ TEST_F(DisplayTest, CompositorFrameWithTransformer) {
         double_scale, rect7, rect7, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect7, rect7, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect7, rect7, SkColors::kBlack, false);
 
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -1690,8 +1692,8 @@ TEST_F(DisplayTest, CompositorFrameWithTransformer) {
         double_scale, rect8, rect8, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect8, rect8, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect8, rect8, SkColors::kBlack, false);
 
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -1718,8 +1720,8 @@ TEST_F(DisplayTest, CompositorFrameWithTransformer) {
         double_scale, rect9, rect9, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect10, rect10, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect9, rect9, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect10, rect10, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect9, rect9, SkColors::kBlack, false);
 
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -1776,8 +1778,8 @@ TEST_F(DisplayTest, CompositorFrameWithEpsilonScaleTransform) {
                                absl::nullopt, are_contents_opaque, opacity,
                                SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect, rect, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect, rect, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect, rect, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect, rect, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // zero matrix transform is non-invertible, so |quad2| is not removed from
@@ -1800,8 +1802,8 @@ TEST_F(DisplayTest, CompositorFrameWithEpsilonScaleTransform) {
                                absl::nullopt, are_contents_opaque, opacity,
                                SkBlendMode::kSrcOver, 1);
 
-    quad->SetNew(shared_quad_state, rect, rect, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect, rect, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect, rect, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect, rect, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // This test verifies that the draw occlusion algorithm does not break when
@@ -1830,8 +1832,8 @@ TEST_F(DisplayTest, CompositorFrameWithEpsilonScaleTransform) {
         larger_epsilon_scale, rect, rect, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect, rect, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect, rect, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect, rect, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect, rect, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // This test verifies that the draw occlusion algorithm works well with
@@ -1878,8 +1880,8 @@ TEST_F(DisplayTest, CompositorFrameWithNegativeScaleTransform) {
         negative_scale, rect, rect, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect, rect, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect, rect, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect, rect, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect, rect, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // Since the x-axis is negated, |quad2| after applying transform does not
@@ -1910,8 +1912,8 @@ TEST_F(DisplayTest, CompositorFrameWithNegativeScaleTransform) {
         negative_scale, rect, rect, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect, rect, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect, rect, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect, rect, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect, rect, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // Since the y-axis is negated, |quad2| after applying transform does not
@@ -1942,8 +1944,8 @@ TEST_F(DisplayTest, CompositorFrameWithNegativeScaleTransform) {
         negative_scale, rect, rect, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect, rect, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect, rect, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect, rect, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect, rect, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // Since z-axis is missing in a 2d plane, negating the z-axis does not cause
@@ -2002,8 +2004,8 @@ TEST_F(DisplayTest, CompositorFrameWithRotation) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect2, rect2, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // In target space, |quad| becomes (0, 0, 71x100) (after applying rotation
@@ -2026,8 +2028,8 @@ TEST_F(DisplayTest, CompositorFrameWithRotation) {
     shared_quad_state2->SetAll(rotate, rect2, rect2, gfx::MaskFilterInfo(),
                                absl::nullopt, are_contents_opaque, opacity,
                                SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // In target space, |quad| becomes (0, 0, 70x100) and |quad2| becomes
@@ -2048,8 +2050,8 @@ TEST_F(DisplayTest, CompositorFrameWithRotation) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect3, rect3, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect3, rect3, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect3, rect3, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // In target space, |quad| becomes (0, 0, 71x100) (after applying rotation
@@ -2074,8 +2076,8 @@ TEST_F(DisplayTest, CompositorFrameWithRotation) {
     shared_quad_state2->SetAll(rotate, rect3, rect3, gfx::MaskFilterInfo(),
                                absl::nullopt, are_contents_opaque, opacity,
                                SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect3, rect3, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect3, rect3, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // Since both |quad| and |quad2| went through the same transform and |rect1|
@@ -2126,8 +2128,8 @@ TEST_F(DisplayTest, CompositorFrameWithPerspective) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect1, rect1, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect1, rect1, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect1, rect1, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // The transform used on |quad| is a combination of rotation and
@@ -2150,8 +2152,8 @@ TEST_F(DisplayTest, CompositorFrameWithPerspective) {
     shared_quad_state2->SetAll(perspective, rect2, rect2, gfx::MaskFilterInfo(),
                                absl::nullopt, are_contents_opaque, opacity,
                                SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // The transform used on |quad2| is a combination of rotation and
@@ -2195,8 +2197,8 @@ TEST_F(DisplayTest, CompositorFrameWithOpacityChange) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect2, rect2, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity1, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // Since the opacity of |rect2| is less than 1, |rect1| cannot occlude
@@ -2217,8 +2219,8 @@ TEST_F(DisplayTest, CompositorFrameWithOpacityChange) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect2, rect2, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity1, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // Repeat the above test and set the opacity of |rect1| to 1.
@@ -2258,8 +2260,8 @@ TEST_F(DisplayTest, CompositorFrameWithOpaquenessChange) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect2, rect2, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // Since the opaqueness of |rect2| is false, |rect1| cannot occlude
@@ -2280,8 +2282,8 @@ TEST_F(DisplayTest, CompositorFrameWithOpaquenessChange) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect2, rect2, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // Repeat the above test and set the opaqueness of |rect2| to true.
@@ -2329,8 +2331,8 @@ TEST_F(DisplayTest, CompositorFrameZTranslate) {
         gfx::Transform(), rect1, rect1, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 1);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect1, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect1, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // Since both |quad| and |quad2| are inside of a 3d object, DrawOcclusion
@@ -2383,8 +2385,8 @@ TEST_F(DisplayTest, CompositorFrameWithTranslateTransformer) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect2, rect2, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // |rect2| and |rect1| are disjoined as show in the first image. The size of
@@ -2412,8 +2414,8 @@ TEST_F(DisplayTest, CompositorFrameWithTranslateTransformer) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect2, rect2, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // Move |quad| defind by |rect1| over |quad2| defind by |rect2| by applying
@@ -2442,8 +2444,8 @@ TEST_F(DisplayTest, CompositorFrameWithTranslateTransformer) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect3, rect3, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect3, rect3, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect3, rect3, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // Move |quad| defind by |rect1| over |quad2| defind by |rect3| by applying
@@ -2507,9 +2509,9 @@ TEST_F(DisplayTest, CompositorFrameWithCombinedSharedQuadState) {
     shared_quad_state3->SetAll(
         gfx::Transform(), rect3, rect3, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
-    quad3->SetNew(shared_quad_state3, rect3, rect3, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
+    quad3->SetNew(shared_quad_state3, rect3, rect3, SkColors::kBlack, false);
     EXPECT_EQ(3u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // The occlusion rect is enlarged horizontally after visiting |rect1| and
@@ -2536,7 +2538,7 @@ TEST_F(DisplayTest, CompositorFrameWithCombinedSharedQuadState) {
     shared_quad_state3->SetAll(
         gfx::Transform(), rect4, rect4, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad3->SetNew(shared_quad_state3, rect4, rect4, SK_ColorBLACK, false);
+    quad3->SetNew(shared_quad_state3, rect4, rect4, SkColors::kBlack, false);
     EXPECT_EQ(3u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // The occlusion rect, which is enlarged horizontally after visiting |rect1|
@@ -2564,7 +2566,7 @@ TEST_F(DisplayTest, CompositorFrameWithCombinedSharedQuadState) {
     shared_quad_state3->SetAll(
         gfx::Transform(), rect5, rect5, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad3->SetNew(shared_quad_state3, rect5, rect5, SK_ColorBLACK, false);
+    quad3->SetNew(shared_quad_state3, rect5, rect5, SkColors::kBlack, false);
     EXPECT_EQ(3u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // The occlusion rect, which is enlarged horizontally after visiting |rect1|
@@ -2613,8 +2615,8 @@ TEST_F(DisplayTest, DrawOcclusionWithMultipleRenderPass) {
         gfx::Transform(), rects[i], rects[i], gfx::MaskFilterInfo(),
         /*clip_rect=*/absl::nullopt, true /*are_contents_opaque*/,
         1.f /*opacity*/, SkBlendMode::kSrcOver, 0 /*sorting_context_id*/);
-    quads[i]->SetNew(shared_quad_states[i], rects[i], rects[i], SK_ColorBLACK,
-                     false /*force_anti_aliasing_off*/);
+    quads[i]->SetNew(shared_quad_states[i], rects[i], rects[i],
+                     SkColors::kBlack, false /*force_anti_aliasing_off*/);
   }
 
   auto& render_pass = frame.render_pass_list.front();
@@ -2681,9 +2683,9 @@ TEST_F(DisplayTest, CompositorFrameWithMultipleRenderPass) {
     shared_quad_state3->SetAll(
         gfx::Transform(), rect3, rect3, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
-    quad3->SetNew(shared_quad_state3, rect3, rect3, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
+    quad3->SetNew(shared_quad_state3, rect3, rect3, SkColors::kBlack, false);
     EXPECT_EQ(2u, frame.render_pass_list.at(1)->quad_list.size());
     EXPECT_EQ(1u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -2750,7 +2752,7 @@ TEST_F(DisplayTest, CompositorFrameWithCoveredRenderPass) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect1, rect1, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
     quad1->SetNew(shared_quad_state2, rect1, rect1, render_pass_id,
                   mask_resource_id, gfx::RectF(), gfx::Size(),
                   gfx::Vector2dF(1, 1), gfx::PointF(), gfx::RectF(), false,
@@ -2809,8 +2811,8 @@ TEST_F(DisplayTest, CompositorFrameWithClip) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect2, rect2, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // |rect1| covers |rect2| as shown in the figure above, So the size of
@@ -2836,8 +2838,8 @@ TEST_F(DisplayTest, CompositorFrameWithClip) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect2, rect2, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // In the target space, a clip is applied on |quad| (defined by |clip_rect|,
@@ -2865,8 +2867,8 @@ TEST_F(DisplayTest, CompositorFrameWithClip) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect3, rect3, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect3, rect3, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect3, rect3, SkColors::kBlack, false);
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // In the target space, a clip is applied on |quad| (defined by |rect3|,
@@ -2912,8 +2914,8 @@ TEST_F(DisplayTest, CompositorFrameWithCopyRequest) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect2, rect2, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
     frame.render_pass_list.front()->copy_requests.push_back(
         CopyOutputRequest::CreateStubForTesting());
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
@@ -2993,8 +2995,8 @@ TEST_F(DisplayTest, CompositorFrameWithRenderPass) {
     R2->SetNew(shared_quad_state, rect2, rect2, render_pass_id,
                mask_resource_id, gfx::RectF(), gfx::Size(),
                gfx::Vector2dF(1, 1), gfx::PointF(), gfx::RectF(), false, 1.0f);
-    D1->SetNew(shared_quad_state3, rect3, rect3, SK_ColorBLACK, false);
-    D2->SetNew(shared_quad_state4, rect4, rect4, SK_ColorBLACK, false);
+    D1->SetNew(shared_quad_state3, rect3, rect3, SkColors::kBlack, false);
+    D2->SetNew(shared_quad_state4, rect4, rect4, SkColors::kBlack, false);
     EXPECT_EQ(4u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // As shown in the image above, the opaque region |d1| and |d2| does not
@@ -3041,8 +3043,8 @@ TEST_F(DisplayTest, CompositorFrameWithRenderPass) {
     R2->SetNew(shared_quad_state, rect1, rect1, render_pass_id,
                mask_resource_id, gfx::RectF(), gfx::Size(),
                gfx::Vector2dF(1, 1), gfx::PointF(), gfx::RectF(), false, 1.0f);
-    D1->SetNew(shared_quad_state3, rect3, rect3, SK_ColorBLACK, false);
-    D2->SetNew(shared_quad_state4, rect6, rect6, SK_ColorBLACK, false);
+    D1->SetNew(shared_quad_state3, rect3, rect3, SkColors::kBlack, false);
+    D2->SetNew(shared_quad_state4, rect6, rect6, SkColors::kBlack, false);
     EXPECT_EQ(4u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // As shown in the image above, the opaque region |d1| and |d2| does not
@@ -3088,8 +3090,8 @@ TEST_F(DisplayTest, CompositorFrameWithRenderPass) {
     R2->SetNew(shared_quad_state, rect1, rect1, render_pass_id,
                mask_resource_id, gfx::RectF(), gfx::Size(),
                gfx::Vector2dF(1, 1), gfx::PointF(), gfx::RectF(), false, 1.0f);
-    D1->SetNew(shared_quad_state3, rect3, rect3, SK_ColorBLACK, false);
-    D2->SetNew(shared_quad_state4, rect7, rect7, SK_ColorBLACK, false);
+    D1->SetNew(shared_quad_state3, rect3, rect3, SkColors::kBlack, false);
+    D2->SetNew(shared_quad_state4, rect7, rect7, SkColors::kBlack, false);
     EXPECT_EQ(4u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // As shown in the image above, the opaque region |d2| is contained in |d1|
@@ -3164,12 +3166,12 @@ TEST_F(DisplayTest, CompositorFrameWithMultipleDrawQuadInSharedQuadState) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect_in_rect1, rect_in_rect1, gfx::MaskFilterInfo(),
         absl::nullopt, opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad1->SetNew(shared_quad_state, rect1_1, rect1_1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state, rect1_2, rect1_2, SK_ColorBLACK, false);
-    quad3->SetNew(shared_quad_state, rect1_3, rect1_3, SK_ColorBLACK, false);
-    quad4->SetNew(shared_quad_state, rect1_4, rect1_4, SK_ColorBLACK, false);
+    quad1->SetNew(shared_quad_state, rect1_1, rect1_1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state, rect1_2, rect1_2, SkColors::kBlack, false);
+    quad3->SetNew(shared_quad_state, rect1_3, rect1_3, SkColors::kBlack, false);
+    quad4->SetNew(shared_quad_state, rect1_4, rect1_4, SkColors::kBlack, false);
     quad5->SetNew(shared_quad_state2, rect_in_rect1, rect_in_rect1,
-                  SK_ColorBLACK, false);
+                  SkColors::kBlack, false);
     EXPECT_EQ(5u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // |visible_rect| of |shared_quad_state| is formed by 4 DrawQuads and it
@@ -3204,7 +3206,7 @@ TEST_F(DisplayTest, CompositorFrameWithMultipleDrawQuadInSharedQuadState) {
                                absl::nullopt, opaque_content, opacity,
                                SkBlendMode::kSrcOver, 0);
     quad5->SetNew(shared_quad_state2, rect_intersects_rect1,
-                  rect_intersects_rect1, SK_ColorBLACK, false);
+                  rect_intersects_rect1, SkColors::kBlack, false);
     EXPECT_EQ(5u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // |visible_rect| of |shared_quad_state| is formed by 4 DrawQuads and it
@@ -3245,12 +3247,14 @@ TEST_F(DisplayTest, CompositorFrameWithMultipleDrawQuadInSharedQuadState) {
     shared_quad_state2->SetAll(
         gfx::Transform(), rect3, rect3, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad1->SetNew(shared_quad_state, rect2_1, rect2_1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state, rect2_2, rect2_2, SK_ColorBLACK, false);
-    quad3->SetNew(shared_quad_state, rect2_3, rect2_3, SK_ColorBLACK, false);
-    quad4->SetNew(shared_quad_state, rect2_4, rect2_4, SK_ColorBLACK, false);
-    quad5->SetNew(shared_quad_state2, rect3_1, rect3_1, SK_ColorBLACK, false);
-    quad6->SetNew(shared_quad_state2, rect3_2, rect3_2, SK_ColorBLACK, false);
+    quad1->SetNew(shared_quad_state, rect2_1, rect2_1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state, rect2_2, rect2_2, SkColors::kBlack, false);
+    quad3->SetNew(shared_quad_state, rect2_3, rect2_3, SkColors::kBlack, false);
+    quad4->SetNew(shared_quad_state, rect2_4, rect2_4, SkColors::kBlack, false);
+    quad5->SetNew(shared_quad_state2, rect3_1, rect3_1, SkColors::kBlack,
+                  false);
+    quad6->SetNew(shared_quad_state2, rect3_2, rect3_2, SkColors::kBlack,
+                  false);
     EXPECT_EQ(6u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // |visible_rect| of |shared_quad_state| is formed by 4 DrawQuads and it
@@ -3335,9 +3339,9 @@ TEST_F(DisplayTest, CompositorFrameWithNonInvertibleTransform) {
     shared_quad_state3->SetAll(
         non_invertible, rect3, rect3, gfx::MaskFilterInfo(), absl::nullopt,
         opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad1->SetNew(shared_quad_state1, rect1, rect1, SK_ColorBLACK, false);
-    quad2->SetNew(shared_quad_state2, rect2, rect2, SK_ColorBLACK, false);
-    quad3->SetNew(shared_quad_state3, rect3, rect3, SK_ColorBLACK, false);
+    quad1->SetNew(shared_quad_state1, rect1, rect1, SkColors::kBlack, false);
+    quad2->SetNew(shared_quad_state2, rect2, rect2, SkColors::kBlack, false);
+    quad3->SetNew(shared_quad_state3, rect3, rect3, SkColors::kBlack, false);
 
     EXPECT_EQ(3u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -3366,8 +3370,8 @@ TEST_F(DisplayTest, CompositorFrameWithNonInvertibleTransform) {
     shared_quad_state3->SetAll(
         non_invertible_miss_z, rect3, rect3, gfx::MaskFilterInfo(),
         absl::nullopt, opaque_content, opacity, SkBlendMode::kSrcOver, 0);
-    quad1->SetNew(shared_quad_state1, rect1, rect1, SK_ColorBLACK, false);
-    quad3->SetNew(shared_quad_state3, rect3, rect3, SK_ColorBLACK, false);
+    quad1->SetNew(shared_quad_state1, rect1, rect1, SkColors::kBlack, false);
+    quad3->SetNew(shared_quad_state3, rect3, rect3, SkColors::kBlack, false);
 
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -3407,7 +3411,7 @@ TEST_F(DisplayTest, DrawOcclusionWithLargeDrawQuad) {
         gfx::Transform(), rect1, rect1, gfx::MaskFilterInfo(), absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
 
-    quad->SetNew(shared_quad_state, rect1, rect1, SK_ColorBLACK, false);
+    quad->SetNew(shared_quad_state, rect1, rect1, SkColors::kBlack, false);
     EXPECT_EQ(1u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
     // This is a base case, the compositor frame contains only one
@@ -3475,7 +3479,7 @@ TEST_F(DisplayTest, CompositorFrameWithPresentationToken) {
         0.5f /* opacity */, SkBlendMode::kSrcOver, 0 /* sorting_context_id */);
     auto* quad1 = pass->quad_list.AllocateAndConstruct<SolidColorDrawQuad>();
     quad1->SetNew(shared_quad_state1, rect1 /* rect */,
-                  rect1 /* visible_rect */, SK_ColorBLACK,
+                  rect1 /* visible_rect */, SkColors::kBlack,
                   false /* force_anti_aliasing_off */);
 
     auto* shared_quad_state2 = pass->CreateAndAppendSharedQuadState();
@@ -3489,7 +3493,7 @@ TEST_F(DisplayTest, CompositorFrameWithPresentationToken) {
     auto* quad2 = pass->quad_list.AllocateAndConstruct<SurfaceDrawQuad>();
     quad2->SetNew(shared_quad_state2, rect2 /* rect */,
                   rect2 /* visible_rect */,
-                  SurfaceRange(absl::nullopt, sub_surface_id), SK_ColorBLACK,
+                  SurfaceRange(absl::nullopt, sub_surface_id), SkColors::kBlack,
                   false /* stretch_content_to_fill_bounds */);
 
     pass_list.push_back(std::move(pass));
@@ -3784,13 +3788,13 @@ TEST_F(DisplayTest, DrawOcclusionWithRoundedCornerDoesNotOcclude) {
         gfx::Transform(), quad_rect, quad_rect, gfx::MaskFilterInfo(),
         absl::nullopt, are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
     occluded_quad->SetNew(shared_quad_state_occluded, quad_rect, quad_rect,
-                          SK_ColorRED, false);
+                          SkColors::kRed, false);
 
     shared_quad_state_with_rrect->SetAll(
         gfx::Transform(), quad_rect, quad_rect, mask_filter_info, absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
     rounded_corner_quad->SetNew(shared_quad_state_with_rrect, quad_rect,
-                                quad_rect, SK_ColorBLUE, false);
+                                quad_rect, SkColors::kBlue, false);
 
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -3839,13 +3843,13 @@ TEST_F(DisplayTest, DrawOcclusionWithRoundedCornerDoesOcclude) {
         gfx::MaskFilterInfo(), absl::nullopt, are_contents_opaque, opacity,
         SkBlendMode::kSrcOver, 0);
     occluded_quad->SetNew(shared_quad_state_occluded, occluded_quad_rect,
-                          occluded_quad_rect, SK_ColorRED, false);
+                          occluded_quad_rect, SkColors::kRed, false);
 
     shared_quad_state_with_rrect->SetAll(
         gfx::Transform(), quad_rect, quad_rect, mask_filter_info, absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
     rounded_corner_quad->SetNew(shared_quad_state_with_rrect, quad_rect,
-                                quad_rect, SK_ColorBLUE, false);
+                                quad_rect, SkColors::kBlue, false);
 
     EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);
@@ -3905,7 +3909,7 @@ TEST_F(DisplayTest, DrawOcclusionSplit) {
         gfx::Transform(), occluding_rect, occluding_rect, gfx::MaskFilterInfo(),
         absl::nullopt, are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
     quads[0]->SetNew(shared_quad_state_occluder, occluding_rect, occluding_rect,
-                     SK_ColorRED, false);
+                     SkColors::kRed, false);
 
     shared_quad_state_occluded->SetAll(gfx::Transform(), occluded_sqs_rect,
                                        occluded_sqs_rect, gfx::MaskFilterInfo(),
@@ -3913,7 +3917,7 @@ TEST_F(DisplayTest, DrawOcclusionSplit) {
                                        opacity, SkBlendMode::kSrcOver, 0);
     for (int i = 1; i < 4; i++) {
       quads[i]->SetNew(shared_quad_state_occluded, quad_rects[i - 1],
-                       quad_rects[i - 1], SK_ColorRED, false);
+                       quad_rects[i - 1], SkColors::kRed, false);
     }
 
     EXPECT_EQ(4u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
@@ -4009,7 +4013,7 @@ TEST_F(DisplayTest, FirstPassVisibleComplexityReduction) {
     SolidColorDrawQuad* quad =
         frame.render_pass_list.front()
             ->quad_list.AllocateAndConstruct<SolidColorDrawQuad>();
-    quad->SetNew(shared_quad_state_occluder, r, r, SK_ColorRED, false);
+    quad->SetNew(shared_quad_state_occluder, r, r, SkColors::kRed, false);
   }
 
   const gfx::Rect occluded_rect(0, 0, 1350, 270);
@@ -4023,7 +4027,7 @@ TEST_F(DisplayTest, FirstPassVisibleComplexityReduction) {
         frame.render_pass_list.front()
             ->quad_list.AllocateAndConstruct<SolidColorDrawQuad>();
     occluded_quad->SetNew(shared_quad_state_occluded, occluded_rect,
-                          occluded_rect, SK_ColorRED, false);
+                          occluded_rect, SkColors::kRed, false);
   }
 
   EXPECT_EQ(3u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
@@ -4086,7 +4090,7 @@ TEST_F(DisplayTest, DrawOcclusionSplitDeviceScaleFactorFractional) {
       gfx::Transform(), occluding_rect, occluding_rect, gfx::MaskFilterInfo(),
       absl::nullopt, are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
   occluding_quad->SetNew(shared_quad_state_occluding, occluding_rect,
-                         occluding_rect, SK_ColorRED, false);
+                         occluding_rect, SkColors::kRed, false);
   // Occluded quad.
   const gfx::Rect occluded_rect = gfx::Rect(0, 0, 1000, 1000);
   SharedQuadState* shared_quad_state_occluded =
@@ -4098,7 +4102,7 @@ TEST_F(DisplayTest, DrawOcclusionSplitDeviceScaleFactorFractional) {
       gfx::Transform(), occluded_rect, occluded_rect, gfx::MaskFilterInfo(),
       absl::nullopt, are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
   occluded_quad->SetNew(shared_quad_state_occluded, occluded_rect,
-                        occluded_rect, SK_ColorRED, false);
+                        occluded_rect, SkColors::kRed, false);
 
   EXPECT_EQ(2u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
   display_->RemoveOverdrawQuads(&frame);
@@ -4171,19 +4175,19 @@ TEST_F(DisplayTest, DrawOcclusionWithRoundedCornerPartialOcclude) {
                                        absl::nullopt, are_contents_opaque,
                                        opacity, SkBlendMode::kSrcOver, 0);
     occluded_quad_1->SetNew(shared_quad_state_occluded, occluded_quad_rect_1,
-                            occluded_quad_rect_1, SK_ColorRED, false);
+                            occluded_quad_rect_1, SkColors::kRed, false);
     occluded_quad_2->SetNew(shared_quad_state_occluded, occluded_quad_rect_2,
-                            occluded_quad_rect_2, SK_ColorRED, false);
+                            occluded_quad_rect_2, SkColors::kRed, false);
     occluded_quad_3->SetNew(shared_quad_state_occluded, occluded_quad_rect_3,
-                            occluded_quad_rect_3, SK_ColorRED, false);
+                            occluded_quad_rect_3, SkColors::kRed, false);
     occluded_quad_4->SetNew(shared_quad_state_occluded, occluded_quad_rect_4,
-                            occluded_quad_rect_4, SK_ColorRED, false);
+                            occluded_quad_rect_4, SkColors::kRed, false);
 
     shared_quad_state_with_rrect->SetAll(
         gfx::Transform(), quad_rect, quad_rect, mask_filter_info, absl::nullopt,
         are_contents_opaque, opacity, SkBlendMode::kSrcOver, 0);
     rounded_corner_quad->SetNew(shared_quad_state_with_rrect, quad_rect,
-                                quad_rect, SK_ColorBLUE, false);
+                                quad_rect, SkColors::kBlue, false);
 
     EXPECT_EQ(5u, NumVisibleRects(frame.render_pass_list.front()->quad_list));
     display_->RemoveOverdrawQuads(&frame);

components/viz/service/display/overlay_ca_unittest.cc

@@ -136,7 +136,7 @@ TextureDrawQuad* CreateCandidateQuadAt(
   auto* overlay_quad = render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   overlay_quad->SetNew(shared_quad_state, rect, rect, needs_blending,
                        resource_id, premultiplied_alpha, kUVTopLeft,
-                       kUVBottomRight, SK_ColorTRANSPARENT, vertex_opacity,
+                       kUVBottomRight, SkColors::kTransparent, vertex_opacity,
                        flipped, nearest_neighbor, /*secure_output_only=*/false,
                        protected_video_type);
   overlay_quad->set_resource_size_in_pixels(resource_size_in_pixels);

components/viz/service/display/overlay_dc_unittest.cc

@@ -133,6 +133,7 @@ ResourceId CreateResource(DisplayResourceProvider* parent_resource_provider,
   return resource_map[list[0].id];
 }
 
+// TODO(crbug.com/1308932): Make this function us SkColor4f
 SolidColorDrawQuad* CreateSolidColorQuadAt(
     const SharedQuadState* shared_quad_state,
     SkColor color,
@@ -140,10 +141,12 @@ SolidColorDrawQuad* CreateSolidColorQuadAt(
     const gfx::Rect& rect) {
   SolidColorDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-  quad->SetNew(shared_quad_state, rect, rect, color, false);
+  quad->SetNew(shared_quad_state, rect, rect, SkColor4f::FromColor(color),
+               false);
   return quad;
 }
 
+// TODO(crbug.com/1308932): Make this function us SkColor4f
 void CreateOpaqueQuadAt(DisplayResourceProvider* resource_provider,
                         const SharedQuadState* shared_quad_state,
                         AggregatedRenderPass* render_pass,
@@ -151,7 +154,8 @@ void CreateOpaqueQuadAt(DisplayResourceProvider* resource_provider,
                         SkColor color) {
   DCHECK_EQ(255u, SkColorGetA(color));
   auto* color_quad = render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-  color_quad->SetNew(shared_quad_state, rect, rect, color, false);
+  color_quad->SetNew(shared_quad_state, rect, rect, SkColor4f::FromColor(color),
+                     false);
 }
 
 YUVVideoDrawQuad* CreateFullscreenCandidateYUVVideoQuad(
@@ -876,7 +880,7 @@ TEST_F(DCLayerOverlayTest, SetEnableDCLayers) {
     damage_rect_ = gfx::Rect(1, 1, 10, 10);
     auto* quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     quad->SetNew(pass->CreateAndAppendSharedQuadState(), damage_rect_,
-                 damage_rect_, SK_ColorRED, false);
+                 damage_rect_, SkColors::kRed, false);
 
     DCLayerOverlayList dc_layer_list;
     OverlayProcessorInterface::FilterOperationsMap render_pass_filters;

components/viz/service/display/overlay_strategy_underlay.cc

@@ -185,10 +185,10 @@ void OverlayStrategyUnderlay::CommitCandidate(
   // need to switch out the video quad with an underlay hole quad.
   if (proposed_candidate.candidate.has_mask_filter) {
     render_pass->ReplaceExistingQuadWithSolidColor(
-        proposed_candidate.quad_iter, SK_ColorBLACK, SkBlendMode::kDstOut);
+        proposed_candidate.quad_iter, SkColors::kBlack, SkBlendMode::kDstOut);
   } else {
     render_pass->ReplaceExistingQuadWithSolidColor(proposed_candidate.quad_iter,
-                                                   SK_ColorTRANSPARENT,
+                                                   SkColors::kTransparent,
                                                    SkBlendMode::kSrcOver);
   }
 }

components/viz/service/display/overlay_strategy_underlay_cast.cc

@@ -270,10 +270,10 @@ void OverlayStrategyUnderlayCast::CommitCandidate(
 
   if (proposed_candidate.candidate.has_mask_filter) {
     render_pass->ReplaceExistingQuadWithSolidColor(
-        proposed_candidate.quad_iter, SK_ColorBLACK, SkBlendMode::kDstOut);
+        proposed_candidate.quad_iter, SkColors::kBlack, SkBlendMode::kDstOut);
   } else {
     render_pass->ReplaceExistingQuadWithSolidColor(proposed_candidate.quad_iter,
-                                                   SK_ColorTRANSPARENT,
+                                                   SkColors::kTransparent,
                                                    SkBlendMode::kSrcOver);
   }
 }

components/viz/service/display/overlay_unittest.cc

@@ -469,6 +469,7 @@ ResourceId CreateResource(DisplayResourceProvider* parent_resource_provider,
                         RGBA_8888);
 }
 
+// TODO(crbug.com/1308932): Make this function use SkColor4f
 SolidColorDrawQuad* CreateSolidColorQuadAt(
     const SharedQuadState* shared_quad_state,
     SkColor color,
@@ -476,7 +477,8 @@ SolidColorDrawQuad* CreateSolidColorQuadAt(
     const gfx::Rect& rect) {
   SolidColorDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-  quad->SetNew(shared_quad_state, rect, rect, color, false);
+  quad->SetNew(shared_quad_state, rect, rect, SkColor4f::FromColor(color),
+               false);
   return quad;
 }
 
@@ -505,7 +507,7 @@ TextureDrawQuad* CreateCandidateQuadAt(
   auto* overlay_quad = render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   overlay_quad->SetNew(shared_quad_state, rect, rect, needs_blending,
                        resource_id, premultiplied_alpha, kUVTopLeft,
-                       kUVBottomRight, SK_ColorTRANSPARENT, vertex_opacity,
+                       kUVBottomRight, SkColors::kTransparent, vertex_opacity,
                        flipped, nearest_neighbor, /*secure_output_only=*/false,
                        protected_video_type);
   overlay_quad->set_resource_size_in_pixels(resource_size_in_pixels);
@@ -593,7 +595,7 @@ TextureDrawQuad* CreateTransparentCandidateQuadAt(
   auto* overlay_quad = render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   overlay_quad->SetNew(shared_quad_state, rect, rect, needs_blending,
                        resource_id, premultiplied_alpha, kUVTopLeft,
-                       kUVBottomRight, SK_ColorTRANSPARENT, vertex_opacity,
+                       kUVBottomRight, SkColors::kTransparent, vertex_opacity,
                        flipped, nearest_neighbor, /*secure_output_only=*/false,
                        gfx::ProtectedVideoType::kClear);
   overlay_quad->set_resource_size_in_pixels(resource_size_in_pixels);
@@ -617,9 +619,10 @@ void CreateOpaqueQuadAt(DisplayResourceProvider* resource_provider,
                         AggregatedRenderPass* render_pass,
                         const gfx::Rect& rect) {
   auto* color_quad = render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-  color_quad->SetNew(shared_quad_state, rect, rect, SK_ColorBLACK, false);
+  color_quad->SetNew(shared_quad_state, rect, rect, SkColors::kBlack, false);
 }
 
+// TODO(crbug.com/1308932): Make this function use SkColor4f
 void CreateOpaqueQuadAt(DisplayResourceProvider* resource_provider,
                         const SharedQuadState* shared_quad_state,
                         AggregatedRenderPass* render_pass,
@@ -627,7 +630,8 @@ void CreateOpaqueQuadAt(DisplayResourceProvider* resource_provider,
                         SkColor color) {
   DCHECK_EQ(255u, SkColorGetA(color));
   auto* color_quad = render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-  color_quad->SetNew(shared_quad_state, rect, rect, color, false);
+  color_quad->SetNew(shared_quad_state, rect, rect, SkColor4f::FromColor(color),
+                     false);
 }
 
 void CreateFullscreenOpaqueQuad(DisplayResourceProvider* resource_provider,
@@ -1246,7 +1250,7 @@ TEST_F(SingleOverlayOnTopTest, StablePrioritizeIntervalFrame) {
     quad_small->SetNew(
         shared_quad_state_a, kCandidateRectA, kCandidateRectA,
         false /*needs_blending*/, resource_id_a, false /*premultiplied_alpha*/,
-        kUVTopLeft, kUVBottomRight, SK_ColorTRANSPARENT, vertex_opacity,
+        kUVTopLeft, kUVBottomRight, SkColors::kTransparent, vertex_opacity,
         false /*flipped*/, false /*nearest_neighbor*/,
         false /*secure_output_only*/, gfx::ProtectedVideoType::kClear);
     quad_small->set_resource_size_in_pixels(kCandidateRectA.size());
@@ -1261,7 +1265,7 @@ TEST_F(SingleOverlayOnTopTest, StablePrioritizeIntervalFrame) {
     quad_big->SetNew(shared_quad_state_b, kCandidateRectB, kCandidateRectB,
                      false /*needs_blending*/, resource_id_b,
                      false /*premultiplied_alpha*/, kUVTopLeft, kUVBottomRight,
-                     SK_ColorTRANSPARENT, vertex_opacity, false /*flipped*/,
+                     SkColors::kTransparent, vertex_opacity, false /*flipped*/,
                      false /*nearest_neighbor*/, false /*secure_output_only*/,
                      gfx::ProtectedVideoType::kClear);
     quad_big->set_resource_size_in_pixels(kCandidateRectB.size());
@@ -2548,7 +2552,7 @@ TEST_F(ChangeSingleOnTopTest, DoNotPromoteIfContentsDontChange) {
         pass->shared_quad_state_list.back(), pass->output_rect,
         pass->output_rect, false /*needs_blending*/, resource_id,
         false /*premultiplied_alpha*/, kUVTopLeft, kUVBottomRight,
-        SK_ColorTRANSPARENT, vertex_opacity, false /*flipped*/,
+        SkColors::kTransparent, vertex_opacity, false /*flipped*/,
         false /*nearest_neighbor*/, false /*secure_output_only*/,
         gfx::ProtectedVideoType::kClear);
     original_quad->set_resource_size_in_pixels(pass->output_rect.size());
@@ -4170,7 +4174,7 @@ void AddQuad(gfx::Rect quad_rect,
 
   SolidColorDrawQuad* solid_quad =
       render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-  solid_quad->SetNew(quad_state, quad_rect, quad_rect, SK_ColorBLACK,
+  solid_quad->SetNew(quad_state, quad_rect, quad_rect, SkColors::kBlack,
                      false /* force_anti_aliasing_off */);
 }
 

components/viz/service/display/renderer_perftest.cc

@@ -200,9 +200,12 @@ void CreateTestTextureDrawQuad(ResourceId resource_id,
   const bool nearest_neighbor = false;
   const float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
   auto* quad = render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
+
+  // TODO(crbug.com/1308932): Input SkColor4f to this function
   quad->SetNew(shared_state, rect, rect, needs_blending, resource_id,
                premultiplied_alpha, uv_top_left, uv_bottom_right,
-               background_color, vertex_opacity, flipped, nearest_neighbor,
+               SkColor4f::FromColor(background_color), vertex_opacity, flipped,
+               nearest_neighbor,
                /*secure_output_only=*/false, gfx::ProtectedVideoType::kClear);
 }
 

components/viz/service/display/resolved_frame_data_unittest.cc

@@ -28,7 +28,7 @@ constexpr gfx::Rect kOutputRect(100, 100);
 CompositorFrame MakeSimpleFrame(const gfx::Rect& damage_rect = kOutputRect) {
   return CompositorFrameBuilder()
       .AddRenderPass(RenderPassBuilder(kOutputRect)
-                         .AddSolidColorQuad(kOutputRect, SK_ColorRED)
+                         .AddSolidColorQuad(kOutputRect, SkColors::kRed)
                          .SetDamageRect(kOutputRect))
       .Build();
 }
@@ -188,7 +188,7 @@ TEST_F(ResolvedFrameDataTest, RenderPassWithPerQuadDamage) {
       CompositorFrameBuilder()
           .AddRenderPass(RenderPassBuilder(kOutputRect)
                              .SetDamageRect(pass_damage_rect)
-                             .AddSolidColorQuad(kOutputRect, SK_ColorRED)
+                             .AddSolidColorQuad(kOutputRect, SkColors::kRed)
                              .AddTextureQuad(kOutputRect, resource_id)
                              .SetQuadDamageRect(quad_damage_rect))
           .PopulateResources()

components/viz/service/display/software_renderer_unittest.cc

@@ -162,13 +162,13 @@ TEST_F(SoftwareRendererTest, SolidColorQuad) {
                             SkBlendMode::kSrcOver, 0);
   auto* inner_quad =
       root_render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-  inner_quad->SetNew(shared_quad_state, inner_rect, inner_rect, SK_ColorCYAN,
+  inner_quad->SetNew(shared_quad_state, inner_rect, inner_rect, SkColors::kCyan,
                      false);
   inner_quad->visible_rect = visible_rect;
   auto* outer_quad =
       root_render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-  outer_quad->SetNew(shared_quad_state, outer_rect, outer_rect, SK_ColorYELLOW,
-                     false);
+  outer_quad->SetNew(shared_quad_state, outer_rect, outer_rect,
+                     SkColors::kYellow, false);
 
   AggregatedRenderPassList list;
   list.push_back(std::move(root_render_pass));
@@ -211,21 +211,21 @@ TEST_F(SoftwareRendererTest, DebugBorderDrawQuad) {
 
   auto* quad_1 =
       root_render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
-  quad_1->SetNew(shared_quad_state, rect_1, rect_1, SK_ColorCYAN, false);
+  quad_1->SetNew(shared_quad_state, rect_1, rect_1, SkColors::kCyan, false);
   auto* quad_2 =
       root_render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
-  quad_2->SetNew(shared_quad_state, rect_2, rect_2, SK_ColorMAGENTA, false);
+  quad_2->SetNew(shared_quad_state, rect_2, rect_2, SkColors::kMagenta, false);
 
   auto* quad_3 =
       root_render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
-  quad_3->SetNew(shared_quad_state, rect_3, rect_3, SK_ColorYELLOW, false);
+  quad_3->SetNew(shared_quad_state, rect_3, rect_3, SkColors::kYellow, false);
 
   // Test one non-opaque color
   SkColor semi_transparent_white = SkColorSetARGB(127, 255, 255, 255);
   auto* quad_4 =
       root_render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
-  quad_4->SetNew(shared_quad_state, rect_4, rect_4, semi_transparent_white,
-                 false);
+  quad_4->SetNew(shared_quad_state, rect_4, rect_4,
+                 SkColor4f::FromColor(semi_transparent_white), false);
 
   AggregatedRenderPassList list;
   list.push_back(std::move(root_render_pass));
@@ -409,7 +409,7 @@ TEST_F(SoftwareRendererTest, ShouldClearRootRenderPass) {
   AggregatedRenderPass* root_clear_pass =
       cc::AddRenderPass(&list, root_clear_pass_id, gfx::Rect(viewport_size),
                         gfx::Transform(), cc::FilterOperations());
-  cc::AddQuad(root_clear_pass, gfx::Rect(viewport_size), SK_ColorGREEN);
+  cc::AddQuad(root_clear_pass, gfx::Rect(viewport_size), SkColors::kGreen);
 
   renderer()->DecideRenderPassAllocationsForFrame(list);
 
@@ -432,7 +432,7 @@ TEST_F(SoftwareRendererTest, ShouldClearRootRenderPass) {
   AggregatedRenderPass* root_smaller_pass =
       cc::AddRenderPass(&list, root_smaller_pass_id, gfx::Rect(viewport_size),
                         gfx::Transform(), cc::FilterOperations());
-  cc::AddQuad(root_smaller_pass, smaller_rect, SK_ColorMAGENTA);
+  cc::AddQuad(root_smaller_pass, smaller_rect, SkColors::kMagenta);
 
   renderer()->DecideRenderPassAllocationsForFrame(list);
 
@@ -464,7 +464,7 @@ TEST_F(SoftwareRendererTest, RenderPassVisibleRect) {
   auto* smaller_pass =
       cc::AddRenderPass(&list, smaller_pass_id, smaller_rect, gfx::Transform(),
                         cc::FilterOperations());
-  cc::AddQuad(smaller_pass, smaller_rect, SK_ColorMAGENTA);
+  cc::AddQuad(smaller_pass, smaller_rect, SkColors::kMagenta);
 
   // Root pass is green.
   AggregatedRenderPassId root_clear_pass_id{1};
@@ -472,7 +472,7 @@ TEST_F(SoftwareRendererTest, RenderPassVisibleRect) {
       AddRenderPass(&list, root_clear_pass_id, gfx::Rect(viewport_size),
                     gfx::Transform(), cc::FilterOperations());
   cc::AddRenderPassQuad(root_clear_pass, smaller_pass);
-  cc::AddQuad(root_clear_pass, gfx::Rect(viewport_size), SK_ColorGREEN);
+  cc::AddQuad(root_clear_pass, gfx::Rect(viewport_size), SkColors::kGreen);
 
   // Interior pass quad has smaller visible rect.
   gfx::Rect interior_visible_rect(30, 30, 40, 40);
@@ -524,8 +524,8 @@ TEST_F(SoftwareRendererTest, ClipRoundRect) {
                               gfx::MaskFilterInfo(), gfx::Rect(1, 1, 30, 30),
                               true, 1.0, SkBlendMode::kSrcOver, 0);
     auto* outer_quad = root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-    outer_quad->SetNew(shared_quad_state, outer_rect, outer_rect, SK_ColorGREEN,
-                       false);
+    outer_quad->SetNew(shared_quad_state, outer_rect, outer_rect,
+                       SkColors::kGreen, false);
   }
 
   // Draw inner round rect.
@@ -540,8 +540,8 @@ TEST_F(SoftwareRendererTest, ClipRoundRect) {
         gfx::MaskFilterInfo(gfx::RRectF(gfx::RectF(5, 5, 10, 10), 2)),
         absl::nullopt, true, 1.0, SkBlendMode::kSrcOver, 0);
     auto* inner_quad = root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-    inner_quad->SetNew(shared_quad_state, inner_rect, inner_rect, SK_ColorRED,
-                       false);
+    inner_quad->SetNew(shared_quad_state, inner_rect, inner_rect,
+                       SkColors::kRed, false);
   }
 
   renderer()->DecideRenderPassAllocationsForFrame(list);
@@ -611,7 +611,7 @@ TEST_F(SoftwareRendererTest, PartialSwap) {
     auto* root_pass =
         AddRenderPass(&list, root_pass_id, gfx::Rect(viewport_size),
                       gfx::Transform(), cc::FilterOperations());
-    cc::AddQuad(root_pass, gfx::Rect(viewport_size), SK_ColorBLACK);
+    cc::AddQuad(root_pass, gfx::Rect(viewport_size), SkColors::kBlack);
 
     // Partial frame, we should pass this rect to the SoftwareOutputDevice.
     // partial swap is enabled.
@@ -629,7 +629,7 @@ TEST_F(SoftwareRendererTest, PartialSwap) {
     auto* root_pass =
         AddRenderPass(&list, root_pass_id, gfx::Rect(viewport_size),
                       gfx::Transform(), cc::FilterOperations());
-    cc::AddQuad(root_pass, gfx::Rect(viewport_size), SK_ColorGREEN);
+    cc::AddQuad(root_pass, gfx::Rect(viewport_size), SkColors::kGreen);
 
     // Partial frame, we should pass this rect to the SoftwareOutputDevice.
     // partial swap is enabled.

components/viz/service/display/surface_aggregator.cc

@@ -939,12 +939,11 @@ void SurfaceAggregator::EmitDefaultBackgroundColorQuad(
 
   auto* solid_color_quad =
       dest_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
-  // TODO(crbug/1308932) remove toSkColor and make all SkColor4f
   solid_color_quad->SetNew(shared_quad_state, surface_quad->rect,
-                           surface_quad->visible_rect,
-                           background_color.toSkColor(), false);
+                           surface_quad->visible_rect, background_color, false);
 }
 
+// TODO(crbug.com/1308932): background_color to SkColor4f
 void SurfaceAggregator::EmitGutterQuadsIfNecessary(
     const gfx::Rect& primary_rect,
     const gfx::Rect& fallback_rect,
@@ -976,7 +975,8 @@ void SurfaceAggregator::EmitGutterQuadsIfNecessary(
     auto* right_gutter =
         dest_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     right_gutter->SetNew(shared_quad_state, right_gutter_rect,
-                         right_gutter_rect, background_color, false);
+                         right_gutter_rect,
+                         SkColor4f::FromColor(background_color), false);
   }
 
   if (fallback_rect.height() < primary_rect.height()) {
@@ -993,7 +993,8 @@ void SurfaceAggregator::EmitGutterQuadsIfNecessary(
     auto* bottom_gutter =
         dest_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     bottom_gutter->SetNew(shared_quad_state, bottom_gutter_rect,
-                          bottom_gutter_rect, background_color, false);
+                          bottom_gutter_rect,
+                          SkColor4f::FromColor(background_color), false);
   }
 }
 
@@ -1347,7 +1348,7 @@ void SurfaceAggregator::CopyQuadsToPass(
               dest_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
           solid_color_quad->SetNew(dest_pass->shared_quad_state_list.back(),
                                    quad->rect, quad->visible_rect,
-                                   SK_ColorBLACK, false);
+                                   SkColors::kBlack, false);
           dest_quad = solid_color_quad;
         } else {
           dest_quad = dest_pass->CopyFromAndAppendDrawQuad(quad);

components/viz/service/display/surface_aggregator_perftest.cc

@@ -126,7 +126,7 @@ class SurfaceAggregatorPerfTest : public VizPerfTest {
         bool premultiplied_alpha = false;
         const gfx::PointF uv_top_left;
         const gfx::PointF uv_bottom_right;
-        SkColor background_color = SK_ColorGREEN;
+        SkColor4f background_color = SkColors::kGreen;
         const float vertex_opacity[4] = {0.f, 0.f, 1.f, 1.f};
         bool flipped = false;
         bool nearest_neighbor = false;
@@ -146,7 +146,7 @@ class SurfaceAggregatorPerfTest : public VizPerfTest {
             SurfaceRange(absl::nullopt,
                          SurfaceId(FrameSinkId(1, i),
                                    LocalSurfaceId(i, child_tokens[i - 1]))),
-            SK_ColorWHITE, /*stretch_content_to_fill_bounds=*/false);
+            SkColors::kWhite, /*stretch_content_to_fill_bounds=*/false);
       }
 
       frame_builder.AddRenderPass(std::move(pass));
@@ -175,7 +175,7 @@ class SurfaceAggregatorPerfTest : public VizPerfTest {
               SurfaceId(FrameSinkId(1, num_surfaces),
                         LocalSurfaceId(num_surfaces,
                                        child_tokens[num_surfaces - 1]))),
-          SK_ColorWHITE, /*stretch_content_to_fill_bounds=*/false);
+          SkColors::kWhite, /*stretch_content_to_fill_bounds=*/false);
 
       pass->output_rect = gfx::Rect(0, 0, 100, 100);
 

components/viz/service/display/surface_aggregator_pixeltest.cc

@@ -98,7 +98,7 @@ TEST_P(SurfaceAggregatorPixelTest, DrawSimpleFrame) {
   auto* color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   bool force_anti_aliasing_off = false;
   color_quad->SetNew(pass->shared_quad_state_list.back(), rect, rect,
-                     SK_ColorGREEN, force_anti_aliasing_off);
+                     SkColors::kGreen, force_anti_aliasing_off);
 
   auto root_frame =
       CompositorFrameBuilder().AddRenderPass(std::move(pass)).Build();
@@ -153,12 +153,12 @@ TEST_P(SurfaceAggregatorPixelTest, DrawSimpleAggregatedFrame) {
     surface_quad->SetNew(
         pass->shared_quad_state_list.back(), gfx::Rect(child_size),
         gfx::Rect(child_size), SurfaceRange(absl::nullopt, child_surface_id),
-        SK_ColorWHITE, /*stretch_content_to_fill_bounds=*/false);
+        SkColors::kWhite, /*stretch_content_to_fill_bounds=*/false);
 
     auto* color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     bool force_anti_aliasing_off = false;
     color_quad->SetNew(pass->shared_quad_state_list.back(), rect, rect,
-                       SK_ColorYELLOW, force_anti_aliasing_off);
+                       SkColors::kYellow, force_anti_aliasing_off);
 
     auto root_frame =
         CompositorFrameBuilder().AddRenderPass(std::move(pass)).Build();
@@ -179,7 +179,7 @@ TEST_P(SurfaceAggregatorPixelTest, DrawSimpleAggregatedFrame) {
     auto* color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     bool force_anti_aliasing_off = false;
     color_quad->SetNew(pass->shared_quad_state_list.back(), rect, rect,
-                       SK_ColorBLUE, force_anti_aliasing_off);
+                       SkColors::kBlue, force_anti_aliasing_off);
 
     auto child_frame =
         CompositorFrameBuilder().AddRenderPass(std::move(pass)).Build();
@@ -247,7 +247,7 @@ TEST_P(SurfaceAggregatorPixelTest, DrawAggregatedFrameWithSurfaceTransforms) {
     left_surface_quad->SetNew(
         pass->shared_quad_state_list.back(), gfx::Rect(child_size),
         gfx::Rect(child_size), SurfaceRange(absl::nullopt, left_child_id),
-        SK_ColorWHITE, /*stretch_content_to_fill_bounds=*/false);
+        SkColors::kWhite, /*stretch_content_to_fill_bounds=*/false);
 
     surface_transform.Translate(100, 0);
     CreateAndAppendTestSharedQuadState(pass.get(), surface_transform,
@@ -257,7 +257,7 @@ TEST_P(SurfaceAggregatorPixelTest, DrawAggregatedFrameWithSurfaceTransforms) {
     right_surface_quad->SetNew(
         pass->shared_quad_state_list.back(), gfx::Rect(child_size),
         gfx::Rect(child_size), SurfaceRange(absl::nullopt, right_child_id),
-        SK_ColorWHITE, /*stretch_content_to_fill_bounds=*/false);
+        SkColors::kWhite, /*stretch_content_to_fill_bounds=*/false);
 
     auto root_frame =
         CompositorFrameBuilder().AddRenderPass(std::move(pass)).Build();
@@ -279,13 +279,13 @@ TEST_P(SurfaceAggregatorPixelTest, DrawAggregatedFrameWithSurfaceTransforms) {
     bool force_anti_aliasing_off = false;
     top_color_quad->SetNew(pass->shared_quad_state_list.back(),
                            gfx::Rect(quad_size), gfx::Rect(quad_size),
-                           SK_ColorGREEN, force_anti_aliasing_off);
+                           SkColors::kGreen, force_anti_aliasing_off);
 
     auto* bottom_color_quad =
         pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     bottom_color_quad->SetNew(
         pass->shared_quad_state_list.back(), gfx::Rect(0, 100, 100, 100),
-        gfx::Rect(0, 100, 100, 100), SK_ColorBLUE, force_anti_aliasing_off);
+        gfx::Rect(0, 100, 100, 100), SkColors::kBlue, force_anti_aliasing_off);
 
     auto child_frame =
         CompositorFrameBuilder().AddRenderPass(std::move(pass)).Build();
@@ -307,13 +307,13 @@ TEST_P(SurfaceAggregatorPixelTest, DrawAggregatedFrameWithSurfaceTransforms) {
     bool force_anti_aliasing_off = false;
     top_color_quad->SetNew(pass->shared_quad_state_list.back(),
                            gfx::Rect(quad_size), gfx::Rect(quad_size),
-                           SK_ColorBLUE, force_anti_aliasing_off);
+                           SkColors::kBlue, force_anti_aliasing_off);
 
     auto* bottom_color_quad =
         pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     bottom_color_quad->SetNew(
         pass->shared_quad_state_list.back(), gfx::Rect(0, 100, 100, 100),
-        gfx::Rect(0, 100, 100, 100), SK_ColorGREEN, force_anti_aliasing_off);
+        gfx::Rect(0, 100, 100, 100), SkColors::kGreen, force_anti_aliasing_off);
 
     auto child_frame =
         CompositorFrameBuilder().AddRenderPass(std::move(pass)).Build();
@@ -349,8 +349,8 @@ TEST_P(SurfaceAggregatorPixelTest, DrawAndEraseDelegatedInkTrail) {
   delegated_ink_helper.CreateAndSendPointFromLastPoint(gfx::PointF(26, 37));
   delegated_ink_helper.CreateAndSendPointFromLastPoint(gfx::PointF(45, 87));
 
-  delegated_ink_helper.CreateAndSendMetadata(kFirstPoint, 7.7f, SK_ColorWHITE,
-                                             kFirstTimestamp,
+  delegated_ink_helper.CreateAndSendMetadata(kFirstPoint, 7.7f,
+                                             SkColors::kWhite, kFirstTimestamp,
                                              gfx::RectF(0, 0, 200, 200));
 
   gfx::Rect rect(this->device_viewport_size_);
@@ -364,7 +364,7 @@ TEST_P(SurfaceAggregatorPixelTest, DrawAndEraseDelegatedInkTrail) {
   auto* color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   bool force_anti_aliasing_off = false;
   color_quad->SetNew(pass->shared_quad_state_list.back(), rect, rect,
-                     SK_ColorGREEN, force_anti_aliasing_off);
+                     SkColors::kGreen, force_anti_aliasing_off);
 
   auto root_frame =
       CompositorFrameBuilder().AddRenderPass(std::move(pass)).Build();

components/viz/service/frame_sinks/video_detector_unittest.cc

@@ -152,7 +152,7 @@ class VideoDetectorTest : public testing::Test {
       quad->SetNew(
           shared_quad_state, gfx::Rect(0, 0, 10, 10), gfx::Rect(0, 0, 5, 5),
           SurfaceRange(absl::nullopt, frame_sink->last_activated_surface_id()),
-          SK_ColorMAGENTA, /*stretch_content_to_fill_bounds=*/false);
+          SkColors::kMagenta, /*stretch_content_to_fill_bounds=*/false);
     }
     root_frame_sink_->SubmitCompositorFrame(
         root_frame_sink_->last_activated_local_surface_id(), std::move(frame));

components/viz/service/surfaces/surface_saved_frame_unittest.cc

@@ -104,7 +104,7 @@ class SurfaceSavedFrameTest : public testing::Test {
         render_pass.CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     solid_color_quad->SetAll(render_pass.shared_quad_state_list.front(),
                              kQuadLayerRect, kVisibleLayerRect, true,
-                             SK_ColorBLACK, true);
+                             SkColors::kBlack, true);
     return solid_color_quad;
   }
 

components/viz/service/transitions/surface_animation_manager.cc

@@ -99,7 +99,7 @@ void CreateAndAppendSrcTextureQuad(CompositorRenderPass* render_pass,
       /*premultiplied_alpha=*/true,
       /*uv_top_left=*/gfx::PointF(0, 0),
       /*uv_bottom_right=*/gfx::PointF(1, 1),
-      /*background_color=*/SK_ColorTRANSPARENT,
+      /*background_color=*/SkColors::kTransparent,
       /*vertex_opacity=*/vertex_opacity, y_flipped,
       /*nearest_neighbor=*/false,
       /*secure_output_only=*/false,
@@ -230,7 +230,7 @@ void ReplaceSharedElementWithTexture(
       /*premultiplied_alpha=*/true,
       /*uv_top_left=*/gfx::PointF(0, 0),
       /*uv_bottom_right=*/gfx::PointF(1, 1),
-      /*background_color=*/SK_ColorTRANSPARENT,
+      /*background_color=*/SkColors::kTransparent,
       /*vertex_opacity=*/vertex_opacity, y_flipped,
       /*nearest_neighbor=*/false,
       /*secure_output_only=*/false,

components/viz/test/compositor_frame_helpers.cc

@@ -116,7 +116,7 @@ RenderPassBuilder& RenderPassBuilder::AddStubCopyOutputRequest(
 
 RenderPassBuilder& RenderPassBuilder::AddSolidColorQuad(
     const gfx::Rect& rect,
-    SkColor color,
+    SkColor4f color,
     SolidColorQuadParms params) {
   return AddSolidColorQuad(rect, rect, color, params);
 }
@@ -124,7 +124,7 @@ RenderPassBuilder& RenderPassBuilder::AddSolidColorQuad(
 RenderPassBuilder& RenderPassBuilder::AddSolidColorQuad(
     const gfx::Rect& rect,
     const gfx::Rect& visible_rect,
-    SkColor color,
+    SkColor4f color,
     SolidColorQuadParms params) {
   auto* sqs = AppendDefaultSharedQuadState(rect, visible_rect);
   auto* quad = pass_->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ -147,6 +147,7 @@ RenderPassBuilder& RenderPassBuilder::AddSurfaceQuad(
     const SurfaceQuadParams& params) {
   auto* sqs = AppendDefaultSharedQuadState(rect, visible_rect);
   auto* quad = pass_->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
+  // TODO (crbug.com/1308932) Change SurfaceQuadParams to use SKColor4f
   quad->SetNew(sqs, rect, visible_rect, surface_range,
                params.default_background_color,
                params.stretch_content_to_fill_bounds);

components/viz/test/compositor_frame_helpers.h

@@ -31,7 +31,7 @@ struct SolidColorQuadParms {
 };
 
 struct SurfaceQuadParams {
-  SkColor default_background_color = SK_ColorWHITE;
+  SkColor4f default_background_color = SkColors::kWhite;
   bool stretch_content_to_fill_bounds = false;
   bool is_reflection = false;
   bool allow_merge = true;
@@ -46,7 +46,7 @@ struct RenderPassQuadParams {
 struct TextureQuadParams {
   bool needs_blending = false;
   bool premultiplied_alpha = false;
-  SkColor background_color = SK_ColorGREEN;
+  SkColor4f background_color = SkColors::kGreen;
   float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
   bool flipped = false;
   bool nearest_neighbor = false;
@@ -101,11 +101,11 @@ class RenderPassBuilder {
   // optional params struct is POD so that designated initializers can be used
   // to construct a new object with specified parameters overridden.
   RenderPassBuilder& AddSolidColorQuad(const gfx::Rect& rect,
-                                       SkColor color,
+                                       SkColor4f color,
                                        SolidColorQuadParms params = {});
   RenderPassBuilder& AddSolidColorQuad(const gfx::Rect& rect,
                                        const gfx::Rect& visible_rect,
-                                       SkColor color,
+                                       SkColor4f color,
                                        SolidColorQuadParms params = {});
 
   RenderPassBuilder& AddSurfaceQuad(const gfx::Rect& rect,

components/viz/test/draw_quad_matchers.cc

@@ -64,13 +64,11 @@ testing::Matcher<const DrawQuad*> IsSolidColorQuad() {
   return IsQuadType(DrawQuad::Material::kSolidColor);
 }
 
-testing::Matcher<const DrawQuad*> IsSolidColorQuad(SkColor expected_color) {
-  // TODO(crbug.com/1308932) Input SkColor4f to this function
+testing::Matcher<const DrawQuad*> IsSolidColorQuad(SkColor4f expected_color) {
   return testing::AllOf(
       IsSolidColorQuad(),
       testing::Truly([expected_color](const DrawQuad* quad) {
-        return SolidColorDrawQuad::MaterialCast(quad)->color ==
-               SkColor4f::FromColor(expected_color);
+        return SolidColorDrawQuad::MaterialCast(quad)->color == expected_color;
       }));
 }
 

components/viz/test/draw_quad_matchers.h

@@ -34,7 +34,7 @@ void PrintTo(DrawQuad::Material material, ::std::ostream* os);
 testing::Matcher<const DrawQuad*> IsSolidColorQuad();
 
 // Matches a SolidColorDrawQuad with |expected_color|.
-testing::Matcher<const DrawQuad*> IsSolidColorQuad(SkColor expected_color);
+testing::Matcher<const DrawQuad*> IsSolidColorQuad(SkColor4f expected_color);
 
 // Matches a TextureDrawQuad.
 testing::Matcher<const DrawQuad*> IsTextureQuad();

device/vr/android/arcore/ar_compositor_frame_sink.cc

@@ -381,7 +381,8 @@ viz::CompositorFrame ArCompositorFrameSink::CreateFrame(WebXrFrame* xr_frame,
           render_pass->CreateAndAppendDrawQuad<viz::SurfaceDrawQuad>();
       dom_quad->SetNew(dom_quad_state, gfx::Rect(output_rect.size()),
                        gfx::Rect(output_rect.size()),
-                       viz::SurfaceRange(*dom_surface_id), SK_ColorTRANSPARENT,
+                       viz::SurfaceRange(*dom_surface_id),
+                       SkColors::kTransparent,
                        /*stretch_content_to_fill_bounds=*/true);
     }
   }
@@ -415,7 +416,7 @@ viz::CompositorFrame ArCompositorFrameSink::CreateFrame(WebXrFrame* xr_frame,
         /*premultiplied_alpha=*/true,
         /*uv_top_left=*/xr_frame->bounds_left.origin(),
         /*uv_bottom_right=*/xr_frame->bounds_left.bottom_right(),
-        /*background_color=*/SK_ColorTRANSPARENT, opacity,
+        /*background_color=*/SkColors::kTransparent, opacity,
         /*y_flipped=*/true,
         /*nearest_neighbor=*/false,
         /*secure_output_only=*/false, gfx::ProtectedVideoType::kClear);
@@ -454,7 +455,7 @@ viz::CompositorFrame ArCompositorFrameSink::CreateFrame(WebXrFrame* xr_frame,
                       /*premultiplied_alpha=*/true,
                       /*uv_top_left=*/gfx::PointF(0.f, 0.f),
                       /*uv_bottom_right=*/gfx::PointF(1.f, 1.f),
-                      /*background_color=*/SK_ColorTRANSPARENT, opacity,
+                      /*background_color=*/SkColors::kTransparent, opacity,
                       /*y_flipped=*/true,
                       /*nearest_neighbor=*/false,
                       /*secure_output_only=*/false,

media/renderers/video_resource_updater.cc

@@ -681,7 +681,7 @@ void VideoResourceUpdater::AppendQuads(
       texture_quad->SetNew(shared_quad_state, quad_rect, visible_quad_rect,
                            needs_blending, frame_resources_[0].id,
                            premultiplied_alpha, uv_top_left, uv_bottom_right,
-                           SK_ColorTRANSPARENT, opacity, flipped,
+                           SkColors::kTransparent, opacity, flipped,
                            nearest_neighbor, false, protected_video_type);
       texture_quad->set_resource_size_in_pixels(coded_size);
       texture_quad->is_video_frame = true;

services/viz/public/cpp/compositing/mojom_traits_perftest.cc

@@ -186,7 +186,8 @@ class VizSerializationPerfTest : public testing::Test {
     int arbitrary_context_id1 = 12;
     int arbitrary_context_id2 = 57;
     int arbitrary_context_id3 = -503;
-    SkColor arbitrary_color = SkColorSetARGB(25, 36, 47, 58);
+    SkColor4f arbitrary_color =
+        SkColor4f::FromColor(SkColorSetARGB(25, 36, 47, 58));
     SkBlendMode arbitrary_blend_mode1 = SkBlendMode::kScreen;
     SkBlendMode arbitrary_blend_mode2 = SkBlendMode::kLighten;
     SkBlendMode arbitrary_blend_mode3 = SkBlendMode::kOverlay;
@@ -316,7 +317,7 @@ class VizSerializationPerfTest : public testing::Test {
         const bool kForceAntiAliasingOff = true;
         auto* quad = render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
         quad->SetNew(render_pass->shared_quad_state_list.back(), bounds, bounds,
-                     SK_ColorRED, kForceAntiAliasingOff);
+                     SkColors::kRed, kForceAntiAliasingOff);
       }
       frame.render_pass_list.push_back(std::move(render_pass));
     }

services/viz/public/cpp/compositing/mojom_traits_unittest.cc

@@ -499,7 +499,7 @@ TEST_F(StructTraitsTest, CompositorFrame) {
 
   // DebugBorderDrawQuad.
   const gfx::Rect rect1(1234, 4321, 1357, 7531);
-  const SkColor color1 = SK_ColorRED;
+  const SkColor4f color1 = SkColors::kRed;
   const int32_t width1 = 1337;
   DebugBorderDrawQuad* debug_quad =
       render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
@@ -507,7 +507,7 @@ TEST_F(StructTraitsTest, CompositorFrame) {
 
   // SolidColorDrawQuad.
   const gfx::Rect rect2(2468, 8642, 4321, 1234);
-  const uint32_t color2 = 0xffffffff;
+  const SkColor4f color2 = SkColors::kWhite;
   const bool force_anti_aliasing_off = true;
   SolidColorDrawQuad* solid_quad =
       render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ -580,15 +580,14 @@ TEST_F(StructTraitsTest, CompositorFrame) {
           out_render_pass->quad_list.ElementAt(0));
   EXPECT_EQ(rect1, out_debug_border_draw_quad->rect);
   EXPECT_EQ(rect1, out_debug_border_draw_quad->visible_rect);
-  EXPECT_EQ(SkColor4f::FromColor(color1), out_debug_border_draw_quad->color);
+  EXPECT_EQ(color1, out_debug_border_draw_quad->color);
   EXPECT_EQ(width1, out_debug_border_draw_quad->width);
 
   const SolidColorDrawQuad* out_solid_color_draw_quad =
       SolidColorDrawQuad::MaterialCast(out_render_pass->quad_list.ElementAt(1));
   EXPECT_EQ(rect2, out_solid_color_draw_quad->rect);
   EXPECT_EQ(rect2, out_solid_color_draw_quad->visible_rect);
-  // TODO(crbug.com/1308932) Make color2 an SkColor4f
-  EXPECT_EQ(SkColor4f::FromColor(color2), out_solid_color_draw_quad->color);
+  EXPECT_EQ(color2, out_solid_color_draw_quad->color);
   EXPECT_EQ(force_anti_aliasing_off,
             out_solid_color_draw_quad->force_anti_aliasing_off);
 }
@@ -801,13 +800,13 @@ TEST_F(StructTraitsTest, RenderPass) {
       input->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
   const gfx::Rect debug_quad_rect(12, 56, 89, 10);
   debug_quad->SetNew(shared_state_1, debug_quad_rect, debug_quad_rect,
-                     SK_ColorBLUE, 1337);
+                     SkColors::kBlue, 1337);
 
   SolidColorDrawQuad* color_quad =
       input->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   const gfx::Rect color_quad_rect(123, 456, 789, 101);
   color_quad->SetNew(shared_state_2, color_quad_rect, color_quad_rect,
-                     SK_ColorRED, true);
+                     SkColors::kRed, true);
 
   SurfaceDrawQuad* surface_quad =
       input->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
@@ -818,7 +817,7 @@ TEST_F(StructTraitsTest, RenderPass) {
           absl::nullopt,
           SurfaceId(FrameSinkId(1337, 1234),
                     LocalSurfaceId(1234, base::UnguessableToken::Create()))),
-      SK_ColorYELLOW, false);
+      SkColors::kYellow, false);
   // Test non-default values.
   surface_quad->is_reflection = !surface_quad->is_reflection;
   surface_quad->allow_merge = !surface_quad->allow_merge;
@@ -951,14 +950,14 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   SharedQuadState* sqs = render_pass->CreateAndAppendSharedQuadState();
 
   const gfx::Rect rect1(1234, 4321, 1357, 7531);
-  const SkColor color1 = SK_ColorRED;
+  const SkColor4f color1 = SkColors::kRed;
   const int32_t width1 = 1337;
   DebugBorderDrawQuad* debug_quad =
       render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
   debug_quad->SetNew(sqs, rect1, rect1, color1, width1);
 
   const gfx::Rect rect2(2468, 8642, 4321, 1234);
-  const uint32_t color2 = 0xffffffff;
+  const SkColor4f color2 = SkColors::kWhite;
   const bool force_anti_aliasing_off = true;
   SolidColorDrawQuad* solid_quad =
       render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ -975,7 +974,7 @@ TEST_F(StructTraitsTest, QuadListBasic) {
       render_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   primary_surface_quad->SetNew(
       sqs, rect3, rect3, SurfaceRange(fallback_surface_id, primary_surface_id),
-      SK_ColorBLUE, false);
+      SkColors::kBlue, false);
 
   const gfx::Rect rect4(1234, 5678, 91012, 13141);
   const bool needs_blending = true;
@@ -1003,7 +1002,7 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   const bool premultiplied_alpha = true;
   const gfx::PointF uv_top_left(12.1f, 34.2f);
   const gfx::PointF uv_bottom_right(56.3f, 78.4f);
-  const SkColor background_color = SK_ColorGREEN;
+  const SkColor4f background_color = SkColors::kGreen;
   const bool y_flipped = true;
   const bool nearest_neighbor = true;
   const bool secure_output_only = true;
@@ -1039,7 +1038,7 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   EXPECT_EQ(rect1, out_debug_border_draw_quad->rect);
   EXPECT_EQ(rect1, out_debug_border_draw_quad->visible_rect);
   EXPECT_FALSE(out_debug_border_draw_quad->needs_blending);
-  EXPECT_EQ(SkColor4f::FromColor(color1), out_debug_border_draw_quad->color);
+  EXPECT_EQ(color1, out_debug_border_draw_quad->color);
   EXPECT_EQ(width1, out_debug_border_draw_quad->width);
 
   const SolidColorDrawQuad* out_solid_color_draw_quad =
@@ -1047,8 +1046,7 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   EXPECT_EQ(rect2, out_solid_color_draw_quad->rect);
   EXPECT_EQ(rect2, out_solid_color_draw_quad->visible_rect);
   EXPECT_FALSE(out_solid_color_draw_quad->needs_blending);
-  // TODO(crbug.com/1308932) Make color2 an SkColor4f
-  EXPECT_EQ(SkColor4f::FromColor(color2), out_solid_color_draw_quad->color);
+  EXPECT_EQ(color2, out_solid_color_draw_quad->color);
   EXPECT_EQ(force_anti_aliasing_off,
             out_solid_color_draw_quad->force_anti_aliasing_off);
 
@@ -1094,9 +1092,7 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   EXPECT_EQ(premultiplied_alpha, out_texture_draw_quad->premultiplied_alpha);
   EXPECT_EQ(uv_top_left, out_texture_draw_quad->uv_top_left);
   EXPECT_EQ(uv_bottom_right, out_texture_draw_quad->uv_bottom_right);
-  // TODO(crbug.com/1308932) Make background_color an SkColor4f
-  EXPECT_EQ(SkColor4f::FromColor(background_color),
-            out_texture_draw_quad->background_color);
+  EXPECT_EQ(background_color, out_texture_draw_quad->background_color);
   EXPECT_EQ(vertex_opacity[0], out_texture_draw_quad->vertex_opacity[0]);
   EXPECT_EQ(vertex_opacity[1], out_texture_draw_quad->vertex_opacity[1]);
   EXPECT_EQ(vertex_opacity[2], out_texture_draw_quad->vertex_opacity[2]);

third_party/blink/renderer/platform/graphics/canvas_resource_dispatcher.cc

@@ -292,8 +292,8 @@ bool CanvasResourceDispatcher::PrepareFrame(
       SharedGpuContext::IsGpuCompositingEnabled() && needs_vertical_flip;
   quad->SetAll(sqs, bounds, bounds, needs_blending, resource_id,
                canvas_resource_size, kPremultipliedAlpha, uv_top_left,
-               uv_bottom_right, SK_ColorTRANSPARENT, vertex_opacity, yflipped,
-               nearest_neighbor, /*secure_output_only=*/false,
+               uv_bottom_right, SkColors::kTransparent, vertex_opacity,
+               yflipped, nearest_neighbor, /*secure_output_only=*/false,
                gfx::ProtectedVideoType::kClear);
 
   frame->render_pass_list.push_back(std::move(pass));

third_party/blink/renderer/platform/widget/compositing/android_webview/synchronous_layer_tree_frame_sink.cc

@@ -363,7 +363,7 @@ void SynchronousLayerTreeFrameSink::SubmitCompositorFrame(
         viz::SurfaceRange(
             absl::nullopt,
             viz::SurfaceId(kChildFrameSinkId, child_local_surface_id_)),
-        SK_ColorWHITE, false /* stretch_content_to_fill_bounds */);
+        SkColors::kWhite, false /* stretch_content_to_fill_bounds */);
 
     child_support_->SubmitCompositorFrame(child_local_surface_id_,
                                           std::move(frame));

third_party/blink/web_tests/TestExpectations

@@ -7066,6 +7066,18 @@ crbug.com/1338420 [ Linux ] external/wpt/event-timing/interactionid-tap.html [ S
 # Flaky on multiple platforms
 crbug.com/1338536 http/tests/devtools/oopif/oopif-elements-nesting.js [ Failure Pass ]
 
+# Tests that compare a float color to an integer color can suffer off-by-one errors
+# There is no mechanism for fuzzing reference tests outside of WPT and tests that require internals cannot be in WPT
+# When the scrollbarOverlay is moved to float color these can be re-enabled
+crbug.com/1308932 compositing/overflow/reparented-overlay-scrollbars-should-respect-ancestor-clip.html [ Failure ]
+crbug.com/1308932 compositing/overflow/reparented-unclipped-overlay-scrollbars-with-offset-from-renderer.html [ Failure ]
+crbug.com/1308932 compositing/squashing/squashing-inside-perspective-with-reparented-scrolling.html [ Failure ]
+crbug.com/1308932 fast/scrolling/overlay-scrollbars.html [ Failure ]
+crbug.com/1308932 scrollbars/overlay-scrollbar-over-child-layer-nested-4.html [ Failure ]
+crbug.com/1308932 compositing/overflow/non-reparented-overlay-scrollbars.html [ Failure ]
+crbug.com/1308932 scrollbars/auto-scrollbar-fades-out.html [ Failure ]
+crbug.com/1308932 scrollbars/overlay-scrollbars-within-overflow-scroll.html [ Failure ]
+
 # Sheriff 2022-06-24
 crbug.com/1339211 [ Mac ] external/wpt/css/css-text-decor/text-decoration-thickness-fixed.html [ Failure Pass ]
 crbug.com/1339214 [ Mac ] external/wpt/webaudio/the-audio-api/the-convolvernode-interface/realtime-conv.html [ Failure Pass ]