Remove remaining makeSimpleColorFrom* variants
authorweinig@apple.com <weinig@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 29 Jun 2020 20:31:18 +0000 (20:31 +0000)
committerweinig@apple.com <weinig@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 29 Jun 2020 20:31:18 +0000 (20:31 +0000)
https://bugs.webkit.org/show_bug.cgi?id=213706

Reviewed by Darin Adler.

Source/WebCore:

Removed makeSimpleColorFromFloats and makeSimpleColorFromCMYKA.
- Updated callers that need to pass floats to use makeSimpleColor(SRGBA { ... });
- Updated callers that don't need to pass floats, mostly compile time constant
  SimpleColors to use makeSimpleColor(...), passing in 0-255 based component
  values.
- Updated callers of makeSimpleColorFromCMYKA to use makeSimpleColor(toSRGBA(CMYKA { ... })).
  This required adding CMYKA type to ColorTypes.h and moving conversion SRGBA to
  ColorUtilities with the other color conversion code.
- Added deduction guides for color types to allow component type deduction. This allows
  us to write:

       function(SRGBA { redFloat, greenFloat, blueFloat, alphaFloat })

  reather than the more cumbersome:

       function(SRGBA<float> { redFloat, greenFloat, blueFloat, alphaFloat })

- Added operator==/operator!= for each color type. Only used by CMYKA at the moment,
  but generally useful, so added for all of them. For all types convertable to ColorComponents,
  the implementation uses the conversion to ColorComponents to avoid redundancy.

* html/canvas/CanvasRenderingContext2DBase.cpp:
(WebCore::CanvasRenderingContext2DBase::setStrokeColor):
(WebCore::CanvasRenderingContext2DBase::setFillColor):
Update to call new typed color based CanvasStyle functions.
(WebCore::CanvasRenderingContext2DBase::setShadow):
Use makeSimpleColor rather than makeSimpleColorFromFloats/makeSimpleColorFromCMYKA.

* html/canvas/CanvasStyle.cpp:
(WebCore::CanvasStyle::CanvasStyle):
Replace constructors taking raw floats with ones taking typed colors (SRGBA<float>/CMYKA<float>)
to make it more clear what the parameters mean.
(WebCore::CanvasStyle::isEquivalentColor const):
Compare the cmyka components using new operator== implementation for CMYKA<float>.
(WebCore::CanvasStyle::isEquivalent const):
(WebCore::CanvasStyle::isEquivalentRGBA const): Deleted.
(WebCore::CanvasStyle::isEquivalentCMYKA const): Deleted.
Replace isEquivalentRGBA/isEquivalentCMYKA with overloaded isEquivalent.
(WebCore::CanvasStyle::applyStrokeColor const):
(WebCore::CanvasStyle::applyFillColor const):
Update for new names of CMYKA members.
* html/canvas/CanvasStyle.h:
Use SRGBA<float> and CMYKA<float> to simplify interfaces

* page/DebugPageOverlays.cpp:
* page/linux/ResourceUsageOverlayLinux.cpp:
(WebCore::ResourceUsageOverlay::platformInitialize):
Use makeSimpleColor rather than makeSimpleColorFromFloats, allowing for
constant expression creation of SimpleColors.

* platform/graphics/Color.cpp:
(WebCore::Color::lightened const):
(WebCore::Color::darkened const):
Use makeSimpleColor(SRGBA { ... }) rather than makeSimpleColorFromFloats.

(WebCore::Color::luminance const):
Fix comment.

(WebCore::blendWithoutPremultiply):
Use makeSimpleColor(...) rather than makeSimpleColorFromFloats.

* platform/graphics/ColorTypes.h:
(WebCore::operator==):
(WebCore::operator!=):
- Add deduction guides and operator==/operator!= for each color type.
- Add CMYKA type. No conversion to ColorComponents yet, as ColorComponents
  only works with 4 component colors, not ones with 5 like CMYKA.

* platform/graphics/ColorUtilities.cpp:
(WebCore::toSRGBA):
Move conversion from CMYKA to SRGBA from makeSimpleColorFromCMYKA to here.

* platform/graphics/ColorUtilities.h:
(WebCore::convertPrescaledToComponentByte):
(WebCore::convertToComponentByte):
Use std::round rather than std::lroundf, since it will have the same result
and it reads nicer.

* platform/graphics/SimpleColor.cpp:
(WebCore::makeSimpleColorFromCMYKA): Deleted.
* platform/graphics/SimpleColor.h:
(WebCore::makeSimpleColor):
(WebCore::makeSimpleColorFromFloats): Deleted.
- Removed makeSimpleColorFromFloats and makeSimpleColorFromCMYKA.
- Added constexpr overload of makeSimpleColor taking a const SRGBA<uint8_t>&.
- Fixed forward declaration of makeSimpleColor that was taking ColorComponents
  to actually take an SRGBA<float>, which is what the inline implementation actually
  takes.

* platform/graphics/avfoundation/InbandTextTrackPrivateAVF.cpp:
(WebCore::makeSimpleColorFromARGBCFArray):
* platform/graphics/cairo/GradientCairo.cpp:
(WebCore::interpolateColorStop):
* platform/graphics/cg/ColorCG.cpp:
(WebCore::makeSimpleColorFromCGColor):
* platform/graphics/win/PlatformContextDirect2D.cpp:
(WebCore::PlatformContextDirect2D::brushWithColor):
Use makeSimpleColor(SRGBA { ... }) rather than makeSimpleColorFromFloats.

* platform/graphics/mac/ColorMac.mm:
(WebCore::makeSimpleColorFromNSColor):
* platform/ios/ColorIOS.mm:
(WebCore::colorFromUIColor):
Use makeSimpleColor(SRGBA { ... }) rather than makeSimpleColorFromFloats. Casting to
float is needed, as the input types are CGFloat which is double in 64-bit environments
and won't automatically narrow with the new types.

* platform/ios/LegacyTileCache.mm:
(WebCore::LegacyTileCache::colorForGridTileBorder const):
* rendering/RenderLayer.cpp:
(WebCore::RenderLayer::beginTransparencyLayers):
Use makeSimpleColor rather than makeSimpleColorFromFloats, allowing for
constant expression creation of SimpleColors.

* rendering/RenderThemeIOS.mm:
(WebCore::RenderThemeIOS::paintCheckboxDecorations):
(WebCore::RenderThemeIOS::paintRadioDecorations):
(WebCore::RenderThemeIOS::paintMenuListButtonDecorations):
(WebCore::RenderThemeIOS::paintSystemPreviewBadge):
Use Color::black/Color::white.colorWithAlpha(...) rather than makeSimpleColorFromFloats,
allowing for constant expression creation of SimpleColors.

Source/WebKit:

* UIProcess/API/wpe/WebKitColor.cpp:
(webkitColorToWebCoreColor):
Use makeSimpleColor(SRGBA { ... }) rather than makeSimpleColorFromFloats.

* WebProcess/Inspector/WebInspectorClient.cpp:
(WebKit::WebInspectorClient::showPaintRect):
* WebProcess/WebPage/FindController.cpp:
(WebKit::FindController::drawRect):
Use makeSimpleColor rather than makeSimpleColorFromFloats, allowing for
constant expression creation of SimpleColors.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@263688 268f45cc-cd09-0410-ab3c-d52691b4dbfc

25 files changed:
Source/WebCore/ChangeLog
Source/WebCore/html/canvas/CanvasRenderingContext2DBase.cpp
Source/WebCore/html/canvas/CanvasStyle.cpp
Source/WebCore/html/canvas/CanvasStyle.h
Source/WebCore/page/DebugPageOverlays.cpp
Source/WebCore/page/linux/ResourceUsageOverlayLinux.cpp
Source/WebCore/platform/graphics/Color.cpp
Source/WebCore/platform/graphics/ColorTypes.h
Source/WebCore/platform/graphics/ColorUtilities.cpp
Source/WebCore/platform/graphics/ColorUtilities.h
Source/WebCore/platform/graphics/SimpleColor.cpp
Source/WebCore/platform/graphics/SimpleColor.h
Source/WebCore/platform/graphics/avfoundation/InbandTextTrackPrivateAVF.cpp
Source/WebCore/platform/graphics/cairo/GradientCairo.cpp
Source/WebCore/platform/graphics/cg/ColorCG.cpp
Source/WebCore/platform/graphics/mac/ColorMac.mm
Source/WebCore/platform/graphics/win/PlatformContextDirect2D.cpp
Source/WebCore/platform/ios/ColorIOS.mm
Source/WebCore/platform/ios/LegacyTileCache.mm
Source/WebCore/rendering/RenderLayer.cpp
Source/WebCore/rendering/RenderThemeIOS.mm
Source/WebKit/ChangeLog
Source/WebKit/UIProcess/API/wpe/WebKitColor.cpp
Source/WebKit/WebProcess/Inspector/WebInspectorClient.cpp
Source/WebKit/WebProcess/WebPage/FindController.cpp

