Added operators to color pipeline components.

Added operators and type conversions to ColorRecipe and
ColorTransform that allow for a cleaner and more intuitive
use of these classes.

Bug: 1887666
Change-Id: I2f0d3455da349c5c39025c6cdf5b1da9ed5e07c4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1912782
Commit-Queue: Thomas Lukaszewicz <tluk@chromium.org>
Reviewed-by: Peter Kasting <pkasting@chromium.org>
Cr-Commit-Position: refs/heads/master@{#715533}

chrome/browser/ui/views/omnibox/omnibox_color_mixer.cc

@@ -18,45 +18,41 @@ void AddOmniboxColorMixer(ui::ColorProvider* provider, bool high_contrast) {
       high_contrast ? 6.0f : color_utils::kMinimumReadableContrastRatio;
 
   // Omnibox background colors.
-  mixer[kColorOmniboxBackground].AddTransform(ui::GetResultingPaintColor(
-      ui::FromTransformInput(), ui::FromInputColor(kColorToolbar)));
-  mixer[kColorOmniboxBackgroundHovered].AddTransform(ui::BlendTowardMaxContrast(
-      ui::FromResultColor(kColorOmniboxBackground), 0x0A));
+  mixer[kColorOmniboxBackground] = ui::GetResultingPaintColor(
+      ui::FromTransformInput(), ui::FromInputColor(kColorToolbar));
+  mixer[kColorOmniboxBackgroundHovered] = ui::BlendTowardMaxContrast(
+      ui::FromResultColor(kColorOmniboxBackground), 0x0A);
 
   // Omnibox text colors.
-  mixer[kColorOmniboxText].AddTransform(ui::GetResultingPaintColor(
-      ui::FromTransformInput(), ui::FromResultColor(kColorOmniboxBackground)));
+  mixer[kColorOmniboxText] = ui::GetResultingPaintColor(
+      ui::FromTransformInput(), ui::FromResultColor(kColorOmniboxBackground));
   {
-    auto& selected_text = mixer[kColorOmniboxResultsTextSelected].AddTransform(
-        ui::FromResultColor(kColorOmniboxText));
+    auto& selected_text = mixer[kColorOmniboxResultsTextSelected];
+    selected_text = ui::FromResultColor(kColorOmniboxText);
     if (high_contrast)
-      selected_text.AddTransform(ui::ContrastInvert(ui::FromTransformInput()));
+      selected_text += ui::ContrastInvert(ui::FromTransformInput());
   }
-  mixer[kColorOmniboxSelectedKeyword].AddTransform(
-      ui::SelectBasedOnDarkInput(ui::FromResultColor(kColorOmniboxBackground),
-                                 ui::FromColor(gfx::kGoogleGrey100),
-                                 ui::FromResultColor(kColorOmniboxResultsUrl)));
+  mixer[kColorOmniboxSelectedKeyword] = ui::SelectBasedOnDarkInput(
+      ui::FromResultColor(kColorOmniboxBackground), gfx::kGoogleGrey100,
+      ui::FromResultColor(kColorOmniboxResultsUrl));
 
   // Bubble outline colors.
-  mixer[kColorOmniboxBubbleOutline].AddTransform(ui::SelectBasedOnDarkInput(
-      ui::FromResultColor(kColorOmniboxBackground),
-      ui::FromColor(gfx::kGoogleGrey100),
-      ui::FromColor(SkColorSetA(gfx::kGoogleGrey900, 0x24))));
-  mixer[kColorOmniboxBubbleOutlineExperimentalKeywordMode].AddTransform(
-      ui::FromResultColor(kColorOmniboxSelectedKeyword));
+  mixer[kColorOmniboxBubbleOutline] = ui::SelectBasedOnDarkInput(
+      ui::FromResultColor(kColorOmniboxBackground), gfx::kGoogleGrey100,
+      SkColorSetA(gfx::kGoogleGrey900, 0x24));
+  mixer[kColorOmniboxBubbleOutlineExperimentalKeywordMode] =
+      ui::FromResultColor(kColorOmniboxSelectedKeyword);
 
   // Results background colors.
-  mixer[kColorOmniboxResultsBackground].AddTransform(
-      ui::GetColorWithMaxContrast(ui::FromResultColor(kColorOmniboxText)));
-  mixer[kColorOmniboxResultsBackgroundHovered].AddTransform(
-      ui::BlendTowardMaxContrast(
-          ui::FromResultColor(kColorOmniboxResultsBackground),
-          gfx::kGoogleGreyAlpha200));
-  mixer[kColorOmniboxResultsBackgroundSelected].AddTransform(
-      ui::BlendTowardMaxContrast(
-          ui::GetColorWithMaxContrast(
-              ui::FromResultColor(kColorOmniboxResultsTextSelected)),
-          gfx::kGoogleGreyAlpha300));
+  mixer[kColorOmniboxResultsBackground] =
+      ui::GetColorWithMaxContrast(ui::FromResultColor(kColorOmniboxText));
+  mixer[kColorOmniboxResultsBackgroundHovered] = ui::BlendTowardMaxContrast(
+      ui::FromResultColor(kColorOmniboxResultsBackground),
+      gfx::kGoogleGreyAlpha200);
+  mixer[kColorOmniboxResultsBackgroundSelected] = ui::BlendTowardMaxContrast(
+      ui::GetColorWithMaxContrast(
+          ui::FromResultColor(kColorOmniboxResultsTextSelected)),
+      gfx::kGoogleGreyAlpha300);
 
   // Results icon colors.
   {
@@ -66,11 +62,11 @@ void AddOmniboxColorMixer(ui::ColorProvider* provider, bool high_contrast) {
           ui::DeriveDefaultIconColor(ui::FromResultColor(text_id)),
           ui::FromResultColor(background_id), base::nullopt, minimum_contrast);
     };
-    mixer[kColorOmniboxResultsIcon].AddTransform(
-        results_icon(kColorOmniboxText, kColorOmniboxResultsBackground));
-    mixer[kColorOmniboxResultsIconSelected].AddTransform(
+    mixer[kColorOmniboxResultsIcon] =
+        results_icon(kColorOmniboxText, kColorOmniboxResultsBackground);
+    mixer[kColorOmniboxResultsIconSelected] =
         results_icon(kColorOmniboxResultsTextSelected,
-                     kColorOmniboxResultsBackgroundSelected));
+                     kColorOmniboxResultsBackgroundSelected);
   }
 
   // Dimmed text colors.
