#include "config.h"

#include "AXObjectCache.h"

#include "BidiResolver.h"

#include "BreakingContext.h"

#include "FloatingObjects.h"

#include "InlineElementBox.h"

#include "InlineIterator.h"

#include "InlineTextBox.h"

#include "InlineTextBoxStyle.h"

#include "LineLayoutState.h"

#include "Logging.h"

#include "RenderBlockFlow.h"

#include "RenderFlowThread.h"

#include "RenderLineBreak.h"

#include "RenderRegion.h"

#include "RenderRubyBase.h"

#include "RenderRubyText.h"

#include "RenderView.h"

#include "SVGRootInlineBox.h"

#include "Settings.h"

#include "SimpleLineLayoutFunctions.h"

#include "TrailingFloatsRootInlineBox.h"

#include "VerticalPositionCache.h"

#include <wtf/RefCountedLeakCounter.h>

#include <wtf/StdLibExtras.h>

namespace WebCore {

static void determineDirectionality(TextDirection& dir, InlineIterator iter)

}

inline BidiRun* createRun(int start, int end, RenderObject& obj, InlineBidiResolver& resolver)

{

return new BidiRun(start, end, obj, resolver.context(), resolver.dir());

}

void RenderBlockFlow::appendRunsForObject(BidiRunList<BidiRun>* runs, int start, int end, RenderObject& obj, InlineBidiResolver& resolver)

}

std::unique_ptr<RootInlineBox> RenderBlockFlow::createRootInlineBox()

{

return std::make_unique<RootInlineBox>(*this);

}

RootInlineBox* RenderBlockFlow::createAndAppendRootInlineBox()

{

auto newRootBox = createRootInlineBox();

RootInlineBox* rootBox = newRootBox.get();

m_lineBoxes.appendLineBox(WTFMove(newRootBox));

if (UNLIKELY(AXObjectCache::accessibilityEnabled()) && firstRootBox() == rootBox) {

if (AXObjectCache* cache = document().existingAXObjectCache())

cache->recomputeIsIgnored(this);

}

return rootBox;

}

static inline InlineBox* createInlineBoxForRenderer(RenderObject* renderer, bool isRootLineBox, bool isOnlyRun = false)

{

if (isRootLineBox)

return downcast<RenderBlockFlow>(*renderer).createAndAppendRootInlineBox();

if (is<RenderText>(*renderer))

return downcast<RenderText>(*renderer).createInlineTextBox();

if (is<RenderBox>(*renderer)) {

// FIXME: This is terrible. This branch returns an *owned* pointer!

return downcast<RenderBox>(*renderer).createInlineBox().release();

}

if (is<RenderLineBreak>(*renderer)) {

// FIXME: This is terrible. This branch returns an *owned* pointer!

auto inlineBox = downcast<RenderLineBreak>(*renderer).createInlineBox().release();

// We only treat a box as text for a <br> if we are on a line by ourself or in strict mode

// (Note the use of strict mode. In "almost strict" mode, we don't treat the box for <br> as text.)

inlineBox->setBehavesLikeText(isOnlyRun || renderer->document().inNoQuirksMode() || renderer->isLineBreakOpportunity());

return inlineBox;

}

return downcast<RenderInline>(*renderer).createAndAppendInlineFlowBox();

}

static inline void dirtyLineBoxesForRenderer(RenderObject& renderer, bool fullLayout)

}

static bool parentIsConstructedOrHaveNext(InlineFlowBox* parentBox)

}

InlineFlowBox* RenderBlockFlow::createLineBoxes(RenderObject* obj, const LineInfo& lineInfo, InlineBox* childBox)

