⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 283367 in webkit


Ignore:
Timestamp:
Oct 1, 2021, 8:12:38 AM (5 years ago)
Author:
Antti Koivisto
Message:

Rename InlineIterator to LegacyInlineIterator
​https://bugs.webkit.org/show_bug.cgi?id=231077

Reviewed by Alan Bujtas.

It is only used by the legacy line layout.

  • Sources.txt:
  • WebCore.xcodeproj/project.pbxproj:
  • dom/Position.cpp:
  • layout/integration/LayoutIntegrationCoverage.cpp:
  • rendering/LegacyInlineIterator.cpp: Renamed from Source/WebCore/rendering/InlineIterator.cpp.

(WebCore::LegacyInlineIterator::surrogateTextDirection const):

  • rendering/LegacyInlineIterator.h: Renamed from Source/WebCore/rendering/InlineIterator.h.

(WebCore::LegacyInlineIterator::LegacyInlineIterator):
(WebCore::operator==):
(WebCore::operator!=):
(WebCore::nextInlineRendererSkippingEmpty):
(WebCore::firstInlineRendererSkippingEmpty):

Rename this to not say "bidi".

(WebCore::LegacyInlineIterator::fastIncrementInTextNode):
(WebCore::LegacyInlineIterator::incrementByCodePointInTextNode):
(WebCore::LegacyInlineIterator::setOffset):
(WebCore::LegacyInlineIterator::setRefersToEndOfPreviousNode):
(WebCore::LegacyInlineIterator::increment):
(WebCore::LegacyInlineIterator::fastDecrement):
(WebCore::LegacyInlineIterator::atEnd const):
(WebCore::LegacyInlineIterator::characterAt const):
(WebCore::LegacyInlineIterator::current const):
(WebCore::LegacyInlineIterator::previousInSameNode const):
(WebCore::LegacyInlineIterator::direction const):
(WebCore::numberOfIsolateAncestors):
(WebCore::InlineBidiResolver::appendRunInternal):

  • rendering/LegacyLineLayout.cpp:

(WebCore::determineDirectionality):
(WebCore::LegacyLineLayout::appendRunsForObject):
(WebCore::constructBidiRunsForSegment):
(WebCore::LegacyLineLayout::createLineBoxesFromBidiRuns):
(WebCore::LegacyLineLayout::layoutRunsAndFloats):
(WebCore::LegacyLineLayout::restartLayoutRunsAndFloatsInRange):
(WebCore::LegacyLineLayout::layoutRunsAndFloatsInRange):
(WebCore::LegacyLineLayout::determineStartPosition):
(WebCore::LegacyLineLayout::determineEndPosition):
(WebCore::LegacyLineLayout::matchedEndLine):

  • rendering/LegacyLineLayout.h:
  • rendering/LegacyRootInlineBox.h:
  • rendering/RenderBlock.cpp:
  • rendering/RenderBlockFlow.cpp:
  • rendering/RenderInline.cpp:

(WebCore::isEmptyInline):

  • rendering/RenderInline.h:
  • rendering/RenderTreeAsText.cpp:
  • rendering/line/BreakingContext.h:

(WebCore::BreakingContext::lineBreak):
(WebCore::BreakingContext::initializeForCurrentObject):
(WebCore::BreakingContext::handleBR):
(WebCore::shouldSkipWhitespaceAfterStartObject):
(WebCore::BreakingContext::handleReplaced):
(WebCore::iteratorIsBeyondEndOfRenderCombineText):
(WebCore::ensureCharacterGetsLineBox):
(WebCore::tryHyphenating):
(WebCore::BreakingContext::handleText):
(WebCore::BreakingContext::trailingSpacesHang):
(WebCore::checkWhitespaceCollapsingTransitions):
(WebCore::BreakingContext::handleEndOfLine):

  • rendering/line/LineBreaker.cpp:

(WebCore::LineBreaker::skipTrailingWhitespace):
(WebCore::LineBreaker::nextLineBreak):

  • rendering/line/LineBreaker.h:
  • rendering/line/LineInlineHeaders.h:

(WebCore::skipNonBreakingSpace):
(WebCore::requiresLineBox):

  • rendering/line/TrailingObjects.cpp:

(WebCore::TrailingObjects::updateWhitespaceCollapsingTransitionsForTrailingBoxes):

  • rendering/line/TrailingObjects.h:
  • rendering/updating/RenderTreeBuilderList.cpp:

(WebCore::generatesLineBoxesForInlineChild):

