ChangeLog

2021-02-03  Zalan Bujtas  <zalan@apple.com>

        [LFC][IFC] Add support for "word separator" when the whitespace content has multiple characters

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

        Reviewed by NOBODY (OOPS!).

        Keep track of word separator characters in whitespace content even when the whitespace content has multiple characters.

        This fixes cases when "word-spacing" has a non-zero value in "space and tab preserve" content (e.g <pre style="word-spacing: 200px">This content has    spaces   and tabs</pre>)

        (On trunk we fail to adjust the run position with the word-spacing value because the whitespace content is not marked as a word separator.)

        * layout/inlineformatting/InlineTextItem.cpp:

        (WebCore::Layout::moveToNextNonWhitespacePosition):

        (WebCore::Layout::InlineTextItem::createAndAppendTextItems):

        * layout/inlineformatting/InlineTextItem.h:

        (WebCore::Layout::InlineTextItem::createNonWhitespaceItem):

2021-02-03  Zalan Bujtas  <zalan@apple.com>

        [LFC][IFC] Move away from using RenderStyle::preserveNewline

Source/WebCore/layout/inlineformatting/InlineTextItem.cpp

@@namespace Layout {

static_assert(sizeof(InlineItem) == sizeof(InlineTextItem), "");

41 static size_t moveToNextNonWhitespacePosition(const StringView& textContent, size_t startPosition, bool preserveNewline)

struct WhitespaceContent {

    size_t length { 0 };

    bool isWordSeparator { true };

};

static Optional<WhitespaceContent> moveToNextNonWhitespacePosition(const StringView& textContent, size_t startPosition, bool preserveNewline, bool preserveTab)

4246{

47 auto hasWordSeparatorCharacter = false;

4348 auto isWhitespaceCharacter = [&](auto character) {

44 return character == space || character == tabCharacter || (character == newlineCharacter && !preserveNewline);

        // white space processing in CSS affects only the document white space characters: spaces (U+0020), tabs (U+0009), and segment breaks.

        auto isTreatedAsSpaceCharacter = character == space || (character == newlineCharacter && !preserveNewline) || (character == tabCharacter && !preserveTab);

        hasWordSeparatorCharacter = hasWordSeparatorCharacter || isTreatedAsSpaceCharacter;

        return isTreatedAsSpaceCharacter || character == tabCharacter;

4553 };

    auto nextNonWhiteSpacePosition = startPosition;

    while (nextNonWhiteSpacePosition < textContent.length() && isWhitespaceCharacter(textContent[nextNonWhiteSpacePosition]))

        ++nextNonWhiteSpacePosition;

50 return nextNonWhiteSpacePosition - startPosition;

57 return nextNonWhiteSpacePosition == startPosition ? WTF::nullopt : makeOptional(WhitespaceContent { nextNonWhiteSpacePosition - startPosition, hasWordSeparatorCharacter });

}

static unsigned moveToNextBreakablePosition(unsigned startPosition, LazyLineBreakIterator& lineBreakIterator, const RenderStyle& style)

@@void InlineTextItem::createAndAppendTextItems(InlineItems& inlineContent, const

            continue;

        }

98 if (auto length = moveToNextNonWhitespacePosition(text, currentPosition, shouldPreseveNewline)) {

105 if (auto whitespaceContent = moveToNextNonWhitespacePosition(text, currentPosition, shouldPreseveNewline, !whitespaceContentIsTreatedAsSingleSpace)) {

106 ASSERT(whitespaceContent->length);

            auto appendWhitespaceItem = [&] (auto startPosition, auto itemLength) {

                auto simpleSingleWhitespaceContent = inlineTextBox.canUseSimplifiedContentMeasuring() && (itemLength == 1 || whitespaceContentIsTreatedAsSingleSpace);

                auto width = simpleSingleWhitespaceContent ? makeOptional(InlineLayoutUnit { font.spaceWidth() }) : inlineItemWidth(startPosition, itemLength);

                auto isWordSeparator = [&] {

                    if (whitespaceContentIsTreatedAsSingleSpace)

                        return true;

                    if (itemLength != 1) {

                        // FIXME: Add support for cases where the whitespace content contains different type of characters (e.g  "\t  \t  \t").

                        return false;

                    }

                    auto whitespaceCharacter = text[startPosition];

                    return whitespaceCharacter == space

                        || whitespaceCharacter == noBreakSpace

                        || whitespaceCharacter == ethiopicWordspace

                        || whitespaceCharacter == aegeanWordSeparatorLine

                        || whitespaceCharacter == aegeanWordSeparatorDot

                        || whitespaceCharacter == ugariticWordDivider;

                }();

                inlineContent.append(InlineTextItem::createWhitespaceItem(inlineTextBox, startPosition, itemLength, isWordSeparator, width));

110 inlineContent.append(InlineTextItem::createWhitespaceItem(inlineTextBox, startPosition, itemLength, whitespaceContent->isWordSeparator, width));

            };

            if (style.whiteSpace() == WhiteSpace::BreakSpaces) {

                // https://www.w3.org/TR/css-text-3/#white-space-phase-1

                // For break-spaces, a soft wrap opportunity exists after every space and every tab.

                // FIXME: if this turns out to be a perf hit with too many individual whitespace inline items, we should transition this logic to line breaking.

123 for (size_t i = 0; i < length; ++i)

116 for (size_t i = 0; i < whitespaceContent->length; ++i)

124117 appendWhitespaceItem(currentPosition + i, 1);

125118 } else

126 appendWhitespaceItem(currentPosition, length);

127 currentPosition += length;

119 appendWhitespaceItem(currentPosition, whitespaceContent->length);

120 currentPosition += whitespaceContent->length;

            continue;

        }

Source/WebCore/ChangeLog

Source/WebCore/layout/inlineformatting/InlineTextItem.cpp

Source/WebCore/layout/inlineformatting/InlineTextItem.h