{

// See if we have an unconstructed line box for this object that is also

// the last item on the line.

unsigned lineDepth = 1;

InlineFlowBox* parentBox = nullptr;

InlineFlowBox* result = nullptr;

bool hasDefaultLineBoxContain = style().lineBoxContain() == RenderStyle::initialLineBoxContain();

do {

ASSERT_WITH_SECURITY_IMPLICATION(is<RenderInline>(*obj) || obj == this);

RenderInline* inlineFlow = obj != this ? downcast<RenderInline>(obj) : nullptr;

// Get the last box we made for this render object.

parentBox = inlineFlow ? inlineFlow->lastLineBox() : downcast<RenderBlockFlow>(*obj).lastRootBox();

// If this box or its ancestor is constructed then it is from a previous line, and we need

// to make a new box for our line. If this box or its ancestor is unconstructed but it has

// something following it on the line, then we know we have to make a new box

// as well. In this situation our inline has actually been split in two on

// the same line (this can happen with very fancy language mixtures).

bool constructedNewBox = false;

bool allowedToConstructNewBox = !hasDefaultLineBoxContain || !inlineFlow || inlineFlow->alwaysCreateLineBoxes();

bool canUseExistingParentBox = parentBox && !parentIsConstructedOrHaveNext(parentBox);

if (allowedToConstructNewBox && !canUseExistingParentBox) {

// We need to make a new box for this render object. Once

// made, we need to place it at the end of the current line.

InlineBox* newBox = createInlineBoxForRenderer(obj, obj == this);

parentBox = downcast<InlineFlowBox>(newBox);

parentBox->setIsFirstLine(lineInfo.isFirstLine());

parentBox->setIsHorizontal(isHorizontalWritingMode());

if (!hasDefaultLineBoxContain)

parentBox->clearDescendantsHaveSameLineHeightAndBaseline();

constructedNewBox = true;

}

if (constructedNewBox || canUseExistingParentBox) {

if (!result)

result = parentBox;

// If we have hit the block itself, then |box| represents the root

// inline box for the line, and it doesn't have to be appended to any parent

// inline.

if (childBox)

parentBox->addToLine(childBox);

if (!constructedNewBox || obj == this)

break;

childBox = parentBox;

}

// If we've exceeded our line depth, then jump straight to the root and skip all the remaining

// intermediate inline flows.

obj = (++lineDepth >= cMaxLineDepth) ? this : obj->parent();

} while (true);

return result;

}

template <typename CharacterType>

static inline bool endsWithASCIISpaces(const CharacterType* characters, unsigned pos, unsigned end)

}

static bool reachedEndOfTextRenderer(const BidiRunList<BidiRun>& bidiRuns)

}

RootInlineBox* RenderBlockFlow::constructLine(BidiRunList<BidiRun>& bidiRuns, const LineInfo& lineInfo)

{

ASSERT(bidiRuns.firstRun());

bool rootHasSelectedChildren = false;

InlineFlowBox* parentBox = 0;

int runCount = bidiRuns.runCount() - lineInfo.runsFromLeadingWhitespace();

for (BidiRun* r = bidiRuns.firstRun(); r; r = r->next()) {

// Create a box for our object.

bool isOnlyRun = (runCount == 1);

if (runCount == 2 && !r->renderer().isListMarker())

isOnlyRun = (!style().isLeftToRightDirection() ? bidiRuns.lastRun() : bidiRuns.firstRun())->renderer().isListMarker();

if (lineInfo.isEmpty())

continue;

InlineBox* box = createInlineBoxForRenderer(&r->renderer(), false, isOnlyRun);

r->setBox(box);

if (!rootHasSelectedChildren && box->renderer().selectionState() != RenderObject::SelectionNone)

rootHasSelectedChildren = true;

// If we have no parent box yet, or if the run is not simply a sibling,

// then we need to construct inline boxes as necessary to properly enclose the

// run's inline box. Segments can only be siblings at the root level, as

// they are positioned separately.

if (!parentBox || &parentBox->renderer() != r->renderer().parent()) {

// Create new inline boxes all the way back to the appropriate insertion point.

RenderObject* parentToUse = r->renderer().parent();

parentBox = createLineBoxes(parentToUse, lineInfo, box);

} else {

// Append the inline box to this line.

parentBox->addToLine(box);

}

bool visuallyOrdered = r->renderer().style().rtlOrdering() == VisualOrder;

box->setBidiLevel(r->level());

if (is<InlineTextBox>(*box)) {

auto& textBox = downcast<InlineTextBox>(*box);

textBox.setStart(r->m_start);

textBox.setLen(r->m_stop - r->m_start);

textBox.setDirOverride(r->dirOverride(visuallyOrdered));

if (r->m_hasHyphen)

textBox.setHasHyphen(true);

}

}

// We should have a root inline box. It should be unconstructed and

// be the last continuation of our line list.

ASSERT(lastRootBox() && !lastRootBox()->isConstructed());

// Set the m_selectedChildren flag on the root inline box if one of the leaf inline box

// from the bidi runs walk above has a selection state.

if (rootHasSelectedChildren)

lastRootBox()->root().setHasSelectedChildren(true);

// Set bits on our inline flow boxes that indicate which sides should

// paint borders/margins/padding. This knowledge will ultimately be used when

// we determine the horizontal positions and widths of all the inline boxes on

// the line.

bool isLogicallyLastRunWrapped = bidiRuns.logicallyLastRun()->renderer().isText() ? !reachedEndOfTextRenderer(bidiRuns) : true;

lastRootBox()->determineSpacingForFlowBoxes(lineInfo.isLastLine(), isLogicallyLastRunWrapped, &bidiRuns.logicallyLastRun()->renderer());

// Now mark the line boxes as being constructed.

lastRootBox()->setConstructed();

// Return the last line.

return lastRootBox();

}

