Source/WebCore/rendering/RenderObjectChildList.cpp

   1 /*
   2  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
   3  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "config.h"
  28 #include "RenderObjectChildList.h"
  29
  30 #include "AXObjectCache.h"
  31 #include "ContentData.h"
  32 #include "RenderBlock.h"
  33 #include "RenderCounter.h"
  34 #include "RenderImage.h"
  35 #include "RenderImageResourceStyleImage.h"
  36 #include "RenderInline.h"
  37 #include "RenderLayer.h"
  38 #include "RenderListItem.h"
  39 #include "RenderQuote.h"
  40 #include "RenderStyle.h"
  41 #include "RenderTextFragment.h"
  42 #include "RenderView.h"
  43
  44 namespace WebCore {
  45
  46 void RenderObjectChildList::destroyLeftoverChildren()
  47 {
  48     while (firstChild()) {
  49         if (firstChild()->isListMarker() || (firstChild()->style()->styleType() == FIRST_LETTER && !firstChild()->isText()))
  50             firstChild()->remove();  // List markers are owned by their enclosing list and so don't get destroyed by this container. Similarly, first letters are destroyed by their remaining text fragment.
  51         else if (firstChild()->isRunIn() && firstChild()->node()) {
  52             firstChild()->node()->setRenderer(0);
  53             firstChild()->node()->setNeedsStyleRecalc();
  54             firstChild()->destroy();
  55         } else {
  56             // Destroy any anonymous children remaining in the render tree, as well as implicit (shadow) DOM elements like those used in the engine-based text fields.
  57             if (firstChild()->node())
  58                 firstChild()->node()->setRenderer(0);
  59             firstChild()->destroy();
  60         }
  61     }
  62 }
  63
  64 RenderObject* RenderObjectChildList::removeChildNode(RenderObject* owner, RenderObject* oldChild, bool fullRemove)
  65 {
  66     ASSERT(oldChild->parent() == owner);
  67
  68     // So that we'll get the appropriate dirty bit set (either that a normal flow child got yanked or
  69     // that a positioned child got yanked).  We also repaint, so that the area exposed when the child
  70     // disappears gets repainted properly.
  71     if (!owner->documentBeingDestroyed() && fullRemove && oldChild->m_everHadLayout) {
  72         oldChild->setNeedsLayoutAndPrefWidthsRecalc();
  73         if (oldChild->isBody())
  74             owner->view()->repaint();
  75         else
  76             oldChild->repaint();
  77     }
  78
  79     // If we have a line box wrapper, delete it.
  80     if (oldChild->isBox())
  81         toRenderBox(oldChild)->deleteLineBoxWrapper();
  82
  83     if (!owner->documentBeingDestroyed() && fullRemove) {
  84         // if we remove visible child from an invisible parent, we don't know the layer visibility any more
  85         RenderLayer* layer = 0;
  86         if (owner->style()->visibility() != VISIBLE && oldChild->style()->visibility() == VISIBLE && !oldChild->hasLayer()) {
  87             layer = owner->enclosingLayer();
  88             layer->dirtyVisibleContentStatus();
  89         }
  90
  91          // Keep our layer hierarchy updated.
  92         if (oldChild->firstChild() || oldChild->hasLayer()) {
  93             if (!layer)
  94                 layer = owner->enclosingLayer();
  95             oldChild->removeLayers(layer);
  96         }
  97
  98         if (oldChild->isListItem())
  99             toRenderListItem(oldChild)->updateListMarkerNumbers();
 100
 101         if (oldChild->isPositioned() && owner->childrenInline())
 102             owner->dirtyLinesFromChangedChild(oldChild);
 103
 104 #if ENABLE(SVG)
 105         // Update cached boundaries in SVG renderers, if a child is removed.
 106         owner->setNeedsBoundariesUpdate();
 107 #endif
 108     }
 109
 110     // If oldChild is the start or end of the selection, then clear the selection to
 111     // avoid problems of invalid pointers.
 112     // FIXME: The SelectionController should be responsible for this when it
 113     // is notified of DOM mutations.
 114     if (!owner->documentBeingDestroyed() && oldChild->isSelectionBorder())
 115         owner->view()->clearSelection();
 116
 117     // remove the child
 118     if (oldChild->previousSibling())
 119         oldChild->previousSibling()->setNextSibling(oldChild->nextSibling());
 120     if (oldChild->nextSibling())
 121         oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling());
 122
 123     if (firstChild() == oldChild)
 124         setFirstChild(oldChild->nextSibling());
 125     if (lastChild() == oldChild)
 126         setLastChild(oldChild->previousSibling());
 127
 128     oldChild->setPreviousSibling(0);
 129     oldChild->setNextSibling(0);
 130     oldChild->setParent(0);
 131
 132     if (oldChild->m_hasCounterNodeMap)
 133         RenderCounter::destroyCounterNodes(oldChild);
 134     RenderQuote::rendererRemovedFromTree(oldChild);
 135
 136     if (AXObjectCache::accessibilityEnabled())
 137         owner->document()->axObjectCache()->childrenChanged(owner);
 138
 139     return oldChild;
 140 }
 141
 142 void RenderObjectChildList::appendChildNode(RenderObject* owner, RenderObject* newChild, bool fullAppend)
 143 {
 144     ASSERT(newChild->parent() == 0);
 145     ASSERT(!owner->isBlockFlow() || (!newChild->isTableSection() && !newChild->isTableRow() && !newChild->isTableCell()));
 146
 147     newChild->setParent(owner);
 148     RenderObject* lChild = lastChild();
 149
 150     if (lChild) {
 151         newChild->setPreviousSibling(lChild);
 152         lChild->setNextSibling(newChild);
 153     } else
 154         setFirstChild(newChild);
 155
 156     setLastChild(newChild);
 157
 158     if (fullAppend) {
 159         // Keep our layer hierarchy updated.  Optimize for the common case where we don't have any children
 160         // and don't have a layer attached to ourselves.
 161         RenderLayer* layer = 0;
 162         if (newChild->firstChild() || newChild->hasLayer()) {
 163             layer = owner->enclosingLayer();
 164             newChild->addLayers(layer, newChild);
 165         }
 166
 167         // if the new child is visible but this object was not, tell the layer it has some visible content
 168         // that needs to be drawn and layer visibility optimization can't be used
 169         if (owner->style()->visibility() != VISIBLE && newChild->style()->visibility() == VISIBLE && !newChild->hasLayer()) {
 170             if (!layer)
 171                 layer = owner->enclosingLayer();
 172             if (layer)
 173                 layer->setHasVisibleContent(true);
 174         }
 175
 176         if (newChild->isListItem())
 177             toRenderListItem(newChild)->updateListMarkerNumbers();
 178
 179         if (!newChild->isFloatingOrPositioned() && owner->childrenInline())
 180             owner->dirtyLinesFromChangedChild(newChild);
 181     }
 182     RenderCounter::rendererSubtreeAttached(newChild);
 183     RenderQuote::rendererSubtreeAttached(newChild);
 184     newChild->setNeedsLayoutAndPrefWidthsRecalc(); // Goes up the containing block hierarchy.
 185     if (!owner->normalChildNeedsLayout())
 186         owner->setChildNeedsLayout(true); // We may supply the static position for an absolute positioned child.
 187
 188     if (AXObjectCache::accessibilityEnabled())
 189         owner->document()->axObjectCache()->childrenChanged(owner);
 190 }
 191
 192 void RenderObjectChildList::insertChildNode(RenderObject* owner, RenderObject* child, RenderObject* beforeChild, bool fullInsert)
 193 {
 194     if (!beforeChild) {
 195         appendChildNode(owner, child, fullInsert);
 196         return;
 197     }
 198
 199     ASSERT(!child->parent());
 200     while (beforeChild->parent() != owner && beforeChild->parent()->isAnonymousBlock())
 201         beforeChild = beforeChild->parent();
 202     ASSERT(beforeChild->parent() == owner);
 203
 204     ASSERT(!owner->isBlockFlow() || (!child->isTableSection() && !child->isTableRow() && !child->isTableCell()));
 205
 206     if (beforeChild == firstChild())
 207         setFirstChild(child);
 208
 209     RenderObject* prev = beforeChild->previousSibling();
 210     child->setNextSibling(beforeChild);
 211     beforeChild->setPreviousSibling(child);
 212     if (prev)
 213         prev->setNextSibling(child);
 214     child->setPreviousSibling(prev);
 215
 216     child->setParent(owner);
 217
 218     if (fullInsert) {
 219         // Keep our layer hierarchy updated.  Optimize for the common case where we don't have any children
 220         // and don't have a layer attached to ourselves.
 221         RenderLayer* layer = 0;
 222         if (child->firstChild() || child->hasLayer()) {
 223             layer = owner->enclosingLayer();
 224             child->addLayers(layer, child);
 225         }
 226
 227         // if the new child is visible but this object was not, tell the layer it has some visible content
 228         // that needs to be drawn and layer visibility optimization can't be used
 229         if (owner->style()->visibility() != VISIBLE && child->style()->visibility() == VISIBLE && !child->hasLayer()) {
 230             if (!layer)
 231                 layer = owner->enclosingLayer();
 232             if (layer)
 233                 layer->setHasVisibleContent(true);
 234         }
 235
 236         if (child->isListItem())
 237             toRenderListItem(child)->updateListMarkerNumbers();
 238
 239         if (!child->isFloating() && owner->childrenInline())
 240             owner->dirtyLinesFromChangedChild(child);
 241     }
 242
 243     RenderCounter::rendererSubtreeAttached(child);
 244     RenderQuote::rendererSubtreeAttached(child);
 245     child->setNeedsLayoutAndPrefWidthsRecalc();
 246     if (!owner->normalChildNeedsLayout())
 247         owner->setChildNeedsLayout(true); // We may supply the static position for an absolute positioned child.
 248
 249     if (AXObjectCache::accessibilityEnabled())
 250         owner->document()->axObjectCache()->childrenChanged(owner);
 251 }
 252
 253 static RenderObject* findBeforeAfterParent(RenderObject* object)
 254 {
 255     // Only table parts need to search for the :before or :after parent
 256     if (!(object->isTable() || object->isTableSection() || object->isTableRow()))
 257         return object;
 258
 259     RenderObject* beforeAfterParent = object;
 260     while (beforeAfterParent && !(beforeAfterParent->isText() || beforeAfterParent->isImage()))
 261         beforeAfterParent = beforeAfterParent->firstChild();
 262     return beforeAfterParent;
 263 }
 264
 265 static void invalidateCountersInContainer(RenderObject* container, const AtomicString& identifier)
 266 {
 267     if (!container)
 268         return;
 269     container = findBeforeAfterParent(container);
 270     if (!container)
 271         return;
 272     // Sometimes the counter is attached directly on the container.
 273     if (container->isCounter()) {
 274         toRenderCounter(container)->invalidate(identifier);
 275         return;
 276     }
 277     for (RenderObject* content = container->firstChild(); content; content = content->nextSibling()) {
 278         if (content->isCounter())
 279             toRenderCounter(content)->invalidate(identifier);
 280     }
 281 }
 282
 283 void RenderObjectChildList::invalidateCounters(const RenderObject* owner, const AtomicString& identifier)
 284 {
 285     ASSERT(!owner->documentBeingDestroyed());
 286     invalidateCountersInContainer(beforePseudoElementRenderer(owner), identifier);
 287     invalidateCountersInContainer(afterPseudoElementRenderer(owner), identifier);
 288 }
 289
 290 RenderObject* RenderObjectChildList::beforePseudoElementRenderer(const RenderObject* owner) const
 291 {
 292     // An anonymous (generated) inline run-in that has PseudoId BEFORE must come from a grandparent.
 293     // Therefore we should skip these generated run-ins when checking our immediate children.
 294     // If we don't find our :before child immediately, then we should check if we own a
 295     // generated inline run-in in the next level of children.
 296     RenderObject* first = const_cast<RenderObject*>(owner);
 297     do {
 298         // Skip list markers and generated run-ins
 299         first = first->firstChild();
 300         while (first && (first->isListMarker() || (first->isRenderInline() && first->isRunIn() && first->isAnonymous())))
 301             first = first->nextSibling();
 302     } while (first && first->isAnonymous() && first->style()->styleType() == NOPSEUDO);
 303
 304     if (!first)
 305         return 0;
 306
 307     if (first->style()->styleType() == BEFORE)
 308         return first;
 309
 310     // Check for a possible generated run-in, using run-in positioning rules.
 311     // Skip inlines and floating / positioned blocks, and place as the first child.
 312     first = owner->firstChild();
 313     if (!first->isRenderBlock())
 314         return 0;
 315     while (first && first->isFloatingOrPositioned())
 316         first = first->nextSibling();
 317     if (first) {
 318         first = first->firstChild();
 319         // We still need to skip any list markers that could exist before the run-in.
 320         while (first && first->isListMarker())
 321             first = first->nextSibling();
 322         if (first && first->style()->styleType() == BEFORE && first->isRenderInline() && first->isRunIn() && first->isAnonymous())
 323             return first;
 324     }
 325     return 0;
 326 }
 327
 328 RenderObject* RenderObjectChildList::afterPseudoElementRenderer(const RenderObject* owner) const
 329 {
 330     RenderObject* last = const_cast<RenderObject*>(owner);
 331     do {
 332         last = last->lastChild();
 333     } while (last && last->isAnonymous() && last->style()->styleType() == NOPSEUDO && !last->isListMarker());
 334     if (last && last->style()->styleType() != AFTER)
 335         return 0;
 336     return last;
 337 }
 338
 339 void RenderObjectChildList::updateBeforeAfterContent(RenderObject* owner, PseudoId type, const RenderObject* styledObject)
 340 {
 341     // Double check that the document did in fact use generated content rules.  Otherwise we should not have been called.
 342     ASSERT(owner->document()->usesBeforeAfterRules());
 343
 344     // In CSS2, before/after pseudo-content cannot nest.  Check this first.
 345     if (owner->style()->styleType() == BEFORE || owner->style()->styleType() == AFTER)
 346         return;
 347
 348     if (!styledObject)
 349         styledObject = owner;
 350
 351     RenderStyle* pseudoElementStyle = styledObject->getCachedPseudoStyle(type);
 352     RenderObject* child;
 353     switch (type) {
 354     case BEFORE:
 355         child = beforePseudoElementRenderer(owner);
 356         break;
 357     case AFTER:
 358         child = afterPseudoElementRenderer(owner);
 359         break;
 360     default:
 361         ASSERT_NOT_REACHED();
 362         return;
 363     }
 364
 365     // Whether or not we currently have generated content attached.
 366     bool oldContentPresent = child;
 367
 368     // Whether or not we now want generated content.
 369     bool newContentWanted = pseudoElementStyle && pseudoElementStyle->display() != NONE;
 370
 371     // For <q><p/></q>, if this object is the inline continuation of the <q>, we only want to generate
 372     // :after content and not :before content.
 373     if (newContentWanted && type == BEFORE && owner->isElementContinuation())
 374         newContentWanted = false;
 375
 376     // Similarly, if we're the beginning of a <q>, and there's an inline continuation for our object,
 377     // then we don't generate the :after content.
 378     if (newContentWanted && type == AFTER && owner->virtualContinuation())
 379         newContentWanted = false;
 380
 381     // If we don't want generated content any longer, or if we have generated content, but it's no longer
 382     // identical to the new content data we want to build render objects for, then we nuke all
 383     // of the old generated content.
 384     if (oldContentPresent && (!newContentWanted || Node::diff(child->style(), pseudoElementStyle) == Node::Detach)) {
 385         // Nuke the child.
 386         if (child->style()->styleType() == type) {
 387             oldContentPresent = false;
 388             child->destroy();
 389             child = (type == BEFORE) ? owner->virtualChildren()->firstChild() : owner->virtualChildren()->lastChild();
 390         }
 391     }
 392
 393     // If we have no pseudo-element style or if the pseudo-element style's display type is NONE, then we
 394     // have no generated content and can now return.
 395     if (!newContentWanted)
 396         return;
 397
 398     if (owner->isRenderInline() && !pseudoElementStyle->isDisplayInlineType() && pseudoElementStyle->floating() == FNONE &&
 399         !(pseudoElementStyle->position() == AbsolutePosition || pseudoElementStyle->position() == FixedPosition))
 400         // According to the CSS2 spec (the end of section 12.1), the only allowed
 401         // display values for the pseudo style are NONE and INLINE for inline flows.
 402         // FIXME: CSS2.1 lifted this restriction, but block display types will crash.
 403         // For now we at least relax the restriction to allow all inline types like inline-block
 404         // and inline-table.
 405         pseudoElementStyle->setDisplay(INLINE);
 406
 407     if (oldContentPresent) {
 408         if (child && child->style()->styleType() == type) {
 409             // We have generated content present still.  We want to walk this content and update our
 410             // style information with the new pseudo-element style.
 411             child->setStyle(pseudoElementStyle);
 412
 413             RenderObject* beforeAfterParent = findBeforeAfterParent(child);
 414             if (!beforeAfterParent)
 415                 return;
 416
 417             // Note that if we ever support additional types of generated content (which should be way off
 418             // in the future), this code will need to be patched.
 419             for (RenderObject* genChild = beforeAfterParent->firstChild(); genChild; genChild = genChild->nextSibling()) {
 420                 if (genChild->isText())
 421                     // Generated text content is a child whose style also needs to be set to the pseudo-element style.
 422                     genChild->setStyle(pseudoElementStyle);
 423                 else if (genChild->isImage()) {
 424                     // Images get an empty style that inherits from the pseudo.
 425                     RefPtr<RenderStyle> style = RenderStyle::create();
 426                     style->inheritFrom(pseudoElementStyle);
 427                     genChild->setStyle(style.release());
 428                 } else {
 429                     // RenderListItem may insert a list marker here. We do not need to care about this case.
 430                     // Otherwise, genChild must be a first-letter container. updateFirstLetter() will take care of it.
 431                     ASSERT(genChild->isListMarker() || genChild->style()->styleType() == FIRST_LETTER);
 432                 }
 433             }
 434         }
 435         return; // We've updated the generated content. That's all we needed to do.
 436     }
 437
 438     RenderObject* insertBefore = (type == BEFORE) ? owner->virtualChildren()->firstChild() : 0;
 439
 440     // Generated content consists of a single container that houses multiple children (specified
 441     // by the content property).  This generated content container gets the pseudo-element style set on it.
 442     RenderObject* generatedContentContainer = 0;
 443
 444     // Walk our list of generated content and create render objects for each.
 445     for (const ContentData* content = pseudoElementStyle->contentData(); content; content = content->next()) {
 446         RenderObject* renderer = 0;
 447         switch (content->type()) {
 448             case CONTENT_NONE:
 449                 break;
 450             case CONTENT_TEXT:
 451                 renderer = new (owner->renderArena()) RenderTextFragment(owner->document() /* anonymous object */, content->text());
 452                 renderer->setStyle(pseudoElementStyle);
 453                 break;
 454             case CONTENT_OBJECT: {
 455                 RenderImage* image = new (owner->renderArena()) RenderImage(owner->document()); // anonymous object
 456                 RefPtr<RenderStyle> style = RenderStyle::create();
 457                 style->inheritFrom(pseudoElementStyle);
 458                 image->setStyle(style.release());
 459                 if (StyleImage* styleImage = content->image())
 460                     image->setImageResource(RenderImageResourceStyleImage::create(styleImage));
 461                 else
 462                     image->setImageResource(RenderImageResource::create());
 463                 renderer = image;
 464                 break;
 465             }
 466         case CONTENT_COUNTER:
 467             renderer = new (owner->renderArena()) RenderCounter(owner->document(), *content->counter());
 468             renderer->setStyle(pseudoElementStyle);
 469             break;
 470         case CONTENT_QUOTE:
 471             renderer = new (owner->renderArena()) RenderQuote(owner->document(), content->quote());
 472             renderer->setStyle(pseudoElementStyle);
 473             break;
 474         }
 475
 476         if (renderer) {
 477             if (!generatedContentContainer) {
 478                 // Make a generated box that might be any display type now that we are able to drill down into children
 479                 // to find the original content properly.
 480                 generatedContentContainer = RenderObject::createObject(owner->document(), pseudoElementStyle);
 481                 ASSERT(styledObject->node()); // The styled object cannot be anonymous or else it could not have ':before' or ':after' pseudo elements.
 482                 generatedContentContainer->setNode(styledObject->node()); // This allows access to the generatingNode.
 483                 generatedContentContainer->setStyle(pseudoElementStyle);
 484                 owner->addChild(generatedContentContainer, insertBefore);
 485             }
 486             if (generatedContentContainer->isChildAllowed(renderer, pseudoElementStyle))
 487                 generatedContentContainer->addChild(renderer);
 488             else
 489                 renderer->destroy();
 490         }
 491     }
 492 }
 493
 494 } // namespace WebCore