Location:
trunk/Source/WebCore
Files:
20 edited
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r283365 r283367  
     12021-10-01  Antti Koivisto  <antti@apple.com>
     2
     3        Rename InlineIterator to LegacyInlineIterator
     4        https://bugs.webkit.org/show_bug.cgi?id=231077
     5
     6        Reviewed by Alan Bujtas.
     7
     8        It is only used by the legacy line layout.
     9
     10        * Sources.txt:
     11        * WebCore.xcodeproj/project.pbxproj:
     12        * dom/Position.cpp:
     13        * layout/integration/LayoutIntegrationCoverage.cpp:
     14        * rendering/LegacyInlineIterator.cpp: Renamed from Source/WebCore/rendering/InlineIterator.cpp.
     15        (WebCore::LegacyInlineIterator::surrogateTextDirection const):
     16        * rendering/LegacyInlineIterator.h: Renamed from Source/WebCore/rendering/InlineIterator.h.
     17        (WebCore::LegacyInlineIterator::LegacyInlineIterator):
     18        (WebCore::operator==):
     19        (WebCore::operator!=):
     20        (WebCore::nextInlineRendererSkippingEmpty):
     21        (WebCore::firstInlineRendererSkippingEmpty):
     22
     23        Rename this to not say "bidi".
     24
     25        (WebCore::LegacyInlineIterator::fastIncrementInTextNode):
     26        (WebCore::LegacyInlineIterator::incrementByCodePointInTextNode):
     27        (WebCore::LegacyInlineIterator::setOffset):
     28        (WebCore::LegacyInlineIterator::setRefersToEndOfPreviousNode):
     29        (WebCore::LegacyInlineIterator::increment):
     30        (WebCore::LegacyInlineIterator::fastDecrement):
     31        (WebCore::LegacyInlineIterator::atEnd const):
     32        (WebCore::LegacyInlineIterator::characterAt const):
     33        (WebCore::LegacyInlineIterator::current const):
     34        (WebCore::LegacyInlineIterator::previousInSameNode const):
     35        (WebCore::LegacyInlineIterator::direction const):
     36        (WebCore::numberOfIsolateAncestors):
     37        (WebCore::InlineBidiResolver::appendRunInternal):
     38        * rendering/LegacyLineLayout.cpp:
     39        (WebCore::determineDirectionality):
     40        (WebCore::LegacyLineLayout::appendRunsForObject):
     41        (WebCore::constructBidiRunsForSegment):
     42        (WebCore::LegacyLineLayout::createLineBoxesFromBidiRuns):
     43        (WebCore::LegacyLineLayout::layoutRunsAndFloats):
     44        (WebCore::LegacyLineLayout::restartLayoutRunsAndFloatsInRange):
     45        (WebCore::LegacyLineLayout::layoutRunsAndFloatsInRange):
     46        (WebCore::LegacyLineLayout::determineStartPosition):
     47        (WebCore::LegacyLineLayout::determineEndPosition):
     48        (WebCore::LegacyLineLayout::matchedEndLine):
     49        * rendering/LegacyLineLayout.h:
     50        * rendering/LegacyRootInlineBox.h:
     51        * rendering/RenderBlock.cpp:
     52        * rendering/RenderBlockFlow.cpp:
     53        * rendering/RenderInline.cpp:
     54        (WebCore::isEmptyInline):
     55        * rendering/RenderInline.h:
     56        * rendering/RenderTreeAsText.cpp:
     57        * rendering/line/BreakingContext.h:
     58        (WebCore::BreakingContext::lineBreak):
     59        (WebCore::BreakingContext::initializeForCurrentObject):
     60        (WebCore::BreakingContext::handleBR):
     61        (WebCore::shouldSkipWhitespaceAfterStartObject):
     62        (WebCore::BreakingContext::handleReplaced):
     63        (WebCore::iteratorIsBeyondEndOfRenderCombineText):
     64        (WebCore::ensureCharacterGetsLineBox):
     65        (WebCore::tryHyphenating):
     66        (WebCore::BreakingContext::handleText):
     67        (WebCore::BreakingContext::trailingSpacesHang):
     68        (WebCore::checkWhitespaceCollapsingTransitions):
     69        (WebCore::BreakingContext::handleEndOfLine):
     70        * rendering/line/LineBreaker.cpp:
     71        (WebCore::LineBreaker::skipTrailingWhitespace):
     72        (WebCore::LineBreaker::nextLineBreak):
     73        * rendering/line/LineBreaker.h:
     74        * rendering/line/LineInlineHeaders.h:
     75        (WebCore::skipNonBreakingSpace):
     76        (WebCore::requiresLineBox):
     77        * rendering/line/TrailingObjects.cpp:
     78        (WebCore::TrailingObjects::updateWhitespaceCollapsingTransitionsForTrailingBoxes):
     79        * rendering/line/TrailingObjects.h:
     80        * rendering/updating/RenderTreeBuilderList.cpp:
     81        (WebCore::generatesLineBoxesForInlineChild):
     82
    1832021-10-01  Antti Koivisto  <antti@apple.com>
    284

  • trunk/Source/WebCore/Sources.txt

    r283347 r283367  
    22152215rendering/ImageQualityController.cpp
    22162216rendering/InlineBoxPainter.cpp
    2217 rendering/InlineIterator.cpp
    22182217rendering/LayerAncestorClippingStack.cpp
    22192218rendering/LayerOverlapMap.cpp
    … …  
    22242223rendering/LegacyInlineElementBox.cpp
    22252224rendering/LegacyInlineFlowBox.cpp
     2225rendering/LegacyInlineIterator.cpp
    22262226rendering/LegacyLineLayout.cpp
    22272227rendering/LegacyRootInlineBox.cpp

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

    r283365 r283367  
    42234223                BCE65BEB0EACDF16007E4533 /* Length.h in Headers */ = {isa = PBXBuildFile; fileRef = BCE65BE90EACDF16007E4533 /* Length.h */; settings = {ATTRIBUTES = (Private, ); }; };
    42244224                BCE691E5264637FC00EBDC3A /* PixelBuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = BC4839BA2646181A00A28B62 /* PixelBuffer.h */; settings = {ATTRIBUTES = (Private, ); }; };
    4225                 BCE789161120D6080060ECE5 /* InlineIterator.h in Headers */ = {isa = PBXBuildFile; fileRef = BCE789151120D6080060ECE5 /* InlineIterator.h */; };
     4225                BCE789161120D6080060ECE5 /* LegacyInlineIterator.h in Headers */ = {isa = PBXBuildFile; fileRef = BCE789151120D6080060ECE5 /* LegacyInlineIterator.h */; };
    42264226                BCE789861120E7A60060ECE5 /* BidiRun.h in Headers */ = {isa = PBXBuildFile; fileRef = BCE789851120E7A60060ECE5 /* BidiRun.h */; };
    42274227                BCE93F451517C567008CCF74 /* RenderFragmentContainerSet.h in Headers */ = {isa = PBXBuildFile; fileRef = BCE93F441517C567008CCF74 /* RenderFragmentContainerSet.h */; };
    … …  
    1167911679                930AACA0250ED4110013DA9F /* JSCSSGroupingRule.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSCSSGroupingRule.h; sourceTree = "<group>"; };
    1168011680                930AACA1250ED4110013DA9F /* JSCSSGroupingRule.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSCSSGroupingRule.cpp; sourceTree = "<group>"; };
    11681                 930C90DC19CF965300D6C21A /* InlineIterator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InlineIterator.cpp; sourceTree = "<group>"; };
     11681                930C90DC19CF965300D6C21A /* LegacyInlineIterator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LegacyInlineIterator.cpp; sourceTree = "<group>"; };
    1168211682                93153BD914181F7A00FCF5BE /* missingImage@2x.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = "missingImage@2x.png"; sourceTree = "<group>"; };
    1168311683                93153BDB141959BB00FCF5BE /* textAreaResizeCorner.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = textAreaResizeCorner.png; sourceTree = "<group>"; };
    … …  
    1467314673                BCE65BE90EACDF16007E4533 /* Length.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Length.h; sourceTree = "<group>"; };
    1467414674                BCE65D310EAD1211007E4533 /* Theme.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Theme.cpp; sourceTree = "<group>"; };
    14675                 BCE789151120D6080060ECE5 /* InlineIterator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InlineIterator.h; sourceTree = "<group>"; };
     14675                BCE789151120D6080060ECE5 /* LegacyInlineIterator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LegacyInlineIterator.h; sourceTree = "<group>"; };
    1467614676                BCE789851120E7A60060ECE5 /* BidiRun.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BidiRun.h; sourceTree = "<group>"; };
    1467714677                BCE7898A1120E8020060ECE5 /* BidiRun.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BidiRun.cpp; sourceTree = "<group>"; };
    … …  
    2996629966                                E4F819C226FB4EAF0094E162 /* InlineBoxPainter.cpp */,
    2996729967                                E4F819C526FB4EBF0094E162 /* InlineBoxPainter.h */,
    29968                                 930C90DC19CF965300D6C21A /* InlineIterator.cpp */,
    29969                                 BCE789151120D6080060ECE5 /* InlineIterator.h */,
    2997029968                                E47CEBC72706EF5100B8D8F5 /* InlineWalker.h */,
    2997129969                                0FEC120B22BF2CC7004E9D35 /* LayerAncestorClippingStack.cpp */,
    … …  
    2998629984                                A8CFF5DD0A155A05000A4234 /* LegacyInlineFlowBox.cpp */,
    2998729985                                A8CFF5DC0A155A05000A4234 /* LegacyInlineFlowBox.h */,
     29986                                930C90DC19CF965300D6C21A /* LegacyInlineIterator.cpp */,
     29987                                BCE789151120D6080060ECE5 /* LegacyInlineIterator.h */,
    2998829988                                BCEA481A097D93020094C9E4 /* LegacyInlineTextBox.cpp */,
    2998929989                                BCEA481B097D93020094C9E4 /* LegacyInlineTextBox.h */,
    … …  
    3298032980                                111FA1C726F0F30F003B8F16 /* InlineInvalidation.h in Headers */,
    3298132981                                6FE7CFA22177EEF2005B1573 /* InlineItem.h in Headers */,
    32982                                 BCE789161120D6080060ECE5 /* InlineIterator.h in Headers */,
    3298332982                                6FAAE71326A2814B00E07502 /* InlineLevelBox.h in Headers */,
    3298432983                                6F0CD695229ED32700C5994E /* InlineLine.h in Headers */,
    … …  
    3401134010                                B57CB52E182A3EFC0079A647 /* LegacyInlineElementBox.h in Headers */,
    3401234011                                A8CFF5E30A155A05000A4234 /* LegacyInlineFlowBox.h in Headers */,
     34012                                BCE789161120D6080060ECE5 /* LegacyInlineIterator.h in Headers */,
    3401334013                                BCEA485A097D93020094C9E4 /* LegacyInlineTextBox.h in Headers */,
    3401434014                                E4E94D6122FF158A00DD191F /* LegacyLineLayout.h in Headers */,

  • trunk/Source/WebCore/dom/Position.cpp

    r283105 r283367  
    3636#include "HTMLParserIdioms.h"
    3737#include "HTMLTableElement.h"
    38 #include "InlineIterator.h"
    3938#include "InlineRunAndOffset.h"
    4039#include "LayoutIntegrationLineIterator.h"

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

    r283365 r283367  
    2828
    2929#include "HTMLTextFormControlElement.h"
    30 #include "InlineIterator.h"
     30#include "InlineWalker.h"
    3131#include "Logging.h"
    3232#include "RenderBlockFlow.h"

  • trunk/Source/WebCore/rendering/LegacyInlineIterator.cpp

    r283366 r283367  
    2626
    2727#include "config.h"
    28 #include "InlineIterator.h"
     28#include "LegacyInlineIterator.h"
    2929
    3030namespace WebCore {
    3131
    32 UCharDirection InlineIterator::surrogateTextDirection(UChar currentCodeUnit) const
     32UCharDirection LegacyInlineIterator::surrogateTextDirection(UChar currentCodeUnit) const
    3333{
    3434    RenderText& text = downcast<RenderText>(*m_renderer);

  • trunk/Source/WebCore/rendering/LegacyInlineIterator.h

    r283366 r283367  
    4848
    4949// This class is used to RenderInline subtrees, stepping by character within the
    50 // text children. InlineIterator will use bidiNext to find the next RenderText
     50// text children. LegacyInlineIterator will use next to find the next RenderText
    5151// optionally notifying a BidiResolver every time it steps into/out of a RenderInline.
    52 class InlineIterator {
     52class LegacyInlineIterator {
    5353public:
    54     InlineIterator()
    55     {
    56     }
    57 
    58     InlineIterator(RenderElement* root, RenderObject* o, unsigned p)
     54    LegacyInlineIterator()
     55    {
     56    }
     57
     58    LegacyInlineIterator(RenderElement* root, RenderObject* o, unsigned p)
    5959        : m_root(root)
    6060        , m_renderer(o)
    … …  
    123123    unsigned m_pos { 0 };
    124124
    125     // There are a couple places where we want to decrement an InlineIterator.
     125    // There are a couple places where we want to decrement an LegacyInlineIterator.
    126126    // Usually this take the form of decrementing m_pos; however, m_pos might be 0.
    127     // However, we shouldn't ever need to decrement an InlineIterator more than
     127    // However, we shouldn't ever need to decrement an LegacyInlineIterator more than
    128128    // once, so rather than implementing a decrement() function which traverses
    129129    // nodes, we can simply keep track of this state and handle it.
    … …  
    131131};
    132132
    133 inline bool operator==(const InlineIterator& it1, const InlineIterator& it2)
     133inline bool operator==(const LegacyInlineIterator& it1, const LegacyInlineIterator& it2)
    134134{
    135135    return it1.offset() == it2.offset() && it1.renderer() == it2.renderer();
    136136}
    137137
    138 inline bool operator!=(const InlineIterator& it1, const InlineIterator& it2)
     138inline bool operator!=(const LegacyInlineIterator& it1, const LegacyInlineIterator& it2)
    139139{
    140140    return it1.offset() != it2.offset() || it1.renderer() != it2.renderer();
    … …  
    200200}
    201201
    202 static bool isEmptyInline(const RenderInline& renderer)
    203 {
    204     for (auto& current : childrenOfType<RenderObject>(renderer)) {
    205         if (current.isFloatingOrOutOfFlowPositioned())
    206             continue;
    207         if (is<RenderText>(current)) {
    208             if (!downcast<RenderText>(current).isAllCollapsibleWhitespace())
    209                 return false;
    210             continue;
    211         }
    212         if (!is<RenderInline>(current) || !isEmptyInline(downcast<RenderInline>(current)))
    213             return false;
    214     }
    215     return true;
    216 }
    217 
    218202template <class Observer>
    219 static inline RenderObject* bidiNextSkippingEmptyInlines(RenderElement& root, RenderObject* current, Observer* observer)
     203static inline RenderObject* nextInlineRendererSkippingEmpty(RenderElement& root, RenderObject* current, Observer* observer)
    220204{
    221205    RenderObject* next = nullptr;
    … …  
    254238
    255239// This makes callers cleaner as they don't have to specify a type for the observer when not providing one.
    256 static inline RenderObject* bidiNextSkippingEmptyInlines(RenderElement& root, RenderObject* current)
     240static inline RenderObject* nextInlineRendererSkippingEmpty(RenderElement& root, RenderObject* current)
    257241{
    258242    InlineBidiResolver* observer = nullptr;
    259     return bidiNextSkippingEmptyInlines(root, current, observer);
    260 }
    261 
    262 static inline RenderObject* bidiFirstSkippingEmptyInlines(RenderElement& root, InlineBidiResolver* resolver = nullptr)
     243    return nextInlineRendererSkippingEmpty(root, current, observer);
     244}
     245
     246static inline RenderObject* firstInlineRendererSkippingEmpty(RenderElement& root, InlineBidiResolver* resolver = nullptr)
    263247{
    264248    RenderObject* renderer = root.firstChild();
    … …  
    269253        notifyObserverEnteredObject(resolver, renderer);
    270254        if (!isEmptyInline(downcast<RenderInline>(*renderer)))
    271             renderer = bidiNextSkippingEmptyInlines(root, renderer, resolver);
     255            renderer = nextInlineRendererSkippingEmpty(root, renderer, resolver);
    272256        else {
    273257            // Never skip empty inlines.
    … …  
    278262    }
    279263
    280     // FIXME: Unify this with the bidiNext call above.
     264    // FIXME: Unify this with the next call above.
    281265    if (renderer && !isIteratorTarget(renderer))
    282         renderer = bidiNextSkippingEmptyInlines(root, renderer, resolver);
     266        renderer = nextInlineRendererSkippingEmpty(root, renderer, resolver);
    283267
    284268    if (resolver)
    … …  
    287271}
    288272
    289 inline void InlineIterator::fastIncrementInTextNode()
     273inline void LegacyInlineIterator::fastIncrementInTextNode()
    290274{
    291275    ASSERT(m_renderer);
    … …  
    294278}
    295279
    296 inline void InlineIterator::incrementByCodePointInTextNode()
     280inline void LegacyInlineIterator::incrementByCodePointInTextNode()
    297281{
    298282    ASSERT(m_renderer);
    … …  
    307291}
    308292
    309 inline void InlineIterator::setOffset(unsigned position)
     293inline void LegacyInlineIterator::setOffset(unsigned position)
    310294{
    311295    ASSERT(position <= UINT_MAX - 10); // Sanity check
    … …  
    313297}
    314298
    315 inline void InlineIterator::setRefersToEndOfPreviousNode()
     299inline void LegacyInlineIterator::setRefersToEndOfPreviousNode()
    316300{
    317301    ASSERT(!m_pos);
    … …  
    321305
    322306
    323 inline void InlineIterator::increment(InlineBidiResolver* resolver)
     307inline void LegacyInlineIterator::increment(InlineBidiResolver* resolver)
    324308{
    325309    if (!m_renderer)
    … …  
    330314            return;
    331315    }
    332     // bidiNext can return nullptr
    333     RenderObject* bidiNext = bidiNextSkippingEmptyInlines(*m_root, m_renderer, resolver);
    334     if (bidiNext)
    335         moveToStartOf(*bidiNext);
     316    // next can return nullptr
     317    RenderObject* next = nextInlineRendererSkippingEmpty(*m_root, m_renderer, resolver);
     318    if (next)
     319        moveToStartOf(*next);
    336320    else
    337321        clear();
    338322}
    339323
    340 inline void InlineIterator::fastDecrement()
     324inline void LegacyInlineIterator::fastDecrement()
    341325{
    342326    ASSERT(!refersToEndOfPreviousNode());
    … …  
    347331}
    348332
    349 inline bool InlineIterator::atEnd() const
     333inline bool LegacyInlineIterator::atEnd() const
    350334{
    351335    return !m_renderer;
    352336}
    353337
    354 inline UChar InlineIterator::characterAt(unsigned index) const
     338inline UChar LegacyInlineIterator::characterAt(unsigned index) const
    355339{
    356340    if (!is<RenderText>(m_renderer))
    … …  
    360344}
    361345
    362 inline UChar InlineIterator::current() const
     346inline UChar LegacyInlineIterator::current() const
    363347{
    364348    return characterAt(m_pos);
    365349}
    366350
    367 inline UChar InlineIterator::previousInSameNode() const
     351inline UChar LegacyInlineIterator::previousInSameNode() const
    368352{
    369353    return characterAt(m_pos - 1);
    370354}
    371355
    372 ALWAYS_INLINE UCharDirection InlineIterator::direction() const
     356ALWAYS_INLINE UCharDirection LegacyInlineIterator::direction() const
    373357{
    374358    if (UNLIKELY(!m_renderer))
    … …  
    409393}
    410394
    411 static inline unsigned numberOfIsolateAncestors(const InlineIterator& iter)
     395static inline unsigned numberOfIsolateAncestors(const LegacyInlineIterator& iter)
    412396{
    413397    unsigned count = 0;
    … …  
    491475            else
    492476                LegacyLineLayout::appendRunsForObject(&m_runs, start, obj->length(), *obj, *this);
    493             // FIXME: start/obj should be an InlineIterator instead of two separate variables.
     477            // FIXME: start/obj should be an LegacyInlineIterator instead of two separate variables.
    494478            start = 0;
    495             obj = bidiNextSkippingEmptyInlines(*m_sor.root(), obj, &isolateTracker);
     479            obj = nextInlineRendererSkippingEmpty(*m_sor.root(), obj, &isolateTracker);
    496480        }
    497481        if (obj) {

  • trunk/Source/WebCore/rendering/LegacyLineLayout.cpp

    r283365 r283367  
    3131#include "FloatingObjects.h"
    3232#include "HTMLParserIdioms.h"
    33 #include "InlineIterator.h"
    3433#include "InlineTextBoxStyle.h"
    3534#include "InlineWalker.h"
    3635#include "LayoutIntegrationRunIterator.h"
    3736#include "LegacyInlineElementBox.h"
     37#include "LegacyInlineIterator.h"
    3838#include "LegacyInlineTextBox.h"
    3939#include "LineLayoutState.h"
    … …  
    6868};
    6969
    70 static void determineDirectionality(TextDirection& dir, InlineIterator iter)
     70static void determineDirectionality(TextDirection& dir, LegacyInlineIterator iter)
    7171{
    7272    while (!iter.atEnd()) {
    … …  
    100100    LineWhitespaceCollapsingState& lineWhitespaceCollapsingState = resolver.whitespaceCollapsingState();
    101101    bool haveNextTransition = (lineWhitespaceCollapsingState.currentTransition() < lineWhitespaceCollapsingState.numTransitions());
    102     InlineIterator nextTransition;
     102    LegacyInlineIterator nextTransition;
    103103    if (haveNextTransition)
    104104        nextTransition = lineWhitespaceCollapsingState.transitions()[lineWhitespaceCollapsingState.currentTransition()];
    … …  
    11701170
    11711171// FIXME: BidiResolver should have this logic.
    1172 static inline void constructBidiRunsForSegment(InlineBidiResolver& topResolver, BidiRunList<BidiRun>& bidiRuns, const InlineIterator& endOfRuns, VisualDirectionOverride override, bool previousLineBrokeCleanly)
     1172static inline void constructBidiRunsForSegment(InlineBidiResolver& topResolver, BidiRunList<BidiRun>& bidiRuns, const LegacyInlineIterator& endOfRuns, VisualDirectionOverride override, bool previousLineBrokeCleanly)
    11731173{
    11741174    // FIXME: We should pass a BidiRunList into createBidiRunsForLine instead
    … …  
    11991199        TextDirection direction;
    12001200        if (unicodeBidi == Plaintext)
    1201             determineDirectionality(direction, InlineIterator(isolatedInline, &isolatedRun.object, 0));
     1201            determineDirectionality(direction, LegacyInlineIterator(isolatedInline, &isolatedRun.object, 0));
    12021202        else {
    12031203            ASSERT(unicodeBidi == Isolate || unicodeBidi == IsolateOverride);
    … …  
    12111211        // during the earlier call to createBidiRunsForLine. This can be but is not necessarily the
    12121212        // first run within the isolate.
    1213         InlineIterator iter = InlineIterator(isolatedInline, &startObject, isolatedRun.position);
     1213        LegacyInlineIterator iter = LegacyInlineIterator(isolatedInline, &startObject, isolatedRun.position);
    12141214        isolatedResolver.setPositionIgnoringNestedIsolates(iter);
    12151215
    … …  
    12371237
    12381238// This function constructs line boxes for all of the text runs in the resolver and computes their position.
    1239 LegacyRootInlineBox* LegacyLineLayout::createLineBoxesFromBidiRuns(unsigned bidiLevel, BidiRunList<BidiRun>& bidiRuns, const InlineIterator& end, LineInfo& lineInfo, VerticalPositionCache& verticalPositionCache, BidiRun* trailingSpaceRun, WordMeasurements& wordMeasurements)
     1239LegacyRootInlineBox* LegacyLineLayout::createLineBoxesFromBidiRuns(unsigned bidiLevel, BidiRunList<BidiRun>& bidiRuns, const LegacyInlineIterator& end, LineInfo& lineInfo, VerticalPositionCache& verticalPositionCache, BidiRun* trailingSpaceRun, WordMeasurements& wordMeasurements)
    12401240{
    12411241    if (!bidiRuns.runCount())
    … …  
    13371337    // We also find the first clean line and extract these lines. We will add them back
    13381338    // if we determine that we're able to synchronize after handling all our dirty lines.
    1339     InlineIterator cleanLineStart;
     1339    LegacyInlineIterator cleanLineStart;
    13401340    BidiStatus cleanLineBidiStatus;
    13411341    if (!layoutState.isFullLayout() && startLine)
    … …  
    13701370
    13711371// Before restarting the layout loop with a new logicalHeight, remove all floats that were added and reset the resolver.
    1372 inline const InlineIterator& LegacyLineLayout::restartLayoutRunsAndFloatsInRange(LayoutUnit oldLogicalHeight, LayoutUnit newLogicalHeight,  FloatingObject* lastFloatFromPreviousLine, InlineBidiResolver& resolver,  const InlineIterator& oldEnd)
     1372inline const LegacyInlineIterator& LegacyLineLayout::restartLayoutRunsAndFloatsInRange(LayoutUnit oldLogicalHeight, LayoutUnit newLogicalHeight,  FloatingObject* lastFloatFromPreviousLine, InlineBidiResolver& resolver,  const LegacyInlineIterator& oldEnd)
    13731373{
    13741374    m_flow.removeFloatingObjectsBelow(lastFloatFromPreviousLine, oldLogicalHeight);
    … …  
    13781378}
    13791379
    1380 void LegacyLineLayout::layoutRunsAndFloatsInRange(LineLayoutState& layoutState, InlineBidiResolver& resolver, const InlineIterator& cleanLineStart, const BidiStatus& cleanLineBidiStatus, unsigned consecutiveHyphenatedLines)
     1380void LegacyLineLayout::layoutRunsAndFloatsInRange(LineLayoutState& layoutState, InlineBidiResolver& resolver, const LegacyInlineIterator& cleanLineStart, const BidiStatus& cleanLineBidiStatus, unsigned consecutiveHyphenatedLines)
    13811381{
    13821382    const RenderStyle& styleToUse = style();
    13831383    bool paginated = layoutContext().layoutState() && layoutContext().layoutState()->isPaginated();
    13841384    LineWhitespaceCollapsingState& lineWhitespaceCollapsingState = resolver.whitespaceCollapsingState();
    1385     InlineIterator end = resolver.position();
     1385    LegacyInlineIterator end = resolver.position();
    13861386    bool checkForEndLineMatch = layoutState.endLine();
    13871387    RenderTextInfo renderTextInfo;
    … …  
    13951395            layoutState.setEndLineMatched(matchedEndLine(layoutState, resolver, cleanLineStart, cleanLineBidiStatus));
    13961396            if (layoutState.endLineMatched()) {
    1397                 resolver.setPosition(InlineIterator(resolver.position().root(), 0, 0), 0);
     1397                resolver.setPosition(LegacyInlineIterator(resolver.position().root(), 0, 0), 0);
    13981398                layoutState.marginInfo().clearMargin();
    13991399                break;
    … …  
    14061406        layoutState.lineInfo().resetRunsFromLeadingWhitespace();
    14071407
    1408         const InlineIterator oldEnd = end;
     1408        const LegacyInlineIterator oldEnd = end;
    14091409        bool isNewUBAParagraph = layoutState.lineInfo().previousLineBrokeCleanly();
    14101410        FloatingObject* lastFloatFromPreviousLine = (m_flow.containsFloats()) ? m_flow.floatingObjects()->set().last().get() : nullptr;
    … …  
    14201420            resolver.markCurrentRunEmpty(); // FIXME: This can probably be replaced by an ASSERT (or just removed).
    14211421            layoutState.setCheckForFloatsFromLastLine(true);
    1422             resolver.setPosition(InlineIterator(resolver.position().root(), 0, 0), 0);
     1422            resolver.setPosition(LegacyInlineIterator(resolver.position().root(), 0, 0), 0);
    14231423            break;
    14241424        }
    … …  
    19591959    if (lastLine) {
    19601960        m_flow.setLogicalHeight(lastLine->lineBoxBottom());
    1961         InlineIterator iter = InlineIterator(&m_flow, lastLine->lineBreakObj(), lastLine->lineBreakPos());
     1961        LegacyInlineIterator iter = LegacyInlineIterator(&m_flow, lastLine->lineBreakObj(), lastLine->lineBreakPos());
    19621962        resolver.setPosition(iter, numberOfIsolateAncestors(iter));
    19631963        resolver.setStatus(lastLine->lineBreakBidiStatus());
    … …  
    19651965        TextDirection direction = style().direction();
    19661966        if (style().unicodeBidi() == Plaintext)
    1967             determineDirectionality(direction, InlineIterator(&m_flow, bidiFirstSkippingEmptyInlines(m_flow), 0));
     1967            determineDirectionality(direction, LegacyInlineIterator(&m_flow, firstInlineRendererSkippingEmpty(m_flow), 0));
    19681968        resolver.setStatus(BidiStatus(direction, isOverride(style().unicodeBidi())));
    1969         InlineIterator iter = InlineIterator(&m_flow, bidiFirstSkippingEmptyInlines(m_flow, &resolver), 0);
     1969        LegacyInlineIterator iter = LegacyInlineIterator(&m_flow, firstInlineRendererSkippingEmpty(m_flow, &resolver), 0);
    19701970        resolver.setPosition(iter, numberOfIsolateAncestors(iter));
    19711971    }
    … …  
    19731973}
    19741974
    1975 void LegacyLineLayout::determineEndPosition(LineLayoutState& layoutState, LegacyRootInlineBox* startLine, InlineIterator& cleanLineStart, BidiStatus& cleanLineBidiStatus)
     1975void LegacyLineLayout::determineEndPosition(LineLayoutState& layoutState, LegacyRootInlineBox* startLine, LegacyInlineIterator& cleanLineStart, BidiStatus& cleanLineBidiStatus)
    19761976{
    19771977    auto iteratorForFirstDirtyFloat = [](LineLayoutState::FloatList& floats) {
    … …  
    20162016    // in the block.
    20172017    LegacyRootInlineBox* previousLine = lastLine->prevRootBox();
    2018     cleanLineStart = InlineIterator(&m_flow, previousLine->lineBreakObj(), previousLine->lineBreakPos());
     2018    cleanLineStart = LegacyInlineIterator(&m_flow, previousLine->lineBreakObj(), previousLine->lineBreakPos());
    20192019    cleanLineBidiStatus = previousLine->lineBreakBidiStatus();
    20202020    layoutState.setEndLineLogicalTop(previousLine->lineBoxBottom());
    … …  
    20852085}
    20862086
    2087 bool LegacyLineLayout::matchedEndLine(LineLayoutState& layoutState, const InlineBidiResolver& resolver, const InlineIterator& endLineStart, const BidiStatus& endLineStatus)
     2087bool LegacyLineLayout::matchedEndLine(LineLayoutState& layoutState, const InlineBidiResolver& resolver, const LegacyInlineIterator& endLineStart, const BidiStatus& endLineStatus)
    20882088{
    20892089    if (resolver.position() == endLineStart) {

  • trunk/Source/WebCore/rendering/LegacyLineLayout.h

    r278405 r283367  
    3939class FrameViewLayoutContext;
    4040class LegacyInlineBox;
    41 class InlineIterator;
     41class LegacyInlineIterator;
    4242class LineInfo;
    4343class LineLayoutState;
    … …  
    9292    inline BidiRun* handleTrailingSpaces(BidiRunList<BidiRun>& bidiRuns, BidiContext* currentContext);
    9393    void appendFloatingObjectToLastLine(FloatingObject&);
    94     LegacyRootInlineBox* createLineBoxesFromBidiRuns(unsigned bidiLevel, BidiRunList<BidiRun>& bidiRuns, const InlineIterator& end, LineInfo&, VerticalPositionCache&, BidiRun* trailingSpaceRun, WordMeasurements&);
     94    LegacyRootInlineBox* createLineBoxesFromBidiRuns(unsigned bidiLevel, BidiRunList<BidiRun>& bidiRuns, const LegacyInlineIterator& end, LineInfo&, VerticalPositionCache&, BidiRun* trailingSpaceRun, WordMeasurements&);
    9595    void layoutRunsAndFloats(LineLayoutState&, bool hasInlineChild);
    96     inline const InlineIterator& restartLayoutRunsAndFloatsInRange(LayoutUnit oldLogicalHeight, LayoutUnit newLogicalHeight, FloatingObject* lastFloatFromPreviousLine, InlineBidiResolver&,  const InlineIterator& oldEnd);
    97     void layoutRunsAndFloatsInRange(LineLayoutState&, InlineBidiResolver&, const InlineIterator& cleanLineStart, const BidiStatus& cleanLineBidiStatus, unsigned consecutiveHyphenatedLines);
     96    inline const LegacyInlineIterator& restartLayoutRunsAndFloatsInRange(LayoutUnit oldLogicalHeight, LayoutUnit newLogicalHeight, FloatingObject* lastFloatFromPreviousLine, InlineBidiResolver&,  const LegacyInlineIterator& oldEnd);
     97    void layoutRunsAndFloatsInRange(LineLayoutState&, InlineBidiResolver&, const LegacyInlineIterator& cleanLineStart, const BidiStatus& cleanLineBidiStatus, unsigned consecutiveHyphenatedLines);
    9898    void reattachCleanLineFloats(LegacyRootInlineBox& cleanLine, LayoutUnit delta, bool isFirstCleanLine);
    9999    void linkToEndLineIfNeeded(LineLayoutState&);
    100100    void checkFloatInCleanLine(LegacyRootInlineBox& cleanLine, RenderBox& floatBoxOnCleanLine, FloatWithRect& matchingFloatWithRect, bool& encounteredNewFloat, bool& dirtiedByFloat);
    101101    LegacyRootInlineBox* determineStartPosition(LineLayoutState&, InlineBidiResolver&);
    102     void determineEndPosition(LineLayoutState&, LegacyRootInlineBox* startLine, InlineIterator& cleanLineStart, BidiStatus& cleanLineBidiStatus);
     102    void determineEndPosition(LineLayoutState&, LegacyRootInlineBox* startLine, LegacyInlineIterator& cleanLineStart, BidiStatus& cleanLineBidiStatus);
    103103    bool checkPaginationAndFloatsAtEndLine(LineLayoutState&);
    104104    bool lineWidthForPaginatedLineChanged(LegacyRootInlineBox* rootBox, LayoutUnit lineDelta, RenderFragmentedFlow*) const;
    105     bool matchedEndLine(LineLayoutState&, const InlineBidiResolver&, const InlineIterator& endLineStart, const BidiStatus& endLineStatus);
     105    bool matchedEndLine(LineLayoutState&, const InlineBidiResolver&, const LegacyInlineIterator& endLineStart, const BidiStatus& endLineStatus);
    106106    void deleteEllipsisLineBoxes();
    107107    void checkLinesForTextOverflow();

  • trunk/Source/WebCore/rendering/LegacyRootInlineBox.h

    r282736 r283367  
    201201
    202202    // Where this line ended. The exact object and the position within that object are stored so that
    203     // we can create an InlineIterator beginning just after the end of this line.
     203    // we can create an LegacyInlineIterator beginning just after the end of this line.
    204204    WeakPtr<RenderObject> m_lineBreakObj;
    205205    RefPtr<BidiContext> m_lineBreakContext;

  • trunk/Source/WebCore/rendering/RenderBlock.cpp

    r283365 r283367  
    4040#include "HitTestResult.h"
    4141#include "ImageBuffer.h"
    42 #include "InlineIterator.h"
    4342#include "InlineWalker.h"
    4443#include "LayoutRepainter.h"

  • trunk/Source/WebCore/rendering/RenderBlockFlow.cpp

    r282873 r283367  
    3434#include "HTMLTextAreaElement.h"
    3535#include "HitTestLocation.h"
    36 #include "InlineIterator.h"
    3736#include "LayoutIntegrationLineIterator.h"
    3837#include "LayoutIntegrationLineLayout.h"

  • trunk/Source/WebCore/rendering/RenderInline.cpp

    r283312 r283367  
    11191119}
    11201120
     1121bool isEmptyInline(const RenderInline& renderer)
     1122{
     1123    for (auto& current : childrenOfType<RenderObject>(renderer)) {
     1124        if (current.isFloatingOrOutOfFlowPositioned())
     1125            continue;
     1126        if (is<RenderText>(current)) {
     1127            if (!downcast<RenderText>(current).isAllCollapsibleWhitespace())
     1128                return false;
     1129            continue;
     1130        }
     1131        if (!is<RenderInline>(current) || !isEmptyInline(downcast<RenderInline>(current)))
     1132            return false;
     1133    }
     1134    return true;
     1135}
     1136
    11211137} // namespace WebCore

  • trunk/Source/WebCore/rendering/RenderInline.h

    r282223 r283367  
    149149};
    150150
     151bool isEmptyInline(const RenderInline&);
     152
    151153} // namespace WebCore
    152154

  • trunk/Source/WebCore/rendering/RenderTreeAsText.cpp

    r282223 r283367  
    3636#include "HTMLNames.h"
    3737#include "HTMLSpanElement.h"
    38 #include "InlineIterator.h"
    3938#include "LayoutIntegrationRunIterator.h"
    4039#include "LegacyInlineTextBox.h"

  • trunk/Source/WebCore/rendering/line/BreakingContext.h

    r281731 r283367  
    130130
    131131    RenderObject* currentObject() { return m_current.renderer(); }
    132     InlineIterator lineBreak() { return m_lineBreak; }
     132    LegacyInlineIterator lineBreak() { return m_lineBreak; }
    133133    LineWidth& lineWidth() { return m_width; }
    134134    bool atEnd() { return m_atEnd; }
    … …  
    146146    void handleReplaced();
    147147    bool handleText(WordMeasurements&, bool& hyphenated, unsigned& consecutiveHyphenatedLines);
    148     void trailingSpacesHang(InlineIterator&, RenderObject&, bool canBreakMidWord, bool previousCharacterIsSpace);
     148    void trailingSpacesHang(LegacyInlineIterator&, RenderObject&, bool canBreakMidWord, bool previousCharacterIsSpace);
    149149    bool canBreakAtThisPosition();
    150150    void commitAndUpdateLineBreakIfNeeded();
    151     InlineIterator handleEndOfLine();
     151    LegacyInlineIterator handleEndOfLine();
    152152   
    153153    float computeAdditionalBetweenWordsWidth(RenderText&, TextLayout*, UChar, WordTrailingSpace&, HashSet<const Font*>& fallbackFonts, WordMeasurements&, const FontCascade&, bool isFixedPitch, unsigned lastSpace, float lastSpaceWordSpacing, float wordSpacingForWordMeasurement, unsigned offset);
    … …  
    178178    InlineBidiResolver& m_resolver;
    179179
    180     InlineIterator m_current;
    181     InlineIterator m_lineBreak;
    182     InlineIterator m_startOfIgnoredSpaces;
     180    LegacyInlineIterator m_current;
     181    LegacyInlineIterator m_lineBreak;
     182    LegacyInlineIterator m_startOfIgnoredSpaces;
    183183
    184184    RenderBlockFlow& m_block;
    … …  
    238238    auto& renderer = *m_current.renderer();
    239239
    240     m_nextObject = bidiNextSkippingEmptyInlines(m_block, &renderer);
     240    m_nextObject = nextInlineRendererSkippingEmpty(m_block, &renderer);
    241241    if (m_nextObject && m_nextObject->parent() && !m_nextObject->parent()->isDescendantOf(renderer.parent()))
    242242        m_includeEndWidth = true;
    … …  
    293293        // FIXME: Do this regardless of the container's alignment - will require rebaselining a lot of test results.
    294294        else if (m_ignoringSpaces && (m_blockStyle.textAlign() == TextAlignMode::Right || m_blockStyle.textAlign() == TextAlignMode::WebKitRight))
    295             m_lineWhitespaceCollapsingState.stopIgnoringSpaces(InlineIterator(0, m_current.renderer(), m_current.offset()));
     295            m_lineWhitespaceCollapsingState.stopIgnoringSpaces(LegacyInlineIterator(0, m_current.renderer(), m_current.offset()));
    296296
    297297        if (!m_lineInfo.isEmpty())
    … …  
    404404inline bool shouldSkipWhitespaceAfterStartObject(RenderBlockFlow& block, RenderObject* o, LineWhitespaceCollapsingState& lineWhitespaceCollapsingState)
    405405{
    406     RenderObject* next = bidiNextSkippingEmptyInlines(block, o);
     406    RenderObject* next = nextInlineRendererSkippingEmpty(block, o);
    407407    while (next && next->isFloatingOrOutOfFlowPositioned())
    408         next = bidiNextSkippingEmptyInlines(block, next);
     408        next = nextInlineRendererSkippingEmpty(block, next);
    409409
    410410    if (is<RenderText>(next) && downcast<RenderText>(*next).text().length() > 0) {
    … …  
    412412        UChar nextChar = nextText.characterAt(0);
    413413        if (nextText.style().isCollapsibleWhiteSpace(nextChar)) {
    414             lineWhitespaceCollapsingState.startIgnoringSpaces(InlineIterator(nullptr, o, 0));
     414            lineWhitespaceCollapsingState.startIgnoringSpaces(LegacyInlineIterator(nullptr, o, 0));
    415415            return true;
    416416        }
    … …  
    475475
    476476    if (m_ignoringSpaces)
    477         m_lineWhitespaceCollapsingState.stopIgnoringSpaces(InlineIterator(0, &replacedBox, 0));
     477        m_lineWhitespaceCollapsingState.stopIgnoringSpaces(LegacyInlineIterator(0, &replacedBox, 0));
    478478
    479479    m_lineInfo.setEmpty(false, &m_block, &m_width);
    … …  
    516516}
    517517
    518 inline bool iteratorIsBeyondEndOfRenderCombineText(const InlineIterator& iter, RenderCombineText& renderer)
     518inline bool iteratorIsBeyondEndOfRenderCombineText(const LegacyInlineIterator& iter, RenderCombineText& renderer)
    519519{
    520520    return iter.renderer() == &renderer && iter.offset() >= renderer.text().length();
    … …  
    562562
    563563// Adding a pair of whitespace collapsing transitions before a character will split it out into a new line box.
    564 inline void ensureCharacterGetsLineBox(LineWhitespaceCollapsingState& lineWhitespaceCollapsingState, InlineIterator& textParagraphSeparator)
    565 {
    566     InlineIterator transition(0, textParagraphSeparator.renderer(), textParagraphSeparator.offset());
    567     lineWhitespaceCollapsingState.startIgnoringSpaces(InlineIterator(0, textParagraphSeparator.renderer(), textParagraphSeparator.offset() - 1));
    568     lineWhitespaceCollapsingState.stopIgnoringSpaces(InlineIterator(0, textParagraphSeparator.renderer(), textParagraphSeparator.offset()));
    569 }
    570 
    571 inline void tryHyphenating(RenderText& text, const FontCascade& font, const AtomString& localeIdentifier, unsigned consecutiveHyphenatedLines, int consecutiveHyphenatedLinesLimit, int minimumPrefixLimit, int minimumSuffixLimit, unsigned lastSpace, unsigned pos, float xPos, float availableWidth, bool isFixedPitch, bool collapseWhiteSpace, int lastSpaceWordSpacing, InlineIterator& lineBreak, std::optional<unsigned> nextBreakable, bool& hyphenated)
     564inline void ensureCharacterGetsLineBox(LineWhitespaceCollapsingState& lineWhitespaceCollapsingState, LegacyInlineIterator& textParagraphSeparator)
     565{
     566    LegacyInlineIterator transition(0, textParagraphSeparator.renderer(), textParagraphSeparator.offset());
     567    lineWhitespaceCollapsingState.startIgnoringSpaces(LegacyInlineIterator(0, textParagraphSeparator.renderer(), textParagraphSeparator.offset() - 1));
     568    lineWhitespaceCollapsingState.stopIgnoringSpaces(LegacyInlineIterator(0, textParagraphSeparator.renderer(), textParagraphSeparator.offset()));
     569}
     570
     571inline void tryHyphenating(RenderText& text, const FontCascade& font, const AtomString& localeIdentifier, unsigned consecutiveHyphenatedLines, int consecutiveHyphenatedLinesLimit, int minimumPrefixLimit, int minimumSuffixLimit, unsigned lastSpace, unsigned pos, float xPos, float availableWidth, bool isFixedPitch, bool collapseWhiteSpace, int lastSpaceWordSpacing, LegacyInlineIterator& lineBreak, std::optional<unsigned> nextBreakable, bool& hyphenated)
    572572{
    573573    // Map 'hyphenate-limit-{before,after}: auto;' to 2.
    … …  
    817817                    wordSpacingForWordMeasurement = 0;
    818818                    lastSpace = m_current.offset(); // e.g., "Foo    goo", don't add in any of the ignored spaces.
    819                     m_lineWhitespaceCollapsingState.stopIgnoringSpaces(InlineIterator(0, &renderer, m_current.offset()));
     819                    m_lineWhitespaceCollapsingState.stopIgnoringSpaces(LegacyInlineIterator(0, &renderer, m_current.offset()));
    820820                    stoppedIgnoringSpaces = true;
    821821                } else {
    … …  
    978978                    // before the second space.
    979979                    m_lineWhitespaceCollapsingState.startIgnoringSpaces(m_startOfIgnoredSpaces);
    980                     m_trailingObjects.updateWhitespaceCollapsingTransitionsForTrailingBoxes(m_lineWhitespaceCollapsingState, InlineIterator(), TrailingObjects::CollapseFirstSpace::No);
     980                    m_trailingObjects.updateWhitespaceCollapsingTransitionsForTrailingBoxes(m_lineWhitespaceCollapsingState, LegacyInlineIterator(), TrailingObjects::CollapseFirstSpace::No);
    981981                }
    982982            }
    … …  
    995995                wordSpacingForWordMeasurement = (applyWordSpacing && wordMeasurements.last().width) ? wordSpacing : 0;
    996996                lastSpace = m_current.offset(); // e.g., "Foo    goo", don't add in any of the ignored spaces.
    997                 m_lineWhitespaceCollapsingState.stopIgnoringSpaces(InlineIterator(nullptr, &renderer, m_current.offset()));
     997                m_lineWhitespaceCollapsingState.stopIgnoringSpaces(LegacyInlineIterator(nullptr, &renderer, m_current.offset()));
    998998            }
    999999            if (m_hangsAtEnd && !renderer.isHangableStopOrComma(c))
    … …  
    10831083}
    10841084
    1085 inline void BreakingContext::trailingSpacesHang(InlineIterator& lineBreak, RenderObject& renderObject, bool canBreakMidWord, bool previousCharacterIsSpace)
     1085inline void BreakingContext::trailingSpacesHang(LegacyInlineIterator& lineBreak, RenderObject& renderObject, bool canBreakMidWord, bool previousCharacterIsSpace)
    10861086{
    10871087    ASSERT(m_currWS == WhiteSpace::BreakSpaces);
    … …  
    11831183}
    11841184
    1185 inline TrailingObjects::CollapseFirstSpace checkWhitespaceCollapsingTransitions(LineWhitespaceCollapsingState& lineWhitespaceCollapsingState, const InlineIterator& lBreak)
     1185inline TrailingObjects::CollapseFirstSpace checkWhitespaceCollapsingTransitions(LineWhitespaceCollapsingState& lineWhitespaceCollapsingState, const LegacyInlineIterator& lBreak)
    11861186{
    11871187    // Check to see if our last transition is a start point beyond the line break. If so,
    … …  
    11891189    // preserve whitespace.
    11901190    if (lBreak.renderer() && lineWhitespaceCollapsingState.numTransitions() && !(lineWhitespaceCollapsingState.numTransitions() % 2)) {
    1191         const InlineIterator* transitions = lineWhitespaceCollapsingState.transitions().data();
    1192         const InlineIterator& endpoint = transitions[lineWhitespaceCollapsingState.numTransitions() - 2];
    1193         const InlineIterator& startpoint = transitions[lineWhitespaceCollapsingState.numTransitions() - 1];
    1194         InlineIterator currpoint = endpoint;
     1191        const LegacyInlineIterator* transitions = lineWhitespaceCollapsingState.transitions().data();
     1192        const LegacyInlineIterator& endpoint = transitions[lineWhitespaceCollapsingState.numTransitions() - 2];
     1193        const LegacyInlineIterator& startpoint = transitions[lineWhitespaceCollapsingState.numTransitions() - 1];
     1194        LegacyInlineIterator currpoint = endpoint;
    11951195        while (!currpoint.atEnd() && currpoint != startpoint && currpoint != lBreak)
    11961196            currpoint.increment();
    … …  
    12071207}
    12081208
    1209 inline InlineIterator BreakingContext::handleEndOfLine()
     1209inline LegacyInlineIterator BreakingContext::handleEndOfLine()
    12101210{
    12111211    if (m_lineBreak == m_resolver.position()) {

  • trunk/Source/WebCore/rendering/line/LineBreaker.cpp

    r278305 r283367  
    4444// NB. this function will insert any floating elements that would otherwise
    4545// be skipped but it will not position them.
    46 void LineBreaker::skipTrailingWhitespace(InlineIterator& iterator, const LineInfo& lineInfo)
     46void LineBreaker::skipTrailingWhitespace(LegacyInlineIterator& iterator, const LineInfo& lineInfo)
    4747{
    4848    while (!iterator.atEnd() && !requiresLineBox(iterator, lineInfo, TrailingWhitespace)) {
    … …  
    7878}
    7979
    80 InlineIterator LineBreaker::nextLineBreak(InlineBidiResolver& resolver, LineInfo& lineInfo, RenderTextInfo& renderTextInfo, FloatingObject* lastFloatFromPreviousLine, unsigned consecutiveHyphenatedLines, WordMeasurements& wordMeasurements)
     80LegacyInlineIterator LineBreaker::nextLineBreak(InlineBidiResolver& resolver, LineInfo& lineInfo, RenderTextInfo& renderTextInfo, FloatingObject* lastFloatFromPreviousLine, unsigned consecutiveHyphenatedLines, WordMeasurements& wordMeasurements)
    8181{
    8282    reset();

  • trunk/Source/WebCore/rendering/line/LineBreaker.h

    r278305 r283367  
    2525#pragma once
    2626
    27 #include "InlineIterator.h"
     27#include "LegacyInlineIterator.h"
    2828#include "LineInfo.h"
    2929#include "LineInlineHeaders.h"
    … …  
    5252    }
    5353
    54     InlineIterator nextLineBreak(InlineBidiResolver&, LineInfo&, RenderTextInfo&, FloatingObject* lastFloatFromPreviousLine, unsigned consecutiveHyphenatedLines, WordMeasurements&);
     54    LegacyInlineIterator nextLineBreak(InlineBidiResolver&, LineInfo&, RenderTextInfo&, FloatingObject* lastFloatFromPreviousLine, unsigned consecutiveHyphenatedLines, WordMeasurements&);
    5555
    5656    bool lineWasHyphenated() { return m_hyphenated; }
    … …  
    6161    void reset();
    6262
    63     void skipTrailingWhitespace(InlineIterator&, const LineInfo&);
     63    void skipTrailingWhitespace(LegacyInlineIterator&, const LineInfo&);
    6464    void skipLeadingWhitespace(InlineBidiResolver&, LineInfo&, FloatingObject* lastFloatFromPreviousLine, LineWidth&);
    6565

  • trunk/Source/WebCore/rendering/line/LineInlineHeaders.h

    r248528 r283367  
    7373}
    7474
    75 inline bool skipNonBreakingSpace(const InlineIterator& it, const LineInfo& lineInfo)
     75inline bool skipNonBreakingSpace(const LegacyInlineIterator& it, const LineInfo& lineInfo)
    7676{
    7777    if (it.renderer()->style().nbspMode() != NBSPMode::Space || it.current() != noBreakSpace)
    … …  
    9797}
    9898
    99 inline bool requiresLineBox(const InlineIterator& it, const LineInfo& lineInfo = LineInfo(), WhitespacePosition whitespacePosition = LeadingWhitespace)
     99inline bool requiresLineBox(const LegacyInlineIterator& it, const LineInfo& lineInfo = LineInfo(), WhitespacePosition whitespacePosition = LeadingWhitespace)
    100100{
    101101    if (it.renderer()->isFloatingOrOutOfFlowPositioned())

  • trunk/Source/WebCore/rendering/line/TrailingObjects.cpp

    r276202 r283367  
    2626#include "TrailingObjects.h"
    2727
    28 #include "InlineIterator.h"
     28#include "LegacyInlineIterator.h"
    2929
    3030namespace WebCore {
    3131
    32 void TrailingObjects::updateWhitespaceCollapsingTransitionsForTrailingBoxes(LineWhitespaceCollapsingState& lineWhitespaceCollapsingState, const InlineIterator& lBreak, CollapseFirstSpace collapseFirstSpace)
     32void TrailingObjects::updateWhitespaceCollapsingTransitionsForTrailingBoxes(LineWhitespaceCollapsingState& lineWhitespaceCollapsingState, const LegacyInlineIterator& lBreak, CollapseFirstSpace collapseFirstSpace)
    3333{
    3434    if (!m_whitespace)
    … …  
    6464        unsigned length = m_whitespace->text().length();
    6565        unsigned pos = length >= 2 ? length - 2 : UINT_MAX;
    66         InlineIterator endMid(0, m_whitespace, pos);
     66        LegacyInlineIterator endMid(0, m_whitespace, pos);
    6767        lineWhitespaceCollapsingState.startIgnoringSpaces(endMid);
    6868        for (size_t i = 0; i < m_boxes.size(); ++i)

  • trunk/Source/WebCore/rendering/line/TrailingObjects.h

    r276202 r283367  
    2929namespace WebCore {
    3030
    31 class InlineIterator;
     31class LegacyInlineIterator;
    3232class RenderBoxModelObject;
    3333class RenderText;
    … …  
    3939template <class Iterator, class Run, class IsolateRun> class BidiResolverWithIsolate;
    4040template <class Iterator> class WhitespaceCollapsingState;
    41 typedef BidiResolverWithIsolate<InlineIterator, BidiRun, BidiIsolatedRun> InlineBidiResolver;
    42 typedef WhitespaceCollapsingState<InlineIterator> LineWhitespaceCollapsingState;
     41typedef BidiResolverWithIsolate<LegacyInlineIterator, BidiRun, BidiIsolatedRun> InlineBidiResolver;
     42typedef WhitespaceCollapsingState<LegacyInlineIterator> LineWhitespaceCollapsingState;
    4343
    4444class TrailingObjects {
    … …  
    5858
    5959    enum class CollapseFirstSpace { No, Yes };
    60     void updateWhitespaceCollapsingTransitionsForTrailingBoxes(LineWhitespaceCollapsingState&, const InlineIterator& lBreak, CollapseFirstSpace);
     60    void updateWhitespaceCollapsingTransitionsForTrailingBoxes(LineWhitespaceCollapsingState&, const LegacyInlineIterator& lBreak, CollapseFirstSpace);
    6161
    6262private:

  • trunk/Source/WebCore/rendering/updating/RenderTreeBuilderList.cpp

    r248517 r283367  
    2525#include "RenderTreeBuilderList.h"
    2626
    27 #include "InlineIterator.h"
     27#include "LegacyInlineIterator.h"
    2828#include "LineInlineHeaders.h"
    2929#include "RenderChildIterator.h"
    … …  
    3535namespace WebCore {
    3636
    37 // FIXME: This shouldn't need InlineIterator
     37// FIXME: This shouldn't need LegacyInlineIterator
    3838static bool generatesLineBoxesForInlineChild(RenderBlock& current, RenderObject* inlineObj)
    3939{
    40     InlineIterator it(&current, inlineObj, 0);
     40    LegacyInlineIterator it(&current, inlineObj, 0);
    4141    while (!it.atEnd() && !requiresLineBox(it))
    4242        it.increment();
Note: See TracChangeset for help on using the changeset viewer.