{

if (!percentHeightDescendantsMap) {

percentHeightDescendantsMap = new TrackedDescendantsMap;

percentHeightContainerMap = new TrackedContainerMap;

}

auto& descendantSet = percentHeightDescendantsMap->ensure(&container, [] {

return std::make_unique<TrackedRendererListHashSet>();

}).iterator->value;

bool added = descendantSet->add(&descendant).isNewEntry;

if (!added) {

ASSERT(percentHeightContainerMap->get(&descendant));

ASSERT(percentHeightContainerMap->get(&descendant)->contains(&container));

return;

}

auto& containerSet = percentHeightContainerMap->ensure(&descendant, [] {

return std::make_unique<HashSet<const RenderBlock*>>();

}).iterator->value;

ASSERT(!containerSet->contains(&container));

containerSet->add(&container);

{

if (!percentHeightDescendantsMap)

return;

std::unique_ptr<HashSet<const RenderBlock*>> containerSet = percentHeightContainerMap->take(&descendant);

if (!containerSet)

return;

for (auto* container : *containerSet) {

// FIXME: Disabling this assert temporarily until we fix the layout

// bugs associated with positioned objects not properly cleared from

// their ancestor chain before being moved. See webkit bug 93766.

// ASSERT(descendant->isDescendantOf(container));

auto descendantsMapIterator = percentHeightDescendantsMap->find(container);

ASSERT(descendantsMapIterator != percentHeightDescendantsMap->end());

if (descendantsMapIterator == percentHeightDescendantsMap->end())

continue;

auto& descendantSet = descendantsMapIterator->value;

ASSERT(descendantSet->contains(&descendant));

descendantSet->remove(&descendant);

if (descendantSet->isEmpty())

percentHeightDescendantsMap->remove(descendantsMapIterator);

}

enum class MoveDescendantToEnd { No, Yes };

void addDescendant(const RenderBlock& containingBlock, RenderBox& positionedDescendant, MoveDescendantToEnd moveDescendantToEnd)

{

// Protect against double insert where a descendant would end up with multiple containing blocks.

auto* previousContainingBlock = m_containerMap.get(&positionedDescendant);

if (previousContainingBlock && previousContainingBlock != &containingBlock) {

if (auto* descendants = m_descendantsMap.get(previousContainingBlock))

descendants->remove(&positionedDescendant);

}

auto& descendants = m_descendantsMap.ensure(&containingBlock, [] {

return std::make_unique<TrackedRendererListHashSet>();

}).iterator->value;

bool isNewEntry = moveDescendantToEnd == MoveDescendantToEnd::Yes ? descendants->appendOrMoveToLast(&positionedDescendant).isNewEntry

: descendants->add(&positionedDescendant).isNewEntry;

if (!isNewEntry) {

ASSERT(m_containerMap.contains(&positionedDescendant));

return;

}

m_containerMap.set(&positionedDescendant, &containingBlock);

}

void removeDescendant(const RenderBox& positionedDescendant)

{

auto* containingBlock = m_containerMap.take(&positionedDescendant);

if (!containingBlock)

return;

auto descendantsIterator = m_descendantsMap.find(containingBlock);

ASSERT(descendantsIterator != m_descendantsMap.end());

if (descendantsIterator == m_descendantsMap.end())

return;

auto& descendants = descendantsIterator->value;

ASSERT(descendants->contains(const_cast<RenderBox*>(&positionedDescendant)));

descendants->remove(const_cast<RenderBox*>(&positionedDescendant));

if (descendants->isEmpty())

m_descendantsMap.remove(descendantsIterator);

}

void removeContainingBlock(const RenderBlock& containingBlock)

{

auto descendants = m_descendantsMap.take(&containingBlock);

if (!descendants)

return;

for (auto* renderer : *descendants)

m_containerMap.remove(renderer);

}

TrackedRendererListHashSet* positionedRenderers(const RenderBlock& containingBlock) const

{

return m_descendantsMap.get(&containingBlock);

}

using DescendantsMap = HashMap<const RenderBlock*, std::unique_ptr<TrackedRendererListHashSet>>;

using ContainerMap = HashMap<const RenderBox*, const RenderBlock*>;

DescendantsMap m_descendantsMap;

ContainerMap m_containerMap;

UpdateScrollInfoAfterLayoutTransaction(const RenderView& view)

: nestedCount(0)

, view(&view)

{

}

int nestedCount;

const RenderView* view;

HashSet<RenderBlock*> blocks;

WTF_MAKE_NONCOPYABLE(RenderBlockRareData); WTF_MAKE_FAST_ALLOCATED;

RenderBlockRareData()

: m_paginationStrut(0)

, m_pageLogicalOffset(0)

, m_flowThreadContainingBlock(Nullopt)

{

}

LayoutUnit m_paginationStrut;

LayoutUnit m_pageLogicalOffset;

Optional<RenderFlowThread*> m_flowThreadContainingBlock;

WTF_MAKE_NONCOPYABLE(OverflowEventDispatcher);

OverflowEventDispatcher(const RenderBlock* block)

: m_block(block)

, m_hadHorizontalLayoutOverflow(false)

, m_hadVerticalLayoutOverflow(false)

{

m_shouldDispatchEvent = !m_block->isAnonymous() && m_block->hasOverflowClip() && m_block->document().hasListenerType(Document::OVERFLOWCHANGED_LISTENER);

if (m_shouldDispatchEvent) {

m_hadHorizontalLayoutOverflow = m_block->hasHorizontalLayoutOverflow();

m_hadVerticalLayoutOverflow = m_block->hasVerticalLayoutOverflow();

}

}

~OverflowEventDispatcher()

{

if (!m_shouldDispatchEvent)

return;

bool hasHorizontalLayoutOverflow = m_block->hasHorizontalLayoutOverflow();

bool hasVerticalLayoutOverflow = m_block->hasVerticalLayoutOverflow();

bool horizontalLayoutOverflowChanged = hasHorizontalLayoutOverflow != m_hadHorizontalLayoutOverflow;

bool verticalLayoutOverflowChanged = hasVerticalLayoutOverflow != m_hadVerticalLayoutOverflow;

if (!horizontalLayoutOverflowChanged && !verticalLayoutOverflowChanged)

return;

Ref<OverflowEvent> overflowEvent = OverflowEvent::create(horizontalLayoutOverflowChanged, hasHorizontalLayoutOverflow, verticalLayoutOverflowChanged, hasVerticalLayoutOverflow);

overflowEvent->setTarget(m_block->element());

m_block->document().enqueueOverflowEvent(WTFMove(overflowEvent));

}

const RenderBlock* m_block;

bool m_shouldDispatchEvent;

bool m_hadHorizontalLayoutOverflow;

bool m_hadVerticalLayoutOverflow;

{

if (!percentHeightDescendantsMap)

return;

std::unique_ptr<TrackedRendererListHashSet> descendantSet = percentHeightDescendantsMap->take(block);

if (!descendantSet)

return;

for (auto* descendant : *descendantSet) {

auto it = percentHeightContainerMap->find(descendant);

ASSERT(it != percentHeightContainerMap->end());

if (it == percentHeightContainerMap->end())

continue;

auto* containerSet = it->value.get();

ASSERT(containerSet->contains(block));

containerSet->remove(block);

if (containerSet->isEmpty())

percentHeightContainerMap->remove(it);

}

{

if (!documentBeingDestroyed()) {

if (parent())

parent()->dirtyLinesFromChangedChild(*this);

}

RenderBox::willBeDestroyed();

{

bool hadTransform = oldStyle.hasTransformRelatedProperty();

bool willHaveTransform = newStyle.hasTransformRelatedProperty();

if (oldStyle.position() == newStyle.position() && hadTransform == willHaveTransform)

return;

// We are no longer the containing block for fixed descendants.

if (hadTransform && !willHaveTransform) {

// Our positioned descendants will be inserted into a new containing block's positioned objects list during the next layout.

removePositionedObjects(nullptr, NewContainingBlock);

return;

}

// We are no longer the containing block for absolute positioned descendants.

if (newStyle.position() == StaticPosition && !willHaveTransform) {

// Our positioned descendants will be inserted into a new containing block's positioned objects list during the next layout.

removePositionedObjects(nullptr, NewContainingBlock);

return;

}

// We are a new containing block.

if (oldStyle.position() == StaticPosition && !hadTransform) {

// Remove our absolutely positioned descendants from their current containing block.

// They will be inserted into our positioned objects list during layout.

auto* containingBlock = parent();

while (containingBlock && !is<RenderView>(*containingBlock)

&& (containingBlock->style().position() == StaticPosition || (containingBlock->isInline() && !containingBlock->isReplaced()))) {

if (containingBlock->style().position() == RelativePosition && containingBlock->isInline() && !containingBlock->isReplaced()) {

containingBlock = containingBlock->containingBlock();

break;

}

containingBlock = containingBlock->parent();

}

if (containingBlock && is<RenderBlock>(*containingBlock))

downcast<RenderBlock>(*containingBlock).removePositionedObjects(this, NewContainingBlock);

}

{

const RenderStyle* oldStyle = hasInitializedStyle() ? &style() : nullptr;

setReplaced(newStyle.isDisplayInlineType());

if (oldStyle)

removePositionedObjectsIfNeeded(*oldStyle, newStyle);

RenderBox::styleWillChange(diff, newStyle);

{

if (newStyle->isHorizontalWritingMode())

return oldStyle->borderLeftWidth() != newStyle->borderLeftWidth()

|| oldStyle->borderRightWidth() != newStyle->borderRightWidth()

|| oldStyle->paddingLeft() != newStyle->paddingLeft()

|| oldStyle->paddingRight() != newStyle->paddingRight();

return oldStyle->borderTopWidth() != newStyle->borderTopWidth()

|| oldStyle->borderBottomWidth() != newStyle->borderBottomWidth()

|| oldStyle->paddingTop() != newStyle->paddingTop()

|| oldStyle->paddingBottom() != newStyle->paddingBottom();

{

RenderStyle& newStyle = style();

bool hadTransform = hasTransform();

bool flowThreadContainingBlockInvalidated = false;

if (oldStyle && oldStyle->position() != newStyle.position()) {

invalidateFlowThreadContainingBlockIncludingDescendants();

flowThreadContainingBlockInvalidated = true;

}

RenderBox::styleDidChange(diff, oldStyle);

if (hadTransform != hasTransform() && !flowThreadContainingBlockInvalidated)

invalidateFlowThreadContainingBlockIncludingDescendants();

if (!isAnonymousBlock()) {

// Ensure that all of our continuation blocks pick up the new style.

for (RenderBlock* currCont = blockElementContinuation(); currCont; currCont = currCont->blockElementContinuation()) {

RenderBoxModelObject* nextCont = currCont->continuation();

currCont->setContinuation(0);

currCont->setStyle(newStyle);

currCont->setContinuation(nextCont);

}

}

propagateStyleToAnonymousChildren(PropagateToBlockChildrenOnly);

// It's possible for our border/padding to change, but for the overall logical width of the block to

// end up being the same. We keep track of this change so in layoutBlock, we can know to set relayoutChildren=true.

setHasBorderOrPaddingLogicalWidthChanged(oldStyle && diff == StyleDifferenceLayout && needsLayout() && borderOrPaddingLogicalWidthChanged(oldStyle, &newStyle));

{

RenderBlock* flow = continuationBefore(beforeChild);

ASSERT(!beforeChild || is<RenderBlock>(*beforeChild->parent()));

RenderBoxModelObject* beforeChildParent = nullptr;

if (beforeChild)

beforeChildParent = downcast<RenderBoxModelObject>(beforeChild->parent());

else {

RenderBoxModelObject* continuation = flow->continuation();

if (continuation)

beforeChildParent = continuation;

else

beforeChildParent = flow;

}

if (newChild->isFloatingOrOutOfFlowPositioned()) {

beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);

return;

}

bool childIsNormal = newChild->isInline() || !newChild->style().columnSpan();

bool bcpIsNormal = beforeChildParent->isInline() || !beforeChildParent->style().columnSpan();

bool flowIsNormal = flow->isInline() || !flow->style().columnSpan();

if (flow == beforeChildParent) {

flow->addChildIgnoringContinuation(newChild, beforeChild);

return;

}

// The goal here is to match up if we can, so that we can coalesce and create the

// minimal # of continuations needed for the inline.

if (childIsNormal == bcpIsNormal) {

beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);

return;

}

if (flowIsNormal == childIsNormal) {

flow->addChildIgnoringContinuation(newChild, 0); // Just treat like an append.

return;

}

beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);

{

RenderPtr<RenderBlock> cloneBlock;

if (isAnonymousBlock()) {

cloneBlock = RenderPtr<RenderBlock>(createAnonymousBlock());

cloneBlock->setChildrenInline(childrenInline());

} else {

RenderTreePosition insertionPosition(*parent());

cloneBlock = static_pointer_cast<RenderBlock>(element()->createElementRenderer(style(), insertionPosition));

cloneBlock->initializeStyle();

// This takes care of setting the right value of childrenInline in case

// generated content is added to cloneBlock and 'this' does not have

// generated content added yet.

cloneBlock->setChildrenInline(cloneBlock->firstChild() ? cloneBlock->firstChild()->isInline() : childrenInline());

}

cloneBlock->setFlowThreadState(flowThreadState());

return cloneBlock;

{

if (continuation() && !isAnonymousBlock())

addChildToContinuation(newChild, beforeChild);

else

addChildIgnoringContinuation(newChild, beforeChild);

{

if (beforeChild && beforeChild->parent() != this) {

RenderElement* beforeChildContainer = beforeChild->parent();

while (beforeChildContainer->parent() != this)

beforeChildContainer = beforeChildContainer->parent();

ASSERT(beforeChildContainer);

if (beforeChildContainer->isAnonymous()) {

// If the requested beforeChild is not one of our children, then this is because

// there is an anonymous container within this object that contains the beforeChild.

RenderElement* beforeChildAnonymousContainer = beforeChildContainer;

if (beforeChildAnonymousContainer->isAnonymousBlock()

#if ENABLE(FULLSCREEN_API)

// Full screen renderers and full screen placeholders act as anonymous blocks, not tables:

|| beforeChildAnonymousContainer->isRenderFullScreen()

|| beforeChildAnonymousContainer->isRenderFullScreenPlaceholder()

#endif

) {

// Insert the child into the anonymous block box instead of here.

if (newChild->isInline() || beforeChild->parent()->firstChild() != beforeChild)

beforeChild->parent()->addChild(newChild, beforeChild);

else

addChild(newChild, beforeChild->parent());

return;

}

ASSERT(beforeChildAnonymousContainer->isTable());

if (newChild->isTablePart()) {

// Insert into the anonymous table.

beforeChildAnonymousContainer->addChild(newChild, beforeChild);

return;

}

beforeChild = splitAnonymousBoxesAroundChild(beforeChild);

ASSERT(beforeChild->parent() == this);

if (beforeChild->parent() != this) {

// We should never reach here. If we do, we need to use the

// safe fallback to use the topmost beforeChild container.

beforeChild = beforeChildContainer;

}

}

}

bool madeBoxesNonInline = false;

// A block has to either have all of its children inline, or all of its children as blocks.

// So, if our children are currently inline and a block child has to be inserted, we move all our

// inline children into anonymous block boxes.

if (childrenInline() && !newChild->isInline() && !newChild->isFloatingOrOutOfFlowPositioned()) {

// This is a block with inline content. Wrap the inline content in anonymous blocks.

makeChildrenNonInline(beforeChild);

madeBoxesNonInline = true;

if (beforeChild && beforeChild->parent() != this) {

beforeChild = beforeChild->parent();

ASSERT(beforeChild->isAnonymousBlock());

ASSERT(beforeChild->parent() == this);

}

} else if (!childrenInline() && (newChild->isFloatingOrOutOfFlowPositioned() || newChild->isInline())) {

// If we're inserting an inline child but all of our children are blocks, then we have to make sure

// it is put into an anomyous block box. We try to use an existing anonymous box if possible, otherwise

// a new one is created and inserted into our list of children in the appropriate position.

RenderObject* afterChild = beforeChild ? beforeChild->previousSibling() : lastChild();

if (afterChild && afterChild->isAnonymousBlock()) {

downcast<RenderBlock>(*afterChild).addChild(newChild);

return;

}

if (newChild->isInline()) {

// No suitable existing anonymous box - create a new one.

RenderBlock* newBox = createAnonymousBlock();

RenderBox::addChild(newBox, beforeChild);

newBox->addChild(newChild);

return;

}

}

invalidateLineLayoutPath();

RenderBox::addChild(newChild, beforeChild);

if (madeBoxesNonInline && is<RenderBlock>(parent()) && isAnonymousBlock())

downcast<RenderBlock>(*parent()).removeLeftoverAnonymousBlock(this);

// this object may be dead here

RenderObject*& inlineRunStart,

RenderObject*& inlineRunEnd)

{

// Beginning at |start| we find the largest contiguous run of inlines that

// we can. We denote the run with start and end points, |inlineRunStart|

// and |inlineRunEnd|. Note that these two values may be the same if

// we encounter only one inline.

//

// We skip any non-inlines we encounter as long as we haven't found any

// inlines yet.

//

// |boundary| indicates a non-inclusive boundary point. Regardless of whether |boundary|

// is inline or not, we will not include it in a run with inlines before it. It's as though we encountered

// a non-inline.

// Start by skipping as many non-inlines as we can.

RenderObject * curr = start;

bool sawInline;

do {

while (curr && !(curr->isInline() || curr->isFloatingOrOutOfFlowPositioned()))

curr = curr->nextSibling();

inlineRunStart = inlineRunEnd = curr;

if (!curr)

return; // No more inline children to be found.

sawInline = curr->isInline();

curr = curr->nextSibling();

while (curr && (curr->isInline() || curr->isFloatingOrOutOfFlowPositioned()) && (curr != boundary)) {

inlineRunEnd = curr;

if (curr->isInline())

sawInline = true;

curr = curr->nextSibling();

}

} while (!sawInline);

{

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

cache->recomputeIsIgnored(this);

{

// makeChildrenNonInline takes a block whose children are *all* inline and it

// makes sure that inline children are coalesced under anonymous

// blocks. If |insertionPoint| is defined, then it represents the insertion point for

// the new block child that is causing us to have to wrap all the inlines. This

// means that we cannot coalesce inlines before |insertionPoint| with inlines following

// |insertionPoint|, because the new child is going to be inserted in between the inlines,

// splitting them.

ASSERT(isInlineBlockOrInlineTable() || !isInline());

ASSERT(!insertionPoint || insertionPoint->parent() == this);

setChildrenInline(false);

RenderObject* child = firstChild();

if (!child)

return;

deleteLines();

while (child) {

RenderObject* inlineRunStart;

RenderObject* inlineRunEnd;

getInlineRun(child, insertionPoint, inlineRunStart, inlineRunEnd);

if (!inlineRunStart)

break;

child = inlineRunEnd->nextSibling();

RenderBlock* block = createAnonymousBlock();

insertChildInternal(block, inlineRunStart, NotifyChildren);

moveChildrenTo(block, inlineRunStart, child);

}

#ifndef NDEBUG

for (RenderObject* c = firstChild(); c; c = c->nextSibling())

ASSERT(!c->isInline());

#endif

repaint();

{

ASSERT(child->isAnonymousBlock());

ASSERT(!child->childrenInline());

if (child->continuation())

return;

RenderObject* firstAnChild = child->firstChild();

RenderObject* lastAnChild = child->lastChild();

if (firstAnChild) {

RenderObject* o = firstAnChild;

while (o) {

o->setParent(this);

o = o->nextSibling();

}

firstAnChild->setPreviousSibling(child->previousSibling());

lastAnChild->setNextSibling(child->nextSibling());

if (child->previousSibling())

child->previousSibling()->setNextSibling(firstAnChild);

if (child->nextSibling())

child->nextSibling()->setPreviousSibling(lastAnChild);

if (child == firstChild())

setFirstChild(firstAnChild);

if (child == lastChild())

setLastChild(lastAnChild);

} else {

if (child == firstChild())

setFirstChild(child->nextSibling());

if (child == lastChild())

setLastChild(child->previousSibling());

if (child->previousSibling())

child->previousSibling()->setNextSibling(child->nextSibling());

if (child->nextSibling())

child->nextSibling()->setPreviousSibling(child->previousSibling());

}

child->setFirstChild(0);

child->m_next = 0;

// Remove all the information in the flow thread associated with the leftover anonymous block.

child->removeFromRenderFlowThread();

child->setParent(0);

child->setPreviousSibling(0);

child->setNextSibling(0);

child->destroy();

{

if (anonymousBlock.beingDestroyed() || anonymousBlock.continuation())

return false;

if (anonymousBlock.isRubyRun() || anonymousBlock.isRubyBase())

return false;

return true;

{

if (oldChild.documentBeingDestroyed() || oldChild.isInline() || oldChild.virtualContinuation())

return false;

if (previous) {

if (!previous->isAnonymousBlock())

return false;

RenderBlock& previousAnonymousBlock = downcast<RenderBlock>(*previous);

if (!canDropAnonymousBlock(previousAnonymousBlock))

return false;

}

if (next) {

if (!next->isAnonymousBlock())

return false;

RenderBlock& nextAnonymousBlock = downcast<RenderBlock>(*next);

if (!canDropAnonymousBlock(nextAnonymousBlock))

return false;

}

return true;

{

parent.setNeedsLayoutAndPrefWidthsRecalc();

parent.setChildrenInline(child.childrenInline());

if (auto* childFlowThread = child.flowThreadContainingBlock())

childFlowThread->removeFlowChildInfo(&child);

RenderObject* nextSibling = child.nextSibling();

parent.removeChildInternal(child, child.hasLayer() ? NotifyChildren : DontNotifyChildren);

child.moveAllChildrenTo(&parent, nextSibling, child.hasLayer());

// Delete the now-empty block's lines and nuke it.

child.deleteLines();

child.destroy();

{

// No need to waste time in merging or removing empty anonymous blocks.

// We can just bail out if our document is getting destroyed.

if (documentBeingDestroyed()) {

RenderBox::removeChild(oldChild);

return;

}

// If this child is a block, and if our previous and next siblings are both anonymous blocks

// with inline content, then we can fold the inline content back together.

RenderObject* prev = oldChild.previousSibling();

RenderObject* next = oldChild.nextSibling();

bool canMergeAnonymousBlocks = canMergeContiguousAnonymousBlocks(oldChild, prev, next);

if (canMergeAnonymousBlocks && prev && next) {

prev->setNeedsLayoutAndPrefWidthsRecalc();

RenderBlock& nextBlock = downcast<RenderBlock>(*next);

RenderBlock& prevBlock = downcast<RenderBlock>(*prev);

if (prev->childrenInline() != next->childrenInline()) {

RenderBlock& inlineChildrenBlock = prev->childrenInline() ? prevBlock : nextBlock;

RenderBlock& blockChildrenBlock = prev->childrenInline() ? nextBlock : prevBlock;

// Place the inline children block inside of the block children block instead of deleting it.

// In order to reuse it, we have to reset it to just be a generic anonymous block. Make sure

// to clear out inherited column properties by just making a new style, and to also clear the

// column span flag if it is set.

ASSERT(!inlineChildrenBlock.continuation());

// Cache this value as it might get changed in setStyle() call.

bool inlineChildrenBlockHasLayer = inlineChildrenBlock.hasLayer();

inlineChildrenBlock.setStyle(RenderStyle::createAnonymousStyleWithDisplay(&style(), BLOCK));

removeChildInternal(inlineChildrenBlock, inlineChildrenBlockHasLayer ? NotifyChildren : DontNotifyChildren);

// Now just put the inlineChildrenBlock inside the blockChildrenBlock.

RenderObject* beforeChild = prev == &inlineChildrenBlock ? blockChildrenBlock.firstChild() : nullptr;

blockChildrenBlock.insertChildInternal(&inlineChildrenBlock, beforeChild,

(inlineChildrenBlockHasLayer || blockChildrenBlock.hasLayer()) ? NotifyChildren : DontNotifyChildren);

next->setNeedsLayoutAndPrefWidthsRecalc();

// inlineChildrenBlock got reparented to blockChildrenBlock, so it is no longer a child

// of "this". we null out prev or next so that is not used later in the function.

if (&inlineChildrenBlock == &prevBlock)

prev = nullptr;

else

next = nullptr;

} else {

// Take all the children out of the |next| block and put them in

// the |prev| block.

nextBlock.moveAllChildrenIncludingFloatsTo(prevBlock, nextBlock.hasLayer() || prevBlock.hasLayer());

// Delete the now-empty block's lines and nuke it.

nextBlock.deleteLines();

nextBlock.destroy();

next = nullptr;

}

}

invalidateLineLayoutPath();

RenderBox::removeChild(oldChild);

RenderObject* child = prev ? prev : next;

if (canMergeAnonymousBlocks && child && !child->previousSibling() && !child->nextSibling() && canDropAnonymousBlockChild()) {

// The removal has knocked us down to containing only a single anonymous

// box. We can pull the content right back up into our box.

dropAnonymousBoxChild(*this, downcast<RenderBlock>(*child));

} else if (((prev && prev->isAnonymousBlock()) || (next && next->isAnonymousBlock())) && canDropAnonymousBlockChild()) {

// It's possible that the removal has knocked us down to a single anonymous

// block with floating siblings.

RenderBlock& anonBlock = downcast<RenderBlock>((prev && prev->isAnonymousBlock()) ? *prev : *next);

if (canDropAnonymousBlock(anonBlock)) {

bool dropAnonymousBlock = true;

for (auto& sibling : childrenOfType<RenderObject>(*this)) {

if (&sibling == &anonBlock)

continue;

if (!sibling.isFloating()) {

dropAnonymousBlock = false;

break;

}

}

if (dropAnonymousBlock)

dropAnonymousBoxChild(*this, anonBlock);

}

}

if (!firstChild()) {

// If this was our last child be sure to clear out our line boxes.

if (childrenInline())

deleteLines();

// If we are an empty anonymous block in the continuation chain,

// we need to remove ourself and fix the continuation chain.

if (!beingDestroyed() && isAnonymousBlockContinuation() && !oldChild.isListMarker()) {

auto containingBlockIgnoringAnonymous = containingBlock();

while (containingBlockIgnoringAnonymous && containingBlockIgnoringAnonymous->isAnonymousBlock())

containingBlockIgnoringAnonymous = containingBlockIgnoringAnonymous->containingBlock();

for (RenderObject* current = this; current; current = current->previousInPreOrder(containingBlockIgnoringAnonymous)) {

if (current->virtualContinuation() != this)

continue;

// Found our previous continuation. We just need to point it to

// |this|'s next continuation.

RenderBoxModelObject* nextContinuation = continuation();

if (is<RenderInline>(*current))

downcast<RenderInline>(*current).setContinuation(nextContinuation);

else if (is<RenderBlock>(*current))

downcast<RenderBlock>(*current).setContinuation(nextContinuation);

else

ASSERT_NOT_REACHED();

break;

}

setContinuation(nullptr);

destroy();

}

}

{

// Whether or not we collapse is dependent on whether all our normal flow children

// are also self-collapsing.

for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {

if (child->isFloatingOrOutOfFlowPositioned())

continue;

if (!child->isSelfCollapsingBlock())

return true;

}

return false;

{

// We are not self-collapsing if we

// (a) have a non-zero height according to layout (an optimization to avoid wasting time)

// (b) are a table,

// (c) have border/padding,

// (d) have a min-height

// (e) have specified that one of our margins can't collapse using a CSS extension

if (logicalHeight() > 0

|| isTable() || borderAndPaddingLogicalHeight()

|| style().logicalMinHeight().isPositive()

|| style().marginBeforeCollapse() == MSEPARATE || style().marginAfterCollapse() == MSEPARATE)

return false;

Length logicalHeightLength = style().logicalHeight();

bool hasAutoHeight = logicalHeightLength.isAuto();

if (logicalHeightLength.isPercentOrCalculated() && !document().inQuirksMode()) {

hasAutoHeight = true;

for (RenderBlock* cb = containingBlock(); cb && !is<RenderView>(*cb); cb = cb->containingBlock()) {

if (cb->style().logicalHeight().isFixed() || cb->isTableCell())

hasAutoHeight = false;

}

}

// If the height is 0 or auto, then whether or not we are a self-collapsing block depends

// on whether we have content that is all self-collapsing or not.

if (hasAutoHeight || ((logicalHeightLength.isFixed() || logicalHeightLength.isPercentOrCalculated()) && logicalHeightLength.isZero()))

return !childrenPreventSelfCollapsing();

return false;