index 5999d10..780d577 100644 (file)
@@ -1,3 +1,132 @@
+2020-06-29  Sam Weinig  <weinig@apple.com>
+
+        Remove remaining makeSimpleColorFrom* variants
+        https://bugs.webkit.org/show_bug.cgi?id=213706
+
+        Reviewed by Darin Adler.
+
+        Removed makeSimpleColorFromFloats and makeSimpleColorFromCMYKA.
+        - Updated callers that need to pass floats to use makeSimpleColor(SRGBA { ... });
+        - Updated callers that don't need to pass floats, mostly compile time constant
+          SimpleColors to use makeSimpleColor(...), passing in 0-255 based component
+          values.
+        - Updated callers of makeSimpleColorFromCMYKA to use makeSimpleColor(toSRGBA(CMYKA { ... })).
+          This required adding CMYKA type to ColorTypes.h and moving conversion SRGBA to
+          ColorUtilities with the other color conversion code.
+        - Added deduction guides for color types to allow component type deduction. This allows 
+          us to write:
+
+               function(SRGBA { redFloat, greenFloat, blueFloat, alphaFloat })
+
+          reather than the more cumbersome:
+
+               function(SRGBA<float> { redFloat, greenFloat, blueFloat, alphaFloat })
+
+        - Added operator==/operator!= for each color type. Only used by CMYKA at the moment,
+          but generally useful, so added for all of them. For all types convertable to ColorComponents,
+          the implementation uses the conversion to ColorComponents to avoid redundancy.
+
+        * html/canvas/CanvasRenderingContext2DBase.cpp:
+        (WebCore::CanvasRenderingContext2DBase::setStrokeColor):
+        (WebCore::CanvasRenderingContext2DBase::setFillColor):
+        Update to call new typed color based CanvasStyle functions.
+        (WebCore::CanvasRenderingContext2DBase::setShadow):
+        Use makeSimpleColor rather than makeSimpleColorFromFloats/makeSimpleColorFromCMYKA.
+
+        * html/canvas/CanvasStyle.cpp:
+        (WebCore::CanvasStyle::CanvasStyle):
+        Replace constructors taking raw floats with ones taking typed colors (SRGBA<float>/CMYKA<float>)
+        to make it more clear what the parameters mean. 
+        (WebCore::CanvasStyle::isEquivalentColor const):
+        Compare the cmyka components using new operator== implementation for CMYKA<float>.
+        (WebCore::CanvasStyle::isEquivalent const):
+        (WebCore::CanvasStyle::isEquivalentRGBA const): Deleted.
+        (WebCore::CanvasStyle::isEquivalentCMYKA const): Deleted.
+        Replace isEquivalentRGBA/isEquivalentCMYKA with overloaded isEquivalent.
+        (WebCore::CanvasStyle::applyStrokeColor const):
+        (WebCore::CanvasStyle::applyFillColor const):
+        Update for new names of CMYKA members.
+        * html/canvas/CanvasStyle.h:
+        Use SRGBA<float> and CMYKA<float> to simplify interfaces
+        
+        * page/DebugPageOverlays.cpp:
+        * page/linux/ResourceUsageOverlayLinux.cpp:
+        (WebCore::ResourceUsageOverlay::platformInitialize):
+        Use makeSimpleColor rather than makeSimpleColorFromFloats, allowing for
+        constant expression creation of SimpleColors.
+
+        * platform/graphics/Color.cpp:
+        (WebCore::Color::lightened const):
+        (WebCore::Color::darkened const):
+        Use makeSimpleColor(SRGBA { ... }) rather than makeSimpleColorFromFloats.
+
+        (WebCore::Color::luminance const):
+        Fix comment.
+
+        (WebCore::blendWithoutPremultiply):
+        Use makeSimpleColor(...) rather than makeSimpleColorFromFloats.
+
+        * platform/graphics/ColorTypes.h:
+        (WebCore::operator==):
+        (WebCore::operator!=):
+        - Add deduction guides and operator==/operator!= for each color type.
+        - Add CMYKA type. No conversion to ColorComponents yet, as ColorComponents
+          only works with 4 component colors, not ones with 5 like CMYKA.
+
+        * platform/graphics/ColorUtilities.cpp:
+        (WebCore::toSRGBA):
+        Move conversion from CMYKA to SRGBA from makeSimpleColorFromCMYKA to here.
+
+        * platform/graphics/ColorUtilities.h:
+        (WebCore::convertPrescaledToComponentByte):
+        (WebCore::convertToComponentByte):
+        Use std::round rather than std::lroundf, since it will have the same result 
+        and it reads nicer.
+
+        * platform/graphics/SimpleColor.cpp:
+        (WebCore::makeSimpleColorFromCMYKA): Deleted.
+        * platform/graphics/SimpleColor.h:
+        (WebCore::makeSimpleColor):
+        (WebCore::makeSimpleColorFromFloats): Deleted.
+        - Removed makeSimpleColorFromFloats and makeSimpleColorFromCMYKA.
+        - Added constexpr overload of makeSimpleColor taking a const SRGBA<uint8_t>&.
+        - Fixed forward declaration of makeSimpleColor that was taking ColorComponents 
+          to actually take an SRGBA<float>, which is what the inline implementation actually
+          takes.
+        * platform/graphics/avfoundation/InbandTextTrackPrivateAVF.cpp:
+        (WebCore::makeSimpleColorFromARGBCFArray):
+        * platform/graphics/cairo/GradientCairo.cpp:
+        (WebCore::interpolateColorStop):
+        * platform/graphics/cg/ColorCG.cpp:
+        (WebCore::makeSimpleColorFromCGColor):
+        * platform/graphics/win/PlatformContextDirect2D.cpp:
+        (WebCore::PlatformContextDirect2D::brushWithColor):
+        Use makeSimpleColor(SRGBA { ... }) rather than makeSimpleColorFromFloats.
+
+        * platform/graphics/mac/ColorMac.mm:
+        (WebCore::makeSimpleColorFromNSColor):
+        * platform/ios/ColorIOS.mm:
+        (WebCore::colorFromUIColor):
+        Use makeSimpleColor(SRGBA { ... }) rather than makeSimpleColorFromFloats. Casting to 
+        float is needed, as the input types are CGFloat which is double in 64-bit environments
+        and won't automatically narrow with the new types.
+
+        * platform/ios/LegacyTileCache.mm:
+        (WebCore::LegacyTileCache::colorForGridTileBorder const):
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::beginTransparencyLayers):
+        Use makeSimpleColor rather than makeSimpleColorFromFloats, allowing for
+        constant expression creation of SimpleColors.
+
+        * rendering/RenderThemeIOS.mm:
+        (WebCore::RenderThemeIOS::paintCheckboxDecorations):
+        (WebCore::RenderThemeIOS::paintRadioDecorations):
+        (WebCore::RenderThemeIOS::paintMenuListButtonDecorations):
+        (WebCore::RenderThemeIOS::paintSystemPreviewBadge):
+        Use Color::black/Color::white.colorWithAlpha(...) rather than makeSimpleColorFromFloats, 
+        allowing for constant expression creation of SimpleColors.
+
 2020-06-29  Chris Fleizach  <cfleizach@apple.com>
 
         AX: aria-modal nodes wrapped in aria-hidden are not honored
 2020-06-29  Chris Fleizach  <cfleizach@apple.com>
 
         AX: aria-modal nodes wrapped in aria-hidden are not honored
index 29ba65c..7577d94 100644 (file)
@@ -371,7 +371,7 @@ void CanvasRenderingContext2DBase::setStrokeStyle(CanvasStyle style)
     if (!style.isValid())
         return;
 
     if (!style.isValid())
         return;
 
-    if (state().strokeStyle.isValid() && state().strokeStyle.isEquivalentColor(style))
+    if (state().strokeStyle.isEquivalentColor(style))
         return;
 
     if (style.isCurrentColor())
         return;
 
     if (style.isCurrentColor())
@@ -394,7 +394,7 @@ void CanvasRenderingContext2DBase::setFillStyle(CanvasStyle style)
     if (!style.isValid())
         return;
 
     if (!style.isValid())
         return;
 
-    if (state().fillStyle.isValid() && state().fillStyle.isEquivalentColor(style))
+    if (state().fillStyle.isEquivalentColor(style))
         return;
 
     if (style.isCurrentColor())
         return;
 
     if (style.isCurrentColor())
