#include "config.h"

#include "LegacyLineLayout.h"

#include "AXObjectCache.h"

#include "BidiResolver.h"

#include "BreakingContext.h"

#include "DocumentInlines.h"

#include "FloatingObjects.h"

#include "HTMLParserIdioms.h"

#include "InlineIteratorBox.h"

#include "InlineIteratorTextBox.h"

#include "InlineTextBoxStyle.h"

#include "InlineWalker.h"

#include "LegacyInlineElementBox.h"

#include "LegacyInlineIterator.h"

#include "LegacyInlineTextBox.h"

#include "LineLayoutState.h"

#include "Logging.h"

#include "RenderBlockFlow.h"

#include "RenderFragmentContainer.h"

#include "RenderFragmentedFlow.h"

#include "RenderLayoutState.h"

#include "RenderLineBreak.h"

#include "RenderRubyBase.h"

#include "RenderRubyText.h"

#include "RenderSVGText.h"

#include "RenderView.h"

#include "SVGElementTypeHelpers.h"

#include "SVGRootInlineBox.h"

#include "Settings.h"

#include "VerticalPositionCache.h"

#include <wtf/StdLibExtras.h>

namespace WebCore {

LegacyLineLayout::LegacyLineLayout(RenderBlockFlow& flow)

: m_flow(flow)

{

}

LegacyLineLayout::~LegacyLineLayout()

{

if (m_flow.containsFloats())

m_flow.floatingObjects()->clearLineBoxTreePointers();

lineBoxes().deleteLineBoxTree();

};

static void determineDirectionality(TextDirection& dir, LegacyInlineIterator iter)

}

inline std::unique_ptr<BidiRun> createRun(int start, int end, RenderObject& obj, InlineBidiResolver& resolver)

{

return makeUnique<BidiRun>(start, end, obj, resolver.context(), resolver.dir());

}

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

}

std::unique_ptr<LegacyRootInlineBox> LegacyLineLayout::createRootInlineBox()

}

LegacyRootInlineBox* LegacyLineLayout::createAndAppendRootInlineBox()

{

auto newRootBox = createRootInlineBox();

LegacyRootInlineBox* rootBox = newRootBox.get();

m_lineBoxes.appendLineBox(WTFMove(newRootBox));

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

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

cache->deferRecomputeIsIgnored(m_flow.element());

}

return rootBox;

}

LegacyInlineBox* LegacyLineLayout::createInlineBoxForRenderer(RenderObject* renderer, bool isOnlyRun)

{

if (renderer == &m_flow)

return 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(LegacyInlineFlowBox* parentBox)

}

LegacyInlineFlowBox* LegacyLineLayout::createLineBoxes(RenderObject* obj, const LineInfo& lineInfo, LegacyInlineBox* childBox)

{

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

// the last item on the line.

unsigned lineDepth = 1;

LegacyInlineFlowBox* parentBox = nullptr;

LegacyInlineFlowBox* result = nullptr;

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

do {

RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(is<RenderInline>(*obj) || obj == &m_flow);

RenderInline* inlineFlow = obj != &m_flow ? 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 canUseExistingParentBox = parentBox && !parentIsConstructedOrHaveNext(parentBox);

if (!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.

LegacyInlineBox* newBox = createInlineBoxForRenderer(obj);

parentBox = downcast<LegacyInlineFlowBox>(newBox);

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

parentBox->setIsHorizontal(m_flow.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 == &m_flow)

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) ? &m_flow : obj->parent();

} while (true);

return result;

}

template<typename CharacterType> static inline bool endsWithHTMLSpaces(const CharacterType* characters, unsigned position, unsigned end)

}

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

}

LegacyRootInlineBox* LegacyLineLayout::constructLine(BidiRunList<BidiRun>& bidiRuns, const LineInfo& lineInfo)

{

ASSERT(bidiRuns.firstRun());

LegacyInlineFlowBox* 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;

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

r->setBox(box);

// 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);

}

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

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

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

textBox.setStart(r->m_start);

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

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 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) : !is<RenderInline>(bidiRuns.logicallyLastRun()->renderer());

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

// Now mark the line boxes as being constructed.

