ChangeLog

2018-07-12  Antoine Quint  <graouts@apple.com>

        Dark Mode: document markers are difficult to see

        https://bugs.webkit.org/show_bug.cgi?id=187632

        <rdar://problem/41099719>

        Reviewed by NOBODY (OOPS!).

        We update the way we draw the document markers for macOS and use more constrasting colors in dark mode.

        Paving the way for future improvements, we move the drawLineForDocumentMarker() method from GraphicsContext

        to RenderTheme and implement a first version in RenderThemeMac. The circles used for the underline are now

        drawn directly with Core Graphics and we no longer use an image resource. To allow both GraphicsContext

        and RenderTheme to have different versions of the drawLineForDocumentMarker() method, the DocumentMarkerLineStyle

        enum is now an "enum class".

        * platform/graphics/GraphicsContext.h:

        * platform/graphics/GraphicsContextImpl.h:

        * platform/graphics/cairo/CairoOperations.cpp:

        (WebCore::Cairo::drawLineForDocumentMarker):

        * platform/graphics/cairo/CairoOperations.h:

        * platform/graphics/cairo/GraphicsContextImplCairo.cpp:

        (WebCore::GraphicsContextImplCairo::drawLineForDocumentMarker):

        * platform/graphics/cairo/GraphicsContextImplCairo.h:

        * platform/graphics/cocoa/GraphicsContextCocoa.mm:

        (WebCore::GraphicsContext::drawLineForDocumentMarker):

        * platform/graphics/displaylists/DisplayListItems.h:

        (WebCore::DisplayList::DrawLineForDocumentMarker::create):

        (WebCore::DisplayList::DrawLineForDocumentMarker::DrawLineForDocumentMarker):

        * platform/graphics/displaylists/DisplayListRecorder.cpp:

        (WebCore::DisplayList::Recorder::drawLineForDocumentMarker):

        * platform/graphics/displaylists/DisplayListRecorder.h:

        * platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp:

        (Nicosia::CairoOperationRecorder::drawLineForDocumentMarker):

        * platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h:

        * platform/graphics/win/GraphicsContextCGWin.cpp:

        (WebCore::GraphicsContext::drawLineForDocumentMarker):

        * rendering/InlineTextBox.cpp:

        (WebCore::InlineTextBox::paintPlatformDocumentMarker): Call drawLineForDocumentMarker() on the RenderTheme on

        macOS and on GraphicsContext in all other cases.

        * rendering/RenderTheme.cpp:

        (WebCore::RenderTheme::drawLineForDocumentMarker):

        * rendering/RenderTheme.h:

        * rendering/RenderThemeMac.h:

        * rendering/RenderThemeMac.mm:

        (WebCore::colorWithComponents):

        (WebCore::colorForStyle): Provide different colors for light and dark modes.

        (WebCore::RenderThemeMac::drawLineForDocumentMarker): A new macOS-specific version of drawLineForDocumentMarker()

        where we paint circles using Core Graphics directly.

2018-07-11  Antoine Quint  <graouts@apple.com>

        [Web Animations] Make WPT test at interfaces/KeyframeEffect/processing-a-keyframes-argument-001.html pass reliably

Source/WebCore/platform/graphics/GraphicsContext.h

@@enum StrokeStyle {

    WavyStroke,

};

enum class DocumentMarkerLineStyle {

    TextCheckingDictationPhraseWithAlternatives,

    Spelling,

    Grammar,

    AutocorrectionReplacement,

    DictationAlternatives

};

namespace DisplayList {

class Recorder;

}

@@public:

    FloatRect computeUnderlineBoundsForText(const FloatPoint&, float width, bool printing);

    WEBCORE_EXPORT void drawLineForText(const FloatPoint&, float width, bool printing, bool doubleLines = false, StrokeStyle = SolidStroke);

    void drawLinesForText(const FloatPoint&, const DashArray& widths, bool printing, bool doubleLines = false, StrokeStyle = SolidStroke);

    enum DocumentMarkerLineStyle {

#if PLATFORM(IOS)

        TextCheckingDictationPhraseWithAlternativesLineStyle,

#endif

        DocumentMarkerSpellingLineStyle,

        DocumentMarkerGrammarLineStyle,

        DocumentMarkerAutocorrectionReplacementLineStyle,

        DocumentMarkerDictationAlternativesLineStyle

    };

    static void updateDocumentMarkerResources();

    void drawLineForDocumentMarker(const FloatPoint&, float width, DocumentMarkerLineStyle);