ETextAlign RenderBlockFlow::textAlignmentForLine(bool endsWithSoftBreak) const

}

static void updateLogicalWidthForLeftAlignedBlock(bool isLeftToRightDirection, BidiRun* trailingSpaceRun, float& logicalLeft, float& totalLogicalWidth, float availableLogicalWidth)

}

static void updateLogicalWidthForRightAlignedBlock(bool isLeftToRightDirection, BidiRun* trailingSpaceRun, float& logicalLeft, float& totalLogicalWidth, float availableLogicalWidth)

}

static void updateLogicalWidthForCenterAlignedBlock(bool isLeftToRightDirection, BidiRun* trailingSpaceRun, float& logicalLeft, float& totalLogicalWidth, float availableLogicalWidth)

}

void RenderBlockFlow::setMarginsForRubyRun(BidiRun* run, RenderRubyRun& renderer, RenderObject* previousObject, const LineInfo& lineInfo)

}

static inline void setLogicalWidthForTextRun(RootInlineBox* lineBox, BidiRun* run, RenderText& renderer, float xPos, const LineInfo& lineInfo,

}

void RenderBlockFlow::updateRubyForJustifiedText(RenderRubyRun& rubyRun, BidiRun& r, const Vector<unsigned, 16>& expansionOpportunities, unsigned& expansionOpportunityCount, float& totalLogicalWidth, float availableLogicalWidth, size_t& i)

}

void RenderBlockFlow::computeExpansionForJustifiedText(BidiRun* firstRun, BidiRun* trailingSpaceRun, const Vector<unsigned, 16>& expansionOpportunities, unsigned expansionOpportunityCount, float totalLogicalWidth, float availableLogicalWidth)

}

void RenderBlockFlow::updateLogicalWidthForAlignment(const ETextAlign& textAlign, const RootInlineBox* rootInlineBox, BidiRun* trailingSpaceRun, float& logicalLeft, float& totalLogicalWidth, float& availableLogicalWidth, int expansionOpportunityCount)

}

static void updateLogicalInlinePositions(RenderBlockFlow& block, float& lineLogicalLeft, float& lineLogicalRight, float& availableLogicalWidth, bool firstLine,

}

void RenderBlockFlow::computeInlineDirectionPositionsForLine(RootInlineBox* lineBox, const LineInfo& lineInfo, BidiRun* firstRun, BidiRun* trailingSpaceRun, bool reachedEnd, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, VerticalPositionCache& verticalPositionCache, WordMeasurements& wordMeasurements)

}

static inline ExpansionBehavior expansionBehaviorForInlineTextBox(RenderBlockFlow& block, InlineTextBox& textBox, BidiRun* previousRun, BidiRun* nextRun, ETextAlign textAlign, bool isAfterExpansion)

}

static inline void applyExpansionBehavior(InlineTextBox& textBox, ExpansionBehavior expansionBehavior)

}

BidiRun* RenderBlockFlow::computeInlineDirectionPositionsForSegment(RootInlineBox* lineBox, const LineInfo& lineInfo, ETextAlign textAlign, float& logicalLeft,

float& availableLogicalWidth, BidiRun* firstRun, BidiRun* trailingSpaceRun, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, VerticalPositionCache& verticalPositionCache,

WordMeasurements& wordMeasurements)