lastRootBox()->setConstructed();

// Return the last line.

return lastRootBox();

}

TextAlignMode LegacyLineLayout::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 LegacyLineLayout::setMarginsForRubyRun(BidiRun* run, RenderRubyRun& renderer, RenderObject* previousObject, const LineInfo& lineInfo)

}

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

}

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

}

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

}

void LegacyLineLayout::updateLogicalWidthForAlignment(RenderBlockFlow& flow, const TextAlignMode& textAlign, const LegacyRootInlineBox* 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 LegacyLineLayout::computeInlineDirectionPositionsForLine(LegacyRootInlineBox* lineBox, const LineInfo& lineInfo, BidiRun* firstRun, BidiRun* trailingSpaceRun, bool reachedEnd, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, VerticalPositionCache& verticalPositionCache, WordMeasurements& wordMeasurements)

}

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

}

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

}

static bool inlineAncestorHasStartBorderPaddingOrMargin(const RenderBlockFlow& block, const LegacyInlineBox& box)

}

static bool inlineAncestorHasEndBorderPaddingOrMargin(const RenderBlockFlow& block, const LegacyInlineBox& box)

}

static bool isLastInFlowRun(BidiRun& runToCheck)

}

BidiRun* LegacyLineLayout::computeInlineDirectionPositionsForSegment(LegacyRootInlineBox* lineBox, const LineInfo& lineInfo, TextAlignMode textAlign, float& lineLogicalLeft,

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

WordMeasurements& wordMeasurements)

{

bool needsWordSpacing = false;

bool canHangPunctuationAtStart = style().hangingPunctuation().contains(HangingPunctuation::First);

bool canHangPunctuationAtEnd = style().hangingPunctuation().contains(HangingPunctuation::Last);

bool isLTR = style().isLeftToRightDirection();

float contentWidth = 0;

unsigned expansionOpportunityCount = 0;

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

Vector<unsigned, 16> expansionOpportunities;

HashMap<LegacyInlineTextBox*, LayoutUnit> logicalSpacingForInlineTextBoxes;

auto collectSpacingLogicalWidths = [&] () {

auto totalSpacingWidth = LayoutUnit { };

// Collect the spacing positions (margin, border padding) for the textboxes by traversing the inline tree of the current line.

Vector<LegacyInlineBox*> queue;

queue.append(lineBox);

// 1. Visit each inline box in a preorder fashion

// 2. Accumulate the spacing when we find an LegacyInlineFlowBox (inline container e.g. span)

// 3. Add the LegacyInlineTextBoxes to the hashmap

while (!queue.isEmpty()) {

while (true) {

auto* inlineBox = queue.last();

if (is<LegacyInlineFlowBox>(inlineBox)) {

auto& inlineFlowBox = downcast<LegacyInlineFlowBox>(*inlineBox);

totalSpacingWidth += inlineFlowBox.marginBorderPaddingLogicalLeft();

if (auto* child = inlineFlowBox.firstChild()) {

queue.append(child);

continue;

}

break;

}

if (is<LegacyInlineTextBox>(inlineBox))

logicalSpacingForInlineTextBoxes.add(downcast<LegacyInlineTextBox>(inlineBox), totalSpacingWidth);

break;

}

while (!queue.isEmpty()) {

auto& inlineBox = *queue.takeLast();

if (is<LegacyInlineFlowBox>(inlineBox))

totalSpacingWidth += downcast<LegacyInlineFlowBox>(inlineBox).marginBorderPaddingLogicalRight();

if (auto* nextSibling = inlineBox.nextOnLine()) {

queue.append(nextSibling);

break;

}

}

}

};

collectSpacingLogicalWidths();

BidiRun* run = firstRun;

BidiRun* previousRun = nullptr;

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

auto computeExpansionOpportunities = [&expansionOpportunities, &expansionOpportunityCount, textAlign, &isAfterExpansion] (RenderBlockFlow& block,

LegacyInlineTextBox& textBox, BidiRun* previousRun, BidiRun* nextRun, StringView stringView, TextDirection direction)

{

if (stringView.isEmpty()) {

// Empty runs should still produce an entry in expansionOpportunities list so that the number of items matches the number of runs.

expansionOpportunities.append(0);

return;

}

ExpansionBehavior expansionBehavior = expansionBehaviorForInlineTextBox(block, textBox, previousRun, nextRun, textAlign, isAfterExpansion);

applyExpansionBehavior(textBox, expansionBehavior);

unsigned opportunitiesInRun;

std::tie(opportunitiesInRun, isAfterExpansion) = FontCascade::expansionOpportunityCount(stringView, direction, expansionBehavior);

expansionOpportunities.append(opportunitiesInRun);

expansionOpportunityCount += opportunitiesInRun;

};

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

// 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.

continue;

}

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

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

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

