Changeset 256304 in webkit


Ignore:
Timestamp:
Feb 11, 2020 7:13:15 AM (4 years ago)
Author:
Alan Bujtas
Message:

[LFC] Introduce Layout::InlineTextBox
​https://bugs.webkit.org/show_bug.cgi?id=207530
<rdar://problem/59336020>

Reviewed by Antti Koivisto.

Any text that is directly contained inside a block container element (not inside an inline element) must be treated as an anonymous inline element.

  • Sources.txt:
  • layout/Verification.cpp:

(WebCore::Layout::checkForMatchingTextRuns):

  • layout/inlineformatting/InlineFormattingContext.cpp:

(WebCore::Layout::InlineFormattingContext::collectInlineContentIfNeeded):

  • layout/inlineformatting/InlineLineBreaker.cpp:

(WebCore::Layout::LineBreaker::tryBreakingTextRun const):

  • layout/inlineformatting/InlineLineBuilder.cpp:

(WebCore::Layout::m_textContext):

  • layout/inlineformatting/InlineSoftLineBreakItem.h:

(WebCore::Layout::InlineSoftLineBreakItem::createSoftLineBreakItem):
(WebCore::Layout::InlineSoftLineBreakItem::InlineSoftLineBreakItem):

  • layout/inlineformatting/InlineTextItem.cpp:

(WebCore::Layout::InlineTextItem::createAndAppendTextItems):
(WebCore::Layout::InlineTextItem::isEmptyContent const):

  • layout/inlineformatting/InlineTextItem.h:

(WebCore::Layout::InlineTextItem::inlineTextBox const):
(WebCore::Layout::InlineTextItem::createWhitespaceItem):
(WebCore::Layout::InlineTextItem::createNonWhitespaceItem):
(WebCore::Layout::InlineTextItem::createEmptyItem):
(WebCore::Layout::InlineTextItem::InlineTextItem):
(WebCore::Layout::InlineTextItem::left const):
(WebCore::Layout::InlineTextItem::right const):

  • layout/inlineformatting/LineLayoutContext.cpp:

(WebCore::Layout::endsWithSoftWrapOpportunity):

  • layout/inlineformatting/text/TextUtil.cpp:

(WebCore::Layout::TextUtil::width):
(WebCore::Layout::TextUtil::split):

  • layout/inlineformatting/text/TextUtil.h:
  • layout/integration/LayoutIntegrationBoxTree.cpp:

(WebCore::LayoutIntegration::BoxTree::buildTree):

  • layout/layouttree/LayoutBox.cpp:

(WebCore::Layout::Box::Box):
(): Deleted.

  • layout/layouttree/LayoutBox.h:

(WebCore::Layout::Box::isInlineTextBox const):
(WebCore::Layout::Box::hasTextContent const): Deleted.
(WebCore::Layout::Box::textContext const): Deleted.

  • layout/layouttree/LayoutContainer.cpp:

(WebCore::Layout::Container::Container):
(): Deleted.

  • layout/layouttree/LayoutInlineTextBox.cpp: Copied from Source/WebCore/layout/layouttree/TextContext.h.

(WebCore::Layout::InlineTextBox::InlineTextBox):
(WebCore::Layout::m_canUseSimplifiedContentMeasuring):

  • layout/layouttree/LayoutInlineTextBox.h: Renamed from Source/WebCore/layout/layouttree/TextContext.h.

(WebCore::Layout::InlineTextBox::content const):
(WebCore::Layout::InlineTextBox::canUseSimplifiedContentMeasuring const):

  • layout/layouttree/LayoutTreeBuilder.cpp:

(WebCore::Layout::TreeBuilder::createTextBox):
(WebCore::Layout::TreeBuilder::createLayoutBox):
(WebCore::Layout::outputLayoutBox):

  • layout/layouttree/LayoutTreeBuilder.h:
