Void testlist::Parent::reset() const { setExists(true); setFirstChild(Child()); setLastChild(Child()); setNextParentFreeParent(Parent()); setNumChilds(0); }
void RenderObjectChildList::appendChildNode(RenderObject* owner, RenderObject* newChild, bool notifyRenderer) { ASSERT(newChild->parent() == 0); ASSERT(!owner->isBlockFlow() || (!newChild->isTableSection() && !newChild->isTableRow() && !newChild->isTableCell())); newChild->setParent(owner); RenderObject* lChild = lastChild(); if (lChild) { newChild->setPreviousSibling(lChild); lChild->setNextSibling(newChild); } else setFirstChild(newChild); setLastChild(newChild); if (!owner->documentBeingDestroyed() && notifyRenderer) newChild->insertedIntoTree(); if (!owner->documentBeingDestroyed()) { RenderCounter::rendererSubtreeAttached(newChild); } newChild->setNeedsLayoutAndPrefWidthsRecalc(); // Goes up the containing block hierarchy. if (!owner->normalChildNeedsLayout()) owner->setChildNeedsLayout(true); // We may supply the static position for an absolute positioned child. if (AXObjectCache::accessibilityEnabled()) owner->document()->axObjectCache()->childrenChanged(owner); }
RenderObject* RenderObjectChildList::removeChildNode(RenderObject* owner, RenderObject* oldChild, bool notifyRenderer) { ASSERT(oldChild->parent() == owner); if (oldChild->isFloatingOrOutOfFlowPositioned()) toRenderBox(oldChild)->removeFloatingOrPositionedChildFromBlockLists(); // So that we'll get the appropriate dirty bit set (either that a normal flow child got yanked or // that a positioned child got yanked). if (!owner->documentBeingDestroyed() && notifyRenderer && oldChild->everHadLayout()) { oldChild->setNeedsLayoutAndPrefWidthsRecalc(); // We only repaint |oldChild| if we have a RenderLayer as its visual overflow may not be tracked by its parent. if (oldChild->hasLayer()) oldChild->repaint(); } // If we have a line box wrapper, delete it. if (oldChild->isBox()) toRenderBox(oldChild)->deleteLineBoxWrapper(); // If oldChild is the start or end of the selection, then clear the selection to // avoid problems of invalid pointers. // FIXME: The FrameSelection should be responsible for this when it // is notified of DOM mutations. if (!owner->documentBeingDestroyed() && oldChild->isSelectionBorder()) owner->view()->clearSelection(); if (!owner->documentBeingDestroyed() && notifyRenderer) oldChild->willBeRemovedFromTree(); // WARNING: There should be no code running between willBeRemovedFromTree and the actual removal below. // This is needed to avoid race conditions where willBeRemovedFromTree would dirty the tree's structure // and the code running here would force an untimely rebuilding, leaving |oldChild| dangling. if (oldChild->previousSibling()) oldChild->previousSibling()->setNextSibling(oldChild->nextSibling()); if (oldChild->nextSibling()) oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling()); if (firstChild() == oldChild) setFirstChild(oldChild->nextSibling()); if (lastChild() == oldChild) setLastChild(oldChild->previousSibling()); oldChild->setPreviousSibling(0); oldChild->setNextSibling(0); oldChild->setParent(0); // rendererRemovedFromTree walks the whole subtree. We can improve performance // by skipping this step when destroying the entire tree. if (!owner->documentBeingDestroyed()) { RenderCounter::rendererRemovedFromTree(oldChild); } if (AXObjectCache::accessibilityEnabled()) owner->document()->axObjectCache()->childrenChanged(owner); return oldChild; }
RenderObject* RenderObjectChildList::removeChildNode(RenderObject* owner, RenderObject* oldChild, bool notifyRenderer) { ASSERT(oldChild->parent() == owner); if (oldChild->isFloatingOrOutOfFlowPositioned()) toRenderBox(oldChild)->removeFloatingOrPositionedChildFromBlockLists(); // So that we'll get the appropriate dirty bit set (either that a normal flow child got yanked or // that a positioned child got yanked). We also repaint, so that the area exposed when the child // disappears gets repainted properly. if (!owner->documentBeingDestroyed() && notifyRenderer && oldChild->everHadLayout()) { oldChild->setNeedsLayoutAndPrefWidthsRecalc(); if (oldChild->isBody()) owner->view()->repaint(); else oldChild->repaint(); } // If we have a line box wrapper, delete it. if (oldChild->isBox()) toRenderBox(oldChild)->deleteLineBoxWrapper(); if (!owner->documentBeingDestroyed() && notifyRenderer) oldChild->willBeRemovedFromTree(); // If oldChild is the start or end of the selection, then clear the selection to // avoid problems of invalid pointers. // FIXME: The FrameSelection should be responsible for this when it // is notified of DOM mutations. if (!owner->documentBeingDestroyed() && oldChild->isSelectionBorder()) owner->view()->clearSelection(); // remove the child if (oldChild->previousSibling()) oldChild->previousSibling()->setNextSibling(oldChild->nextSibling()); if (oldChild->nextSibling()) oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling()); if (firstChild() == oldChild) setFirstChild(oldChild->nextSibling()); if (lastChild() == oldChild) setLastChild(oldChild->previousSibling()); oldChild->setPreviousSibling(0); oldChild->setNextSibling(0); oldChild->setParent(0); // rendererRemovedFromTree walks the whole subtree. We can improve performance // by skipping this step when destroying the entire tree. if (!owner->documentBeingDestroyed()) { RenderCounter::rendererRemovedFromTree(oldChild); } if (AXObjectCache::accessibilityEnabled()) owner->document()->axObjectCache()->childrenChanged(owner); return oldChild; }
void RenderObjectChildList::appendChildNode(RenderObject* owner, RenderObject* newChild, bool fullAppend) { ASSERT(newChild->parent() == 0); ASSERT(!owner->isBlockFlow() || (!newChild->isTableSection() && !newChild->isTableRow() && !newChild->isTableCell())); newChild->setParent(owner); RenderObject* lChild = lastChild(); if (lChild) { newChild->setPreviousSibling(lChild); lChild->setNextSibling(newChild); } else setFirstChild(newChild); setLastChild(newChild); if (fullAppend) { // Keep our layer hierarchy updated. Optimize for the common case where we don't have any children // and don't have a layer attached to ourselves. RenderLayer* layer = 0; if (newChild->firstChild() || newChild->hasLayer()) { layer = owner->enclosingLayer(); newChild->addLayers(layer); } // if the new child is visible but this object was not, tell the layer it has some visible content // that needs to be drawn and layer visibility optimization can't be used if (owner->style()->visibility() != VISIBLE && newChild->style()->visibility() == VISIBLE && !newChild->hasLayer()) { if (!layer) layer = owner->enclosingLayer(); if (layer) layer->setHasVisibleContent(true); } if (newChild->isListItem()) toRenderListItem(newChild)->updateListMarkerNumbers(); if (!newChild->isFloating() && owner->childrenInline()) owner->dirtyLinesFromChangedChild(newChild); if (newChild->isRenderRegion()) toRenderRegion(newChild)->attachRegion(); if (RenderNamedFlowThread* containerFlowThread = renderNamedFlowThreadContainer(owner)) containerFlowThread->addFlowChild(newChild); } RenderCounter::rendererSubtreeAttached(newChild); RenderQuote::rendererSubtreeAttached(newChild); newChild->setNeedsLayoutAndPrefWidthsRecalc(); // Goes up the containing block hierarchy. if (!owner->normalChildNeedsLayout()) owner->setChildNeedsLayout(true); // We may supply the static position for an absolute positioned child. if (AXObjectCache::accessibilityEnabled()) owner->document()->axObjectCache()->childrenChanged(owner); }
RenderObject* RenderObjectChildList::removeChildNode(RenderObject* owner, RenderObject* oldChild, bool notifyRenderer) { ASSERT(oldChild->parent() == owner); if (oldChild->isFloatingOrOutOfFlowPositioned()) toRenderBox(oldChild)->removeFloatingOrPositionedChildFromBlockLists(); { // FIXME: We should not be allowing paint invalidation during layout. crbug.com/336250 AllowPaintInvalidationScope scoper(owner->frameView()); // So that we'll get the appropriate dirty bit set (either that a normal flow child got yanked or // that a positioned child got yanked). We also issue paint invalidations, so that the area exposed when the child // disappears gets paint invalidated properly. if (!owner->documentBeingDestroyed() && notifyRenderer && oldChild->everHadLayout()) { oldChild->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(); oldChild->invalidatePaintForWholeRenderer(); } } // If we have a line box wrapper, delete it. if (oldChild->isBox()) toRenderBox(oldChild)->deleteLineBoxWrapper(); // If oldChild is the start or end of the selection, then clear the selection to // avoid problems of invalid pointers. // FIXME: The FrameSelection should be responsible for this when it // is notified of DOM mutations. if (!owner->documentBeingDestroyed() && oldChild->isSelectionBorder()) owner->view()->clearSelection(); if (!owner->documentBeingDestroyed() && notifyRenderer) oldChild->willBeRemovedFromTree(); // WARNING: There should be no code running between willBeRemovedFromTree and the actual removal below. // This is needed to avoid race conditions where willBeRemovedFromTree would dirty the tree's structure // and the code running here would force an untimely rebuilding, leaving |oldChild| dangling. if (oldChild->previousSibling()) oldChild->previousSibling()->setNextSibling(oldChild->nextSibling()); if (oldChild->nextSibling()) oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling()); if (firstChild() == oldChild) setFirstChild(oldChild->nextSibling()); if (lastChild() == oldChild) setLastChild(oldChild->previousSibling()); oldChild->setPreviousSibling(0); oldChild->setNextSibling(0); oldChild->setParent(0); return oldChild; }
void Node::append(Node* node) { assert(!node->parent()); assert(!node->previousSibling()); assert(!node->nextSibling()); node->setParent(this); if (!firstChild()) { assert(!lastChild()); setFirstChild(node); setLastChild(node); } else { assert(lastChild()); Node* lastChild = this->lastChild(); assert(!lastChild->nextSibling()); lastChild->setNextSibling(node); node->setPreviousSibling(lastChild); setLastChild(node); } }
void RenderObjectChildList::insertChildNode(RenderObject* owner, RenderObject* newChild, RenderObject* beforeChild, bool notifyRenderer) { ASSERT(!newChild->parent()); ASSERT(!owner->isBlockFlow() || (!newChild->isTableSection() && !newChild->isTableRow() && !newChild->isTableCell())); while (beforeChild && beforeChild->parent() && beforeChild->parent() != owner) beforeChild = beforeChild->parent(); // This should never happen, but if it does prevent render tree corruption // where child->parent() ends up being owner but child->nextSibling()->parent() // is not owner. if (beforeChild && beforeChild->parent() != owner) { ASSERT_NOT_REACHED(); return; } newChild->setParent(owner); if (firstChild() == beforeChild) setFirstChild(newChild); if (beforeChild) { RenderObject* previousSibling = beforeChild->previousSibling(); if (previousSibling) previousSibling->setNextSibling(newChild); newChild->setPreviousSibling(previousSibling); newChild->setNextSibling(beforeChild); beforeChild->setPreviousSibling(newChild); } else { if (lastChild()) lastChild()->setNextSibling(newChild); newChild->setPreviousSibling(lastChild()); setLastChild(newChild); } if (!owner->documentBeingDestroyed() && notifyRenderer) newChild->insertedIntoTree(); if (!owner->documentBeingDestroyed()) { RenderCounter::rendererSubtreeAttached(newChild); } newChild->setNeedsLayoutAndPrefWidthsRecalc(); owner->setPreferredLogicalWidthsDirty(true); if (!owner->normalChildNeedsLayout()) owner->setChildNeedsLayout(true); // We may supply the static position for an absolute positioned child. if (AXObjectCache* cache = owner->document().axObjectCache()) cache->childrenChanged(owner); }
Bool testlist::Parent::pushBackChild(const Child & child) const { if(!child.isExists() || child.getParent().isValid()) return false; Child last_child = getLastChild(); child.setPrevParentChild(last_child); if(last_child.isValid()) last_child.setNextParentChild(child); else setFirstChild(child); child.setNextParentChild(Child()); setLastChild(child); setNumChilds(getNumChilds() + 1); child.setParent(*this); child.setupParentHandler(); return true; }
testlist::Child testlist::Parent::popBackChild() const { Child result = getLastChild(); if(result.isValid()) { result.removeParentHandler(); Child prev = result.getPrevParentChild(); result.setPrevParentChild(Child()); result.setNextParentChild(Child()); setLastChild(prev); if(!prev.isValid()) setFirstChild(Child()); else prev.setNextParentChild(Child()); setNumChilds(getNumChilds() - 1); result.setParent(Parent()); } return result; }
testlist::Child testlist::Parent::popFrontChild() const { Child result = getFirstChild(); if(result.isValid()) { result.removeParentHandler(); Child next = result.getNextParentChild(); result.setNextParentChild(Child()); result.setPrevParentChild(Child()); setFirstChild(next); if(!next.isValid()) setLastChild(Child()); else next.setPrevParentChild(Child()); setNumChilds(getNumChilds() - 1); result.setParent(Parent()); } return result; }
Bool testlist::Parent::insertAfterChild(const Child & child, const Child & prev) const { if(!child.isExists() || !prev.isExists() || prev.getParent() != *this || child.getParent().isValid()) return false; Child next = prev.getNextParentChild(); prev.setNextParentChild(child); child.setPrevParentChild(prev); child.setNextParentChild(next); if(next.isValid()) next.setPrevParentChild(child); else setLastChild(child); child.setParent(*this); setNumChilds(getNumChilds() + 1); child.setupParentHandler(); return true; }
void RenderObjectChildList::insertChildNode(RenderObject* owner, RenderObject* newChild, RenderObject* beforeChild, bool notifyRenderer) { ASSERT(!newChild->parent()); while (beforeChild && beforeChild->parent() && beforeChild->parent() != owner) beforeChild = beforeChild->parent(); // This should never happen, but if it does prevent render tree corruption // where child->parent() ends up being owner but child->nextSibling()->parent() // is not owner. if (beforeChild && beforeChild->parent() != owner) { ASSERT_NOT_REACHED(); return; } newChild->setParent(owner); if (firstChild() == beforeChild) setFirstChild(newChild); if (beforeChild) { RenderObject* previousSibling = beforeChild->previousSibling(); if (previousSibling) previousSibling->setNextSibling(newChild); newChild->setPreviousSibling(previousSibling); newChild->setNextSibling(beforeChild); beforeChild->setPreviousSibling(newChild); } else { if (lastChild()) lastChild()->setNextSibling(newChild); newChild->setPreviousSibling(lastChild()); setLastChild(newChild); } if (!owner->documentBeingDestroyed() && notifyRenderer) newChild->insertedIntoTree(); newChild->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(); if (!owner->normalChildNeedsLayout()) owner->setChildNeedsLayout(); // We may supply the static position for an absolute positioned child. }
Bool testlist::Parent::removeChild(const Child & child) const { if( !child.isExists() || child.getParent() != *this) return false; child.removeParentHandler(); Child next = child.getNextParentChild(), prev = child.getPrevParentChild(); if(next.isValid()) next.setPrevParentChild(prev); else if (getLastChild() == child) setLastChild(prev); else return false; if(prev.isValid()) prev.setNextParentChild(next); else if (getFirstChild() == child) setFirstChild(next); else return false; child.setNextParentChild(Child()); child.setPrevParentChild(Child()); child.setParent(Parent()); setNumChilds(getNumChilds() - 1); return true; }
LayoutObject* LayoutObjectChildList::removeChildNode(LayoutObject* owner, LayoutObject* oldChild, bool notifyLayoutObject) { ASSERT(oldChild->parent() == owner); ASSERT(this == owner->virtualChildren()); if (oldChild->isFloatingOrOutOfFlowPositioned()) toLayoutBox(oldChild)->removeFloatingOrPositionedChildFromBlockLists(); { // So that we'll get the appropriate dirty bit set (either that a normal flow child got yanked or // that a positioned child got yanked). We also issue paint invalidations, so that the area exposed when the child // disappears gets paint invalidated properly. if (!owner->documentBeingDestroyed() && notifyLayoutObject && oldChild->everHadLayout()) { oldChild->setNeedsLayoutAndPrefWidthsRecalc(LayoutInvalidationReason::RemovedFromLayout); invalidatePaintOnRemoval(*oldChild); } } // If we have a line box wrapper, delete it. if (oldChild->isBox()) toLayoutBox(oldChild)->deleteLineBoxWrapper(); // If oldChild is the start or end of the selection, then clear the selection to // avoid problems of invalid pointers. // FIXME: The FrameSelection should be responsible for this when it // is notified of DOM mutations. if (!owner->documentBeingDestroyed() && oldChild->isSelectionBorder()) owner->view()->clearSelection(); if (!owner->documentBeingDestroyed()) owner->notifyOfSubtreeChange(); if (!owner->documentBeingDestroyed() && notifyLayoutObject) { LayoutCounter::layoutObjectSubtreeWillBeDetached(oldChild); oldChild->willBeRemovedFromTree(); } // WARNING: There should be no code running between willBeRemovedFromTree and the actual removal below. // This is needed to avoid race conditions where willBeRemovedFromTree would dirty the tree's structure // and the code running here would force an untimely rebuilding, leaving |oldChild| dangling. if (oldChild->previousSibling()) oldChild->previousSibling()->setNextSibling(oldChild->nextSibling()); if (oldChild->nextSibling()) oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling()); if (firstChild() == oldChild) setFirstChild(oldChild->nextSibling()); if (lastChild() == oldChild) setLastChild(oldChild->previousSibling()); oldChild->setPreviousSibling(nullptr); oldChild->setNextSibling(nullptr); oldChild->setParent(nullptr); oldChild->registerSubtreeChangeListenerOnDescendants(oldChild->consumesSubtreeChangeNotification()); if (AXObjectCache* cache = owner->document().existingAXObjectCache()) cache->childrenChanged(owner); return oldChild; }
void LayoutObjectChildList::insertChildNode(LayoutObject* owner, LayoutObject* newChild, LayoutObject* beforeChild, bool notifyLayoutObject) { ASSERT(!newChild->parent()); ASSERT(this == owner->virtualChildren()); ASSERT(!owner->isLayoutBlockFlow() || (!newChild->isTableSection() && !newChild->isTableRow() && !newChild->isTableCell())); while (beforeChild && beforeChild->parent() && beforeChild->parent() != owner) beforeChild = beforeChild->parent(); // This should never happen, but if it does prevent layout tree corruption // where child->parent() ends up being owner but child->nextSibling()->parent() // is not owner. if (beforeChild && beforeChild->parent() != owner) { ASSERT_NOT_REACHED(); return; } newChild->setParent(owner); if (firstChild() == beforeChild) setFirstChild(newChild); if (beforeChild) { LayoutObject* previousSibling = beforeChild->previousSibling(); if (previousSibling) previousSibling->setNextSibling(newChild); newChild->setPreviousSibling(previousSibling); newChild->setNextSibling(beforeChild); beforeChild->setPreviousSibling(newChild); } else { if (lastChild()) lastChild()->setNextSibling(newChild); newChild->setPreviousSibling(lastChild()); setLastChild(newChild); } if (!owner->documentBeingDestroyed() && notifyLayoutObject) { newChild->insertedIntoTree(); LayoutCounter::layoutObjectSubtreeAttached(newChild); } // Propagate the need to notify ancestors down into any // child nodes. if (owner->hasSubtreeChangeListenerRegistered()) newChild->registerSubtreeChangeListenerOnDescendants(true); // If the inserted node is currently marked as needing to notify children then // we have to propagate that mark up the tree. if (newChild->wasNotifiedOfSubtreeChange()) owner->notifyAncestorsOfSubtreeChange(); newChild->setNeedsLayoutAndPrefWidthsRecalc(LayoutInvalidationReason::AddedToLayout); newChild->setShouldDoFullPaintInvalidation(PaintInvalidationLayoutObjectInsertion); if (!owner->normalChildNeedsLayout()) owner->setChildNeedsLayout(); // We may supply the static position for an absolute positioned child. if (!owner->documentBeingDestroyed()) owner->notifyOfSubtreeChange(); if (AXObjectCache* cache = owner->document().axObjectCache()) cache->childrenChanged(owner); }
RenderObject* RenderObjectChildList::removeChildNode(RenderObject* owner, RenderObject* oldChild, bool fullRemove) { ASSERT(oldChild->parent() == owner); if (oldChild->isFloatingOrOutOfFlowPositioned()) toRenderBox(oldChild)->removeFloatingOrPositionedChildFromBlockLists(); // So that we'll get the appropriate dirty bit set (either that a normal flow child got yanked or // that a positioned child got yanked). We also repaint, so that the area exposed when the child // disappears gets repainted properly. if (!owner->documentBeingDestroyed() && fullRemove && oldChild->everHadLayout()) { oldChild->setNeedsLayoutAndPrefWidthsRecalc(); if (oldChild->isBody()) owner->view()->repaint(); else oldChild->repaint(); } // If we have a line box wrapper, delete it. if (oldChild->isBox()) toRenderBox(oldChild)->deleteLineBoxWrapper(); if (!owner->documentBeingDestroyed() && fullRemove) { // if we remove visible child from an invisible parent, we don't know the layer visibility any more RenderLayer* layer = 0; if (owner->style()->visibility() != VISIBLE && oldChild->style()->visibility() == VISIBLE && !oldChild->hasLayer()) { if ((layer = owner->enclosingLayer())) layer->dirtyVisibleContentStatus(); } // Keep our layer hierarchy updated. if (oldChild->firstChild() || oldChild->hasLayer()) { if (!layer) layer = owner->enclosingLayer(); oldChild->removeLayers(layer); } if (oldChild->isListItem()) toRenderListItem(oldChild)->updateListMarkerNumbers(); if (oldChild->isOutOfFlowPositioned() && owner->childrenInline()) owner->dirtyLinesFromChangedChild(oldChild); if (oldChild->isRenderRegion()) toRenderRegion(oldChild)->detachRegion(); if (oldChild->isQuote()) toRenderQuote(oldChild)->detachQuote(); if (oldChild->inRenderFlowThread()) { if (oldChild->isBox()) oldChild->enclosingRenderFlowThread()->removeRenderBoxRegionInfo(toRenderBox(oldChild)); oldChild->enclosingRenderFlowThread()->clearRenderObjectCustomStyle(oldChild); } if (RenderNamedFlowThread* containerFlowThread = renderNamedFlowThreadContainer(owner)) containerFlowThread->removeFlowChild(oldChild); #if ENABLE(SVG) // Update cached boundaries in SVG renderers, if a child is removed. owner->setNeedsBoundariesUpdate(); #endif } // If oldChild is the start or end of the selection, then clear the selection to // avoid problems of invalid pointers. // FIXME: The FrameSelection should be responsible for this when it // is notified of DOM mutations. if (!owner->documentBeingDestroyed() && oldChild->isSelectionBorder()) owner->view()->clearSelection(); // remove the child if (oldChild->previousSibling()) oldChild->previousSibling()->setNextSibling(oldChild->nextSibling()); if (oldChild->nextSibling()) oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling()); if (firstChild() == oldChild) setFirstChild(oldChild->nextSibling()); if (lastChild() == oldChild) setLastChild(oldChild->previousSibling()); oldChild->setPreviousSibling(0); oldChild->setNextSibling(0); oldChild->setParent(0); // rendererRemovedFromTree walks the whole subtree. We can improve performance // by skipping this step when destroying the entire tree. if (!owner->documentBeingDestroyed()) { RenderCounter::rendererRemovedFromTree(oldChild); } if (AXObjectCache::accessibilityEnabled()) owner->document()->axObjectCache()->childrenChanged(owner); return oldChild; }
RenderObject* RenderObjectChildList::removeChildNode(RenderObject* owner, RenderObject* oldChild, bool fullRemove) { ASSERT(oldChild->parent() == owner); // So that we'll get the appropriate dirty bit set (either that a normal flow child got yanked or // that a positioned child got yanked). We also repaint, so that the area exposed when the child // disappears gets repainted properly. if (!owner->documentBeingDestroyed() && fullRemove && oldChild->m_everHadLayout) { oldChild->setNeedsLayoutAndPrefWidthsRecalc(); oldChild->repaint(); } // If we have a line box wrapper, delete it. if (oldChild->isBox()) toRenderBox(oldChild)->deleteLineBoxWrapper(); if (!owner->documentBeingDestroyed() && fullRemove) { // if we remove visible child from an invisible parent, we don't know the layer visibility any more RenderLayer* layer = 0; if (owner->style()->visibility() != VISIBLE && oldChild->style()->visibility() == VISIBLE && !oldChild->hasLayer()) { layer = owner->enclosingLayer(); layer->dirtyVisibleContentStatus(); } // Keep our layer hierarchy updated. if (oldChild->firstChild() || oldChild->hasLayer()) { if (!layer) layer = owner->enclosingLayer(); oldChild->removeLayers(layer); } if (oldChild->isListItem()) toRenderListItem(oldChild)->updateListMarkerNumbers(); if (oldChild->isPositioned() && owner->childrenInline()) owner->dirtyLinesFromChangedChild(oldChild); } // If oldChild is the start or end of the selection, then clear the selection to // avoid problems of invalid pointers. // FIXME: The SelectionController should be responsible for this when it // is notified of DOM mutations. if (!owner->documentBeingDestroyed() && oldChild->isSelectionBorder()) owner->view()->clearSelection(); // remove the child if (oldChild->previousSibling()) oldChild->previousSibling()->setNextSibling(oldChild->nextSibling()); if (oldChild->nextSibling()) oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling()); if (firstChild() == oldChild) setFirstChild(oldChild->nextSibling()); if (lastChild() == oldChild) setLastChild(oldChild->previousSibling()); oldChild->setPreviousSibling(0); oldChild->setNextSibling(0); oldChild->setParent(0); if (AXObjectCache::accessibilityEnabled()) owner->document()->axObjectCache()->childrenChanged(owner); return oldChild; }