if (canHangPunctuationAtStart && lineInfo.isFirstLine() && (isLTR || isLastInFlowRun(*run))

&& !inlineAncestorHasStartBorderPaddingOrMargin(m_flow, *run->box())) {

float hangStartWidth = renderText.hangablePunctuationStartWidth(run->m_start);

availableLogicalWidth += hangStartWidth;

if (style().isLeftToRightDirection())

lineLogicalLeft -= hangStartWidth;

canHangPunctuationAtStart = false;

}

if (canHangPunctuationAtEnd && lineInfo.isLastLine() && run->m_stop > 0 && (!isLTR || isLastInFlowRun(*run))

&& !inlineAncestorHasEndBorderPaddingOrMargin(m_flow, *run->box())) {

float hangEndWidth = renderText.hangablePunctuationEndWidth(run->m_stop - 1);

availableLogicalWidth += hangEndWidth;

if (!style().isLeftToRightDirection())

lineLogicalLeft -= hangEndWidth;

canHangPunctuationAtEnd = false;

}

if (textAlign == TextAlignMode::Justify && run != trailingSpaceRun)

computeExpansionOpportunities(m_flow, textBox, previousRun, run->next(), renderText.stringView(run->m_start, run->m_stop), run->box()->direction());

if (unsigned length = renderText.text().length()) {

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

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

// run->m_start == run->m_stop should only be true iff the run is a replaced run for bidi: isolate.

ASSERT(run->m_stop > 0 || run->m_start == run->m_stop);

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

}

auto currentLogicalLeftPosition = logicalSpacingForInlineTextBoxes.get(&textBox) + contentWidth;

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

} else {

canHangPunctuationAtStart = false;

bool encounteredJustifiedRuby = false;

if (is<RenderRubyRun>(run->renderer()) && textAlign == TextAlignMode::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()->firstLeafDescendant(); leafChild; leafChild = leafChild->nextLeafOnLine()) {

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

continue;

encounteredJustifiedRuby = true;

computeExpansionOpportunities(*rubyBase, downcast<LegacyInlineTextBox>(*leafChild), nullptr, nullptr,

downcast<RenderText>(leafChild->renderer()).stringView(), leafChild->direction());

}

}

}

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(m_flow.logicalWidthForChild(renderBox));

contentWidth += m_flow.marginStartForChild(renderBox) + m_flow.marginEndForChild(renderBox);

}

}

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

previousRun = run;

}

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

// FIXME: see <webkit.org/b/139393#c11>

int lastValidExpansionOpportunitiesIndex = expansionOpportunities.size() - 1;

while (lastValidExpansionOpportunitiesIndex >= 0 && !expansionOpportunities.at(lastValidExpansionOpportunitiesIndex))

--lastValidExpansionOpportunitiesIndex;

if (lastValidExpansionOpportunitiesIndex >= 0) {

ASSERT(expansionOpportunities.at(lastValidExpansionOpportunitiesIndex));

expansionOpportunities.at(lastValidExpansionOpportunitiesIndex)--;

expansionOpportunityCount--;

}

}

if (is<RenderRubyBase>(m_flow) && !expansionOpportunityCount)

textAlign = TextAlignMode::Center;

auto totalLogicalWidth = contentWidth + lineBox->getFlowSpacingLogicalWidth();

updateLogicalWidthForAlignment(m_flow, textAlign, lineBox, trailingSpaceRun, lineLogicalLeft, totalLogicalWidth, availableLogicalWidth, expansionOpportunityCount);

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

return run;

}