@@ -86,30 +82,28 @@ void AddOmniboxColorMixer(ui::ColorProvider* provider, bool high_contrast) {
                                   base::nullopt, minimum_contrast),
           minimum_contrast);
     };
-    mixer[kColorOmniboxResultsTextDimmed].AddTransform(
-        blend_with_clamped_contrast(kColorOmniboxText,
-                                    kColorOmniboxResultsBackgroundHovered));
-    mixer[kColorOmniboxResultsTextDimmedSelected].AddTransform(
+    mixer[kColorOmniboxResultsTextDimmed] = blend_with_clamped_contrast(
+        kColorOmniboxText, kColorOmniboxResultsBackgroundHovered);
+    mixer[kColorOmniboxResultsTextDimmedSelected] =
         blend_with_clamped_contrast(kColorOmniboxResultsTextSelected,
-                                    kColorOmniboxResultsBackgroundSelected));
-    mixer[kColorOmniboxTextDimmed].AddTransform(blend_with_clamped_contrast(
-        kColorOmniboxText, kColorOmniboxBackgroundHovered));
+                                    kColorOmniboxResultsBackgroundSelected);
+    mixer[kColorOmniboxTextDimmed] = blend_with_clamped_contrast(
+        kColorOmniboxText, kColorOmniboxBackgroundHovered);
   }
 
   // Results URL colors.
   {
     const auto url_color = [minimum_contrast](ui::ColorId id) {
       return ui::BlendForMinContrast(
-          ui::FromColor(gfx::kGoogleBlue500), ui::FromResultColor(id),
+          gfx::kGoogleBlue500, ui::FromResultColor(id),
           ui::SelectBasedOnDarkInput(ui::FromResultColor(id),
-                                     ui::FromColor(gfx::kGoogleBlue050),
-                                     ui::FromColor(gfx::kGoogleBlue900)),
+                                     gfx::kGoogleBlue050, gfx::kGoogleBlue900),
           minimum_contrast);
     };