Source/WebCore/platform/graphics/GraphicsContextImpl.h

@@public:

    virtual void drawRect(const FloatRect&, float borderThickness) = 0;

    virtual void drawLine(const FloatPoint&, const FloatPoint&) = 0;

    virtual void drawLinesForText(const FloatPoint&, const DashArray& widths, bool printing, bool doubleLines, float strokeThickness) = 0;

82 virtual void drawLineForDocumentMarker(const FloatPoint&, float width, ~~GraphicsContext::~~DocumentMarkerLineStyle) = 0;

82 virtual void drawLineForDocumentMarker(const FloatPoint&, float width, DocumentMarkerLineStyle) = 0;

    virtual void drawEllipse(const FloatRect&) = 0;

    virtual void drawPath(const Path&) = 0;

Source/WebCore/platform/graphics/cairo/CairoOperations.cpp

@@void drawLinesForText(PlatformContextCairo& platformContext, const FloatPoint& p

    cairo_restore(cr);

}

1052 void drawLineForDocumentMarker(PlatformContextCairo& platformContext, const FloatPoint& origin, float width, ~~GraphicsContext::~~DocumentMarkerLineStyle style)

1052void drawLineForDocumentMarker(PlatformContextCairo& platformContext, const FloatPoint& origin, float width, DocumentMarkerLineStyle style)