{

bool needsWordSpacing = false;

float totalLogicalWidth = lineBox->getFlowSpacingLogicalWidth();

unsigned expansionOpportunityCount = 0;

bool isAfterExpansion = is<RenderRubyBase>(*this) ? downcast<RenderRubyBase>(*this).isAfterExpansion() : true;

Vector<unsigned, 16> expansionOpportunities;

BidiRun* run = firstRun;

BidiRun* previousRun = nullptr;

for (; run; run = run->next()) {

if (!run->box() || run->renderer().isOutOfFlowPositioned() || run->box()->isLineBreak()) {

continue; // Positioned objects are only participating to figure out their

// correct static x position. They have no effect on the width.

// Similarly, line break boxes have no effect on the width.

}

if (is<RenderText>(run->renderer())) {

auto& renderText = downcast<RenderText>(run->renderer());

auto& textBox = downcast<InlineTextBox>(*run->box());

if (textAlign == JUSTIFY && run != trailingSpaceRun) {

ExpansionBehavior expansionBehavior = expansionBehaviorForInlineTextBox(*this, textBox, previousRun, run->next(), textAlign, isAfterExpansion);

applyExpansionBehavior(textBox, expansionBehavior);

unsigned opportunitiesInRun;

std::tie(opportunitiesInRun, isAfterExpansion) = FontCascade::expansionOpportunityCount(renderText.stringView(run->m_start, run->m_stop), run->box()->direction(), expansionBehavior);

expansionOpportunities.append(opportunitiesInRun);

expansionOpportunityCount += opportunitiesInRun;

}

if (int length = renderText.textLength()) {

if (!run->m_start && needsWordSpacing && isSpaceOrNewline(renderText.characterAt(run->m_start)))

totalLogicalWidth += lineStyle(*renderText.parent(), lineInfo).fontCascade().wordSpacing();

needsWordSpacing = !isSpaceOrNewline(renderText.characterAt(run->m_stop - 1)) && run->m_stop == length;

}

setLogicalWidthForTextRun(lineBox, run, renderText, totalLogicalWidth, lineInfo, textBoxDataMap, verticalPositionCache, wordMeasurements);

} else {

bool encounteredJustifiedRuby = false;

if (is<RenderRubyRun>(run->renderer()) && textAlign == JUSTIFY && run != trailingSpaceRun && downcast<RenderRubyRun>(run->renderer()).rubyBase()) {

auto* rubyBase = downcast<RenderRubyRun>(run->renderer()).rubyBase();

if (rubyBase->firstRootBox() && !rubyBase->firstRootBox()->nextRootBox() && run->renderer().style().collapseWhiteSpace()) {

rubyBase->setIsAfterExpansion(isAfterExpansion);

for (auto* leafChild = rubyBase->firstRootBox()->firstLeafChild(); leafChild; leafChild = leafChild->nextLeafChild()) {

if (!is<InlineTextBox>(*leafChild))

continue;

auto& textBox = downcast<InlineTextBox>(*leafChild);

encounteredJustifiedRuby = true;

auto& renderText = downcast<RenderText>(leafChild->renderer());

ExpansionBehavior expansionBehavior = expansionBehaviorForInlineTextBox(*rubyBase, textBox, nullptr, nullptr, textAlign, isAfterExpansion);

applyExpansionBehavior(textBox, expansionBehavior);

unsigned opportunitiesInRun;

std::tie(opportunitiesInRun, isAfterExpansion) = FontCascade::expansionOpportunityCount(renderText.stringView(), leafChild->direction(), expansionBehavior);

expansionOpportunities.append(opportunitiesInRun);

expansionOpportunityCount += opportunitiesInRun;

}

}

}

if (!encounteredJustifiedRuby)

isAfterExpansion = false;

if (!is<RenderInline>(run->renderer())) {

auto& renderBox = downcast<RenderBox>(run->renderer());

if (is<RenderRubyRun>(renderBox))

setMarginsForRubyRun(run, downcast<RenderRubyRun>(renderBox), previousRun ? &previousRun->renderer() : nullptr, lineInfo);

run->box()->setLogicalWidth(logicalWidthForChild(renderBox));

totalLogicalWidth += marginStartForChild(renderBox) + marginEndForChild(renderBox);

}

}

totalLogicalWidth += run->box()->logicalWidth();

previousRun = run;

}

if (isAfterExpansion && !expansionOpportunities.isEmpty()) {

expansionOpportunities.last()--;

expansionOpportunityCount--;

}

if (is<RenderRubyBase>(*this) && !expansionOpportunityCount)

textAlign = CENTER;

updateLogicalWidthForAlignment(textAlign, lineBox, trailingSpaceRun, logicalLeft, totalLogicalWidth, availableLogicalWidth, expansionOpportunityCount);

computeExpansionForJustifiedText(firstRun, trailingSpaceRun, expansionOpportunities, expansionOpportunityCount, totalLogicalWidth, availableLogicalWidth);

return run;

}

void RenderBlockFlow::removeInlineBox(BidiRun& run, const RootInlineBox& rootLineBox) const

}

void RenderBlockFlow::computeBlockDirectionPositionsForLine(RootInlineBox* lineBox, BidiRun* firstRun, GlyphOverflowAndFallbackFontsMap& textBoxDataMap,

}

static inline bool isCollapsibleSpace(UChar character, const RenderText& renderer)

}

template <typename CharacterType>

static inline int findFirstTrailingSpace(const RenderText& lastText, const CharacterType* characters, int start, int stop)

}

inline BidiRun* RenderBlockFlow::handleTrailingSpaces(BidiRunList<BidiRun>& bidiRuns, BidiContext* currentContext)

{

if (!bidiRuns.runCount()

|| !bidiRuns.logicallyLastRun()->renderer().style().breakOnlyAfterWhiteSpace()

|| !bidiRuns.logicallyLastRun()->renderer().style().autoWrap())

return nullptr;

BidiRun* trailingSpaceRun = bidiRuns.logicallyLastRun();

const RenderObject& lastObject = trailingSpaceRun->renderer();

if (!is<RenderText>(lastObject))

return nullptr;

const RenderText& lastText = downcast<RenderText>(lastObject);