@@ -914,23 +914,26 @@ void CanvasRenderingContext2DBase::setStrokeColor(const String& color, Optional<
 
 void CanvasRenderingContext2DBase::setStrokeColor(float grayLevel, float alpha)
 {
 
 void CanvasRenderingContext2DBase::setStrokeColor(float grayLevel, float alpha)
 {
-    if (state().strokeStyle.isValid() && state().strokeStyle.isEquivalentRGBA(grayLevel, grayLevel, grayLevel, alpha))
+    auto color = SRGBA { grayLevel, grayLevel, grayLevel, alpha };
+    if (state().strokeStyle.isEquivalent(color))
         return;
         return;
-    setStrokeStyle(CanvasStyle(grayLevel, alpha));
+    setStrokeStyle(CanvasStyle(color));
 }
 
 void CanvasRenderingContext2DBase::setStrokeColor(float r, float g, float b, float a)
 {
 }
 
 void CanvasRenderingContext2DBase::setStrokeColor(float r, float g, float b, float a)
 {
-    if (state().strokeStyle.isValid() && state().strokeStyle.isEquivalentRGBA(r, g, b, a))
+    auto color = SRGBA { r, g, b, a };
+    if (state().strokeStyle.isEquivalent(color))
         return;
         return;
-    setStrokeStyle(CanvasStyle(r, g, b, a));
+    setStrokeStyle(CanvasStyle(color));
 }
 
 void CanvasRenderingContext2DBase::setStrokeColor(float c, float m, float y, float k, float a)
 {
 }
 
 void CanvasRenderingContext2DBase::setStrokeColor(float c, float m, float y, float k, float a)
 {
-    if (state().strokeStyle.isValid() && state().strokeStyle.isEquivalentCMYKA(c, m, y, k, a))
+    auto color = CMYKA { c, m, y, k, a };
+    if (state().strokeStyle.isEquivalent(color))
         return;
         return;
-    setStrokeStyle(CanvasStyle(c, m, y, k, a));
+    setStrokeStyle(CanvasStyle(color));
 }
 
 void CanvasRenderingContext2DBase::setFillColor(const String& color, Optional<float> alpha)
 }
 
 void CanvasRenderingContext2DBase::setFillColor(const String& color, Optional<float> alpha)
@@ -950,23 +953,26 @@ void CanvasRenderingContext2DBase::setFillColor(const String& color, Optional<fl
 
 void CanvasRenderingContext2DBase::setFillColor(float grayLevel, float alpha)
 {
 
 void CanvasRenderingContext2DBase::setFillColor(float grayLevel, float alpha)
 {
-    if (state().fillStyle.isValid() && state().fillStyle.isEquivalentRGBA(grayLevel, grayLevel, grayLevel, alpha))
+    auto color = SRGBA { grayLevel, grayLevel, grayLevel, alpha };
+    if (state().fillStyle.isEquivalent(color))
         return;
         return;
-    setFillStyle(CanvasStyle(grayLevel, alpha));
+    setFillStyle(CanvasStyle(color));
 }
 
 void CanvasRenderingContext2DBase::setFillColor(float r, float g, float b, float a)
 {
 }
 
 void CanvasRenderingContext2DBase::setFillColor(float r, float g, float b, float a)
 {
-    if (state().fillStyle.isValid() && state().fillStyle.isEquivalentRGBA(r, g, b, a))
+    auto color = SRGBA { r, g, b, a };
+    if (state().fillStyle.isEquivalent(color))
         return;
         return;
-    setFillStyle(CanvasStyle(r, g, b, a));
+    setFillStyle(CanvasStyle(color));
 }
 
 void CanvasRenderingContext2DBase::setFillColor(float c, float m, float y, float k, float a)
 {
 }
 
 void CanvasRenderingContext2DBase::setFillColor(float c, float m, float y, float k, float a)
 {
-    if (state().fillStyle.isValid() && state().fillStyle.isEquivalentCMYKA(c, m, y, k, a))
+    auto color = CMYKA { c, m, y, k, a };
+    if (state().fillStyle.isEquivalent(color))
         return;
         return;
-    setFillStyle(CanvasStyle(c, m, y, k, a));
+    setFillStyle(CanvasStyle(color));
 }
 
 void CanvasRenderingContext2DBase::beginPath()
 }
 
 void CanvasRenderingContext2DBase::beginPath()
@@ -1307,17 +1313,17 @@ void CanvasRenderingContext2DBase::setShadow(float width, float height, float bl
 
 void CanvasRenderingContext2DBase::setShadow(float width, float height, float blur, float grayLevel, float alpha)
 {
 
 void CanvasRenderingContext2DBase::setShadow(float width, float height, float blur, float grayLevel, float alpha)
 {
-    setShadow(FloatSize(width, height), blur, makeSimpleColorFromFloats(grayLevel, grayLevel, grayLevel, alpha));
+    setShadow(FloatSize(width, height), blur, makeSimpleColor(SRGBA { grayLevel, grayLevel, grayLevel, alpha }));
 }
 
 void CanvasRenderingContext2DBase::setShadow(float width, float height, float blur, float r, float g, float b, float a)
 {
 }
 
 void CanvasRenderingContext2DBase::setShadow(float width, float height, float blur, float r, float g, float b, float a)
 {
-    setShadow(FloatSize(width, height), blur, makeSimpleColorFromFloats(r, g, b, a));
+    setShadow(FloatSize(width, height), blur, makeSimpleColor(SRGBA { r, g, b, a }));
 }
 
 void CanvasRenderingContext2DBase::setShadow(float width, float height, float blur, float c, float m, float y, float k, float a)
 {
 }
 
 void CanvasRenderingContext2DBase::setShadow(float width, float height, float blur, float c, float m, float y, float k, float a)
 {
-    setShadow(FloatSize(width, height), blur, makeSimpleColorFromCMYKA(c, m, y, k, a));
+    setShadow(FloatSize(width, height), blur, makeSimpleColor(toSRGBA(CMYKA { c, m, y, k, a })));
 }
 
 void CanvasRenderingContext2DBase::clearShadow()
 }
 
 void CanvasRenderingContext2DBase::clearShadow()
index 0586d5c..d0b0eb4 100644 (file)
@@ -92,18 +92,13 @@ CanvasStyle::CanvasStyle(Color color)
 {
 }
 
 {
 }
 
-CanvasStyle::CanvasStyle(float grayLevel, float alpha)
-    : m_style(makeSimpleColorFromFloats(grayLevel, grayLevel, grayLevel, alpha))
+CanvasStyle::CanvasStyle(const SRGBA<float>& colorComponents)
+    : m_style(makeSimpleColor(colorComponents))
 {
 }
 
 {
 }
 
-CanvasStyle::CanvasStyle(float r, float g, float b, float a)
-    : m_style(makeSimpleColorFromFloats(r, g, b, a))
-{
-}
-
-CanvasStyle::CanvasStyle(float c, float m, float y, float k, float a)
-    : m_style(CMYKAColor { makeSimpleColorFromCMYKA(c, m, y, k, a), c, m, y, k, a })
+CanvasStyle::CanvasStyle(const CMYKA<float>& colorComponents)
+    : m_style(CMYKAColor { makeSimpleColor(toSRGBA(colorComponents)), colorComponents })
 {
 }
 
 {
 }
 
@@ -151,27 +146,20 @@ bool CanvasStyle::isEquivalentColor(const CanvasStyle& other) const
     if (WTF::holds_alternative<Color>(m_style) && WTF::holds_alternative<Color>(other.m_style))
         return WTF::get<Color>(m_style) == WTF::get<Color>(other.m_style);
 
     if (WTF::holds_alternative<Color>(m_style) && WTF::holds_alternative<Color>(other.m_style))
         return WTF::get<Color>(m_style) == WTF::get<Color>(other.m_style);
 
-    if (WTF::holds_alternative<CMYKAColor>(m_style) && WTF::holds_alternative<CMYKAColor>(other.m_style)) {
-        auto& a = WTF::get<CMYKAColor>(m_style);
-        auto& b = WTF::get<CMYKAColor>(other.m_style);
-        return a.c == b.c && a.m == b.m && a.y == b.y && a.k == b.k && a.a == b.a;
-    }
+    if (WTF::holds_alternative<CMYKAColor>(m_style) && WTF::holds_alternative<CMYKAColor>(other.m_style))
+        return WTF::get<CMYKAColor>(m_style).components == WTF::get<CMYKAColor>(other.m_style).components;
 
     return false;
 }
 
 
     return false;
 }
 
-bool CanvasStyle::isEquivalentRGBA(float r, float g, float b, float a) const
+bool CanvasStyle::isEquivalent(const SRGBA<float>& components) const
 {
 {
-    return WTF::holds_alternative<Color>(m_style) && WTF::get<Color>(m_style) == makeSimpleColorFromFloats(r, g, b, a);
+    return WTF::holds_alternative<Color>(m_style) && WTF::get<Color>(m_style) == makeSimpleColor(components);
 }
 
 }
 
-bool CanvasStyle::isEquivalentCMYKA(float c, float m, float y, float k, float a) const
+bool CanvasStyle::isEquivalent(const CMYKA<float>& components) const
 {
 {
-    if (!WTF::holds_alternative<CMYKAColor>(m_style))
-        return false;
-
-    auto& channels = WTF::get<CMYKAColor>(m_style);
-    return c == channels.c && m == channels.m && y == channels.y && k == channels.k && a == channels.a;
+    return WTF::holds_alternative<CMYKAColor>(m_style) && WTF::get<CMYKAColor>(m_style).components == components;
 }
 
 void CanvasStyle::applyStrokeColor(GraphicsContext& context) const
 }
 
 void CanvasStyle::applyStrokeColor(GraphicsContext& context) const
@@ -184,9 +172,9 @@ void CanvasStyle::applyStrokeColor(GraphicsContext& context) const
             // FIXME: Do this through platform-independent GraphicsContext API.
             // We'll need a fancier Color abstraction to support CMYKA correctly
 #if USE(CG)
             // FIXME: Do this through platform-independent GraphicsContext API.
             // We'll need a fancier Color abstraction to support CMYKA correctly
 #if USE(CG)
-            CGContextSetCMYKStrokeColor(context.platformContext(), color.c, color.m, color.y, color.k, color.a);
+            CGContextSetCMYKStrokeColor(context.platformContext(), color.components.cyan, color.components.magenta, color.components.yellow, color.components.black, color.components.alpha);
 #else
 #else
-            context.setStrokeColor(color.color);
+            context.setStrokeColor(color.colorConvertedToSRGBA);
 #endif
         },
         [&context] (const RefPtr<CanvasGradient>& gradient) {
 #endif
         },
         [&context] (const RefPtr<CanvasGradient>& gradient) {
@@ -214,9 +202,9 @@ void CanvasStyle::applyFillColor(GraphicsContext& context) const
             // FIXME: Do this through platform-independent GraphicsContext API.
             // We'll need a fancier Color abstraction to support CMYKA correctly
 #if USE(CG)
             // FIXME: Do this through platform-independent GraphicsContext API.
             // We'll need a fancier Color abstraction to support CMYKA correctly
 #if USE(CG)
-            CGContextSetCMYKFillColor(context.platformContext(), color.c, color.m, color.y, color.k, color.a);
+            CGContextSetCMYKFillColor(context.platformContext(), color.components.cyan, color.components.magenta, color.components.yellow, color.components.black, color.components.alpha);
 #else
 #else
-            context.setFillColor(color.color);
+            context.setFillColor(color.colorConvertedToSRGBA);
 #endif
         },
         [&context] (const RefPtr<CanvasGradient>& gradient) {
 #endif
         },
         [&context] (const RefPtr<CanvasGradient>& gradient) {
index 0b52712..685fc72 100644 (file)
@@ -41,9 +41,8 @@ class CanvasStyle {
 public:
     CanvasStyle();
     CanvasStyle(Color);
 public:
     CanvasStyle();
     CanvasStyle(Color);
-    CanvasStyle(float grayLevel, float alpha);
-    CanvasStyle(float r, float g, float b, float alpha);
-    CanvasStyle(float c, float m, float y, float k, float alpha);
+    CanvasStyle(const SRGBA<float>&);
+    CanvasStyle(const CMYKA<float>&);
     CanvasStyle(CanvasGradient&);
     CanvasStyle(CanvasPattern&);
 
     CanvasStyle(CanvasGradient&);
     CanvasStyle(CanvasPattern&);
 
@@ -53,7 +52,6 @@ public:
     bool isValid() const { return !WTF::holds_alternative<Invalid>(m_style); }
     bool isCurrentColor() const { return WTF::holds_alternative<CurrentColor>(m_style); }
     Optional<float> overrideAlpha() const { return WTF::get<CurrentColor>(m_style).overrideAlpha; }
     bool isValid() const { return !WTF::holds_alternative<Invalid>(m_style); }
     bool isCurrentColor() const { return WTF::holds_alternative<CurrentColor>(m_style); }
     Optional<float> overrideAlpha() const { return WTF::get<CurrentColor>(m_style).overrideAlpha; }
-    
 
     String color() const;
     RefPtr<CanvasGradient> canvasGradient() const;
 
     String color() const;
     RefPtr<CanvasGradient> canvasGradient() const;
@@ -63,21 +61,15 @@ public:
     void applyStrokeColor(GraphicsContext&) const;
 
     bool isEquivalentColor(const CanvasStyle&) const;
     void applyStrokeColor(GraphicsContext&) const;
 
     bool isEquivalentColor(const CanvasStyle&) const;
-    bool isEquivalentRGBA(float red, float green, float blue, float alpha) const;
-    bool isEquivalentCMYKA(float cyan, float magenta, float yellow, float black, float alpha) const;
+    bool isEquivalent(const SRGBA<float>&) const;
+    bool isEquivalent(const CMYKA<float>&) const;
 
 private:
     struct Invalid { };
 
     struct CMYKAColor {
 
 private:
     struct Invalid { };
 
     struct CMYKAColor {
-        Color color;
-        float c { 0 };
-        float m { 0 };
-        float y { 0 };
-        float k { 0 };
-        float a { 0 };
-
-        CMYKAColor(const CMYKAColor&) = default;
+        Color colorConvertedToSRGBA;
+        CMYKA<float> components;
     };
 
     struct CurrentColor {
     };
 
     struct CurrentColor {
@@ -116,7 +108,7 @@ inline RefPtr<CanvasPattern> CanvasStyle::canvasPattern() const
 
 inline String CanvasStyle::color() const
 {
 
 inline String CanvasStyle::color() const
 {
-    auto& color = WTF::holds_alternative<Color>(m_style) ? WTF::get<Color>(m_style) : WTF::get<CMYKAColor>(m_style).color;
+    auto& color = WTF::holds_alternative<Color>(m_style) ? WTF::get<Color>(m_style) : WTF::get<CMYKAColor>(m_style).colorConvertedToSRGBA;
     return color.serialized();
 }
 
     return color.serialized();
 }
 
index 9f42b77..afb71da 100644 (file)
@@ -82,7 +82,7 @@ public:
 
 private:
     explicit MouseWheelRegionOverlay(Page& page)
 
 private:
     explicit MouseWheelRegionOverlay(Page& page)
-        : RegionOverlay(page, makeSimpleColorFromFloats(0.5f, 0.0f, 0.0f, 0.4f))
+        : RegionOverlay(page, makeSimpleColor(128, 0, 0, 102))
     {
     }
 
     {
     }
 
@@ -118,7 +118,7 @@ public:
 
 private:
     explicit NonFastScrollableRegionOverlay(Page& page)
 
 private:
     explicit NonFastScrollableRegionOverlay(Page& page)
-        : RegionOverlay(page, makeSimpleColorFromFloats(1.0f, 0.5f, 0.0f, 0.4f))
+        : RegionOverlay(page, makeSimpleColor(255, 128, 0, 102))
     {
     }
 
     {
     }
 
index 432331a..c7eaa32 100644 (file)
@@ -88,8 +88,8 @@ private:
     void paintContents(const GraphicsLayer*, GraphicsContext& context, const FloatRect& clip, GraphicsLayerPaintBehavior) override
     {
         GraphicsContextStateSaver stateSaver(context);
     void paintContents(const GraphicsLayer*, GraphicsContext& context, const FloatRect& clip, GraphicsLayerPaintBehavior) override
     {
         GraphicsContextStateSaver stateSaver(context);
-        context.fillRect(clip, makeSimpleColorFromFloats(0.0f, 0.0f, 0.0f, 0.8f));
-        context.setFillColor(makeSimpleColorFromFloats(0.9f, 0.9f, 0.9f, 1.f));
+        context.fillRect(clip, makeSimpleColor(0, 0, 0, 204));
+        context.setFillColor(makeSimpleColor(230, 230, 230, 255));
 
         FloatPoint position = { 10, 20 };
         String string =  "CPU: " + cpuUsageString(gData.cpu);
 
         FloatPoint position = { 10, 20 };
         String string =  "CPU: " + cpuUsageString(gData.cpu);
@@ -137,7 +137,7 @@ void ResourceUsageOverlay::platformInitialize()
     m_paintLayer = GraphicsLayer::create(overlay().page()->chrome().client().graphicsLayerFactory(), *m_overlayPainter);
     m_paintLayer->setAnchorPoint(FloatPoint3D());
     m_paintLayer->setSize({ normalWidth, normalHeight });
     m_paintLayer = GraphicsLayer::create(overlay().page()->chrome().client().graphicsLayerFactory(), *m_overlayPainter);
     m_paintLayer->setAnchorPoint(FloatPoint3D());
     m_paintLayer->setSize({ normalWidth, normalHeight });
-    m_paintLayer->setBackgroundColor(makeSimpleColorFromFloats(0.0f, 0.0f, 0.0f, 0.8f));
+    m_paintLayer->setBackgroundColor(makeSimpleColor(0, 0, 0, 204));
     m_paintLayer->setDrawsContent(true);
     overlay().layer().addChild(*m_paintLayer);
 
     m_paintLayer->setDrawsContent(true);
     overlay().layer().addChild(*m_paintLayer);
 
index ff5f1e5..f5c35c5 100644 (file)
@@ -114,7 +114,7 @@ Color Color::lightened() const
 
     float multiplier = std::min(1.0f, v + 0.33f) / v;
 
 
     float multiplier = std::min(1.0f, v + 0.33f) / v;
 
-    return makeSimpleColorFromFloats(multiplier * r, multiplier * g, multiplier * b, a);
+    return makeSimpleColor(SRGBA { multiplier * r, multiplier * g, multiplier * b, a });
 }
 
 Color Color::darkened() const
 }
 
 Color Color::darkened() const
@@ -128,7 +128,7 @@ Color Color::darkened() const
     float v = std::max({ r, g, b });
     float multiplier = std::max(0.0f, (v - 0.33f) / v);
 
     float v = std::max({ r, g, b });
     float multiplier = std::max(0.0f, (v - 0.33f) / v);
 
-    return makeSimpleColorFromFloats(multiplier * r, multiplier * g, multiplier * b, a);
+    return makeSimpleColor(SRGBA { multiplier * r, multiplier * g, multiplier * b, a });
 }
 
 bool Color::isDark() const
 }
 
 bool Color::isDark() const
@@ -147,7 +147,8 @@ float Color::lightness() const
 
 float Color::luminance() const
 {
 
 float Color::luminance() const
 {
-    // FIXME: This can probably avoid conversion to sRGB by having per-colorspace algorithms for luminance (e.g. convertToXYZ(c).yComponent()).
+    // FIXME: This can probably avoid conversion to sRGB by having per-colorspace algorithms
+    // for luminance (e.g. convertToXYZ(c).yComponent()).
     return WebCore::luminance(toSRGBALossy());
 }
 
     return WebCore::luminance(toSRGBALossy());
 }
 
@@ -290,7 +291,7 @@ Color blendWithoutPremultiply(const Color& from, const Color& to, double progres
     auto fromSRGB = from.toSRGBASimpleColorLossy();
     auto toSRGB = from.toSRGBASimpleColorLossy();
 
     auto fromSRGB = from.toSRGBASimpleColorLossy();
     auto toSRGB = from.toSRGBASimpleColorLossy();
 
-    return makeSimpleColorFromFloats(
+    return makeSimpleColor(
         WebCore::blend(fromSRGB.redComponent(), toSRGB.redComponent(), progress),
         WebCore::blend(fromSRGB.greenComponent(), toSRGB.greenComponent(), progress),
         WebCore::blend(fromSRGB.blueComponent(), toSRGB.blueComponent(), progress),
         WebCore::blend(fromSRGB.redComponent(), toSRGB.redComponent(), progress),
         WebCore::blend(fromSRGB.greenComponent(), toSRGB.greenComponent(), progress),
         WebCore::blend(fromSRGB.blueComponent(), toSRGB.blueComponent(), progress),
index bd73dff..2625478 100644 (file)
@@ -36,6 +36,8 @@ template<typename T> struct SRGBA {
     T alpha;
 };
 
     T alpha;
 };
 
+template<typename T> SRGBA(T, T, T, T) -> SRGBA<T>;
+
 template<typename T> constexpr ColorComponents<T> asColorComponents(const SRGBA<T>& c)
 {
     return { c.red, c.green, c.blue, c.alpha };
 template<typename T> constexpr ColorComponents<T> asColorComponents(const SRGBA<T>& c)
 {
     return { c.red, c.green, c.blue, c.alpha };
@@ -46,6 +48,16 @@ template<typename T> constexpr SRGBA<T> asSRGBA(const ColorComponents<T>& c)
     return { c[0], c[1], c[2], c[3] };
 }
 
     return { c[0], c[1], c[2], c[3] };
 }
 
+template<typename T> constexpr bool operator==(const SRGBA<T>& a, const SRGBA<T>& b)
+{
+    return asColorComponents(a) == asColorComponents(b);
+}
+
+template<typename T> constexpr bool operator!=(const SRGBA<T>& a, const SRGBA<T>& b)
+{
+    return !(a == b);
+}
+
 template<typename T, typename Functor> void forEachNonAlphaComponent(SRGBA<T>& color, Functor&& f)
 {
     color.red = f(color.red);
 template<typename T, typename Functor> void forEachNonAlphaComponent(SRGBA<T>& color, Functor&& f)
 {
     color.red = f(color.red);
@@ -53,6 +65,7 @@ template<typename T, typename Functor> void forEachNonAlphaComponent(SRGBA<T>& c
     color.blue = f(color.blue);
 }
 
     color.blue = f(color.blue);
 }
 
+
 template<typename T> struct LinearSRGBA {
     T red;
     T green;
 template<typename T> struct LinearSRGBA {
     T red;
     T green;
@@ -60,6 +73,8 @@ template<typename T> struct LinearSRGBA {
     T alpha;
 };
 
     T alpha;
 };
 
+template<typename T> LinearSRGBA(T, T, T, T) -> LinearSRGBA<T>;
+
 template<typename T> constexpr ColorComponents<T> asColorComponents(const LinearSRGBA<T>& c)
 {
     return { c.red, c.green, c.blue, c.alpha };
 template<typename T> constexpr ColorComponents<T> asColorComponents(const LinearSRGBA<T>& c)
 {
     return { c.red, c.green, c.blue, c.alpha };
@@ -70,6 +85,17 @@ template<typename T> constexpr LinearSRGBA<T> asLinearSRGBA(const ColorComponent
     return { c[0], c[1], c[2], c[3] };
 }
 
     return { c[0], c[1], c[2], c[3] };
 }
 
+template<typename T> constexpr bool operator==(const LinearSRGBA<T>& a, const LinearSRGBA<T>& b)
+{
+    return asColorComponents(a) == asColorComponents(b);
+}
+
+template<typename T> constexpr bool operator!=(const LinearSRGBA<T>& a, const LinearSRGBA<T>& b)
+{
+    return !(a == b);
+}
+
+
 template<typename T> struct DisplayP3 {
     T red;
     T green;
 template<typename T> struct DisplayP3 {
     T red;
     T green;
@@ -77,6 +103,8 @@ template<typename T> struct DisplayP3 {
     T alpha;
 };
 
     T alpha;
 };
 
+template<typename T> DisplayP3(T, T, T, T) -> DisplayP3<T>;
+
 template<typename T> constexpr ColorComponents<T> asColorComponents(const DisplayP3<T>& c)
 {
     return { c.red, c.green, c.blue, c.alpha };
 template<typename T> constexpr ColorComponents<T> asColorComponents(const DisplayP3<T>& c)
 {
     return { c.red, c.green, c.blue, c.alpha };
@@ -87,6 +115,17 @@ template<typename T> constexpr DisplayP3<T> asDisplayP3(const ColorComponents<T>
     return { c[0], c[1], c[2], c[3] };
 }
 
     return { c[0], c[1], c[2], c[3] };
 }
 
+template<typename T> constexpr bool operator==(const DisplayP3<T>& a, const DisplayP3<T>& b)
+{
+    return asColorComponents(a) == asColorComponents(b);
+}
+
+template<typename T> constexpr bool operator!=(const DisplayP3<T>& a, const DisplayP3<T>& b)
+{
+    return !(a == b);
+}
+
+
 template<typename T> struct LinearDisplayP3 {
     T red;
     T green;
 template<typename T> struct LinearDisplayP3 {
     T red;
     T green;
@@ -94,6 +133,8 @@ template<typename T> struct LinearDisplayP3 {
     T alpha;
 };
 
     T alpha;
 };
 
+template<typename T> LinearDisplayP3(T, T, T, T) -> LinearDisplayP3<T>;
+
 template<typename T> constexpr ColorComponents<T> asColorComponents(const LinearDisplayP3<T>& c)
 {
     return { c.red, c.green, c.blue, c.alpha };
 template<typename T> constexpr ColorComponents<T> asColorComponents(const LinearDisplayP3<T>& c)
 {
     return { c.red, c.green, c.blue, c.alpha };
@@ -104,6 +145,17 @@ template<typename T> constexpr LinearDisplayP3<T> asLinearDisplayP3(const ColorC
     return { c[0], c[1], c[2], c[3] };
 }
 
     return { c[0], c[1], c[2], c[3] };
 }
 
+template<typename T> constexpr bool operator==(const LinearDisplayP3<T>& a, const LinearDisplayP3<T>& b)
+{
+    return asColorComponents(a) == asColorComponents(b);
+}
+
+template<typename T> constexpr bool operator!=(const LinearDisplayP3<T>& a, const LinearDisplayP3<T>& b)
+{
+    return !(a == b);
+}
+
+
 template<typename T> struct HSLA {
     T hue;
     T saturation;
 template<typename T> struct HSLA {
     T hue;
     T saturation;
@@ -111,6 +163,8 @@ template<typename T> struct HSLA {
     T alpha;
 };
 
     T alpha;
 };
 
+template<typename T> HSLA(T, T, T, T) -> HSLA<T>;
+
 template<typename T> constexpr ColorComponents<T> asColorComponents(const HSLA<T>& c)
 {
     return { c.hue, c.saturation, c.lightness, c.alpha };
 template<typename T> constexpr ColorComponents<T> asColorComponents(const HSLA<T>& c)
 {
     return { c.hue, c.saturation, c.lightness, c.alpha };
@@ -121,6 +175,39 @@ template<typename T> constexpr HSLA<T> asHSLA(const ColorComponents<T>& c)
     return { c[0], c[1], c[2], c[3] };
 }
 
     return { c[0], c[1], c[2], c[3] };
 }
 
+template<typename T> constexpr bool operator==(const HSLA<T>& a, const HSLA<T>& b)
+{
+    return asColorComponents(a) == asColorComponents(b);
+}
+
+template<typename T> constexpr bool operator!=(const HSLA<T>& a, const HSLA<T>& b)
+{
+    return !(a == b);
+}
+
+
+// FIXME: When ColorComponents supports more than length == 4, add conversion to/from ColorComponents<T> for CMYKA
+template<typename T> struct CMYKA {
+    T cyan;
+    T magenta;
+    T yellow;
+    T black;
+    T alpha;
+};
+
+template<typename T> CMYKA(T, T, T, T, T) -> CMYKA<T>;
+
+template<typename T> constexpr bool operator==(const CMYKA<T>& a, const CMYKA<T>& b)
+{
+    return a.cyan == b.cyan && a.magenta == b.magenta && a.yellow == b.yellow && a.black == b.black && a.alpha == b.alpha;
+}
+
+template<typename T> constexpr bool operator!=(const CMYKA<T>& a, const CMYKA<T>& b)
+{
+    return !(a == b);
+}
+
+
 template<typename T> struct XYZA {
     T x;
     T y;
 template<typename T> struct XYZA {
     T x;
     T y;
@@ -128,6 +215,8 @@ template<typename T> struct XYZA {
     T alpha;
 };
 
     T alpha;
 };
 
+template<typename T> XYZA(T, T, T, T) -> XYZA<T>;
+
 template<typename T> constexpr ColorComponents<T> asColorComponents(const XYZA<T>& c)
 {
     return { c.x, c.y, c.z, c.alpha };
 template<typename T> constexpr ColorComponents<T> asColorComponents(const XYZA<T>& c)
 {
     return { c.x, c.y, c.z, c.alpha };
@@ -138,4 +227,14 @@ template<typename T> constexpr XYZA<T> asXYZA(const ColorComponents<T>& c)
     return { c[0], c[1], c[2], c[3] };
 }
 
     return { c[0], c[1], c[2], c[3] };
 }
 
+template<typename T> constexpr bool operator==(const XYZA<T>& a, const XYZA<T>& b)
+{
+    return asColorComponents(a) == asColorComponents(b);
+}
+
+template<typename T> constexpr bool operator!=(const XYZA<T>& a, const XYZA<T>& b)
+{
+    return !(a == b);
+}
+
 } // namespace WebCore
 } // namespace WebCore
index 36a5a15..f3eea43 100644 (file)
@@ -259,6 +259,16 @@ SRGBA<float> toSRGBA(const HSLA<float>& color)
     };
 }
 
     };
 }
 
+SRGBA<float> toSRGBA(const CMYKA<float>& color)
+{
+    auto [c, m, y, k, a] = color;
+    float colors = 1 - k;
+    float r = colors * (1.0f - c);
+    float g = colors * (1.0f - m);
+    float b = colors * (1.0f - y);
+    return { r, g, b, a };
+}
+
 SRGBA<float> premultiplied(const SRGBA<float>& color)
 {
     auto [r, g, b, a] = color;
 SRGBA<float> premultiplied(const SRGBA<float>& color)
 {
     auto [r, g, b, a] = color;
index 224080a..7e789e6 100644 (file)
@@ -30,6 +30,7 @@
 
 namespace WebCore {
 
 
 namespace WebCore {
 
+template<typename> struct CMYKA;
 template<typename> struct DisplayP3;
 template<typename> struct HSLA;
 template<typename> struct LinearDisplayP3;
 template<typename> struct DisplayP3;
 template<typename> struct HSLA;
 template<typename> struct LinearDisplayP3;
@@ -52,21 +53,23 @@ DisplayP3<float> toDisplayP3(const SRGBA<float>&);
 WEBCORE_EXPORT HSLA<float> toHSLA(const SRGBA<float>&);
 WEBCORE_EXPORT SRGBA<float> toSRGBA(const HSLA<float>&);
 
 WEBCORE_EXPORT HSLA<float> toHSLA(const SRGBA<float>&);
 WEBCORE_EXPORT SRGBA<float> toSRGBA(const HSLA<float>&);
 
+SRGBA<float> toSRGBA(const CMYKA<float>&);
+
+
 float lightness(const SRGBA<float>&);
 float luminance(const SRGBA<float>&);
 float lightness(const SRGBA<float>&);
 float luminance(const SRGBA<float>&);
-
 float contrastRatio(const SRGBA<float>&, const SRGBA<float>&);
 
 SRGBA<float> premultiplied(const SRGBA<float>&);
 
 inline uint8_t convertPrescaledToComponentByte(float f)
 {
 float contrastRatio(const SRGBA<float>&, const SRGBA<float>&);
 
 SRGBA<float> premultiplied(const SRGBA<float>&);
 
 inline uint8_t convertPrescaledToComponentByte(float f)
 {
-    return std::clamp(static_cast<int>(std::lroundf(f)), 0, 255);
+    return std::clamp(std::lround(f), 0l, 255l);
 }
 
 inline uint8_t convertToComponentByte(float f)
 {
 }
 
 inline uint8_t convertToComponentByte(float f)
 {
-    return std::clamp(static_cast<int>(std::lroundf(f * 255.0f)), 0, 255);
+    return std::clamp(std::lround(f * 255.0f), 0l, 255l);
 }
 
 constexpr float convertToComponentFloat(uint8_t byte)
 }
 
 constexpr float convertToComponentFloat(uint8_t byte)
index ee29bb8..5c2b254 100644 (file)
@@ -62,15 +62,6 @@ SimpleColor unpremultiply(SimpleColor color)
     return makeSimpleColor(unpremultiplyChannel(r, a), unpremultiplyChannel(g, a), unpremultiplyChannel(b, a), a);
 }
 
     return makeSimpleColor(unpremultiplyChannel(r, a), unpremultiplyChannel(g, a), unpremultiplyChannel(b, a), a);
 }
 
-SimpleColor makeSimpleColorFromCMYKA(float c, float m, float y, float k, float a)
-{
-    float colors = 1 - k;
-    float r = colors * (1.0f - c);
-    float g = colors * (1.0f - m);
-    float b = colors * (1.0f - y);
-    return makeSimpleColorFromFloats(r, g, b, a);
-}
-
 String SimpleColor::serializationForHTML() const
 {
     if (isOpaque())
 String SimpleColor::serializationForHTML() const
 {
     if (isOpaque())
index 00c79bc..c1cf6dc 100644 (file)
@@ -91,10 +91,8 @@ bool operator!=(SimpleColor, SimpleColor);
 
 constexpr SimpleColor makeSimpleColor(int r, int g, int b);
 constexpr SimpleColor makeSimpleColor(int r, int g, int b, int a);
 
 constexpr SimpleColor makeSimpleColor(int r, int g, int b);
 constexpr SimpleColor makeSimpleColor(int r, int g, int b, int a);
-
-SimpleColor makeSimpleColor(const ColorComponents<float>& sRGBComponents);
-SimpleColor makeSimpleColorFromFloats(float r, float g, float b, float a);
-SimpleColor makeSimpleColorFromCMYKA(float c, float m, float y, float k, float a);
+constexpr SimpleColor makeSimpleColor(const SRGBA<uint8_t>&);
+SimpleColor makeSimpleColor(const SRGBA<float>&);
 
 SimpleColor premultiplyFlooring(SimpleColor);
 SimpleColor premultiplyCeiling(SimpleColor);
 
 SimpleColor premultiplyFlooring(SimpleColor);
 SimpleColor premultiplyCeiling(SimpleColor);
@@ -120,14 +118,15 @@ constexpr SimpleColor makeSimpleColor(int r, int g, int b, int a)
     return { static_cast<uint8_t>(std::clamp(r, 0, 0xFF)), static_cast<uint8_t>(std::clamp(g, 0, 0xFF)), static_cast<uint8_t>(std::clamp(b, 0, 0xFF)), static_cast<uint8_t>(std::clamp(a, 0, 0xFF)) };
 }
 
     return { static_cast<uint8_t>(std::clamp(r, 0, 0xFF)), static_cast<uint8_t>(std::clamp(g, 0, 0xFF)), static_cast<uint8_t>(std::clamp(b, 0, 0xFF)), static_cast<uint8_t>(std::clamp(a, 0, 0xFF)) };
 }
 
-inline SimpleColor makeSimpleColor(const SRGBA<float>& sRGBA)
+constexpr SimpleColor makeSimpleColor(const SRGBA<uint8_t>& sRGBA)
 {
     auto [r, g, b, a] = sRGBA;
 {
     auto [r, g, b, a] = sRGBA;
-    return makeSimpleColorFromFloats(r, g, b, a);
+    return { r, g, b, a };
 }
 
 }
 
-inline SimpleColor makeSimpleColorFromFloats(float r, float g, float b, float a)
+inline SimpleColor makeSimpleColor(const SRGBA<float>& sRGBA)
 {
 {
+    auto [r, g, b, a] = sRGBA;
     return { convertToComponentByte(r), convertToComponentByte(g), convertToComponentByte(b), convertToComponentByte(a) };
 }
 
     return { convertToComponentByte(r), convertToComponentByte(g), convertToComponentByte(b), convertToComponentByte(a) };
 }
 
index 692c639..e808157 100644 (file)
@@ -80,7 +80,7 @@ static Optional<SimpleColor> makeSimpleColorFromARGBCFArray(CFArrayRef colorArra
         componentArray[i] = component;
     }
 
         componentArray[i] = component;
     }
 
-    return makeSimpleColorFromFloats(componentArray[1], componentArray[2], componentArray[3], componentArray[0]);
+    return makeSimpleColor(SRGBA { componentArray[1], componentArray[2], componentArray[3], componentArray[0] });
 }
 
 Ref<InbandGenericCue> InbandTextTrackPrivateAVF::processCueAttributes(CFAttributedStringRef attributedString)
 }
 
 Ref<InbandGenericCue> InbandTextTrackPrivateAVF::processCueAttributes(CFAttributedStringRef attributedString)
index 1fe5c96..00e1599 100644 (file)
@@ -144,7 +144,7 @@ static Gradient::ColorStop interpolateColorStop(Gradient::ColorStop from, Gradie
     float b = b1 + (b2 - b1) * 0.5f;
     float a = a1 + (a2 - a1) * 0.5f;
 
     float b = b1 + (b2 - b1) * 0.5f;
     float a = a1 + (a2 - a1) * 0.5f;
 
-    return Gradient::ColorStop(offset, makeSimpleColorFromFloats(r, g, b, a));
+    return Gradient::ColorStop(offset, makeSimpleColor(SRGBA { r, g, b, a }));
 }
 
 static cairo_pattern_t* createConic(float xo, float yo, float r, float angleRadians,
 }
 
 static cairo_pattern_t* createConic(float xo, float yo, float r, float angleRadians,
index 7c11ebb..f08b4bd 100644 (file)
@@ -78,7 +78,7 @@ static SimpleColor makeSimpleColorFromCGColor(CGColorRef color)
         ASSERT_NOT_REACHED();
     }
 
         ASSERT_NOT_REACHED();
     }
 
-    return makeSimpleColorFromFloats(r, g, b, a);
+    return makeSimpleColor(SRGBA { r, g, b, a });
 }
 
 Color::Color(CGColorRef color)
 }
 
 Color::Color(CGColorRef color)
index 4c5f354..816b7da 100644 (file)
@@ -97,7 +97,7 @@ static SimpleColor makeSimpleColorFromNSColor(NSColor *color)
     [rgbColor getRed:&redComponent green:&greenComponent blue:&blueComponent alpha:&alpha];
     END_BLOCK_OBJC_EXCEPTIONS;
 
     [rgbColor getRed:&redComponent green:&greenComponent blue:&blueComponent alpha:&alpha];
     END_BLOCK_OBJC_EXCEPTIONS;
 
-    return makeSimpleColorFromFloats(redComponent, greenComponent, blueComponent, alpha);
+    return makeSimpleColor(SRGBA { static_cast<float>(redComponent), static_cast<float>(greenComponent), static_cast<float>(blueComponent), static_cast<float>(alpha) });
 }
 
 Color colorFromNSColor(NSColor *color)
 }
 
 Color colorFromNSColor(NSColor *color)
index 4d8c31d..f149ffc 100644 (file)
@@ -132,7 +132,7 @@ void PlatformContextDirect2D::setActiveLayer(COMPtr<ID2D1Layer>&& layer)
 
 COMPtr<ID2D1SolidColorBrush> PlatformContextDirect2D::brushWithColor(const D2D1_COLOR_F& color)
 {
 
 COMPtr<ID2D1SolidColorBrush> PlatformContextDirect2D::brushWithColor(const D2D1_COLOR_F& color)
 {
-    SimpleColor colorKey = makeSimpleColorFromFloats(color.r, color.g, color.b, color.a);
+    auto colorKey = makeSimpleColor(SRGBA { color.r, color.g, color.b, color.a });
 
     if (!colorKey) {
         if (!m_zeroBrush)
 
     if (!colorKey) {
         if (!m_zeroBrush)
index 474704a..cfc3bc3 100644 (file)
@@ -47,7 +47,7 @@ Color colorFromUIColor(UIColor *color)
 
     [color getRed:&redComponent green:&greenComponent blue:&blueComponent alpha:&alpha];
 
 
     [color getRed:&redComponent green:&greenComponent blue:&blueComponent alpha:&alpha];
 
-    return makeSimpleColorFromFloats(redComponent, greenComponent, blueComponent, alpha);
+    return makeSimpleColor(SRGBA { static_cast<float>(redComponent), static_cast<float>(greenComponent), static_cast<float>(blueComponent), static_cast<float>(alpha) });
 }
 
 } // namespace WebCore
 }
 
 } // namespace WebCore
index 276db8e..f2597ec 100644 (file)
@@ -462,9 +462,8 @@ unsigned LegacyTileCache::tileCapacityForGrid(LegacyTileGrid* grid)
 Color LegacyTileCache::colorForGridTileBorder(LegacyTileGrid* grid) const
 {
     if (grid == m_zoomedOutTileGrid.get())
 Color LegacyTileCache::colorForGridTileBorder(LegacyTileGrid* grid) const
 {
     if (grid == m_zoomedOutTileGrid.get())
-        return makeSimpleColorFromFloats(0.2f, 1.0f, 0.f, 0.5f);
-
-    return makeSimpleColorFromFloats(0.2f, 0.9f, 0.f, 0.5f);
+        return makeSimpleColor(51, 255, 0, 128);
+    return makeSimpleColor(51, 230, 0, 128);
 }
 
 static bool shouldRepaintInPieces(const CGRect& dirtyRect, CGSRegionObj dirtyRegion, CGFloat contentsScale)
 }
 
 static bool shouldRepaintInPieces(const CGRect& dirtyRect, CGSRegionObj dirtyRegion, CGFloat contentsScale)
index 66c2b90..ec0ef54 100644 (file)
@@ -2218,7 +2218,7 @@ void RenderLayer::beginTransparencyLayers(GraphicsContext& context, const LayerP
 #endif
 
 #ifdef REVEAL_TRANSPARENCY_LAYERS
 #endif
 
 #ifdef REVEAL_TRANSPARENCY_LAYERS
-        context.setFillColor(makeSimpleColorFromFloats(0.0f, 0.0f, 0.5f, 0.2f));
+        context.setFillColor(makeSimpleColor(0, 0, 128, 51));
         context.fillRect(pixelSnappedClipRect);
 #endif
     }
         context.fillRect(pixelSnappedClipRect);
 #endif
     }