-    mixer[kColorOmniboxResultsUrl].AddTransform(
-        url_color(kColorOmniboxResultsBackgroundHovered));
-    mixer[kColorOmniboxResultsUrlSelected].AddTransform(
-        url_color(kColorOmniboxResultsBackgroundSelected));
+    mixer[kColorOmniboxResultsUrl] =
+        url_color(kColorOmniboxResultsBackgroundHovered);
+    mixer[kColorOmniboxResultsUrlSelected] =
+        url_color(kColorOmniboxResultsBackgroundSelected);
   }
 
   // Security chip colors.
@@ -125,11 +119,11 @@ void AddOmniboxColorMixer(ui::ColorProvider* provider, bool high_contrast) {
                   ui::FromResultColor(kColorOmniboxBackgroundHovered),
                   base::nullopt, minimum_contrast));
         };
-    mixer[kColorOmniboxSecurityChipDangerous].AddTransform(
-        security_chip_color(ui::FromColor(gfx::kGoogleRed600)));
-    mixer[kColorOmniboxSecurityChipSecure].AddTransform(security_chip_color(
-        ui::DeriveDefaultIconColor(ui::FromResultColor(kColorOmniboxText))));
+    mixer[kColorOmniboxSecurityChipDangerous] =
+        security_chip_color(gfx::kGoogleRed600);
+    mixer[kColorOmniboxSecurityChipSecure] = security_chip_color(
+        ui::DeriveDefaultIconColor(ui::FromResultColor(kColorOmniboxText)));
   }
-  mixer[kColorOmniboxSecurityChipDefault].AddTransform(
-      ui::FromResultColor(kColorOmniboxSecurityChipSecure));
+  mixer[kColorOmniboxSecurityChipDefault] =
+      ui::FromResultColor(kColorOmniboxSecurityChipSecure);
 }

ui/color/color_mixer_unittest.cc

