Use SkColor in dark mode.

To facilitate calling dark mode filter at raster time, dark mode filter
module will be moved to cc/paint. This change replaces blink::Color by
SkColor.

Bug: 1091095

Change-Id: I65d888ab5df454592ac0df004b0bbe48e9a093d4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2167804Reviewed-by: Philip Rogers <pdr@chromium.org>
Commit-Queue: Prashant Nevase <prashant.n@samsung.com>
Cr-Commit-Position: refs/heads/master@{#775274}

third_party/blink/renderer/core/accessibility/apply_dark_mode.cc

@@ -35,7 +35,7 @@ bool HasLightBackground(const LayoutView& root) {
   if (color.Alpha() < kAlphaThreshold)
     return true;
 
-  return DarkModeColorClassifier::CalculateColorBrightness(color) >
+  return DarkModeColorClassifier::CalculateColorBrightness(color.Rgb()) >
          kBrightnessThreshold;
 }
 

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

@@ -4,6 +4,7 @@
 
 #include "third_party/blink/renderer/platform/graphics/dark_mode_color_classifier.h"
 
+#include "base/logging.h"
 #include "third_party/blink/renderer/platform/graphics/graphics_types.h"
 
 namespace blink {
@@ -21,7 +22,7 @@ class SimpleColorClassifier : public DarkModeColorClassifier {
         new SimpleColorClassifier(DarkModeClassification::kApplyFilter));
   }
 
-  DarkModeClassification ShouldInvertColor(const Color& color) override {
+  DarkModeClassification ShouldInvertColor(SkColor color) override {
     return value_;
   }
 
@@ -39,7 +40,7 @@ class InvertLowBrightnessColorsClassifier : public DarkModeColorClassifier {
     DCHECK_LT(brightness_threshold_, 256);
   }
 
-  DarkModeClassification ShouldInvertColor(const Color& color) override {
+  DarkModeClassification ShouldInvertColor(SkColor color) override {
     if (CalculateColorBrightness(color) < brightness_threshold_)
       return DarkModeClassification::kApplyFilter;
     return DarkModeClassification::kDoNotApplyFilter;
@@ -57,7 +58,7 @@ class InvertHighBrightnessColorsClassifier : public DarkModeColorClassifier {
     DCHECK_LT(brightness_threshold_, 256);
   }
 
-  DarkModeClassification ShouldInvertColor(const Color& color) override {
+  DarkModeClassification ShouldInvertColor(SkColor color) override {
     if (CalculateColorBrightness(color) > brightness_threshold_)
       return DarkModeClassification::kApplyFilter;
     return DarkModeClassification::kDoNotApplyFilter;
@@ -74,10 +75,10 @@ class InvertHighBrightnessColorsClassifier : public DarkModeColorClassifier {
 //
 // We don't use HSL or HSV here because perceived brightness is a function of
 // hue as well as lightness/value.
-int DarkModeColorClassifier::CalculateColorBrightness(const Color& color) {
-  int weighted_red = color.Red() * 299;
-  int weighted_green = color.Green() * 587;
-  int weighted_blue = color.Blue() * 114;
+int DarkModeColorClassifier::CalculateColorBrightness(SkColor color) {
+  int weighted_red = SkColorGetR(color) * 299;
+  int weighted_green = SkColorGetG(color) * 587;
+  int weighted_blue = SkColorGetB(color) * 114;
   return (weighted_red + weighted_green + weighted_blue) / 1000;
 }
 

third_party/blink/renderer/platform/graphics/dark_mode_color_classifier.h

@@ -7,7 +7,6 @@
 
 #include <memory>
 
-#include "third_party/blink/renderer/platform/graphics/color.h"
 #include "third_party/blink/renderer/platform/graphics/dark_mode_settings.h"
 #include "third_party/blink/renderer/platform/graphics/graphics_types.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
@@ -17,7 +16,7 @@ namespace blink {
 class PLATFORM_EXPORT DarkModeColorClassifier {
  public:
   // Determine perceived brightness of a color.
-  static int CalculateColorBrightness(const Color& color);
+  static int CalculateColorBrightness(SkColor color);
 
   static std::unique_ptr<DarkModeColorClassifier> MakeTextColorClassifier(
       const DarkModeSettings& settings);
@@ -30,7 +29,7 @@ class PLATFORM_EXPORT DarkModeColorClassifier {
   // whether to invert a color. The background is likely to be dark, so a lower
   // opacity will usually decrease the effective brightness of both the original
   // and the inverted colors.
-  virtual DarkModeClassification ShouldInvertColor(const Color& color) = 0;
+  virtual DarkModeClassification ShouldInvertColor(SkColor color) = 0;
 };
 
 }  // namespace blink

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

@@ -4,8 +4,8 @@
 
 #include "third_party/blink/renderer/platform/graphics/dark_mode_color_classifier.h"
 
+#include "base/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/blink/renderer/platform/graphics/color.h"
 #include "third_party/blink/renderer/platform/graphics/dark_mode_settings.h"
 #include "third_party/blink/renderer/platform/graphics/graphics_types.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ -13,11 +13,11 @@
 namespace blink {
 namespace {
 
-Color GetColorWithBrightness(int target_brightness) {
+SkColor GetColorWithBrightness(int target_brightness) {
   CHECK_GE(target_brightness, 0);
   CHECK_LE(target_brightness, 256);
 
-  return Color(target_brightness, target_brightness, target_brightness);
+  return SkColorSetRGB(target_brightness, target_brightness, target_brightness);
 }
 
 TEST(DarkModeColorClassifierTest, ApplyFilterToDarkTextOnly) {
@@ -37,10 +37,10 @@ TEST(DarkModeColorClassifierTest, ApplyFilterToDarkTextOnly) {
             classifier->ShouldInvertColor(GetColorWithBrightness(
                 settings.text_brightness_threshold - 5)));
   EXPECT_EQ(DarkModeClassification::kApplyFilter,
-            classifier->ShouldInvertColor(Color::kBlack));
+            classifier->ShouldInvertColor(SK_ColorBLACK));
 
   EXPECT_EQ(DarkModeClassification::kDoNotApplyFilter,
-            classifier->ShouldInvertColor(Color::kWhite));
+            classifier->ShouldInvertColor(SK_ColorWHITE));
   EXPECT_EQ(DarkModeClassification::kDoNotApplyFilter,
             classifier->ShouldInvertColor(GetColorWithBrightness(
                 settings.text_brightness_threshold + 5)));
@@ -57,9 +57,9 @@ TEST(DarkModeColorClassifierTest, ApplyFilterToLightBackgroundElementsOnly) {
       DarkModeColorClassifier::MakeBackgroundColorClassifier(settings);
 
   EXPECT_EQ(DarkModeClassification::kApplyFilter,
-            classifier->ShouldInvertColor(Color::kWhite));
+            classifier->ShouldInvertColor(SK_ColorWHITE));
   EXPECT_EQ(DarkModeClassification::kDoNotApplyFilter,
-            classifier->ShouldInvertColor(Color::kBlack));
+            classifier->ShouldInvertColor(SK_ColorBLACK));
 
   EXPECT_EQ(DarkModeClassification::kApplyFilter,
             classifier->ShouldInvertColor(GetColorWithBrightness(

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

@@ -35,8 +35,8 @@ class SkColorFilterWrapper : public DarkModeColorFilter {
         new SkColorFilterWrapper(SkHighContrastFilter::Make(config)));
   }
 
-  Color InvertColor(const Color& color) const override {
-    return Color(filter_->filterColor(color.Rgb()));
+  SkColor InvertColor(SkColor color) const override {
+    return filter_->filterColor(color);
   }
 
   sk_sp<SkColorFilter> ToSkColorFilter() const override { return filter_; }
@@ -59,20 +59,20 @@ class LabColorFilter : public DarkModeColorFilter {
     filter_ = SkHighContrastFilter::Make(config);
   }
 
-  Color InvertColor(const Color& color) const override {
-    blink::FloatPoint3D rgb = {color.Red() / 255.0f, color.Green() / 255.0f,
-                               color.Blue() / 255.0f};
+  SkColor InvertColor(SkColor color) const override {
+    blink::FloatPoint3D rgb = {SkColorGetR(color) / 255.0f,
+                               SkColorGetG(color) / 255.0f,
+                               SkColorGetB(color) / 255.0f};
     blink::FloatPoint3D lab = transformer_.sRGBToLab(rgb);
     float invertedL = std::min(110.0f - lab.X(), 100.0f);
     lab.SetX(invertedL);
     rgb = transformer_.LabToSRGB(lab);
 
-    Color inverted_color(Color(static_cast<unsigned int>(rgb.X() * 255 + 0.5),
-                               static_cast<unsigned int>(rgb.Y() * 255 + 0.5),
-                               static_cast<unsigned int>(rgb.Z() * 255 + 0.5),
-                               color.Alpha()));
-    AdjustGray(&inverted_color);
-    return inverted_color;
+    SkColor inverted_color = SkColorSetARGB(
+        SkColorGetA(color), static_cast<unsigned int>(rgb.X() * 255 + 0.5),
+        static_cast<unsigned int>(rgb.Y() * 255 + 0.5),
+        static_cast<unsigned int>(rgb.Z() * 255 + 0.5));
+    return AdjustGray(inverted_color);
   }
 
   sk_sp<SkColorFilter> ToSkColorFilter() const override { return filter_; }
@@ -84,17 +84,21 @@ class LabColorFilter : public DarkModeColorFilter {
   //
   // TODO(gilmanmh): Consider adding a more general way to adjust colors after
   // applying the main filter.
-  void AdjustGray(Color* color) const {
-    DCHECK(color);
-    static const int kBrightnessThreshold = 32;
-    static const int kAdjustedBrightness = 18;
-
-    if (color->Red() == color->Blue() && color->Red() == color->Green() &&
-        color->Red() < kBrightnessThreshold &&
-        color->Red() > kAdjustedBrightness) {
-      color->SetRGB(kAdjustedBrightness, kAdjustedBrightness,
-                    kAdjustedBrightness);
+  SkColor AdjustGray(SkColor color) const {
+    static const uint8_t kBrightnessThreshold = 32;
+    static const uint8_t kAdjustedBrightness = 18;
+
+    uint8_t r = SkColorGetR(color);
+    uint8_t g = SkColorGetG(color);
+    uint8_t b = SkColorGetB(color);
+
+    if (r == b && r == g && r < kBrightnessThreshold &&
+        r > kAdjustedBrightness) {
+      return SkColorSetRGB(kAdjustedBrightness, kAdjustedBrightness,
+                           kAdjustedBrightness);
     }
+
+    return color;
   }
 
   const LabColorSpace::RGBLABTransformer transformer_;

third_party/blink/renderer/platform/graphics/dark_mode_color_filter.h

@@ -7,10 +7,10 @@
 
 #include <memory>
 
-#include "third_party/blink/renderer/platform/graphics/color.h"
 #include "third_party/blink/renderer/platform/graphics/dark_mode_settings.h"
 #include "third_party/blink/renderer/platform/graphics/lab_color_space.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
+#include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 
 class SkColorFilter;
@@ -24,7 +24,7 @@ class PLATFORM_EXPORT DarkModeColorFilter {
       const DarkModeSettings& settings);
 
   virtual ~DarkModeColorFilter();
-  virtual Color InvertColor(const Color& color) const = 0;
+  virtual SkColor InvertColor(SkColor color) const = 0;
   virtual sk_sp<SkColorFilter> ToSkColorFilter() const = 0;
 };
 

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

@@ -104,7 +104,7 @@ class DarkModeInvertedColorCache {
     if (cached_value)
       return *cached_value;
 
-    SkColor inverted_color = filter->InvertColor(Color(color)).Rgb();
+    SkColor inverted_color = filter->InvertColor(color);
     cache_.Put(key, std::move(inverted_color));
     return inverted_color;
   }
@@ -161,8 +161,7 @@ void DarkModeFilter::UpdateSettings(const DarkModeSettings& new_settings) {
       DarkModeColorClassifier::MakeBackgroundColorClassifier(settings_);
 }
 
-Color DarkModeFilter::InvertColorIfNeeded(const Color& color,
-                                          ElementRole role) {
+SkColor DarkModeFilter::InvertColorIfNeeded(SkColor color, ElementRole role) {
   if (!IsDarkModeActive())
     return color;
 
@@ -170,8 +169,7 @@ Color DarkModeFilter::InvertColorIfNeeded(const Color& color,
     role = role_override_.value();
 
   if (ShouldApplyToColor(color, role)) {
-    return Color(inverted_color_cache_->GetInvertedColor(color_filter_.get(),
-                                                         color.Rgb()));
+    return inverted_color_cache_->GetInvertedColor(color_filter_.get(), color);
   }
 
   return color;
@@ -215,7 +213,7 @@ bool DarkModeFilter::IsDarkModeActive() const {
 // already done so. This allows the caller to exit earlier if it needs to
 // perform some other logic in between confirming dark mode is active and
 // checking the color classifiers.
-bool DarkModeFilter::ShouldApplyToColor(const Color& color, ElementRole role) {
+bool DarkModeFilter::ShouldApplyToColor(SkColor color, ElementRole role) {
   switch (role) {
     case ElementRole::kText:
       DCHECK(text_classifier_);

third_party/blink/renderer/platform/graphics/dark_mode_filter.h

@@ -40,7 +40,7 @@ class PLATFORM_EXPORT DarkModeFilter {
   // invert shadows, but we may need to do some other kind of processing for
   // them.
   enum class ElementRole { kText, kListSymbol, kBackground, kSVG };
-  Color InvertColorIfNeeded(const Color& color, ElementRole element_role);
+  SkColor InvertColorIfNeeded(SkColor color, ElementRole element_role);
   base::Optional<cc::PaintFlags> ApplyToFlagsIfNeeded(
       const cc::PaintFlags& flags,
       ElementRole element_role);
@@ -59,7 +59,7 @@ class PLATFORM_EXPORT DarkModeFilter {
 
   DarkModeSettings settings_;
 
-  bool ShouldApplyToColor(const Color& color, ElementRole role);
+  bool ShouldApplyToColor(SkColor color, ElementRole role);
 
   std::unique_ptr<DarkModeColorClassifier> text_classifier_;
   std::unique_ptr<DarkModeColorClassifier> background_classifier_;

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

@@ -7,7 +7,6 @@
 #include "base/optional.h"
 #include "cc/paint/paint_flags.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/blink/renderer/platform/graphics/color.h"
 #include "third_party/blink/renderer/platform/graphics/dark_mode_settings.h"
 #include "third_party/skia/include/core/SkColor.h"
 
@@ -21,12 +20,12 @@ TEST(DarkModeFilterTest, DoNotApplyFilterWhenDarkModeIsOff) {
   settings.mode = DarkModeInversionAlgorithm::kOff;
   filter.UpdateSettings(settings);
 
-  EXPECT_EQ(Color::kWhite,
+  EXPECT_EQ(SK_ColorWHITE,
             filter.InvertColorIfNeeded(
-                Color::kWhite, DarkModeFilter::ElementRole::kBackground));
-  EXPECT_EQ(Color::kBlack,
+                SK_ColorWHITE, DarkModeFilter::ElementRole::kBackground));
+  EXPECT_EQ(SK_ColorBLACK,
             filter.InvertColorIfNeeded(
-                Color::kBlack, DarkModeFilter::ElementRole::kBackground));
+                SK_ColorBLACK, DarkModeFilter::ElementRole::kBackground));
 
   EXPECT_EQ(base::nullopt,
             filter.ApplyToFlagsIfNeeded(
@@ -42,18 +41,18 @@ TEST(DarkModeFilterTest, ApplyDarkModeToColorsAndFlags) {
   settings.mode = DarkModeInversionAlgorithm::kSimpleInvertForTesting;
   filter.UpdateSettings(settings);
 
-  EXPECT_EQ(Color::kBlack,
+  EXPECT_EQ(SK_ColorBLACK,
             filter.InvertColorIfNeeded(
-                Color::kWhite, DarkModeFilter::ElementRole::kBackground));
-  EXPECT_EQ(Color::kWhite,
+                SK_ColorWHITE, DarkModeFilter::ElementRole::kBackground));
+  EXPECT_EQ(SK_ColorWHITE,
             filter.InvertColorIfNeeded(
-                Color::kBlack, DarkModeFilter::ElementRole::kBackground));
+                SK_ColorBLACK, DarkModeFilter::ElementRole::kBackground));
 
-  EXPECT_EQ(Color::kWhite,
-            filter.InvertColorIfNeeded(Color::kWhite,
+  EXPECT_EQ(SK_ColorWHITE,
+            filter.InvertColorIfNeeded(SK_ColorWHITE,
                                        DarkModeFilter::ElementRole::kSVG));
-  EXPECT_EQ(Color::kBlack,
-            filter.InvertColorIfNeeded(Color::kBlack,
+  EXPECT_EQ(SK_ColorBLACK,
+            filter.InvertColorIfNeeded(SK_ColorBLACK,
                                        DarkModeFilter::ElementRole::kSVG));
 
   cc::PaintFlags flags;
@@ -73,14 +72,14 @@ TEST(DarkModeFilterTest, InvertedColorCacheSize) {
   settings.mode = DarkModeInversionAlgorithm::kSimpleInvertForTesting;
   filter.UpdateSettings(settings);
   EXPECT_EQ(0u, filter.GetInvertedColorCacheSizeForTesting());
-  EXPECT_EQ(Color::kBlack,
+  EXPECT_EQ(SK_ColorBLACK,
             filter.InvertColorIfNeeded(
-                Color::kWhite, DarkModeFilter::ElementRole::kBackground));
+                SK_ColorWHITE, DarkModeFilter::ElementRole::kBackground));
   EXPECT_EQ(1u, filter.GetInvertedColorCacheSizeForTesting());
   // Should get cached value.
-  EXPECT_EQ(Color::kBlack,
+  EXPECT_EQ(SK_ColorBLACK,
             filter.InvertColorIfNeeded(
-                Color::kWhite, DarkModeFilter::ElementRole::kBackground));
+                SK_ColorWHITE, DarkModeFilter::ElementRole::kBackground));
   EXPECT_EQ(1u, filter.GetInvertedColorCacheSizeForTesting());
 
   // On changing DarkModeSettings, cache should be reset.
@@ -96,24 +95,22 @@ TEST(DarkModeFilterTest, InvertedColorCacheZeroMaxKeys) {
   filter.UpdateSettings(settings);
 
   EXPECT_EQ(0u, filter.GetInvertedColorCacheSizeForTesting());
-  EXPECT_EQ(Color::kBlack, filter.InvertColorIfNeeded(
-                               Color(SK_ColorWHITE),
-                               DarkModeFilter::ElementRole::kBackground));
+  EXPECT_EQ(SK_ColorBLACK,
+            filter.InvertColorIfNeeded(
+                SK_ColorWHITE, DarkModeFilter::ElementRole::kBackground));
   EXPECT_EQ(1u, filter.GetInvertedColorCacheSizeForTesting());
-  EXPECT_EQ(
-      Color(SK_ColorTRANSPARENT),
-      filter.InvertColorIfNeeded(Color(SK_ColorTRANSPARENT),
-                                 DarkModeFilter::ElementRole::kBackground));
+  EXPECT_EQ(SK_ColorTRANSPARENT,
+            filter.InvertColorIfNeeded(
+                SK_ColorTRANSPARENT, DarkModeFilter::ElementRole::kBackground));
   EXPECT_EQ(2u, filter.GetInvertedColorCacheSizeForTesting());
 
   // Results returned from cache.
-  EXPECT_EQ(Color::kBlack, filter.InvertColorIfNeeded(
-                               Color(SK_ColorWHITE),
-                               DarkModeFilter::ElementRole::kBackground));
-  EXPECT_EQ(
-      Color(SK_ColorTRANSPARENT),
-      filter.InvertColorIfNeeded(Color(SK_ColorTRANSPARENT),
-                                 DarkModeFilter::ElementRole::kBackground));
+  EXPECT_EQ(SK_ColorBLACK,
+            filter.InvertColorIfNeeded(
+                SK_ColorWHITE, DarkModeFilter::ElementRole::kBackground));
+  EXPECT_EQ(SK_ColorTRANSPARENT,
+            filter.InvertColorIfNeeded(
+                SK_ColorTRANSPARENT, DarkModeFilter::ElementRole::kBackground));
   EXPECT_EQ(2u, filter.GetInvertedColorCacheSizeForTesting());
 }
 

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

@@ -355,9 +355,8 @@ void GraphicsContext::DrawFocusRingPath(const SkPath& path,
                                         float border_radius) {
   DrawPlatformFocusRing(
       path, canvas_,
-      dark_mode_filter_
-          .InvertColorIfNeeded(color, DarkModeFilter::ElementRole::kBackground)
-          .Rgb(),
+      dark_mode_filter_.InvertColorIfNeeded(
+          color.Rgb(), DarkModeFilter::ElementRole::kBackground),
       width, border_radius);
 }
 
@@ -367,9 +366,8 @@ void GraphicsContext::DrawFocusRingRect(const SkRect& rect,
                                         float border_radius) {
   DrawPlatformFocusRing(
       rect, canvas_,
-      dark_mode_filter_
-          .InvertColorIfNeeded(color, DarkModeFilter::ElementRole::kBackground)
-          .Rgb(),
+      dark_mode_filter_.InvertColorIfNeeded(
+          color.Rgb(), DarkModeFilter::ElementRole::kBackground),
       width, border_radius);
 }
 
@@ -468,14 +466,14 @@ void GraphicsContext::DrawInnerShadow(const FloatRoundedRect& rect,
                                       float shadow_blur,
                                       float shadow_spread,
                                       Edges clipped_edges) {
-  Color shadow_color = dark_mode_filter_.InvertColorIfNeeded(
-      orig_shadow_color, DarkModeFilter::ElementRole::kBackground);
+  SkColor shadow_color = dark_mode_filter_.InvertColorIfNeeded(
+      orig_shadow_color.Rgb(), DarkModeFilter::ElementRole::kBackground);
 
   FloatRect hole_rect(rect.Rect());
   hole_rect.Inflate(-shadow_spread);
 
   if (hole_rect.IsEmpty()) {
-    FillRoundedRect(rect, shadow_color);
+    FillRoundedRect(rect, Color(shadow_color));
     return;
   }
 
@@ -496,8 +494,8 @@ void GraphicsContext::DrawInnerShadow(const FloatRoundedRect& rect,
     hole_rect.SetHeight(hole_rect.Height() -
                         std::min(shadow_offset.Height(), 0.0f) + shadow_blur);
 
-  Color fill_color(shadow_color.Red(), shadow_color.Green(),
-                   shadow_color.Blue(), 255);
+  Color fill_color(SkColorGetR(shadow_color), SkColorGetG(shadow_color),
+                   SkColorGetB(shadow_color), 255);
 
   FloatRect outer_rect = AreaCastingShadowInHole(rect.Rect(), shadow_blur,
                                                  shadow_spread, shadow_offset);
@@ -1102,10 +1100,8 @@ void GraphicsContext::FillDRRect(const FloatRoundedRect& outer,
       canvas_->drawDRRect(outer, inner, ImmutableState()->FillFlags());
     } else {
       PaintFlags flags(ImmutableState()->FillFlags());
-      flags.setColor(dark_mode_filter_
-                         .InvertColorIfNeeded(
-                             color, DarkModeFilter::ElementRole::kBackground)
-                         .Rgb());
+      flags.setColor(dark_mode_filter_.InvertColorIfNeeded(
+          color.Rgb(), DarkModeFilter::ElementRole::kBackground));
       canvas_->drawDRRect(outer, inner, flags);
     }
 
@@ -1118,10 +1114,8 @@ void GraphicsContext::FillDRRect(const FloatRoundedRect& outer,
   stroke_r_rect.inset(stroke_width / 2, stroke_width / 2);
 
   PaintFlags stroke_flags(ImmutableState()->FillFlags());
-  stroke_flags.setColor(
-      dark_mode_filter_
-          .InvertColorIfNeeded(color, DarkModeFilter::ElementRole::kBackground)
-          .Rgb());
+  stroke_flags.setColor(dark_mode_filter_.InvertColorIfNeeded(
+      color.Rgb(), DarkModeFilter::ElementRole::kBackground));
   stroke_flags.setStyle(PaintFlags::kStroke_Style);
   stroke_flags.setStrokeWidth(stroke_width);
 
@@ -1284,10 +1278,8 @@ void GraphicsContext::FillRectWithRoundedHole(
     const FloatRoundedRect& rounded_hole_rect,
     const Color& color) {
   PaintFlags flags(ImmutableState()->FillFlags());
-  flags.setColor(
-      dark_mode_filter_
-          .InvertColorIfNeeded(color, DarkModeFilter::ElementRole::kBackground)
-          .Rgb());
+  flags.setColor(dark_mode_filter_.InvertColorIfNeeded(
+      color.Rgb(), DarkModeFilter::ElementRole::kBackground));
   canvas_->drawDRRect(SkRRect::MakeRect(rect), rounded_hole_rect, flags);
 }