index d11e378..e6735f7 100644 (file)
@@ -380,7 +380,7 @@ bool RenderThemeIOS::paintCheckboxDecorations(const RenderObject& box, const Pai
 
     if (checked || indeterminate) {
         auto border = box.style().getRoundedBorderFor(rect);
 
     if (checked || indeterminate) {
         auto border = box.style().getRoundedBorderFor(rect);
-        paintInfo.context().fillRoundedRect(border.pixelSnappedRoundedRectForPainting(box.document().deviceScaleFactor()), makeSimpleColorFromFloats(0.0f, 0.0f, 0.0f, 0.8f));
+        paintInfo.context().fillRoundedRect(border.pixelSnappedRoundedRectForPainting(box.document().deviceScaleFactor()), Color::black.colorWithAlpha(204));
 
         auto clip = addRoundedBorderClip(box, paintInfo.context(), rect);
         auto width = clip.width();
 
         auto clip = addRoundedBorderClip(box, paintInfo.context(), rect);
         auto width = clip.width();
@@ -416,10 +416,10 @@ bool RenderThemeIOS::paintCheckboxDecorations(const RenderObject& box, const Pai
         }
 
         lineWidth = std::max<float>(lineWidth, 1);
         }
 
         lineWidth = std::max<float>(lineWidth, 1);
-        drawJoinedLines(cgContext, Vector<CGPoint> { WTFMove(shadow) }, kCGLineCapSquare, lineWidth, makeSimpleColorFromFloats(0.0f, 0.0f, 0.0f, 0.7f));
+        drawJoinedLines(cgContext, Vector<CGPoint> { WTFMove(shadow) }, kCGLineCapSquare, lineWidth, Color::black.colorWithAlpha(179));
 
         lineWidth = std::max<float>(std::min(width, height) * thicknessRatio, 1);
 
         lineWidth = std::max<float>(std::min(width, height) * thicknessRatio, 1);
-        drawJoinedLines(cgContext, Vector<CGPoint> { WTFMove(line) }, kCGLineCapButt, lineWidth, makeSimpleColorFromFloats(1.0f, 1.0f, 1.0f, 240 / 255.0f));
+        drawJoinedLines(cgContext, Vector<CGPoint> { WTFMove(line) }, kCGLineCapButt, lineWidth, Color::white.colorWithAlpha(240));
     } else {
         auto clip = addRoundedBorderClip(box, paintInfo.context(), rect);
         auto width = clip.width();
     } else {
         auto clip = addRoundedBorderClip(box, paintInfo.context(), rect);
         auto width = clip.width();
@@ -477,7 +477,7 @@ bool RenderThemeIOS::paintRadioDecorations(const RenderObject& box, const PaintI
 
     if (isChecked(box)) {
         auto border = box.style().getRoundedBorderFor(rect);
 
     if (isChecked(box)) {
         auto border = box.style().getRoundedBorderFor(rect);
-        paintInfo.context().fillRoundedRect(border.pixelSnappedRoundedRectForPainting(box.document().deviceScaleFactor()), makeSimpleColorFromFloats(0.0f, 0.0f, 0.0f, 0.8f));
+        paintInfo.context().fillRoundedRect(border.pixelSnappedRoundedRectForPainting(box.document().deviceScaleFactor()), Color::black.colorWithAlpha(204));
 
         auto clip = addRoundedBorderClip(box, paintInfo.context(), rect);
         drawAxialGradient(cgContext, gradientWithName(ConcaveGradient), clip.location(), FloatPoint(clip.x(), clip.maxY()), LinearInterpolation);
 
         auto clip = addRoundedBorderClip(box, paintInfo.context(), rect);
         drawAxialGradient(cgContext, gradientWithName(ConcaveGradient), clip.location(), FloatPoint(clip.x(), clip.maxY()), LinearInterpolation);
@@ -490,7 +490,7 @@ bool RenderThemeIOS::paintRadioDecorations(const RenderObject& box, const PaintI
         clip.inflateX(-clip.width() * InnerInverseRatio);
         clip.inflateY(-clip.height() * InnerInverseRatio);
         
         clip.inflateX(-clip.width() * InnerInverseRatio);
         clip.inflateY(-clip.height() * InnerInverseRatio);
         
-        constexpr auto shadowColor = makeSimpleColor(0, 0, 0, 0.7f * 255);
+        constexpr auto shadowColor = Color::black.colorWithAlpha(179);
         paintInfo.context().drawRaisedEllipse(clip, Color::white, shadowColor);
 
         FloatSize radius(clip.width() / 2.0f, clip.height() / 2.0f);
         paintInfo.context().drawRaisedEllipse(clip, Color::white, shadowColor);
 
         FloatSize radius(clip.width() / 2.0f, clip.height() / 2.0f);
@@ -738,7 +738,7 @@ bool RenderThemeIOS::paintMenuListButtonDecorations(const RenderBox& box, const
         FloatRect ellipse(buttonClip.x() + (buttonClip.width() - count * (size + padding) + padding) / 2.0, buttonClip.maxY() - 10.0, size, size);
 
         for (int i = 0; i < count; ++i) {
         FloatRect ellipse(buttonClip.x() + (buttonClip.width() - count * (size + padding) + padding) / 2.0, buttonClip.maxY() - 10.0, size, size);
 
         for (int i = 0; i < count; ++i) {
-            paintInfo.context().drawRaisedEllipse(ellipse, Color::white, makeSimpleColorFromFloats(0.0f, 0.0f, 0.0f, 0.5f));
+            paintInfo.context().drawRaisedEllipse(ellipse, Color::white, Color::black.colorWithAlpha(128));
             ellipse.move(size + padding, 0);
         }
     }  else {
             ellipse.move(size + padding, 0);
         }
     }  else {
@@ -757,9 +757,9 @@ bool RenderThemeIOS::paintMenuListButtonDecorations(const RenderBox& box, const
             { arrow[2].x(), arrow[2].y() + 1 }
         };
 
             { arrow[2].x(), arrow[2].y() + 1 }
         };
 
-        float opacity = isReadOnlyControl(box) ? 0.2 : 0.5;
-        paintInfo.context().setStrokeColor(makeSimpleColorFromFloats(0.0f, 0.0f, 0.0f, opacity));
-        paintInfo.context().setFillColor(makeSimpleColorFromFloats(0.0f, 0.0f, 0.0f, opacity));
+        uint8_t opacity = isReadOnlyControl(box) ? 51 : 128;
+        paintInfo.context().setStrokeColor(Color::black.colorWithAlpha(opacity));
+        paintInfo.context().setFillColor(Color::black.colorWithAlpha(opacity));
         paintInfo.context().drawPath(Path::polygonPathFromPoints(shadow));
 
         paintInfo.context().setStrokeColor(Color::white);
         paintInfo.context().drawPath(Path::polygonPathFromPoints(shadow));
 
         paintInfo.context().setStrokeColor(Color::white);
@@ -1840,7 +1840,7 @@ void RenderThemeIOS::paintSystemPreviewBadge(Image& image, const PaintInfo& pain
     // Draw a drop shadow around the circle.
     // Use the GraphicsContext function, because it calculates the blur radius in context space,
     // rather than screen space.
     // Draw a drop shadow around the circle.
     // Use the GraphicsContext function, because it calculates the blur radius in context space,
     // rather than screen space.
-    auto shadowColor = makeSimpleColorFromFloats(0.f, 0.f, 0.f, 0.1f);
+    constexpr auto shadowColor = Color::black.colorWithAlpha(26);
     graphicsContext.setShadow(FloatSize { }, 16, shadowColor);
 
     // The circle must have an alpha channel value of 1 for the shadow color to appear.
     graphicsContext.setShadow(FloatSize { }, 16, shadowColor);
 
     // The circle must have an alpha channel value of 1 for the shadow color to appear.
index eca4091..db8c3d5 100644 (file)
@@ -1,3 +1,21 @@
+2020-06-29  Sam Weinig  <weinig@apple.com>
+
+        Remove remaining makeSimpleColorFrom* variants
+        https://bugs.webkit.org/show_bug.cgi?id=213706
+
+        Reviewed by Darin Adler.
+
+        * UIProcess/API/wpe/WebKitColor.cpp:
+        (webkitColorToWebCoreColor):
+        Use makeSimpleColor(SRGBA { ... }) rather than makeSimpleColorFromFloats.
+
+        * WebProcess/Inspector/WebInspectorClient.cpp:
+        (WebKit::WebInspectorClient::showPaintRect):
+        * WebProcess/WebPage/FindController.cpp:
+        (WebKit::FindController::drawRect):
+        Use makeSimpleColor rather than makeSimpleColorFromFloats, allowing for
+        constant expression creation of SimpleColors.
+
 2020-06-29  Youenn Fablet  <youenn@apple.com>
 
         Send WebRTC packets received from network process to web process from a background thread
 2020-06-29  Youenn Fablet  <youenn@apple.com>
 
         Send WebRTC packets received from network process to web process from a background thread
index 0c0a37d..9d8059a 100644 (file)
@@ -75,8 +75,7 @@ G_DEFINE_BOXED_TYPE(WebKitColor, webkit_color, webkit_color_copy, webkit_color_f
 
 const WebCore::Color webkitColorToWebCoreColor(WebKitColor* color)
 {
 
 const WebCore::Color webkitColorToWebCoreColor(WebKitColor* color)
 {
-    return WebCore::makeSimpleColorFromFloats(static_cast<float>(color->red), static_cast<float>(color->green),
-        static_cast<float>(color->blue), static_cast<float>(color->alpha));
+    return WebCore::makeSimpleColor(WebCore::SRGBA { static_cast<float>(color->red), static_cast<float>(color->green), static_cast<float>(color->blue), static_cast<float>(color->alpha) });
 }
 
 void webkitColorFillFromWebCoreColor(const WebCore::Color& webCoreColor, WebKitColor* color)
 }
 
 void webkitColorFillFromWebCoreColor(const WebCore::Color& webCoreColor, WebKitColor* color)
index c4fe42b..da183c9 100644 (file)
@@ -177,7 +177,7 @@ void WebInspectorClient::showPaintRect(const FloatRect& rect)
     paintLayer->setAnchorPoint(FloatPoint3D());
     paintLayer->setPosition(rect.location());
     paintLayer->setSize(rect.size());
     paintLayer->setAnchorPoint(FloatPoint3D());
     paintLayer->setPosition(rect.location());
     paintLayer->setSize(rect.size());
-    paintLayer->setBackgroundColor(makeSimpleColorFromFloats(1.0f, 0.0f, 0.0f, 0.2f));
+    paintLayer->setBackgroundColor(makeSimpleColor(255, 0, 0, 51));
 
     KeyframeValueList fadeKeyframes(AnimatedPropertyOpacity);
     fadeKeyframes.insert(makeUnique<FloatAnimationValue>(0, 1));
 
     KeyframeValueList fadeKeyframes(AnimatedPropertyOpacity);
     fadeKeyframes.insert(makeUnique<FloatAnimationValue>(0, 1));
index b533ae8..4bdae01 100644 (file)
@@ -509,8 +509,8 @@ void FindController::drawRect(PageOverlay&, GraphicsContext& graphicsContext, co
 {
     const int borderWidth = 1;
 
 {
     const int borderWidth = 1;
 
-    auto overlayBackgroundColor = makeSimpleColorFromFloats(0.1f, 0.1f, 0.1f, 0.25f);
-    auto shadowColor = makeSimpleColorFromFloats(0.0f, 0.0f, 0.0f, 0.5f);
+    constexpr auto overlayBackgroundColor = makeSimpleColor(26, 26, 26, 64);
+    constexpr auto shadowColor = makeSimpleColor(0, 0, 0, 128);
 
     IntRect borderInflatedDirtyRect = dirtyRect;
     borderInflatedDirtyRect.inflate(borderWidth);
 
     IntRect borderInflatedDirtyRect = dirtyRect;
     borderInflatedDirtyRect.inflate(borderWidth);