@@ -30,7 +30,7 @@ TEST(ColorMixerTest, AddSet) {
 // Tests that the recipe returned by operator[] is respected by the mixer.
 TEST(ColorMixerTest, AccessOperator) {
   ColorMixer mixer;
-  mixer[kColorTest0].AddTransform(FromColor(SK_ColorGREEN));
+  mixer[kColorTest0] = ColorTransform(SK_ColorGREEN);
   EXPECT_EQ(SK_ColorGREEN, mixer.GetResultColor(kColorTest0));
 }
 
@@ -86,8 +86,7 @@ TEST(ColorMixerTest, GetInputColorPreviousMixer) {
 TEST(ColorMixerTest, GetInputColorIgnoresRecipe) {
   ColorMixer mixer;
   mixer.AddSet({kColorSetTest0, {{kColorTest0, SK_ColorGREEN}}});
-  mixer[kColorTest0].AddTransform(
-      GetColorWithMaxContrast(FromTransformInput()));
+  mixer[kColorTest0] = GetColorWithMaxContrast(FromTransformInput());
   EXPECT_EQ(SK_ColorGREEN, mixer.GetInputColor(kColorTest0));
 }
 
@@ -97,8 +96,7 @@ TEST(ColorMixerTest, GetInputColorIgnoresRecipe) {
 TEST(ColorMixerTest, GetInputColorRespectsRecipePreviousMixer) {
   ColorMixer mixer0;
   mixer0.AddSet({kColorSetTest0, {{kColorTest0, SK_ColorGREEN}}});
-  mixer0[kColorTest0].AddTransform(
-      GetColorWithMaxContrast(FromTransformInput()));
+  mixer0[kColorTest0] = GetColorWithMaxContrast(FromTransformInput());
   ColorMixer mixer1(&mixer0);
   mixer1.AddSet({kColorSetTest1, {{kColorTest1, SK_ColorRED}}});
   EXPECT_EQ(color_utils::GetColorWithMaxContrast(SK_ColorGREEN),
@@ -169,8 +167,7 @@ TEST(ColorMixerTest, GetOriginalColorFromSetPreviousMixer) {
 TEST(ColorMixerTest, GetOriginalColorFromSetIgnoresRecipe) {
   ColorMixer mixer;
   mixer.AddSet({kColorSetTest0, {{kColorTest0, SK_ColorGREEN}}});
-  mixer[kColorTest0].AddTransform(
-      GetColorWithMaxContrast(FromTransformInput()));
+  mixer[kColorTest0] = GetColorWithMaxContrast(FromTransformInput());
   EXPECT_EQ(SK_ColorGREEN,
             mixer.GetOriginalColorFromSet(kColorTest0, kColorSetTest0));
 }
@@ -181,8 +178,7 @@ TEST(ColorMixerTest, GetOriginalColorFromSetIgnoresRecipe) {
 TEST(ColorMixerTest, GetOriginalColorFromSetIgnoresRecipePreviousMixer) {
   ColorMixer mixer0;
   mixer0.AddSet({kColorSetTest0, {{kColorTest0, SK_ColorGREEN}}});
-  mixer0[kColorTest0].AddTransform(
-      GetColorWithMaxContrast(FromTransformInput()));
+  mixer0[kColorTest0] = GetColorWithMaxContrast(FromTransformInput());
   ColorMixer mixer1(&mixer0);
   mixer1.AddSet({kColorSetTest1, {{kColorTest1, SK_ColorRED}}});
   EXPECT_EQ(SK_ColorGREEN,
@@ -207,9 +203,8 @@ TEST(ColorMixerTest, GetResultColorNoRecipe) {
 // initial value for its requested color.
 TEST(ColorMixerTest, GetResultColorNoSet) {
   ColorMixer mixer;
-  mixer[kColorTest0].AddTransform(FromColor(SK_ColorGREEN));
-  mixer[kColorTest1].AddTransform(
-      GetColorWithMaxContrast(FromTransformInput()));
+  mixer[kColorTest0] = ColorTransform(SK_ColorGREEN);
+  mixer[kColorTest1] = GetColorWithMaxContrast(FromTransformInput());
   EXPECT_EQ(SK_ColorGREEN, mixer.GetResultColor(kColorTest0));
   EXPECT_NE(gfx::kPlaceholderColor, mixer.GetResultColor(kColorTest1));
 }
@@ -220,8 +215,8 @@ TEST(ColorMixerTest, GetResultColorIgnoresSet) {
   ColorMixer mixer;
   mixer.AddSet({kColorSetTest0,
                 {{kColorTest0, SK_ColorWHITE}, {kColorTest1, SK_ColorBLACK}}});
-  mixer[kColorTest0].AddTransform(FromColor(SK_ColorGREEN));
-  mixer[kColorTest1].AddTransform(FromColor(SK_ColorGREEN));
+  mixer[kColorTest0] = ColorTransform(SK_ColorGREEN);
+  mixer[kColorTest1] = ColorTransform(SK_ColorGREEN);
   EXPECT_EQ(SK_ColorGREEN, mixer.GetResultColor(kColorTest0));
   EXPECT_EQ(SK_ColorGREEN, mixer.GetResultColor(kColorTest1));
 }
@@ -231,12 +226,12 @@ TEST(ColorMixerTest, GetResultColorIgnoresSet) {
 TEST(ColorMixerTest, GetResultColorChained) {
   ColorMixer mixer;
   mixer.AddSet({kColorSetTest0, {{kColorTest1, SK_ColorWHITE}}});
-  mixer[kColorTest0].AddTransform(FromColor(gfx::kGoogleBlue050));
-  mixer[kColorTest1].AddTransform(BlendTowardMaxContrast(
-      GetColorWithMaxContrast(FromTransformInput()), 0x29));
-  mixer[kColorTest2].AddTransform(BlendForMinContrast(
-      FromColor(gfx::kGoogleBlue500), FromResultColor(kColorTest1),
-      FromResultColor(kColorTest0)));
+  mixer[kColorTest0] = ColorTransform(gfx::kGoogleBlue050);
+  mixer[kColorTest1] = BlendTowardMaxContrast(
+      GetColorWithMaxContrast(FromTransformInput()), 0x29);
+  mixer[kColorTest2] =
+      BlendForMinContrast(gfx::kGoogleBlue500, FromResultColor(kColorTest1),
+                          FromResultColor(kColorTest0));
   EXPECT_EQ(SkColorSetRGB(0x89, 0xB3, 0xF8), mixer.GetResultColor(kColorTest2));
 }
 

ui/color/color_recipe.cc

@@ -12,14 +12,22 @@ namespace ui {
 
 ColorRecipe::ColorRecipe() = default;
 
+ColorRecipe::ColorRecipe(const ColorTransform& transform) {
+  *this += transform;
+}
+
+ColorRecipe::ColorRecipe(const ColorRecipe&) = default;
+
+ColorRecipe& ColorRecipe::operator=(const ColorRecipe&) = default;
+
 ColorRecipe::ColorRecipe(ColorRecipe&&) noexcept = default;
 
 ColorRecipe& ColorRecipe::operator=(ColorRecipe&&) noexcept = default;
 
 ColorRecipe::~ColorRecipe() = default;
 
-ColorRecipe& ColorRecipe::AddTransform(ColorTransform transform) {
-  transforms_.push_back(std::move(transform));
+ColorRecipe& ColorRecipe::operator+=(const ColorTransform& transform) {
+  transforms_.push_back(transform);
   return *this;
 }
 
@@ -30,4 +38,9 @@ SkColor ColorRecipe::GenerateResult(SkColor input,
   return input;
 }
 
+ColorRecipe operator+(ColorRecipe recipe, const ColorTransform& transform) {
+  recipe += transform;
+  return recipe;
+}
+
 }  // namespace ui
\ No newline at end of file

ui/color/color_recipe.h

@@ -22,15 +22,16 @@ class ColorMixer;
 class COMPONENT_EXPORT(COLOR) ColorRecipe {
  public:
   ColorRecipe();
-  // ColorRecipe is movable since it holds the full list of transforms, which
-  // might be expensive to copy.
+  // This constructor acts as a shorthand initialization of a recipe with a
+  // transform which is by far the most common means of recipe initialization.
+  ColorRecipe(const ColorTransform& transform);
+  ColorRecipe(const ColorRecipe&);
+  ColorRecipe& operator=(const ColorRecipe&);
   ColorRecipe(ColorRecipe&&) noexcept;
   ColorRecipe& operator=(ColorRecipe&&) noexcept;
   ~ColorRecipe();
 
-  // Adds a transform to the end of the current recipe.  Returns a non-const ref
-  // to allow chaining calls.
-  ColorRecipe& AddTransform(ColorTransform transform);
+  ColorRecipe& operator+=(const ColorTransform& transform);
 
   // Generates the output color for |input| by applying all transforms.  |mixer|
   // is passed to each transform, since it might need to request other colors.
@@ -40,6 +41,9 @@ class COMPONENT_EXPORT(COLOR) ColorRecipe {
   std::list<ColorTransform> transforms_;
 };
 
+COMPONENT_EXPORT(COLOR)
+ColorRecipe operator+(ColorRecipe recipe, const ColorTransform& transform);
+
 }  // namespace ui
 
 #endif  // UI_COLOR_COLOR_RECIPE_H_

ui/color/color_recipe_unittest.cc

@@ -8,6 +8,7 @@
 #include "ui/color/color_mixer.h"
 #include "ui/color/color_set.h"
 #include "ui/color/color_test_ids.h"
+#include "ui/color/color_transform.h"
 #include "ui/gfx/color_palette.h"
 
 namespace ui {
@@ -28,8 +29,7 @@ TEST(ColorRecipeTest, EmptyRecipeIsPassthrough) {
 // Tests that a transform in a recipe has an effect.
 TEST(ColorRecipeTest, OneTransform) {
   constexpr SkColor kOutput = SK_ColorGREEN;
-  ColorRecipe recipe;
-  recipe.AddTransform(FromColor(kOutput));
+  ColorRecipe recipe = ColorTransform(kOutput);
   const auto verify_transform = [&](SkColor input) {
     EXPECT_EQ(kOutput, recipe.GenerateResult(input, ColorMixer()));
   };
@@ -40,10 +40,9 @@ TEST(ColorRecipeTest, OneTransform) {
 
 // Tests that in a recipe with multiple transforms, each is applied.
 TEST(ColorRecipeTest, ChainedTransforms) {
-  ColorRecipe recipe;
-  recipe.AddTransform(DeriveDefaultIconColor(FromTransformInput()))
-      .AddTransform(BlendForMinContrast(FromTransformInput(),
-                                        FromInputColor(kColorTest0)));
+  ColorRecipe recipe =
+      DeriveDefaultIconColor(FromTransformInput()) +
+      BlendForMinContrast(FromTransformInput(), FromInputColor(kColorTest0));
   constexpr SkColor kBackground = SK_ColorWHITE;
   ColorMixer mixer;
   mixer.AddSet({kColorSetTest0, {{kColorTest0, kBackground}}});

ui/color/color_transform.cc

@@ -9,6 +9,26 @@
 
 namespace ui {
 
+ColorTransform::ColorTransform(Callback callback)
+    : callback_(std::move(callback)) {}
+
+ColorTransform::ColorTransform(SkColor color) {
+  const auto generator = [](SkColor color, SkColor input_color,
+                            const ColorMixer& mixer) { return color; };
+  callback_ = base::Bind(generator, color);
+}
+
+ColorTransform::ColorTransform(const ColorTransform&) = default;
+
+ColorTransform& ColorTransform::operator=(const ColorTransform&) = default;
+
+ColorTransform::~ColorTransform() = default;
+
+SkColor ColorTransform::Run(SkColor input_color,
+                            const ColorMixer& mixer) const {
+  return callback_.Run(input_color, mixer);
+}
+
 ColorTransform AlphaBlend(ColorTransform foreground_transform,
                           ColorTransform background_transform,
                           SkAlpha alpha) {
@@ -95,12 +115,6 @@ ColorTransform DeriveDefaultIconColor(ColorTransform transform) {
   return base::Bind(generator, std::move(transform));
 }
 
-ColorTransform FromColor(SkColor color) {
-  const auto generator = [](SkColor color, SkColor input_color,
-                            const ColorMixer& mixer) { return color; };
-  return base::Bind(generator, color);
-}
-
 ColorTransform FromOriginalColorFromSet(ColorId id, ColorSetId set_id) {
   DCHECK_COLOR_ID_VALID(id);
   DCHECK_COLOR_SET_ID_VALID(set_id);

ui/color/color_transform.h

@@ -16,13 +16,29 @@ namespace ui {
 
 class ColorMixer;
 
-// ColorTransform is a function which transforms an |input| color, optionally
-// using a |mixer| (to obtain other colors).  ColorTransforms can be chained
-// together in ColorRecipes, where each will be applied to the preceding
-// transform's output.
-using ColorTransform =
+// Callback is a function which transforms an |input| color, optionally using a
+// |mixer| (to obtain other colors).
+using Callback =
     base::RepeatingCallback<SkColor(SkColor input, const ColorMixer& mixer)>;
 
+// ColorTransform wraps Callback and can be chained together in ColorRecipes,
+// where each will be applied to the preceding transform's output.
+class COMPONENT_EXPORT(COLOR) ColorTransform {
+ public:
+  // Allows simple conversion from a Callback to a ColorTransform.
+  ColorTransform(Callback callback);
+  // Creates a transform that returns the supplied |color|.
+  ColorTransform(SkColor color);
+  ColorTransform(const ColorTransform&);
+  ColorTransform& operator=(const ColorTransform&);
+  ~ColorTransform();
+
+  SkColor Run(SkColor input_color, const ColorMixer& mixer) const;
+
+ private:
+  Callback callback_;
+};
+
 // Functions to create common transforms:
 
 // A transform which blends the result of |foreground_transform| atop the result
@@ -66,9 +82,6 @@ COMPONENT_EXPORT(COLOR) ColorTransform ContrastInvert(ColorTransform transform);
 COMPONENT_EXPORT(COLOR)
 ColorTransform DeriveDefaultIconColor(ColorTransform transform);
 
-// A transform which outputs |color|.
-COMPONENT_EXPORT(COLOR) ColorTransform FromColor(SkColor color);
-
 // A transform which returns the color |id| from set |set_id|.
 COMPONENT_EXPORT(COLOR)
 ColorTransform FromOriginalColorFromSet(ColorId id, ColorSetId set_id);

ui/color/color_transform_unittest.cc

@@ -13,11 +13,22 @@
 namespace ui {
 namespace {
 
+// Tests initialization with an SkColor value.
+TEST(ColorRecipeTest, TestColorRecipeInitialization) {
+  const auto verify_initialization = [&](SkColor color) {
+    ColorTransform transform = color;
+    EXPECT_EQ(color, transform.Run(SK_ColorBLACK, ColorMixer()));
+  };
+  verify_initialization(SK_ColorBLUE);
+  verify_initialization(SK_ColorRED);
+  verify_initialization(SK_ColorGREEN);
+}
+
 // Tests that AlphaBlend() produces a transform that blends its inputs.
 TEST(ColorTransformTest, AlphaBlend) {
   const auto blend = [](SkAlpha alpha) {
     const ColorTransform transform =
-        AlphaBlend(FromColor(SK_ColorWHITE), FromColor(SK_ColorBLACK), alpha);
+        AlphaBlend(SK_ColorWHITE, SK_ColorBLACK, alpha);
     return transform.Run(gfx::kPlaceholderColor, ColorMixer());
   };
   EXPECT_EQ(SK_ColorBLACK, blend(SK_AlphaTRANSPARENT));
@@ -131,11 +142,11 @@ TEST(ColorTransformTest, DeriveDefaultIconColor) {
   verify_derive(SK_ColorRED);
 }
 
-// Tests that FromColor() produces a transform that ignores the input color and
-// always outputs a specified SkColor.
+// Tests that initializing a transform from a color produces a transform that
+// ignores the input color and always outputs a specified SkColor.
 TEST(ColorTransformTest, FromColor) {
   constexpr SkColor kOutput = SK_ColorGREEN;
-  const ColorTransform transform = FromColor(kOutput);
+  const ColorTransform transform = kOutput;
   const auto verify_color = [&](SkColor input) {
     EXPECT_EQ(kOutput, transform.Run(input, ColorMixer()));
   };
@@ -185,7 +196,7 @@ TEST(ColorTransformTest, FromResultColor) {
   ColorMixer mixer;
   mixer.AddSet({kColorSetTest0,
                 {{kColorTest0, SK_ColorGREEN}, {kColorTest1, kTest1Color}}});
-  mixer[kColorTest0].AddTransform(FromInputColor(kColorTest1));
+  mixer[kColorTest0] = FromInputColor(kColorTest1);
   const auto verify_color = [&](SkColor input) {
     EXPECT_EQ(kTest1Color, transform.Run(input, mixer));
   };
@@ -238,8 +249,8 @@ TEST(ColorTransformTest, GetResultingPaintColor) {
 TEST(ColorTransformTest, SelectBasedOnDarkInput) {
   constexpr SkColor kDarkOutput = SK_ColorGREEN;
   constexpr SkColor kLightOutput = SK_ColorRED;
-  const ColorTransform transform = SelectBasedOnDarkInput(
-      FromTransformInput(), FromColor(kDarkOutput), FromColor(kLightOutput));
+  const ColorTransform transform =
+      SelectBasedOnDarkInput(FromTransformInput(), kDarkOutput, kLightOutput);
   EXPECT_EQ(kDarkOutput, transform.Run(SK_ColorBLACK, ColorMixer()));
   EXPECT_EQ(kLightOutput, transform.Run(SK_ColorWHITE, ColorMixer()));
   EXPECT_EQ(kDarkOutput, transform.Run(SK_ColorBLUE, ColorMixer()));

ui/color/core_default_color_mixer.cc

@@ -67,12 +67,12 @@ ColorMixer& AddMixerForLightMode(ColorProvider* provider) {
 void AddCoreDefaultColorMixers(ColorProvider* provider, bool dark_window) {
   ColorMixer& mixer = dark_window ? AddMixerForDarkMode(provider)
                                   : AddMixerForLightMode(provider);
-  mixer[kColorSecondaryBackground].AddTransform(BlendForMinContrastWithSelf(
-      FromResultColor(kColorPrimaryBackground), 1.67f));
-  mixer[kColorSecondaryForeground].AddTransform(
+  mixer[kColorSecondaryBackground] = BlendForMinContrastWithSelf(
+      FromResultColor(kColorPrimaryBackground), 1.67f);
+  mixer[kColorSecondaryForeground] =
       BlendForMinContrast(FromResultColor(kColorDisabledForeground),
                           FromResultColor(kColorPrimaryBackground),
-                          FromResultColor(kColorPrimaryForeground)));
+                          FromResultColor(kColorPrimaryForeground));
   // TODO(pkasting): High contrast?
 }