10531053{

1054 if (style != ~~GraphicsContext::~~DocumentMarker~~Spelling~~LineStyle

1055 && style != ~~GraphicsContext::~~DocumentMarker~~Grammar~~LineStyle)

1054 if (style != DocumentMarkerLineStyle::Spelling

1055 && style != DocumentMarkerLineStyle::Grammar)

        return;

    cairo_t* cr = platformContext.cr();

    cairo_save(cr);

1061 if (style == ~~GraphicsContext::~~DocumentMarker~~Spelling~~LineStyle)

1061 if (style == DocumentMarkerLineStyle::Spelling)

10621062 cairo_set_source_rgb(cr, 1, 0, 0);

1063 else if (style == ~~GraphicsContext::~~DocumentMarker~~Grammar~~LineStyle)

1063 else if (style == DocumentMarkerLineStyle::Grammar)

        cairo_set_source_rgb(cr, 0, 1, 0);

    drawErrorUnderline(cr, origin.x(), origin.y(), width, cMisspellingLineThickness);

Source/WebCore/platform/graphics/cairo/CairoOperations.h

@@WEBCORE_EXPORT void drawSurface(PlatformContextCairo&, cairo_surface_t*, const F

void drawRect(PlatformContextCairo&, const FloatRect&, float, const Color&, StrokeStyle, const Color&);

void drawLine(PlatformContextCairo&, const FloatPoint&, const FloatPoint&, StrokeStyle, const Color&, float, bool);

void drawLinesForText(PlatformContextCairo&, const FloatPoint&, const DashArray&, bool, bool, const Color&, float);

148 void drawLineForDocumentMarker(PlatformContextCairo&, const FloatPoint&, float, ~~GraphicsContext::~~DocumentMarkerLineStyle);

148void drawLineForDocumentMarker(PlatformContextCairo&, const FloatPoint&, float, DocumentMarkerLineStyle);

void drawEllipse(PlatformContextCairo&, const FloatRect&, const Color&, StrokeStyle, const Color&, float);

void drawFocusRing(PlatformContextCairo&, const Path&, float, const Color&);

Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp

@@void GraphicsContextImplCairo::drawLinesForText(const FloatPoint& point, const D

    Cairo::drawLinesForText(m_platformContext, point, widths, printing, doubleUnderlines, state.strokeColor, state.strokeThickness);

}

304 void GraphicsContextImplCairo::drawLineForDocumentMarker(const FloatPoint& origin, float width, ~~GraphicsContext::~~DocumentMarkerLineStyle style)

304void GraphicsContextImplCairo::drawLineForDocumentMarker(const FloatPoint& origin, float width, DocumentMarkerLineStyle style)

{

    Cairo::drawLineForDocumentMarker(m_platformContext, origin, width, style);

}

Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h

@@public:

    void drawRect(const FloatRect&, float) override;

    void drawLine(const FloatPoint&, const FloatPoint&) override;

    void drawLinesForText(const FloatPoint&, const DashArray&, bool, bool, float) override;

83 void drawLineForDocumentMarker(const FloatPoint&, float, ~~GraphicsContext::~~DocumentMarkerLineStyle) override;

83 void drawLineForDocumentMarker(const FloatPoint&, float, DocumentMarkerLineStyle) override;

    void drawEllipse(const FloatRect&) override;

    void drawPath(const Path&) override;

Source/WebCore/platform/graphics/cocoa/GraphicsContextCocoa.mm

@@void GraphicsContext::drawLineForDocumentMarker(const FloatPoint& point, float w

    CGPatternRef dotPattern;

#endif

    switch (style) {

248 case DocumentMarker~~Spelling~~LineStyle: {

248 case DocumentMarkerLineStyle::Spelling: {

        // Constants for spelling pattern color.

        static bool usingDotForSpelling = false;

#if !PLATFORM(IOS)

@@void GraphicsContext::drawLineForDocumentMarker(const FloatPoint& point, float w

        usingDot = usingDotForSpelling;

        break;

    }

263 case DocumentMarker~~Grammar~~LineStyle: {

263 case DocumentMarkerLineStyle::Grammar: {

#if !PLATFORM(IOS)

        // Constants for grammar pattern color.

        static bool usingDotForGrammar = false;

@@void GraphicsContext::drawLineForDocumentMarker(const FloatPoint& point, float w

    }

#if PLATFORM(MAC)

    // To support correction panel.

280 case DocumentMarkerAutocorrectionReplacement~~LineStyle~~:

281 case DocumentMarkerDictationAlternatives~~LineStyle~~: {

280 case DocumentMarkerLineStyle::AutocorrectionReplacement:

281 case DocumentMarkerLineStyle::DictationAlternatives: {

        // Constants for spelling pattern color.

        static bool usingDotForSpelling = false;

        if (!correctionImage)

@@void GraphicsContext::drawLineForDocumentMarker(const FloatPoint& point, float w

    }

#endif

#if PLATFORM(IOS)

293 case TextCheckingDictationPhraseWithAlternatives~~LineStyle~~: {

293 case DocumentMarkerLineStyle::TextCheckingDictationPhraseWithAlternatives: {

        static bool usingDotForDictationPhraseWithAlternatives = false;

        static CGPatternRef dictationPhraseWithAlternativesPattern = createDotPattern(usingDotForDictationPhraseWithAlternatives, "DictationPhraseWithAlternativesDot").leakRef();

        dotPattern = dictationPhraseWithAlternativesPattern;

Source/WebCore/platform/graphics/displaylists/DisplayListItems.h

@@private:

class DrawLineForDocumentMarker : public DrawingItem {

public:

833 static Ref<DrawLineForDocumentMarker> create(const FloatPoint& point, float width, ~~GraphicsContext::~~DocumentMarkerLineStyle style)

833 static Ref<DrawLineForDocumentMarker> create(const FloatPoint& point, float width, DocumentMarkerLineStyle style)

    {

        return adoptRef(*new DrawLineForDocumentMarker(point, width, style));

    }

@@public:

    float width() const { return m_width; }

private:

842 DrawLineForDocumentMarker(const FloatPoint& point, float width, ~~GraphicsContext::~~DocumentMarkerLineStyle style)

842 DrawLineForDocumentMarker(const FloatPoint& point, float width, DocumentMarkerLineStyle style)

        : DrawingItem(ItemType::DrawLineForDocumentMarker)

        , m_point(point)

        , m_width(width)

@@private:

    FloatPoint m_point;

    float m_width;

856 ~~GraphicsContext::~~DocumentMarkerLineStyle m_style;

856 DocumentMarkerLineStyle m_style;

};

class DrawEllipse : public DrawingItem {

Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp

@@void Recorder::drawLinesForText(const FloatPoint& point, const DashArray& widths

    updateItemExtent(newItem);

}

239 void Recorder::drawLineForDocumentMarker(const FloatPoint& point, float width, ~~GraphicsContext::~~DocumentMarkerLineStyle style)

239void Recorder::drawLineForDocumentMarker(const FloatPoint& point, float width, DocumentMarkerLineStyle style)

{

    DrawingItem& newItem = downcast<DrawingItem>(appendItem(DrawLineForDocumentMarker::create(point, width, style)));

    updateItemExtent(newItem);

Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h

@@private:

    void drawRect(const FloatRect&, float borderThickness) override;

    void drawLine(const FloatPoint&, const FloatPoint&) override;

    void drawLinesForText(const FloatPoint&, const DashArray& widths, bool printing, bool doubleLines, float strokeThickness) override;

101 void drawLineForDocumentMarker(const FloatPoint&, float width, ~~GraphicsContext::~~DocumentMarkerLineStyle) override;

101 void drawLineForDocumentMarker(const FloatPoint&, float width, DocumentMarkerLineStyle) override;

    void drawEllipse(const FloatRect&) override;

    void drawPath(const Path&) override;

Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp

@@void CairoOperationRecorder::drawLinesForText(const FloatPoint& point, const Das

    append(createCommand<DrawLinesForText>(point, widths, printing, doubleUnderlines, state.strokeColor, state.strokeThickness));

}

655 void CairoOperationRecorder::drawLineForDocumentMarker(const FloatPoint& origin, float width, ~~GraphicsContext::~~DocumentMarkerLineStyle style)

655void CairoOperationRecorder::drawLineForDocumentMarker(const FloatPoint& origin, float width, DocumentMarkerLineStyle style)

656656{

657 struct DrawLineForDocumentMarker final : PaintingOperation, OperationData<FloatPoint, float, ~~GraphicsContext::~~DocumentMarkerLineStyle> {

657 struct DrawLineForDocumentMarker final : PaintingOperation, OperationData<FloatPoint, float, DocumentMarkerLineStyle> {

        virtual ~DrawLineForDocumentMarker() = default;

        void execute(PaintingOperationReplay& replayer) override

Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h

@@private:

    void drawRect(const WebCore::FloatRect&, float) override;

    void drawLine(const WebCore::FloatPoint&, const WebCore::FloatPoint&) override;

    void drawLinesForText(const WebCore::FloatPoint&, const DashArray&, bool, bool, float) override;

76 void drawLineForDocumentMarker(const WebCore::FloatPoint&, float, WebCore::~~GraphicsContext::~~DocumentMarkerLineStyle) override;

76 void drawLineForDocumentMarker(const WebCore::FloatPoint&, float, WebCore::DocumentMarkerLineStyle) override;

    void drawEllipse(const WebCore::FloatRect&) override;

    void drawPath(const WebCore::Path&) override;

Source/WebCore/platform/graphics/win/GraphicsContextCGWin.cpp

@@void GraphicsContext::drawLineForDocumentMarker(const FloatPoint& point, float w

    if (paintingDisabled())

        return;

198 if (style != DocumentMarker~~Spelling~~LineStyle && style != DocumentMarker~~Grammar~~LineStyle)

198 if (style != DocumentMarkerLineStyle::Spelling && style != DocumentMarkerLineStyle::Grammar)

        return;

    // These are the same for misspelling or bad grammar

@@void GraphicsContext::drawLineForDocumentMarker(const FloatPoint& point, float w

    CGContextRef context = platformContext();

    CGContextSaveGState(context);

221 const Color& patternColor = style == DocumentMarker~~Grammar~~LineStyle ? grammarPatternColor() : spellingPatternColor();

221 const Color& patternColor = style == DocumentMarkerLineStyle::Grammar ? grammarPatternColor() : spellingPatternColor();

    setCGStrokeColor(context, patternColor);

    wkSetPatternPhaseInUserSpace(context, point);

Source/WebCore/rendering/InlineTextBox.cpp

@@void InlineTextBox::paintPlatformDocumentMarker(GraphicsContext& context, const

    auto lineStyleForMarkedTextType = [] (MarkedText::Type type) {

        switch (type) {

        case MarkedText::SpellingError:

692 return ~~GraphicsContext::~~DocumentMarker~~Spelling~~LineStyle;

692 return DocumentMarkerLineStyle::Spelling;

693693 case MarkedText::GrammarError:

694 return ~~GraphicsContext::~~DocumentMarker~~Grammar~~LineStyle;

694 return DocumentMarkerLineStyle::Grammar;

695695 case MarkedText::Correction:

696 return ~~GraphicsContext::~~DocumentMarkerAutocorrectionReplacement~~LineStyle~~;

696 return DocumentMarkerLineStyle::AutocorrectionReplacement;

697697 case MarkedText::DictationAlternatives:

698 return ~~GraphicsContext::~~DocumentMarkerDictationAlternatives~~LineStyle~~;

698 return DocumentMarkerLineStyle::DictationAlternatives;

699699#if PLATFORM(IOS)

700700 case MarkedText::DictationPhraseWithAlternatives:

701 // FIXME: Rename TextCheckingDictationPhraseWithAlternatives~~LineStyle~~ and remove the PLATFORM(IOS)-guard.

702 return GraphicsContext::TextCheckingDictationPhraseWithAlternatives~~LineStyle~~;

701 // FIXME: Rename DocumentMarkerLineStyle::TextCheckingDictationPhraseWithAlternatives and remove the PLATFORM(IOS)-guard.

702 return GraphicsContext::DocumentMarkerLineStyle::TextCheckingDictationPhraseWithAlternatives;

#endif

        default:

            ASSERT_NOT_REACHED();

706 return ~~GraphicsContext::~~DocumentMarker~~Spelling~~LineStyle;

706 return DocumentMarkerLineStyle::Spelling;

        }

    };

@@void InlineTextBox::paintPlatformDocumentMarker(GraphicsContext& context, const

        // In larger fonts, though, place the underline up near the baseline to prevent a big gap.

        underlineOffset = baseline + 2;

    }

#if PLATFORM(MAC)

    RenderTheme::singleton().drawLineForDocumentMarker(renderer(), context, FloatPoint(boxOrigin.x() + start, boxOrigin.y() + underlineOffset), width, lineStyleForMarkedTextType(markedText.type));

#else

727731 context.drawLineForDocumentMarker(FloatPoint(boxOrigin.x() + start, boxOrigin.y() + underlineOffset), width, lineStyleForMarkedTextType(markedText.type));

732#endif

}

auto InlineTextBox::computeStyleForUnmarkedMarkedText(const PaintInfo& paintInfo) const -> MarkedTextStyle

Source/WebCore/rendering/RenderTheme.cpp

@@Color RenderTheme::platformTapHighlightColor() const

#endif

void RenderTheme::drawLineForDocumentMarker(const RenderText&, GraphicsContext&, const FloatPoint&, float, DocumentMarkerLineStyle)

{

}

14151419} // namespace WebCore

Source/WebCore/rendering/RenderTheme.h

#include "ColorHash.h"

#include "ControlStates.h"

25#include "GraphicsContext.h"

#include "PaintInfo.h"

#include "PopupMenuStyle.h"

#include "ScrollTypes.h"

@@public:

    virtual void paintSystemPreviewBadge(Image&, const PaintInfo&, const FloatRect&);

#endif

256 virtual void drawLineForDocumentMarker(const RenderText&, GraphicsContext&, const FloatPoint&, float, DocumentMarkerLineStyle);

257

protected:

    virtual FontCascadeDescription& cachedSystemFontDescription(CSSValueID systemFontID) const;

    virtual void updateCachedSystemFontDescription(CSSValueID systemFontID, FontCascadeDescription&) const = 0;

Source/WebCore/rendering/RenderThemeMac.h

@@private:

    bool paintAttachment(const RenderObject&, const PaintInfo&, const IntRect&) final;

#endif

171 void drawLineForDocumentMarker(const RenderText&, GraphicsContext&, const FloatPoint&, float, DocumentMarkerLineStyle) final;

172

private:

    String fileListNameForWidth(const FileList*, const FontCascade&, int width, bool multipleFilesAllowed) const final;

Source/WebCore/rendering/RenderThemeMac.mm

#import "FrameSelection.h"

#import "FrameView.h"

#import "GeometryUtilities.h"

38#import "GraphicsContext.h"

#import "GraphicsContextCG.h"

#import "HTMLAttachmentElement.h"

#import "HTMLInputElement.h"

@@bool RenderThemeMac::paintAttachment(const RenderObject& renderer, const PaintIn

#endif // ENABLE(ATTACHMENT_ELEMENT)

static RetainPtr<CGColorRef> colorWithComponents(int r, int g, int b, int a)

{

    CGFloat components[4] = { CGFloat(r / 255.0), CGFloat(g / 255.0), CGFloat(b / 255.0), CGFloat(a / 100.0) };

    return adoptCF(CGColorCreate(sRGBColorSpaceRef(), components));

}

static RetainPtr<CGColorRef> colorForStyle(DocumentMarkerLineStyle style, bool useDarkMode)

{

    switch (style) {

    // Red.

    case DocumentMarkerLineStyle::Spelling:

        return useDarkMode ? colorWithComponents(255, 140, 140, 85) : colorWithComponents(255, 59, 48, 75);

    // Blue.

    case DocumentMarkerLineStyle::DictationAlternatives:

    case DocumentMarkerLineStyle::TextCheckingDictationPhraseWithAlternatives:

    case DocumentMarkerLineStyle::AutocorrectionReplacement:

        return useDarkMode ? colorWithComponents(40, 145, 255, 85) : colorWithComponents(0, 122, 255, 75);

    // Green.

    case DocumentMarkerLineStyle::Grammar:

        return useDarkMode ? colorWithComponents(50, 215, 75, 85) : colorWithComponents(25, 175, 50, 75);

    }

}

void RenderThemeMac::drawLineForDocumentMarker(const RenderText& renderer, GraphicsContext& context, const FloatPoint& origin, float width, DocumentMarkerLineStyle style)

{

    if (context.paintingDisabled())

        return;

    auto patternWidth = cMisspellingLinePatternWidth;

    auto patternHeight = cMisspellingLineThickness;

    auto dotSize = CGSizeMake(patternHeight, patternHeight);

    auto circleColor = colorForStyle(style, renderer.page().useSystemAppearance() && renderer.page().useDarkAppearance());

    // Make sure to draw only complete dots allowing slightly more considering that the pattern ends with a transparent pixel.

    FloatPoint offsetPoint = origin;

    float widthMod = fmodf(width, patternWidth);

    if (patternWidth - widthMod > cMisspellingLinePatternGapWidth) {

        float gapIncludeWidth = 0;

        if (width > patternWidth)

            gapIncludeWidth = cMisspellingLinePatternGapWidth;

        offsetPoint.move(floor((widthMod + gapIncludeWidth) / 2), 0);

        width -= widthMod;

    }

    CGContextRef ctx = context.platformContext();

    CGContextStateSaver stateSaver { ctx };

    CGContextSetFillColorWithColor(ctx, circleColor.get());

    for (int numberOfDots = 0; numberOfDots * patternWidth < width; ++numberOfDots)

        CGContextAddEllipseInRect(ctx, CGRectMake(offsetPoint.x() + numberOfDots * patternWidth, offsetPoint.y(), dotSize.width, dotSize.height));

    CGContextSetCompositeOperation(ctx, kCGCompositeSover);

    CGContextFillPath(ctx);

}

} // namespace WebCore

#endif // PLATFORM(MAC)