Location:
trunk/Source/WebCore
Files:
20 edited
1 copied
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r256301 r256304  
     12020-02-11  Zalan Bujtas  <zalan@apple.com>
     2
     3        [LFC] Introduce Layout::InlineTextBox
     4        https://bugs.webkit.org/show_bug.cgi?id=207530
     5        <rdar://problem/59336020>
     6
     7        Reviewed by Antti Koivisto.
     8
     9        Any text that is directly contained inside a block container element (not inside an inline element) must be treated as an anonymous inline element.
     10
     11        * Sources.txt:
     12        * layout/Verification.cpp:
     13        (WebCore::Layout::checkForMatchingTextRuns):
     14        * layout/inlineformatting/InlineFormattingContext.cpp:
     15        (WebCore::Layout::InlineFormattingContext::collectInlineContentIfNeeded):
     16        * layout/inlineformatting/InlineLineBreaker.cpp:
     17        (WebCore::Layout::LineBreaker::tryBreakingTextRun const):
     18        * layout/inlineformatting/InlineLineBuilder.cpp:
     19        (WebCore::Layout::m_textContext):
     20        * layout/inlineformatting/InlineSoftLineBreakItem.h:
     21        (WebCore::Layout::InlineSoftLineBreakItem::createSoftLineBreakItem):
     22        (WebCore::Layout::InlineSoftLineBreakItem::InlineSoftLineBreakItem):
     23        * layout/inlineformatting/InlineTextItem.cpp:
     24        (WebCore::Layout::InlineTextItem::createAndAppendTextItems):
     25        (WebCore::Layout::InlineTextItem::isEmptyContent const):
     26        * layout/inlineformatting/InlineTextItem.h:
     27        (WebCore::Layout::InlineTextItem::inlineTextBox const):
     28        (WebCore::Layout::InlineTextItem::createWhitespaceItem):
     29        (WebCore::Layout::InlineTextItem::createNonWhitespaceItem):
     30        (WebCore::Layout::InlineTextItem::createEmptyItem):
     31        (WebCore::Layout::InlineTextItem::InlineTextItem):
     32        (WebCore::Layout::InlineTextItem::left const):
     33        (WebCore::Layout::InlineTextItem::right const):
     34        * layout/inlineformatting/LineLayoutContext.cpp:
     35        (WebCore::Layout::endsWithSoftWrapOpportunity):
     36        * layout/inlineformatting/text/TextUtil.cpp:
     37        (WebCore::Layout::TextUtil::width):
     38        (WebCore::Layout::TextUtil::split):
     39        * layout/inlineformatting/text/TextUtil.h:
     40        * layout/integration/LayoutIntegrationBoxTree.cpp:
     41        (WebCore::LayoutIntegration::BoxTree::buildTree):
     42        * layout/layouttree/LayoutBox.cpp:
     43        (WebCore::Layout::Box::Box):
     44        (): Deleted.
     45        * layout/layouttree/LayoutBox.h:
     46        (WebCore::Layout::Box::isInlineTextBox const):
     47        (WebCore::Layout::Box::hasTextContent const): Deleted.
     48        (WebCore::Layout::Box::textContext const): Deleted.
     49        * layout/layouttree/LayoutContainer.cpp:
     50        (WebCore::Layout::Container::Container):
     51        (): Deleted.
     52        * layout/layouttree/LayoutInlineTextBox.cpp: Copied from Source/WebCore/layout/layouttree/TextContext.h.
     53        (WebCore::Layout::InlineTextBox::InlineTextBox):
     54        (WebCore::Layout::m_canUseSimplifiedContentMeasuring):
     55        * layout/layouttree/LayoutInlineTextBox.h: Renamed from Source/WebCore/layout/layouttree/TextContext.h.
     56        (WebCore::Layout::InlineTextBox::content const):
     57        (WebCore::Layout::InlineTextBox::canUseSimplifiedContentMeasuring const):
     58        * layout/layouttree/LayoutTreeBuilder.cpp:
     59        (WebCore::Layout::TreeBuilder::createTextBox):
     60        (WebCore::Layout::TreeBuilder::createLayoutBox):
     61        (WebCore::Layout::outputLayoutBox):
     62        * layout/layouttree/LayoutTreeBuilder.h:
     63
    1642020-02-11  Carlos Garcia Campos  <cgarcia@igalia.com>
    265

  • trunk/Source/WebCore/Headers.cmake

    r256196 r256304  
    687687    layout/layouttree/LayoutBox.h
    688688    layout/layouttree/LayoutReplaced.h
    689     layout/layouttree/TextContext.h
    690689
    691690    loader/AdClickAttribution.h

  • trunk/Source/WebCore/Sources.txt

    r256196 r256304  
    14521452layout/layouttree/LayoutBox.cpp
    14531453layout/layouttree/LayoutContainer.cpp
     1454layout/layouttree/LayoutInlineTextBox.cpp
    14541455layout/layouttree/LayoutReplaced.cpp
    14551456layout/layouttree/LayoutTreeBuilder.cpp

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r256196 r256304  
    380380                11310CF720BA4A620065A8D0 /* LayoutAncestorIterator.h in Headers */ = {isa = PBXBuildFile; fileRef = 11100FCA2092868D0081AA6C /* LayoutAncestorIterator.h */; settings = {ATTRIBUTES = (Private, ); }; };
    381381                113409DA203E038000C66915 /* RenderTreeBuilderContinuation.h in Headers */ = {isa = PBXBuildFile; fileRef = 113409D8203E038000C66915 /* RenderTreeBuilderContinuation.h */; };
    382                 113A3CB42385860100AE3ECE /* TextContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 113A3CB22385860000AE3ECE /* TextContext.h */; settings = {ATTRIBUTES = (Private, ); }; };
    383382                113D0B521F9FDD2B00F611BB /* FrameViewLayoutContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 113D0B501F9FDD2B00F611BB /* FrameViewLayoutContext.h */; settings = {ATTRIBUTES = (Private, ); }; };
    384383                115CFA6A208AF7D0001E6991 /* FormattingContext.h in Headers */ = {isa = PBXBuildFile; fileRef = 115CFA68208AF7D0001E6991 /* FormattingContext.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    20512050                6ED8C37A183BFF8C009E53BD /* BoxShape.h in Headers */ = {isa = PBXBuildFile; fileRef = 6ED8C378183BFF8C009E53BD /* BoxShape.h */; settings = {ATTRIBUTES = (Private, ); }; };
    20522051                6EE8A77310F803F3005A4A24 /* JSWebGLContextAttributes.h in Headers */ = {isa = PBXBuildFile; fileRef = 6EE8A77110F803F3005A4A24 /* JSWebGLContextAttributes.h */; };
     2052                6F0B98B523F268EC00EEC2F2 /* LayoutInlineTextBox.h in Headers */ = {isa = PBXBuildFile; fileRef = 6F0B98B323F268EB00EEC2F2 /* LayoutInlineTextBox.h */; settings = {ATTRIBUTES = (Private, ); }; };
    20532053                6F0CD695229ED32700C5994E /* InlineLineBuilder.h in Headers */ = {isa = PBXBuildFile; fileRef = 6F0CD694229ED32700C5994E /* InlineLineBuilder.h */; };
    20542054                6F1CC1DE225F8B4900720AD2 /* InlineTextItem.h in Headers */ = {isa = PBXBuildFile; fileRef = 6F1CC1DD225F8B4200720AD2 /* InlineTextItem.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    59165916                113409D7203E038000C66915 /* RenderTreeBuilderContinuation.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RenderTreeBuilderContinuation.cpp; sourceTree = "<group>"; };
    59175917                113409D8203E038000C66915 /* RenderTreeBuilderContinuation.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RenderTreeBuilderContinuation.h; sourceTree = "<group>"; };
    5918                 113A3CB22385860000AE3ECE /* TextContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TextContext.h; sourceTree = "<group>"; };
    59195918                113D0B4F1F9FDD2B00F611BB /* FrameViewLayoutContext.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = FrameViewLayoutContext.cpp; sourceTree = "<group>"; };
    59205919                113D0B501F9FDD2B00F611BB /* FrameViewLayoutContext.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = FrameViewLayoutContext.h; sourceTree = "<group>"; };
    … …  
    92959294                6EE8A77110F803F3005A4A24 /* JSWebGLContextAttributes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSWebGLContextAttributes.h; sourceTree = "<group>"; };
    92969295                6F0830DF20B46951008A945B /* BlockFormattingContextGeometry.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = BlockFormattingContextGeometry.cpp; sourceTree = "<group>"; };
     9296                6F0B98B323F268EB00EEC2F2 /* LayoutInlineTextBox.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LayoutInlineTextBox.h; sourceTree = "<group>"; };
     9297                6F0B98B623F2690600EEC2F2 /* LayoutInlineTextBox.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = LayoutInlineTextBox.cpp; sourceTree = "<group>"; };
    92979298                6F0CD692229ED31900C5994E /* InlineLineBuilder.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = InlineLineBuilder.cpp; sourceTree = "<group>"; };
    92989299                6F0CD694229ED32700C5994E /* InlineLineBuilder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InlineLineBuilder.h; sourceTree = "<group>"; };
    … …  
    1674416745                                1199FA44208E35A3002358CC /* LayoutContainer.h */,
    1674516746                                11B042FB20B0E21400828A6B /* LayoutDescendantIterator.h */,
     16747                                6F0B98B623F2690600EEC2F2 /* LayoutInlineTextBox.cpp */,
     16748                                6F0B98B323F268EB00EEC2F2 /* LayoutInlineTextBox.h */,
    1674616749                                11100FC72092764C0081AA6C /* LayoutIterator.h */,
    1674716750                                111C615720AD1AE1005B82FA /* LayoutReplaced.cpp */,
    … …  
    1674916752                                11100FD5209514DE0081AA6C /* LayoutTreeBuilder.cpp */,
    1675016753                                11100FD7209514DF0081AA6C /* LayoutTreeBuilder.h */,
    16751                                 113A3CB22385860000AE3ECE /* TextContext.h */,
    1675216754                        );
    1675316755                        path = layouttree;
    … …  
    3130231304                                6F26BB6C23343E6F002F2BEA /* LayoutContext.h in Headers */,
    3130331305                                11310CF520BA4A4C0065A8D0 /* LayoutDescendantIterator.h in Headers */,
     31306                                6F0B98B523F268EC00EEC2F2 /* LayoutInlineTextBox.h in Headers */,
    3130431307                                E418025523D4549B00FFB071 /* LayoutIntegrationBoxTree.h in Headers */,
    3130531308                                E4ABABDD236088FE00FA4345 /* LayoutIntegrationLineLayout.h in Headers */,
    … …  
    3269932702                                B2C3DA420D006C1D00EF6F26 /* TextCodecUTF16.h in Headers */,
    3270032703                                9343CB8212F25E510033C5EE /* TextCodecUTF8.h in Headers */,
    32701                                 113A3CB42385860100AE3ECE /* TextContext.h in Headers */,
    3270232704                                142B97CA13138943008BEF4B /* TextControlInnerElements.h in Headers */,
    3270332705                                582DE3251C30C85400BE02A8 /* TextDecorationPainter.h in Headers */,

  • trunk/Source/WebCore/layout/Verification.cpp

    r255143 r256304  
    126126
    127127
    128 static bool checkForMatchingTextRuns(const Display::Run& inlineRun, const InlineTextBox& inlineTextBox)
     128static bool checkForMatchingTextRuns(const Display::Run& inlineRun, const WebCore::InlineTextBox& inlineTextBox)
    129129{
    130130    return areEssentiallyEqual(inlineTextBox.left(), inlineRun.left())

  • trunk/Source/WebCore/layout/inlineformatting/InlineFormattingContext.cpp

    r256101 r256304  
    3737#include "LayoutContainer.h"
    3838#include "LayoutContext.h"
     39#include "LayoutInlineTextBox.h"
    3940#include "LayoutState.h"
    4041#include "Logging.h"
    … …  
    339340                formattingState.addInlineItem({ layoutBox, InlineItem::Type::Box });
    340341            else if (layoutBox.isAnonymous()) {
    341                 ASSERT(layoutBox.hasTextContent());
    342                 InlineTextItem::createAndAppendTextItems(formattingState.inlineItems(), layoutBox);
     342                ASSERT(layoutBox.isInlineTextBox());
     343                InlineTextItem::createAndAppendTextItems(formattingState.inlineItems(), downcast<InlineTextBox>(layoutBox));
    343344            } else if (layoutBox.isInlineBox())
    344345                formattingState.addInlineItem({ layoutBox, InlineItem::Type::ContainerEnd });

  • trunk/Source/WebCore/layout/inlineformatting/InlineLineBreaker.cpp

    r254661 r256304  
    314314        }
    315315        // FIXME: Pass in the content logical left to be able to measure tabs.
    316         auto splitData = TextUtil::split(inlineTextItem.layoutBox(), inlineTextItem.start(), inlineTextItem.length(), overflowRun.logicalWidth, availableWidth, { });
     316        auto splitData = TextUtil::split(inlineTextItem.inlineTextBox(), inlineTextItem.start(), inlineTextItem.length(), overflowRun.logicalWidth, availableWidth, { });
    317317        return PartialRun { splitData.length, splitData.logicalWidth, false };
    318318    }
    … …  
    337337            if (availableWidthExcludingHyphen <= 0 || !enoughWidthForHyphenation(availableWidthExcludingHyphen, fontCascade.pixelSize()))
    338338                return { };
    339             leftSideLength = TextUtil::split(inlineTextItem.layoutBox(), inlineTextItem.start(), runLength, overflowRun.logicalWidth, availableWidthExcludingHyphen, { }).length;
     339            leftSideLength = TextUtil::split(inlineTextItem.inlineTextBox(), inlineTextItem.start(), runLength, overflowRun.logicalWidth, availableWidthExcludingHyphen, { }).length;
    340340        }
    341341        if (leftSideLength < limitBefore)
    342342            return { };
    343         auto textContent = inlineTextItem.layoutBox().textContext()->content;
    344343        // Adjust before index to accommodate the limit-after value (it's the last potential hyphen location in this run).
    345344        auto hyphenBefore = std::min(leftSideLength, runLength - limitAfter) + 1;
    346         unsigned hyphenLocation = lastHyphenLocation(StringView(textContent).substring(inlineTextItem.start(), inlineTextItem.length()), hyphenBefore, style.locale());
     345        unsigned hyphenLocation = lastHyphenLocation(StringView(inlineTextItem.inlineTextBox().content()).substring(inlineTextItem.start(), inlineTextItem.length()), hyphenBefore, style.locale());
    347346        if (!hyphenLocation || hyphenLocation < limitBefore)
    348347            return { };

  • trunk/Source/WebCore/layout/inlineformatting/InlineLineBuilder.cpp

    r255257 r256304  
    751751    , m_layoutBox(&softLineBreakItem.layoutBox())
    752752    , m_logicalRect({ 0, logicalLeft, 0, 0 })
    753     , m_textContext({ softLineBreakItem.position(), 1, softLineBreakItem.layoutBox().textContext()->content })
     753    , m_textContext({ softLineBreakItem.position(), 1, softLineBreakItem.inlineTextBox().content() })
    754754{
    755755}
    … …  
    760760    , m_logicalRect({ 0, logicalLeft, logicalWidth, 0 })
    761761    , m_trailingWhitespaceType(trailingWhitespaceType(inlineTextItem))
    762     , m_textContext({ inlineTextItem.start(), m_trailingWhitespaceType == TrailingWhitespace::Collapsed ? 1 : inlineTextItem.length(), inlineTextItem.layoutBox().textContext()->content })
     762    , m_textContext({ inlineTextItem.start(), m_trailingWhitespaceType == TrailingWhitespace::Collapsed ? 1 : inlineTextItem.length(), inlineTextItem.inlineTextBox().content() })
    763763{
    764764    if (m_trailingWhitespaceType != TrailingWhitespace::None) {

  • trunk/Source/WebCore/layout/inlineformatting/InlineSoftLineBreakItem.h

    r254749 r256304  
    3535class InlineSoftLineBreakItem : public InlineItem {
    3636public:
    37     static InlineSoftLineBreakItem createSoftLineBreakItem(const Box&, unsigned position);
     37    static InlineSoftLineBreakItem createSoftLineBreakItem(const InlineTextBox&, unsigned position);
    3838
    3939    unsigned position() const { return m_startOrPosition; }
     40    const InlineTextBox& inlineTextBox() const { return downcast<InlineTextBox>(layoutBox()); }
    4041
    41     InlineSoftLineBreakItem(const Box&, unsigned position);
     42    InlineSoftLineBreakItem(const InlineTextBox&, unsigned position);
    4243};
    4344
    44 inline InlineSoftLineBreakItem InlineSoftLineBreakItem::createSoftLineBreakItem(const Box& inlineBox, unsigned position)
     45inline InlineSoftLineBreakItem InlineSoftLineBreakItem::createSoftLineBreakItem(const InlineTextBox& inlineTextBox, unsigned position)
    4546{
    46     return { inlineBox, position };
     47    return { inlineTextBox, position };
    4748}
    4849
    49 inline InlineSoftLineBreakItem::InlineSoftLineBreakItem(const Box& inlineBox, unsigned position)
    50     : InlineItem(inlineBox, Type::SoftLineBreak)
     50inline InlineSoftLineBreakItem::InlineSoftLineBreakItem(const InlineTextBox& inlineTextBox, unsigned position)
     51    : InlineItem(inlineTextBox, Type::SoftLineBreak)
    5152{
    5253    m_startOrPosition = position;

  • trunk/Source/WebCore/layout/inlineformatting/InlineTextItem.cpp

    r254754 r256304  
    6666}
    6767
    68 void InlineTextItem::createAndAppendTextItems(InlineItems& inlineContent, const Box& inlineBox)
     68void InlineTextItem::createAndAppendTextItems(InlineItems& inlineContent, const InlineTextBox& inlineTextBox)
    6969{
    70     auto& textContext = *inlineBox.textContext();
    71     auto text = textContext.content;
     70    auto text = inlineTextBox.content();
    7271    if (!text.length())
    73         return inlineContent.append(InlineTextItem::createEmptyItem(inlineBox));
     72        return inlineContent.append(InlineTextItem::createEmptyItem(inlineTextBox));
    7473
    75     auto& style = inlineBox.style();
     74    auto& style = inlineTextBox.style();
    7675    auto& font = style.fontCascade();
    7776    LazyLineBreakIterator lineBreakIterator(text);
    … …  
    7978
    8079    auto inlineItemWidth = [&](auto startPosition, auto length) -> Optional<InlineLayoutUnit> {
    81         if (!textContext.canUseSimplifiedContentMeasuring)
     80        if (!inlineTextBox.canUseSimplifiedContentMeasuring())
    8281            return { };
    83         return TextUtil::width(inlineBox, startPosition, startPosition + length);
     82        return TextUtil::width(inlineTextBox, startPosition, startPosition + length);
    8483    };
    8584
    … …  
    9190        // Segment breaks with preserve new line style (white-space: pre, pre-wrap, break-spaces and pre-line) compute to forced line break.
    9291        if (isSegmentBreakCandidate(text[currentPosition]) && style.preserveNewline()) {
    93             inlineContent.append(InlineSoftLineBreakItem::createSoftLineBreakItem(inlineBox, currentPosition));
     92            inlineContent.append(InlineSoftLineBreakItem::createSoftLineBreakItem(inlineTextBox, currentPosition));
    9493            ++currentPosition;
    9594            continue;
    … …  
    9897        if (isWhitespaceCharacter(text[currentPosition], style.preserveNewline())) {
    9998            auto appendWhitespaceItem = [&] (auto startPosition, auto itemLength) {
    100                 auto simpleSingleWhitespaceContent = textContext.canUseSimplifiedContentMeasuring && (itemLength == 1 || style.collapseWhiteSpace());
     99                auto simpleSingleWhitespaceContent = inlineTextBox.canUseSimplifiedContentMeasuring() && (itemLength == 1 || style.collapseWhiteSpace());
    101100                auto width = simpleSingleWhitespaceContent ? makeOptional(InlineLayoutUnit { font.spaceWidth() }) : inlineItemWidth(startPosition, itemLength);
    102                 inlineContent.append(InlineTextItem::createWhitespaceItem(inlineBox, startPosition, itemLength, width));
     101                inlineContent.append(InlineTextItem::createWhitespaceItem(inlineTextBox, startPosition, itemLength, width));
    103102            };
    104103
    … …  
    117116
    118117        auto length = moveToNextBreakablePosition(currentPosition, lineBreakIterator, style);
    119         inlineContent.append(InlineTextItem::createNonWhitespaceItem(inlineBox, currentPosition, length, inlineItemWidth(currentPosition, length)));
     118        inlineContent.append(InlineTextItem::createNonWhitespaceItem(inlineTextBox, currentPosition, length, inlineItemWidth(currentPosition, length)));
    120119        currentPosition += length;
    121120    }
    … …  
    125124{
    126125    // FIXME: We should check for more zero width content and not just U+200B.
    127     return !m_length || (m_length == 1 && layoutBox().textContext()->content[start()] == zeroWidthSpace);
     126    return !m_length || (m_length == 1 && inlineTextBox().content()[start()] == zeroWidthSpace);
    128127}
    129128

  • trunk/Source/WebCore/layout/inlineformatting/InlineTextItem.h

    r254754 r256304  
    3030#include "InlineFormattingState.h"
    3131#include "InlineItem.h"
     32#include "LayoutInlineTextBox.h"
    3233
    3334namespace WebCore {
    … …  
    3637class InlineTextItem : public InlineItem {
    3738public:
    38     static void createAndAppendTextItems(InlineItems&, const Box&);
     39    static void createAndAppendTextItems(InlineItems&, const InlineTextBox&);
    3940
    4041    unsigned start() const { return m_startOrPosition; }
    … …  
    4748    bool isEmptyContent() const;
    4849
     50    const InlineTextBox& inlineTextBox() const { return downcast<InlineTextBox>(layoutBox()); }
     51
    4952    InlineTextItem left(unsigned length) const;
    5053    InlineTextItem right(unsigned length) const;
    … …  
    5356    using InlineItem::TextItemType;
    5457
    55     InlineTextItem(const Box&, unsigned start, unsigned length, Optional<InlineLayoutUnit> width, TextItemType);
    56     InlineTextItem(const Box&);
     58    InlineTextItem(const InlineTextBox&, unsigned start, unsigned length, Optional<InlineLayoutUnit> width, TextItemType);
     59    InlineTextItem(const InlineTextBox&);
    5760
    58     static InlineTextItem createWhitespaceItem(const Box&, unsigned start, unsigned length, Optional<InlineLayoutUnit> width);
    59     static InlineTextItem createNonWhitespaceItem(const Box&, unsigned start, unsigned length, Optional<InlineLayoutUnit> width);
    60     static InlineTextItem createEmptyItem(const Box&);
     61    static InlineTextItem createWhitespaceItem(const InlineTextBox&, unsigned start, unsigned length, Optional<InlineLayoutUnit> width);
     62    static InlineTextItem createNonWhitespaceItem(const InlineTextBox&, unsigned start, unsigned length, Optional<InlineLayoutUnit> width);
     63    static InlineTextItem createEmptyItem(const InlineTextBox&);
    6164};
    6265
    63 inline InlineTextItem InlineTextItem::createWhitespaceItem(const Box& inlineBox, unsigned start, unsigned length, Optional<InlineLayoutUnit> width)
     66inline InlineTextItem InlineTextItem::createWhitespaceItem(const InlineTextBox& inlineTextBox, unsigned start, unsigned length, Optional<InlineLayoutUnit> width)
    6467{
    65     return { inlineBox, start, length, width, TextItemType::Whitespace };
     68    return { inlineTextBox, start, length, width, TextItemType::Whitespace };
    6669}
    6770
    68 inline InlineTextItem InlineTextItem::createNonWhitespaceItem(const Box& inlineBox, unsigned start, unsigned length, Optional<InlineLayoutUnit> width)
     71inline InlineTextItem InlineTextItem::createNonWhitespaceItem(const InlineTextBox& inlineTextBox, unsigned start, unsigned length, Optional<InlineLayoutUnit> width)
    6972{
    70     return { inlineBox, start, length, width, TextItemType::NonWhitespace };
     73    return { inlineTextBox, start, length, width, TextItemType::NonWhitespace };
    7174}
    7275
    73 inline InlineTextItem InlineTextItem::createEmptyItem(const Box& inlineBox)
     76inline InlineTextItem InlineTextItem::createEmptyItem(const InlineTextBox& inlineTextBox)
    7477{
    75     return { inlineBox };
     78    return { inlineTextBox };
    7679}
    7780
    78 inline InlineTextItem::InlineTextItem(const Box& inlineBox, unsigned start, unsigned length, Optional<InlineLayoutUnit> width, TextItemType textItemType)
    79     : InlineItem(inlineBox, Type::Text)
     81inline InlineTextItem::InlineTextItem(const InlineTextBox& inlineTextBox, unsigned start, unsigned length, Optional<InlineLayoutUnit> width, TextItemType textItemType)
     82    : InlineItem(inlineTextBox, Type::Text)
    8083{
    8184    m_startOrPosition = start;
    8285    m_length = length;
    8386    m_hasWidth = !!width;
    84     m_isCollapsible = textItemType == TextItemType::Whitespace && inlineBox.style().collapseWhiteSpace();
     87    m_isCollapsible = textItemType == TextItemType::Whitespace && inlineTextBox.style().collapseWhiteSpace();
    8588    m_width = width.valueOr(0);
    8689    m_textItemType = textItemType;
    8790}
    8891
    89 inline InlineTextItem::InlineTextItem(const Box& inlineBox)
    90     : InlineItem(inlineBox, Type::Text)
     92inline InlineTextItem::InlineTextItem(const InlineTextBox& inlineTextBox)
     93    : InlineItem(inlineTextBox, Type::Text)
    9194{
    9295}
    … …  
    97100    ASSERT(m_textItemType != TextItemType::Undefined);
    98101    ASSERT(length);
    99     return { layoutBox(), start(), length, WTF::nullopt, m_textItemType };
     102    return { inlineTextBox(), start(), length, WTF::nullopt, m_textItemType };
    100103}
    101104
    … …  
    105108    ASSERT(m_textItemType != TextItemType::Undefined);
    106109    ASSERT(length);
    107     return { layoutBox(), end() - length, length, WTF::nullopt, m_textItemType };
     110    return { inlineTextBox(), end() - length, length, WTF::nullopt, m_textItemType };
    108111}
    109112

  • trunk/Source/WebCore/layout/inlineformatting/LineLayoutContext.cpp

    r255273 r256304  
    4444    // When both these non-whitespace runs belong to the same layout box, it's guaranteed that
    4545    // they are split at a soft breaking opportunity. See InlineTextItem::moveToNextBreakablePosition.
    46     if (&currentTextItem.layoutBox() == &nextInlineTextItem.layoutBox())
     46    if (&currentTextItem.inlineTextBox() == &nextInlineTextItem.inlineTextBox())
    4747        return true;
    4848    // Now we need to collect at least 3 adjacent characters to be able to make a decision whether the previous text item ends with breaking opportunity.
    4949    // [ex-][ample] <- second to last[x] last[-] current[a]
    5050    // We need at least 1 character in the current inline text item and 2 more from previous inline items.
    51     auto previousContent = currentTextItem.layoutBox().textContext()->content;
    52     auto lineBreakIterator = LazyLineBreakIterator { nextInlineTextItem.layoutBox().textContext()->content };
     51    auto previousContent = currentTextItem.inlineTextBox().content();
     52    auto lineBreakIterator = LazyLineBreakIterator { nextInlineTextItem.inlineTextBox().content() };
    5353    auto previousContentLength = previousContent.length();
    5454    // FIXME: We should look into the entire uncommitted content for more text context.

  • trunk/Source/WebCore/layout/inlineformatting/text/TextUtil.cpp

    r254750 r256304  
    3232#include "FontCascade.h"
    3333#include "InlineTextItem.h"
     34#include "LayoutInlineTextBox.h"
    3435#include "RenderBox.h"
    3536#include "RenderStyle.h"
    … …  
    4546        return font.spaceWidth() + font.wordSpacing();
    4647    }
    47     return TextUtil::width(inlineTextItem.layoutBox(), from, to, contentLogicalLeft);
     48    return TextUtil::width(inlineTextItem.inlineTextBox(), from, to, contentLogicalLeft);
    4849}
    4950
    50 InlineLayoutUnit TextUtil::width(const Box& inlineBox, unsigned from, unsigned to, InlineLayoutUnit contentLogicalLeft)
     51InlineLayoutUnit TextUtil::width(const InlineTextBox& inlineTextBox, unsigned from, unsigned to, InlineLayoutUnit contentLogicalLeft)
    5152{
    52     auto& style = inlineBox.style();
     53    auto& style = inlineTextBox.style();
    5354    auto& font = style.fontCascade();
    5455    if (!font.size() || from == to)
    5556        return 0;
    5657
    57     auto& textContext = *inlineBox.textContext();
    58     auto& text = textContext.content;
     58    auto text = inlineTextBox.content();
    5959    ASSERT(to <= text.length());
    6060    auto hasKerningOrLigatures = font.enableKerning() || font.requiresShaping();
    … …  
    6363        ++to;
    6464    float width = 0;
    65     if (textContext.canUseSimplifiedContentMeasuring) {
     65    if (inlineTextBox.canUseSimplifiedContentMeasuring()) {
    6666        if (font.isFixedPitch())
    6767            width = fixedPitchWidth(text, style, from, to, contentLogicalLeft);
    … …  
    101101}
    102102
    103 TextUtil::SplitData TextUtil::split(const Box& inlineBox, unsigned startPosition, unsigned length, InlineLayoutUnit textWidth, InlineLayoutUnit availableWidth, InlineLayoutUnit contentLogicalLeft)
     103TextUtil::SplitData TextUtil::split(const InlineTextBox& inlineTextBox, unsigned startPosition, unsigned length, InlineLayoutUnit textWidth, InlineLayoutUnit availableWidth, InlineLayoutUnit contentLogicalLeft)
    104104{
    105105    ASSERT(availableWidth >= 0);
    … …  
    114114    while (left < right) {
    115115        auto middle = (left + right) / 2;
    116         auto width = TextUtil::width(inlineBox, startPosition, middle + 1, contentLogicalLeft);
     116        auto width = TextUtil::width(inlineTextBox, startPosition, middle + 1, contentLogicalLeft);
    117117        if (width < availableWidth) {
    118118            left = middle + 1;

  • trunk/Source/WebCore/layout/inlineformatting/text/TextUtil.h

    r254750 r256304  
    3838namespace Layout {
    3939
     40class InlineTextBox;
    4041class InlineTextItem;
    4142
    … …  
    4344public:
    4445    static InlineLayoutUnit width(const InlineTextItem&, unsigned from, unsigned to, InlineLayoutUnit contentLogicalLeft = 0);
    45     static InlineLayoutUnit width(const Box&, unsigned from, unsigned to, InlineLayoutUnit contentLogicalLeft = 0);
     46    static InlineLayoutUnit width(const InlineTextBox&, unsigned from, unsigned to, InlineLayoutUnit contentLogicalLeft = 0);
    4647    struct SplitData {
    4748        unsigned start { 0 };
    … …  
    4950        InlineLayoutUnit logicalWidth { 0 };
    5051    };
    51     static SplitData split(const Box&, unsigned startPosition, unsigned length, InlineLayoutUnit textWidth, InlineLayoutUnit availableWidth, InlineLayoutUnit contentLogicalLeft);
     52    static SplitData split(const InlineTextBox&, unsigned startPosition, unsigned length, InlineLayoutUnit textWidth, InlineLayoutUnit availableWidth, InlineLayoutUnit contentLogicalLeft);
    5253    static bool shouldPreserveTrailingWhitespace(const RenderStyle&);
    5354    static unsigned findNextBreakablePosition(LazyLineBreakIterator&, unsigned startPosition, const RenderStyle&);

  • trunk/Source/WebCore/layout/integration/LayoutIntegrationBoxTree.cpp

    r254825 r256304  
    5959        if (is<RenderText>(childRenderer)) {
    6060            auto& textRenderer = downcast<RenderText>(childRenderer);
    61             auto textContent = Layout::TextContext { textRenderer.text(), textRenderer.canUseSimplifiedTextMeasuring() };
    62             childBox = makeUnique<Layout::Box>(WTFMove(textContent), RenderStyle::createAnonymousStyleWithDisplay(m_root.style(), DisplayType::Inline));
    63             childBox->setIsAnonymous();
     61            childBox = makeUnique<Layout::InlineTextBox>(textRenderer.text(), textRenderer.canUseSimplifiedTextMeasuring(), RenderStyle::createAnonymousStyleWithDisplay(m_root.style(), DisplayType::Inline));
    6462        } else if (childRenderer.isLineBreak()) {
    6563            auto clonedStyle = RenderStyle::clone(childRenderer.style());

  • trunk/Source/WebCore/layout/layouttree/LayoutBox.cpp

    r256098 r256304  
    4141WTF_MAKE_ISO_ALLOCATED_IMPL(Box);
    4242
    43 Box::Box(Optional<ElementAttributes> attributes, Optional<TextContext> textContext, RenderStyle&& style, BaseTypeFlags baseTypeFlags)
     43Box::Box(Optional<ElementAttributes> attributes, RenderStyle&& style, BaseTypeFlags baseTypeFlags)
    4444    : m_style(WTFMove(style))
    4545    , m_elementAttributes(attributes)
    46     , m_textContext(textContext)
    4746    , m_baseTypeFlags(baseTypeFlags)
    4847    , m_hasRareData(false)
    … …  
    5453
    5554Box::Box(Optional<ElementAttributes> attributes, RenderStyle&& style)
    56     : Box(attributes, { }, WTFMove(style), BaseTypeFlag::BoxFlag)
    57 {
    58 }
    59 
    60 Box::Box(TextContext&& textContext, RenderStyle&& style)
    61     : Box({ }, WTFMove(textContext), WTFMove(style), BaseTypeFlag::BoxFlag)
    62 {
    63     ASSERT(isInlineLevelBox());
     55    : Box(attributes, WTFMove(style), BaseTypeFlag::BoxFlag)
     56{
    6457}
    6558

  • trunk/Source/WebCore/layout/layouttree/LayoutBox.h

    r256098 r256304  
    3030#include "LayoutReplaced.h"
    3131#include "RenderStyle.h"
    32 #include "TextContext.h"
    3332#include <wtf/IsoMalloc.h>
    3433#include <wtf/WeakPtr.h>
    … …  
    6564
    6665    enum BaseTypeFlag {
    67         BoxFlag               = 1 << 0,
    68         ContainerFlag         = 1 << 1
     66        BoxFlag                = 1 << 0,
     67        InlineTextBox          = 1 << 1,
     68        ContainerFlag          = 1 << 2
    6969    };
    7070    typedef unsigned BaseTypeFlags;
    7171
    7272    Box(Optional<ElementAttributes>, RenderStyle&&);
    73     Box(TextContext&&, RenderStyle&&);
    74     ~Box();
     73    virtual ~Box();
    7574
    7675    bool establishesFormattingContext() const;
    … …  
    143142
    144143    bool isContainer() const { return m_baseTypeFlags & ContainerFlag; }
     144    bool isInlineTextBox() const { return m_baseTypeFlags & InlineTextBox; }
    145145
    146146    bool isPaddingApplicable() const;
    … …  
    153153    // FIXME: Temporary until after intrinsic size change is tracked by Replaced.
    154154    Replaced* replaced();
    155     bool hasTextContent() const { return !!m_textContext; }
    156     const Optional<TextContext>& textContext() const { return m_textContext; }
    157155
    158156    // FIXME: Find a better place for random DOM things.
    … …  
    177175
    178176protected:
    179     Box(Optional<ElementAttributes>, Optional<TextContext>, RenderStyle&&, BaseTypeFlags);
     177    Box(Optional<ElementAttributes>, RenderStyle&&, BaseTypeFlags);
    180178
    181179private:
    … …  
    208206    Box* m_nextSibling { nullptr };
    209207   
    210     const Optional<TextContext> m_textContext;
    211 
    212208    // First LayoutState gets a direct cache.
    213209    mutable WeakPtr<LayoutState> m_cachedLayoutState;

  • trunk/Source/WebCore/layout/layouttree/LayoutContainer.cpp

    r254806 r256304  
    3838
    3939Container::Container(Optional<ElementAttributes> attributes, RenderStyle&& style, BaseTypeFlags baseTypeFlags)
    40     : Box(attributes, { }, WTFMove(style), baseTypeFlags | ContainerFlag)
     40    : Box(attributes, WTFMove(style), baseTypeFlags | ContainerFlag)
    4141{
    4242}

  • trunk/Source/WebCore/layout/layouttree/LayoutInlineTextBox.cpp

    r256303 r256304  
    11/*
    2  * Copyright (C) 2019 Apple Inc. All rights reserved.
     2 * Copyright (C) 2020 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2424 */
    2525
    26 #pragma once
     26#include "config.h"
     27#include "LayoutInlineTextBox.h"
    2728
    2829#if ENABLE(LAYOUT_FORMATTING_CONTEXT)
    2930
    30 #include <wtf/text/StringView.h>
     31#include "RenderStyle.h"
     32#include <wtf/IsoMallocInlines.h>
    3133
    3234namespace WebCore {
    3335namespace Layout {
    3436
    35 struct TextContext {
    36     WTF_MAKE_FAST_ALLOCATED;
    37 public:
    38     String content;
    39     bool canUseSimplifiedContentMeasuring { false };
    40 };
     37WTF_MAKE_ISO_ALLOCATED_IMPL(InlineTextBox);
     38
     39InlineTextBox::InlineTextBox(String content, bool canUseSimplifiedContentMeasuring, RenderStyle&& style)
     40    : Box({ }, WTFMove(style), Box::InlineTextBox)
     41    , m_content(content)
     42    , m_canUseSimplifiedContentMeasuring(canUseSimplifiedContentMeasuring)
     43{
     44    setIsAnonymous();
     45}
    4146
    4247}
    4348}
     49
    4450#endif

  • trunk/Source/WebCore/layout/layouttree/LayoutInlineTextBox.h

    r256303 r256304  
    11/*
    2  * Copyright (C) 2019 Apple Inc. All rights reserved.
     2 * Copyright (C) 2020 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2828#if ENABLE(LAYOUT_FORMATTING_CONTEXT)
    2929
    30 #include <wtf/text/StringView.h>
     30#include "LayoutBox.h"
     31#include <wtf/IsoMalloc.h>
    3132
    3233namespace WebCore {
     34
    3335namespace Layout {
    3436
    35 struct TextContext {
    36     WTF_MAKE_FAST_ALLOCATED;
     37class InlineTextBox : public Box {
     38    WTF_MAKE_ISO_ALLOCATED(InlineTextBox);
    3739public:
    38     String content;
    39     bool canUseSimplifiedContentMeasuring { false };
     40    InlineTextBox(String, bool canUseSimplifiedContentMeasuring, RenderStyle&&);
     41    virtual ~InlineTextBox() = default;
     42
     43    String content() const { return m_content; }
     44    // FIXME: This should not be a box's property.
     45    bool canUseSimplifiedContentMeasuring() const { return m_canUseSimplifiedContentMeasuring; }
     46
     47private:
     48    String m_content;
     49    bool m_canUseSimplifiedContentMeasuring { false };
    4050};
    4151
    4252}
    4353}
     54
     55SPECIALIZE_TYPE_TRAITS_LAYOUT_BOX(InlineTextBox, isInlineTextBox())
     56
    4457#endif

  • trunk/Source/WebCore/layout/layouttree/LayoutTreeBuilder.cpp

    r255257 r256304  
    4343#include "LayoutContext.h"
    4444#include "LayoutDescendantIterator.h"
     45#include "LayoutInlineTextBox.h"
    4546#include "LayoutPhase.h"
    4647#include "LayoutSize.h"
    … …  
    151152}
    152153
    153 Box& TreeBuilder::createTextBox(TextContext&& textContent, RenderStyle&& style)
    154 {
    155     auto newBox = makeUnique<Box>(WTFMove(textContent), WTFMove(style));
     154Box& TreeBuilder::createTextBox(String text, bool canUseSimplifiedTextMeasuring, RenderStyle&& style)
     155{
     156    auto newBox = makeUnique<InlineTextBox>(text, canUseSimplifiedTextMeasuring, WTFMove(style));
    156157    auto& box = *newBox;
    157158    m_layoutTreeContent.addBox(WTFMove(newBox));
    … …  
    192193        // RenderText::text() has already applied text-transform and text-security properties.
    193194        String text = textRenderer.text();
    194         auto textContent = TextContext { text, canUseSimplifiedTextMeasuring(text, parentContainer.style().fontCascade(), parentContainer.style().collapseWhiteSpace()) };
     195        auto useSimplifiedTextMeasuring = canUseSimplifiedTextMeasuring(text, parentContainer.style().fontCascade(), parentContainer.style().collapseWhiteSpace());
    195196        if (parentContainer.style().display() == DisplayType::Inline)
    196             childLayoutBox = &createTextBox(WTFMove(textContent), RenderStyle::clone(parentContainer.style()));
     197            childLayoutBox = &createTextBox(text, useSimplifiedTextMeasuring, RenderStyle::clone(parentContainer.style()));
    197198        else
    198             childLayoutBox = &createTextBox(WTFMove(textContent), RenderStyle::createAnonymousStyleWithDisplay(parentContainer.style(), DisplayType::Inline));
    199         childLayoutBox->setIsAnonymous();
     199            childLayoutBox = &createTextBox(text, useSimplifiedTextMeasuring, RenderStyle::createAnonymousStyleWithDisplay(parentContainer.style(), DisplayType::Inline));
    200200    } else {
    201201        auto& renderer = downcast<RenderElement>(childRenderer);
    … …  
    407407        stream << " at (" << displayBox->left() << "," << displayBox->top() << ") size " << displayBox->width() << "x" << displayBox->height();
    408408    stream << " layout box->(" << &layoutBox << ")";
    409     if (layoutBox.isInlineLevelBox() && layoutBox.isAnonymous())
    410         stream << " text content [\"" << layoutBox.textContext()->content.utf8().data() << "\"]";
     409    if (is<InlineTextBox>(layoutBox))
     410        stream << " text content [\"" << downcast<InlineTextBox>(layoutBox).content().utf8().data() << "\"]";
    411411
    412412    stream.nextLine();

  • trunk/Source/WebCore/layout/layouttree/LayoutTreeBuilder.h

    r254806 r256304  
    9292
    9393    Box& createBox(Optional<Box::ElementAttributes>, RenderStyle&&);
    94     Box& createTextBox(TextContext&&, RenderStyle&&);
     94    Box& createTextBox(String text, bool canUseSimplifiedTextMeasuring, RenderStyle&&);
    9595    Container& createContainer(Optional<Box::ElementAttributes>, RenderStyle&&);
    9696
Note: See TracChangeset for help on using the changeset viewer.