src/third_party/WebKit/Source/core/rendering/RenderInline.cpp

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   4  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public License
  17  * along with this library; see the file COPYING.LIB.  If not, write to
  18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  *
  21  */
  22
  23 #include "config.h"
  24 #include "core/rendering/RenderInline.h"
  25
  26 #include "core/dom/Fullscreen.h"
  27 #include "core/dom/StyleEngine.h"
  28 #include "core/page/Chrome.h"
  29 #include "core/page/Page.h"
  30 #include "core/paint/BoxPainter.h"
  31 #include "core/paint/InlinePainter.h"
  32 #include "core/paint/ObjectPainter.h"
  33 #include "core/rendering/GraphicsContextAnnotator.h"
  34 #include "core/rendering/HitTestResult.h"
  35 #include "core/rendering/InlineTextBox.h"
  36 #include "core/rendering/RenderBlock.h"
  37 #include "core/rendering/RenderFlowThread.h"
  38 #include "core/rendering/RenderFullScreen.h"
  39 #include "core/rendering/RenderGeometryMap.h"
  40 #include "core/rendering/RenderLayer.h"
  41 #include "core/rendering/RenderTheme.h"
  42 #include "core/rendering/RenderView.h"
  43 #include "core/rendering/style/StyleInheritedData.h"
  44 #include "platform/geometry/FloatQuad.h"
  45 #include "platform/geometry/TransformState.h"
  46 #include "platform/graphics/GraphicsContext.h"
  47
  48 namespace blink {
  49
  50 struct SameSizeAsRenderInline : public RenderBoxModelObject {
  51     virtual ~SameSizeAsRenderInline() { }
  52     RenderObjectChildList m_children;
  53     RenderLineBoxList m_lineBoxes;
  54 };
  55
  56 COMPILE_ASSERT(sizeof(RenderInline) == sizeof(SameSizeAsRenderInline), RenderInline_should_stay_small);
  57
  58 RenderInline::RenderInline(Element* element)
  59     : RenderBoxModelObject(element)
  60 {
  61     setChildrenInline(true);
  62 }
  63
  64 void RenderInline::trace(Visitor* visitor)
  65 {
  66     visitor->trace(m_children);
  67     RenderBoxModelObject::trace(visitor);
  68 }
  69
  70 RenderInline* RenderInline::createAnonymous(Document* document)
  71 {
  72     RenderInline* renderer = new RenderInline(0);
  73     renderer->setDocumentForAnonymous(document);
  74     return renderer;
  75 }
  76
  77 void RenderInline::willBeDestroyed()
  78 {
  79 #if ENABLE(ASSERT)
  80     // Make sure we do not retain "this" in the continuation outline table map of our containing blocks.
  81     if (parent() && style()->visibility() == VISIBLE && style()->hasOutline()) {
  82         bool containingBlockPaintsContinuationOutline = continuation() || isInlineElementContinuation();
  83         if (containingBlockPaintsContinuationOutline) {
  84             if (RenderBlock* cb = containingBlock()) {
  85                 if (RenderBlock* cbCb = cb->containingBlock())
  86                     ASSERT(!cbCb->paintsContinuationOutline(this));
  87             }
  88         }
  89     }
  90 #endif
  91
  92     // Make sure to destroy anonymous children first while they are still connected to the rest of the tree, so that they will
  93     // properly dirty line boxes that they are removed from.  Effects that do :before/:after only on hover could crash otherwise.
  94     children()->destroyLeftoverChildren();
  95
  96     // Destroy our continuation before anything other than anonymous children.
  97     // The reason we don't destroy it before anonymous children is that they may
  98     // have continuations of their own that are anonymous children of our continuation.
  99     RenderBoxModelObject* continuation = this->continuation();
 100     if (continuation) {
 101         continuation->destroy();
 102         setContinuation(0);
 103     }
 104
 105     if (!documentBeingDestroyed()) {
 106         if (firstLineBox()) {
 107             // We can't wait for RenderBoxModelObject::destroy to clear the selection,
 108             // because by then we will have nuked the line boxes.
 109             // FIXME: The FrameSelection should be responsible for this when it
 110             // is notified of DOM mutations.
 111             if (isSelectionBorder())
 112                 view()->clearSelection();
 113
 114             // If line boxes are contained inside a root, that means we're an inline.
 115             // In that case, we need to remove all the line boxes so that the parent
 116             // lines aren't pointing to deleted children. If the first line box does
 117             // not have a parent that means they are either already disconnected or
 118             // root lines that can just be destroyed without disconnecting.
 119             if (firstLineBox()->parent()) {
 120                 for (InlineFlowBox* box = firstLineBox(); box; box = box->nextLineBox())
 121                     box->remove();
 122             }
 123         } else if (parent())
 124             parent()->dirtyLinesFromChangedChild(this);
 125     }
 126
 127     m_lineBoxes.deleteLineBoxes();
 128
 129     RenderBoxModelObject::willBeDestroyed();
 130 }
 131
 132 RenderInline* RenderInline::inlineElementContinuation() const
 133 {
 134     RenderBoxModelObject* continuation = this->continuation();
 135     if (!continuation || continuation->isInline())
 136         return toRenderInline(continuation);
 137     return toRenderBlock(continuation)->inlineElementContinuation();
 138 }
 139
 140 void RenderInline::updateFromStyle()
 141 {
 142     RenderBoxModelObject::updateFromStyle();
 143
 144     // FIXME: Is this still needed. Was needed for run-ins, since run-in is considered a block display type.
 145     setInline(true);
 146
 147     // FIXME: Support transforms and reflections on inline flows someday.
 148     setHasTransform(false);
 149     setHasReflection(false);
 150 }
 151
 152 static RenderObject* inFlowPositionedInlineAncestor(RenderObject* p)
 153 {
 154     while (p && p->isRenderInline()) {
 155         if (p->isRelPositioned())
 156             return p;
 157         p = p->parent();
 158     }
 159     return 0;
 160 }
 161
 162 static void updateStyleOfAnonymousBlockContinuations(RenderObject* block, const RenderStyle* newStyle, const RenderStyle* oldStyle)
 163 {
 164     for (;block && block->isAnonymousBlock(); block = block->nextSibling()) {
 165         if (!toRenderBlock(block)->isAnonymousBlockContinuation())
 166             continue;
 167
 168         RefPtr<RenderStyle> newBlockStyle;
 169
 170         if (!block->style()->isOutlineEquivalent(newStyle)) {
 171             newBlockStyle = RenderStyle::clone(block->style());
 172             newBlockStyle->setOutlineFromStyle(*newStyle);
 173         }
 174
 175         if (block->style()->position() != newStyle->position()) {
 176             // If we are no longer in-flow positioned but our descendant block(s) still have an in-flow positioned ancestor then
 177             // their containing anonymous block should keep its in-flow positioning.
 178             if (oldStyle->hasInFlowPosition()
 179                 && inFlowPositionedInlineAncestor(toRenderBlock(block)->inlineElementContinuation()))
 180                 continue;
 181             if (!newBlockStyle)
 182                 newBlockStyle = RenderStyle::clone(block->style());
 183             newBlockStyle->setPosition(newStyle->position());
 184         }
 185
 186         if (newBlockStyle)
 187             block->setStyle(newBlockStyle);
 188     }
 189 }
 190
 191 void RenderInline::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 192 {
 193     RenderBoxModelObject::styleDidChange(diff, oldStyle);
 194
 195     // Ensure that all of the split inlines pick up the new style. We
 196     // only do this if we're an inline, since we don't want to propagate
 197     // a block's style to the other inlines.
 198     // e.g., <font>foo <h4>goo</h4> moo</font>.  The <font> inlines before
 199     // and after the block share the same style, but the block doesn't
 200     // need to pass its style on to anyone else.
 201     RenderStyle* newStyle = style();
 202     RenderInline* continuation = inlineElementContinuation();
 203     for (RenderInline* currCont = continuation; currCont; currCont = currCont->inlineElementContinuation()) {
 204         RenderBoxModelObject* nextCont = currCont->continuation();
 205         currCont->setContinuation(0);
 206         currCont->setStyle(newStyle);
 207         currCont->setContinuation(nextCont);
 208     }
 209
 210     // If an inline's outline or in-flow positioning has changed then any descendant blocks will need to change their styles accordingly.
 211     // Do this by updating the styles of the descendant blocks' containing anonymous blocks - there may be more than one.
 212     if (continuation && oldStyle
 213         && (!newStyle->isOutlineEquivalent(oldStyle)
 214             || (newStyle->position() != oldStyle->position() && (newStyle->hasInFlowPosition() || oldStyle->hasInFlowPosition())))) {
 215         // If any descendant blocks exist then they will be in the next anonymous block and its siblings.
 216         RenderObject* block = containingBlock()->nextSibling();
 217         if (block && block->isAnonymousBlock())
 218             updateStyleOfAnonymousBlockContinuations(block, newStyle, oldStyle);
 219     }
 220
 221     if (!alwaysCreateLineBoxes()) {
 222         bool alwaysCreateLineBoxesNew = hasSelfPaintingLayer() || hasBoxDecorationBackground() || newStyle->hasPadding() || newStyle->hasMargin() || newStyle->hasOutline();
 223         if (oldStyle && alwaysCreateLineBoxesNew) {
 224             dirtyLineBoxes(false);
 225             setNeedsLayoutAndFullPaintInvalidation();
 226         }
 227         setAlwaysCreateLineBoxes(alwaysCreateLineBoxesNew);
 228     }
 229 }
 230
 231 void RenderInline::updateAlwaysCreateLineBoxes(bool fullLayout)
 232 {
 233     // Once we have been tainted once, just assume it will happen again. This way effects like hover highlighting that change the
 234     // background color will only cause a layout on the first rollover.
 235     if (alwaysCreateLineBoxes())
 236         return;
 237
 238     RenderStyle* parentStyle = parent()->style();
 239     RenderInline* parentRenderInline = parent()->isRenderInline() ? toRenderInline(parent()) : 0;
 240     bool checkFonts = document().inNoQuirksMode();
 241     bool alwaysCreateLineBoxesNew = (parentRenderInline && parentRenderInline->alwaysCreateLineBoxes())
 242         || (parentRenderInline && parentStyle->verticalAlign() != BASELINE)
 243         || style()->verticalAlign() != BASELINE
 244         || style()->textEmphasisMark() != TextEmphasisMarkNone
 245         || (checkFonts && (!parentStyle->font().fontMetrics().hasIdenticalAscentDescentAndLineGap(style()->font().fontMetrics())
 246         || parentStyle->lineHeight() != style()->lineHeight()));
 247
 248     if (!alwaysCreateLineBoxesNew && checkFonts && document().styleEngine()->usesFirstLineRules()) {
 249         // Have to check the first line style as well.
 250         parentStyle = parent()->style(true);
 251         RenderStyle* childStyle = style(true);
 252         alwaysCreateLineBoxesNew = !parentStyle->font().fontMetrics().hasIdenticalAscentDescentAndLineGap(childStyle->font().fontMetrics())
 253         || childStyle->verticalAlign() != BASELINE
 254         || parentStyle->lineHeight() != childStyle->lineHeight();
 255     }
 256
 257     if (alwaysCreateLineBoxesNew) {
 258         if (!fullLayout)
 259             dirtyLineBoxes(false);
 260         setAlwaysCreateLineBoxes();
 261     }
 262 }
 263
 264 LayoutRect RenderInline::localCaretRect(InlineBox* inlineBox, int, LayoutUnit* extraWidthToEndOfLine)
 265 {
 266     if (firstChild()) {
 267         // This condition is possible if the RenderInline is at an editing boundary,
 268         // i.e. the VisiblePosition is:
 269         //   <RenderInline editingBoundary=true>|<RenderText> </RenderText></RenderInline>
 270         // FIXME: need to figure out how to make this return a valid rect, note that
 271         // there are no line boxes created in the above case.
 272         return LayoutRect();
 273     }
 274
 275     ASSERT_UNUSED(inlineBox, !inlineBox);
 276
 277     if (extraWidthToEndOfLine)
 278         *extraWidthToEndOfLine = 0;
 279
 280     LayoutRect caretRect = localCaretRectForEmptyElement(borderAndPaddingWidth(), 0);
 281
 282     if (InlineBox* firstBox = firstLineBox())
 283         caretRect.moveBy(roundedLayoutPoint(firstBox->topLeft()));
 284
 285     return caretRect;
 286 }
 287
 288 void RenderInline::addChild(RenderObject* newChild, RenderObject* beforeChild)
 289 {
 290     if (continuation())
 291         return addChildToContinuation(newChild, beforeChild);
 292     return addChildIgnoringContinuation(newChild, beforeChild);
 293 }
 294
 295 static RenderBoxModelObject* nextContinuation(RenderObject* renderer)
 296 {
 297     if (renderer->isInline() && !renderer->isReplaced())
 298         return toRenderInline(renderer)->continuation();
 299     return toRenderBlock(renderer)->inlineElementContinuation();
 300 }
 301
 302 RenderBoxModelObject* RenderInline::continuationBefore(RenderObject* beforeChild)
 303 {
 304     if (beforeChild && beforeChild->parent() == this)
 305         return this;
 306
 307     RenderBoxModelObject* curr = nextContinuation(this);
 308     RenderBoxModelObject* nextToLast = this;
 309     RenderBoxModelObject* last = this;
 310     while (curr) {
 311         if (beforeChild && beforeChild->parent() == curr) {
 312             if (curr->slowFirstChild() == beforeChild)
 313                 return last;
 314             return curr;
 315         }
 316
 317         nextToLast = last;
 318         last = curr;
 319         curr = nextContinuation(curr);
 320     }
 321
 322     if (!beforeChild && !last->slowFirstChild())
 323         return nextToLast;
 324     return last;
 325 }
 326
 327 void RenderInline::addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild)
 328 {
 329     // Make sure we don't append things after :after-generated content if we have it.
 330     if (!beforeChild && isAfterContent(lastChild()))
 331         beforeChild = lastChild();
 332
 333     if (!newChild->isInline() && !newChild->isFloatingOrOutOfFlowPositioned()) {
 334         // We are placing a block inside an inline. We have to perform a split of this
 335         // inline into continuations.  This involves creating an anonymous block box to hold
 336         // |newChild|.  We then make that block box a continuation of this inline.  We take all of
 337         // the children after |beforeChild| and put them in a clone of this object.
 338         RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), BLOCK);
 339
 340         // If inside an inline affected by in-flow positioning the block needs to be affected by it too.
 341         // Giving the block a layer like this allows it to collect the x/y offsets from inline parents later.
 342         if (RenderObject* positionedAncestor = inFlowPositionedInlineAncestor(this))
 343             newStyle->setPosition(positionedAncestor->style()->position());
 344
 345         // Push outline style to the block continuation.
 346         if (!newStyle->isOutlineEquivalent(style()))
 347             newStyle->setOutlineFromStyle(*style());
 348
 349         RenderBlockFlow* newBox = RenderBlockFlow::createAnonymous(&document());
 350         newBox->setStyle(newStyle.release());
 351         RenderBoxModelObject* oldContinuation = continuation();
 352         setContinuation(newBox);
 353
 354         splitFlow(beforeChild, newBox, newChild, oldContinuation);
 355         return;
 356     }
 357
 358     RenderBoxModelObject::addChild(newChild, beforeChild);
 359
 360     newChild->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
 361 }
 362
 363 RenderInline* RenderInline::clone() const
 364 {
 365     RenderInline* cloneInline = new RenderInline(node());
 366     cloneInline->setStyle(style());
 367     cloneInline->setFlowThreadState(flowThreadState());
 368     return cloneInline;
 369 }
 370
 371 void RenderInline::splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock,
 372                                 RenderBlock* middleBlock,
 373                                 RenderObject* beforeChild, RenderBoxModelObject* oldCont)
 374 {
 375     // Create a clone of this inline.
 376     RenderInline* cloneInline = clone();
 377     cloneInline->setContinuation(oldCont);
 378
 379     // If we're splitting the inline containing the fullscreened element,
 380     // |beforeChild| may be the renderer for the fullscreened element. However,
 381     // that renderer is wrapped in a RenderFullScreen, so |this| is not its
 382     // parent. Since the splitting logic expects |this| to be the parent, set
 383     // |beforeChild| to be the RenderFullScreen.
 384     if (Fullscreen* fullscreen = Fullscreen::fromIfExists(document())) {
 385         const Element* fullScreenElement = fullscreen->webkitCurrentFullScreenElement();
 386         if (fullScreenElement && beforeChild && beforeChild->node() == fullScreenElement)
 387             beforeChild = fullscreen->fullScreenRenderer();
 388     }
 389
 390     // Now take all of the children from beforeChild to the end and remove
 391     // them from |this| and place them in the clone.
 392     RenderObject* o = beforeChild;
 393     while (o) {
 394         RenderObject* tmp = o;
 395         o = tmp->nextSibling();
 396         cloneInline->addChildIgnoringContinuation(children()->removeChildNode(this, tmp), 0);
 397         tmp->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
 398     }
 399
 400     // Hook |clone| up as the continuation of the middle block.
 401     middleBlock->setContinuation(cloneInline);
 402
 403     // We have been reparented and are now under the fromBlock.  We need
 404     // to walk up our inline parent chain until we hit the containing block.
 405     // Once we hit the containing block we're done.
 406     RenderBoxModelObject* curr = toRenderBoxModelObject(parent());
 407     RenderBoxModelObject* currChild = this;
 408
 409     // FIXME: Because splitting is O(n^2) as tags nest pathologically, we cap the depth at which we're willing to clone.
 410     // There will eventually be a better approach to this problem that will let us nest to a much
 411     // greater depth (see bugzilla bug 13430) but for now we have a limit.  This *will* result in
 412     // incorrect rendering, but the alternative is to hang forever.
 413     unsigned splitDepth = 1;
 414     const unsigned cMaxSplitDepth = 200;
 415     while (curr && curr != fromBlock) {
 416         ASSERT(curr->isRenderInline());
 417         if (splitDepth < cMaxSplitDepth) {
 418             // Create a new clone.
 419             RenderInline* cloneChild = cloneInline;
 420             cloneInline = toRenderInline(curr)->clone();
 421
 422             // Insert our child clone as the first child.
 423             cloneInline->addChildIgnoringContinuation(cloneChild, 0);
 424
 425             // Hook the clone up as a continuation of |curr|.
 426             RenderInline* inlineCurr = toRenderInline(curr);
 427             oldCont = inlineCurr->continuation();
 428             inlineCurr->setContinuation(cloneInline);
 429             cloneInline->setContinuation(oldCont);
 430
 431             // Now we need to take all of the children starting from the first child
 432             // *after* currChild and append them all to the clone.
 433             o = currChild->nextSibling();
 434             while (o) {
 435                 RenderObject* tmp = o;
 436                 o = tmp->nextSibling();
 437                 cloneInline->addChildIgnoringContinuation(inlineCurr->children()->removeChildNode(curr, tmp), 0);
 438                 tmp->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
 439             }
 440         }
 441
 442         // Keep walking up the chain.
 443         currChild = curr;
 444         curr = toRenderBoxModelObject(curr->parent());
 445         splitDepth++;
 446     }
 447
 448     // Now we are at the block level. We need to put the clone into the toBlock.
 449     toBlock->children()->appendChildNode(toBlock, cloneInline);
 450
 451     // Now take all the children after currChild and remove them from the fromBlock
 452     // and put them in the toBlock.
 453     o = currChild->nextSibling();
 454     while (o) {
 455         RenderObject* tmp = o;
 456         o = tmp->nextSibling();
 457         toBlock->children()->appendChildNode(toBlock, fromBlock->children()->removeChildNode(fromBlock, tmp));
 458     }
 459 }
 460
 461 void RenderInline::splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
 462                              RenderObject* newChild, RenderBoxModelObject* oldCont)
 463 {
 464     RenderBlock* pre = 0;
 465     RenderBlock* block = containingBlock();
 466
 467     // Delete our line boxes before we do the inline split into continuations.
 468     block->deleteLineBoxTree();
 469
 470     bool madeNewBeforeBlock = false;
 471     if (block->isAnonymousBlock() && (!block->parent() || !block->parent()->createsAnonymousWrapper())) {
 472         // We can reuse this block and make it the preBlock of the next continuation.
 473         pre = block;
 474         pre->removePositionedObjects(0);
 475         if (pre->isRenderBlockFlow())
 476             toRenderBlockFlow(pre)->removeFloatingObjects();
 477         block = block->containingBlock();
 478     } else {
 479         // No anonymous block available for use.  Make one.
 480         pre = block->createAnonymousBlock();
 481         madeNewBeforeBlock = true;
 482     }
 483
 484     RenderBlock* post = toRenderBlock(pre->createAnonymousBoxWithSameTypeAs(block));
 485
 486     RenderObject* boxFirst = madeNewBeforeBlock ? block->firstChild() : pre->nextSibling();
 487     if (madeNewBeforeBlock)
 488         block->children()->insertChildNode(block, pre, boxFirst);
 489     block->children()->insertChildNode(block, newBlockBox, boxFirst);
 490     block->children()->insertChildNode(block, post, boxFirst);
 491     block->setChildrenInline(false);
 492
 493     if (madeNewBeforeBlock) {
 494         RenderObject* o = boxFirst;
 495         while (o) {
 496             RenderObject* no = o;
 497             o = no->nextSibling();
 498             pre->children()->appendChildNode(pre, block->children()->removeChildNode(block, no));
 499             no->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
 500         }
 501     }
 502
 503     splitInlines(pre, post, newBlockBox, beforeChild, oldCont);
 504
 505     // We already know the newBlockBox isn't going to contain inline kids, so avoid wasting
 506     // time in makeChildrenNonInline by just setting this explicitly up front.
 507     newBlockBox->setChildrenInline(false);
 508
 509     newBlockBox->addChild(newChild);
 510
 511     // Always just do a full layout in order to ensure that line boxes (especially wrappers for images)
 512     // get deleted properly.  Because objects moves from the pre block into the post block, we want to
 513     // make new line boxes instead of leaving the old line boxes around.
 514     pre->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
 515     block->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
 516     post->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
 517 }
 518
 519 void RenderInline::addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild)
 520 {
 521     RenderBoxModelObject* flow = continuationBefore(beforeChild);
 522     ASSERT(!beforeChild || beforeChild->parent()->isRenderBlock() || beforeChild->parent()->isRenderInline());
 523     RenderBoxModelObject* beforeChildParent = 0;
 524     if (beforeChild)
 525         beforeChildParent = toRenderBoxModelObject(beforeChild->parent());
 526     else {
 527         RenderBoxModelObject* cont = nextContinuation(flow);
 528         if (cont)
 529             beforeChildParent = cont;
 530         else
 531             beforeChildParent = flow;
 532     }
 533
 534     if (newChild->isFloatingOrOutOfFlowPositioned())
 535         return beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);
 536
 537     // A continuation always consists of two potential candidates: an inline or an anonymous
 538     // block box holding block children.
 539     bool childInline = newChild->isInline();
 540     bool bcpInline = beforeChildParent->isInline();
 541     bool flowInline = flow->isInline();
 542
 543     if (flow == beforeChildParent)
 544         return flow->addChildIgnoringContinuation(newChild, beforeChild);
 545     else {
 546         // The goal here is to match up if we can, so that we can coalesce and create the
 547         // minimal # of continuations needed for the inline.
 548         if (childInline == bcpInline || (beforeChild && beforeChild->isInline()))
 549             return beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);
 550         if (flowInline == childInline)
 551             return flow->addChildIgnoringContinuation(newChild, 0); // Just treat like an append.
 552         return beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);
 553     }
 554 }
 555
 556 void RenderInline::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 557 {
 558     InlinePainter(*this).paint(paintInfo, paintOffset);
 559 }
 560
 561 template<typename GeneratorContext>
 562 void RenderInline::generateLineBoxRects(GeneratorContext& yield) const
 563 {
 564     if (!alwaysCreateLineBoxes())
 565         generateCulledLineBoxRects(yield, this);
 566     else if (InlineFlowBox* curr = firstLineBox()) {
 567         for (; curr; curr = curr->nextLineBox())
 568             yield(FloatRect(curr->topLeft(), curr->size()));
 569     } else
 570         yield(FloatRect());
 571 }
 572
 573 template<typename GeneratorContext>
 574 void RenderInline::generateCulledLineBoxRects(GeneratorContext& yield, const RenderInline* container) const
 575 {
 576     if (!culledInlineFirstLineBox()) {
 577         yield(FloatRect());
 578         return;
 579     }
 580
 581     bool isHorizontal = style()->isHorizontalWritingMode();
 582
 583     for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
 584         if (curr->isFloatingOrOutOfFlowPositioned())
 585             continue;
 586
 587         // We want to get the margin box in the inline direction, and then use our font ascent/descent in the block
 588         // direction (aligned to the root box's baseline).
 589         if (curr->isBox()) {
 590             RenderBox* currBox = toRenderBox(curr);
 591             if (currBox->inlineBoxWrapper()) {
 592                 RootInlineBox& rootBox = currBox->inlineBoxWrapper()->root();
 593                 int logicalTop = rootBox.logicalTop() + (rootBox.renderer().style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent() - container->style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent());
 594                 int logicalHeight = container->style(rootBox.isFirstLineStyle())->font().fontMetrics().height();
 595                 if (isHorizontal)
 596                     yield(FloatRect(currBox->inlineBoxWrapper()->x() - currBox->marginLeft(), logicalTop, (currBox->width() + currBox->marginWidth()).toFloat(), logicalHeight));
 597                 else
 598                     yield(FloatRect(logicalTop, currBox->inlineBoxWrapper()->y() - currBox->marginTop(), logicalHeight, (currBox->height() + currBox->marginHeight()).toFloat()));
 599             }
 600         } else if (curr->isRenderInline()) {
 601             // If the child doesn't need line boxes either, then we can recur.
 602             RenderInline* currInline = toRenderInline(curr);
 603             if (!currInline->alwaysCreateLineBoxes())
 604                 currInline->generateCulledLineBoxRects(yield, container);
 605             else {
 606                 for (InlineFlowBox* childLine = currInline->firstLineBox(); childLine; childLine = childLine->nextLineBox()) {
 607                     RootInlineBox& rootBox = childLine->root();
 608                     int logicalTop = rootBox.logicalTop() + (rootBox.renderer().style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent() - container->style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent());
 609                     int logicalHeight = container->style(rootBox.isFirstLineStyle())->font().fontMetrics().height();
 610                     if (isHorizontal)
 611                         yield(FloatRect(childLine->x() - childLine->marginLogicalLeft(),
 612                             logicalTop,
 613                             childLine->logicalWidth() + childLine->marginLogicalLeft() + childLine->marginLogicalRight(),
 614                             logicalHeight));
 615                     else
 616                         yield(FloatRect(logicalTop,
 617                             childLine->y() - childLine->marginLogicalLeft(),
 618                             logicalHeight,
 619                             childLine->logicalWidth() + childLine->marginLogicalLeft() + childLine->marginLogicalRight()));
 620                 }
 621             }
 622         } else if (curr->isText()) {
 623             RenderText* currText = toRenderText(curr);
 624             for (InlineTextBox* childText = currText->firstTextBox(); childText; childText = childText->nextTextBox()) {
 625                 RootInlineBox& rootBox = childText->root();
 626                 int logicalTop = rootBox.logicalTop() + (rootBox.renderer().style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent() - container->style(rootBox.isFirstLineStyle())->font().fontMetrics().ascent());
 627                 int logicalHeight = container->style(rootBox.isFirstLineStyle())->font().fontMetrics().height();
 628                 if (isHorizontal)
 629                     yield(FloatRect(childText->x(), logicalTop, childText->logicalWidth(), logicalHeight));
 630                 else
 631                     yield(FloatRect(logicalTop, childText->y(), logicalHeight, childText->logicalWidth()));
 632             }
 633         }
 634     }
 635 }
 636
 637 namespace {
 638
 639 class AbsoluteRectsGeneratorContext {
 640 public:
 641     AbsoluteRectsGeneratorContext(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset)
 642         : m_rects(rects)
 643         , m_accumulatedOffset(accumulatedOffset) { }
 644
 645     void operator()(const FloatRect& rect)
 646     {
 647         IntRect intRect = enclosingIntRect(rect);
 648         intRect.move(m_accumulatedOffset.x(), m_accumulatedOffset.y());
 649         m_rects.append(intRect);
 650     }
 651 private:
 652     Vector<IntRect>& m_rects;
 653     const LayoutPoint& m_accumulatedOffset;
 654 };
 655
 656 } // unnamed namespace
 657
 658 void RenderInline::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
 659 {
 660     AbsoluteRectsGeneratorContext context(rects, accumulatedOffset);
 661     generateLineBoxRects(context);
 662
 663     if (continuation()) {
 664         if (continuation()->isBox()) {
 665             RenderBox* box = toRenderBox(continuation());
 666             continuation()->absoluteRects(rects, toLayoutPoint(accumulatedOffset - containingBlock()->location() + box->locationOffset()));
 667         } else
 668             continuation()->absoluteRects(rects, toLayoutPoint(accumulatedOffset - containingBlock()->location()));
 669     }
 670 }
 671
 672
 673 namespace {
 674
 675 class AbsoluteQuadsGeneratorContext {
 676 public:
 677     AbsoluteQuadsGeneratorContext(const RenderInline* renderer, Vector<FloatQuad>& quads)
 678         : m_quads(quads)
 679         , m_geometryMap()
 680     {
 681         m_geometryMap.pushMappingsToAncestor(renderer, 0);
 682     }
 683
 684     void operator()(const FloatRect& rect)
 685     {
 686         m_quads.append(m_geometryMap.absoluteRect(rect));
 687     }
 688 private:
 689     Vector<FloatQuad>& m_quads;
 690     RenderGeometryMap m_geometryMap;
 691 };
 692
 693 } // unnamed namespace
 694
 695 void RenderInline::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
 696 {
 697     AbsoluteQuadsGeneratorContext context(this, quads);
 698     generateLineBoxRects(context);
 699
 700     if (continuation())
 701         continuation()->absoluteQuads(quads, wasFixed);
 702 }
 703
 704 LayoutUnit RenderInline::offsetLeft() const
 705 {
 706     LayoutPoint topLeft;
 707     if (InlineBox* firstBox = firstLineBoxIncludingCulling())
 708         topLeft = flooredLayoutPoint(firstBox->topLeft());
 709     return adjustedPositionRelativeToOffsetParent(topLeft).x();
 710 }
 711
 712 LayoutUnit RenderInline::offsetTop() const
 713 {
 714     LayoutPoint topLeft;
 715     if (InlineBox* firstBox = firstLineBoxIncludingCulling())
 716         topLeft = flooredLayoutPoint(firstBox->topLeft());
 717     return adjustedPositionRelativeToOffsetParent(topLeft).y();
 718 }
 719
 720 static LayoutUnit computeMargin(const RenderInline* renderer, const Length& margin)
 721 {
 722     if (margin.isAuto())
 723         return 0;
 724     if (margin.isFixed())
 725         return margin.value();
 726     if (margin.isPercent())
 727         return minimumValueForLength(margin, std::max<LayoutUnit>(0, renderer->containingBlock()->availableLogicalWidth()));
 728     return 0;
 729 }
 730
 731 LayoutUnit RenderInline::marginLeft() const
 732 {
 733     return computeMargin(this, style()->marginLeft());
 734 }
 735
 736 LayoutUnit RenderInline::marginRight() const
 737 {
 738     return computeMargin(this, style()->marginRight());
 739 }
 740
 741 LayoutUnit RenderInline::marginTop() const
 742 {
 743     return computeMargin(this, style()->marginTop());
 744 }
 745
 746 LayoutUnit RenderInline::marginBottom() const
 747 {
 748     return computeMargin(this, style()->marginBottom());
 749 }
 750
 751 LayoutUnit RenderInline::marginStart(const RenderStyle* otherStyle) const
 752 {
 753     return computeMargin(this, style()->marginStartUsing(otherStyle ? otherStyle : style()));
 754 }
 755
 756 LayoutUnit RenderInline::marginEnd(const RenderStyle* otherStyle) const
 757 {
 758     return computeMargin(this, style()->marginEndUsing(otherStyle ? otherStyle : style()));
 759 }
 760
 761 LayoutUnit RenderInline::marginBefore(const RenderStyle* otherStyle) const
 762 {
 763     return computeMargin(this, style()->marginBeforeUsing(otherStyle ? otherStyle : style()));
 764 }
 765
 766 LayoutUnit RenderInline::marginAfter(const RenderStyle* otherStyle) const
 767 {
 768     return computeMargin(this, style()->marginAfterUsing(otherStyle ? otherStyle : style()));
 769 }
 770
 771 const char* RenderInline::renderName() const
 772 {
 773     if (isRelPositioned())
 774         return "RenderInline (relative positioned)";
 775     // FIXME: Cleanup isPseudoElement duplication with other renderName methods.
 776     // crbug.com/415653
 777     if (isPseudoElement()) {
 778         if (style()->styleType() == BEFORE)
 779             return "RenderInline (pseudo:before)";
 780         if (style()->styleType() == AFTER)
 781             return "RenderInline (pseudo:after)";
 782         if (style()->styleType() == BACKDROP)
 783             return "RenderInline (pseudo:backdrop)";
 784         ASSERT_NOT_REACHED();
 785     }
 786     if (isAnonymous())
 787         return "RenderInline (generated)";
 788     return "RenderInline";
 789 }
 790
 791 bool RenderInline::nodeAtPoint(const HitTestRequest& request, HitTestResult& result,
 792                                 const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
 793 {
 794     return m_lineBoxes.hitTest(this, request, result, locationInContainer, accumulatedOffset, hitTestAction);
 795 }
 796
 797 namespace {
 798
 799 class HitTestCulledInlinesGeneratorContext {
 800 public:
 801     HitTestCulledInlinesGeneratorContext(Region& region, const HitTestLocation& location) : m_intersected(false), m_region(region), m_location(location) { }
 802     void operator()(const FloatRect& rect)
 803     {
 804         m_intersected = m_intersected || m_location.intersects(rect);
 805         m_region.unite(enclosingIntRect(rect));
 806     }
 807     bool intersected() const { return m_intersected; }
 808 private:
 809     bool m_intersected;
 810     Region& m_region;
 811     const HitTestLocation& m_location;
 812 };
 813
 814 } // unnamed namespace
 815
 816 bool RenderInline::hitTestCulledInline(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset)
 817 {
 818     ASSERT(result.isRectBasedTest() && !alwaysCreateLineBoxes());
 819     if (!visibleToHitTestRequest(request))
 820         return false;
 821
 822     HitTestLocation tmpLocation(locationInContainer, -toLayoutSize(accumulatedOffset));
 823
 824     Region regionResult;
 825     HitTestCulledInlinesGeneratorContext context(regionResult, tmpLocation);
 826     generateCulledLineBoxRects(context, this);
 827
 828     if (context.intersected()) {
 829         updateHitTestResult(result, tmpLocation.point());
 830         // We can not use addNodeToRectBasedTestResult to determine if we fully enclose the hit-test area
 831         // because it can only handle rectangular targets.
 832         result.addNodeToRectBasedTestResult(node(), request, locationInContainer);
 833         return regionResult.contains(tmpLocation.boundingBox());
 834     }
 835     return false;
 836 }
 837
 838 PositionWithAffinity RenderInline::positionForPoint(const LayoutPoint& point)
 839 {
 840     // FIXME: Does not deal with relative positioned inlines (should it?)
 841     RenderBlock* cb = containingBlock();
 842     if (firstLineBox()) {
 843         // This inline actually has a line box.  We must have clicked in the border/padding of one of these boxes.  We
 844         // should try to find a result by asking our containing block.
 845         return cb->positionForPoint(point);
 846     }
 847
 848     // Translate the coords from the pre-anonymous block to the post-anonymous block.
 849     LayoutPoint parentBlockPoint = cb->location() + point;
 850     RenderBoxModelObject* c = continuation();
 851     while (c) {
 852         RenderBox* contBlock = c->isInline() ? c->containingBlock() : toRenderBlock(c);
 853         if (c->isInline() || c->slowFirstChild())
 854             return c->positionForPoint(parentBlockPoint - contBlock->locationOffset());
 855         c = toRenderBlock(c)->inlineElementContinuation();
 856     }
 857
 858     return RenderBoxModelObject::positionForPoint(point);
 859 }
 860
 861 namespace {
 862
 863 class LinesBoundingBoxGeneratorContext {
 864 public:
 865     LinesBoundingBoxGeneratorContext(FloatRect& rect) : m_rect(rect) { }
 866     void operator()(const FloatRect& rect)
 867     {
 868         m_rect.uniteIfNonZero(rect);
 869     }
 870 private:
 871     FloatRect& m_rect;
 872 };
 873
 874 } // unnamed namespace
 875
 876 IntRect RenderInline::linesBoundingBox() const
 877 {
 878     if (!alwaysCreateLineBoxes()) {
 879         ASSERT(!firstLineBox());
 880         FloatRect floatResult;
 881         LinesBoundingBoxGeneratorContext context(floatResult);
 882         generateCulledLineBoxRects(context, this);
 883         return enclosingIntRect(floatResult);
 884     }
 885
 886     IntRect result;
 887
 888     // See <rdar://problem/5289721>, for an unknown reason the linked list here is sometimes inconsistent, first is non-zero and last is zero.  We have been
 889     // unable to reproduce this at all (and consequently unable to figure ot why this is happening).  The assert will hopefully catch the problem in debug
 890     // builds and help us someday figure out why.  We also put in a redundant check of lastLineBox() to avoid the crash for now.
 891     ASSERT(!firstLineBox() == !lastLineBox());  // Either both are null or both exist.
 892     if (firstLineBox() && lastLineBox()) {
 893         // Return the width of the minimal left side and the maximal right side.
 894         float logicalLeftSide = 0;
 895         float logicalRightSide = 0;
 896         for (InlineFlowBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) {
 897             if (curr == firstLineBox() || curr->logicalLeft() < logicalLeftSide)
 898                 logicalLeftSide = curr->logicalLeft();
 899             if (curr == firstLineBox() || curr->logicalRight() > logicalRightSide)
 900                 logicalRightSide = curr->logicalRight();
 901         }
 902
 903         bool isHorizontal = style()->isHorizontalWritingMode();
 904
 905         float x = isHorizontal ? logicalLeftSide : firstLineBox()->x();
 906         float y = isHorizontal ? firstLineBox()->y() : logicalLeftSide;
 907         float width = isHorizontal ? logicalRightSide - logicalLeftSide : lastLineBox()->logicalBottom() - x;
 908         float height = isHorizontal ? lastLineBox()->logicalBottom() - y : logicalRightSide - logicalLeftSide;
 909         result = enclosingIntRect(FloatRect(x, y, width, height));
 910     }
 911
 912     return result;
 913 }
 914
 915 InlineBox* RenderInline::culledInlineFirstLineBox() const
 916 {
 917     for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
 918         if (curr->isFloatingOrOutOfFlowPositioned())
 919             continue;
 920
 921         // We want to get the margin box in the inline direction, and then use our font ascent/descent in the block
 922         // direction (aligned to the root box's baseline).
 923         if (curr->isBox())
 924             return toRenderBox(curr)->inlineBoxWrapper();
 925         if (curr->isRenderInline()) {
 926             RenderInline* currInline = toRenderInline(curr);
 927             InlineBox* result = currInline->firstLineBoxIncludingCulling();
 928             if (result)
 929                 return result;
 930         } else if (curr->isText()) {
 931             RenderText* currText = toRenderText(curr);
 932             if (currText->firstTextBox())
 933                 return currText->firstTextBox();
 934         }
 935     }
 936     return 0;
 937 }
 938
 939 InlineBox* RenderInline::culledInlineLastLineBox() const
 940 {
 941     for (RenderObject* curr = lastChild(); curr; curr = curr->previousSibling()) {
 942         if (curr->isFloatingOrOutOfFlowPositioned())
 943             continue;
 944
 945         // We want to get the margin box in the inline direction, and then use our font ascent/descent in the block
 946         // direction (aligned to the root box's baseline).
 947         if (curr->isBox())
 948             return toRenderBox(curr)->inlineBoxWrapper();
 949         if (curr->isRenderInline()) {
 950             RenderInline* currInline = toRenderInline(curr);
 951             InlineBox* result = currInline->lastLineBoxIncludingCulling();
 952             if (result)
 953                 return result;
 954         } else if (curr->isText()) {
 955             RenderText* currText = toRenderText(curr);
 956             if (currText->lastTextBox())
 957                 return currText->lastTextBox();
 958         }
 959     }
 960     return 0;
 961 }
 962
 963 LayoutRect RenderInline::culledInlineVisualOverflowBoundingBox() const
 964 {
 965     FloatRect floatResult;
 966     LinesBoundingBoxGeneratorContext context(floatResult);
 967     generateCulledLineBoxRects(context, this);
 968     LayoutRect result(enclosingLayoutRect(floatResult));
 969     bool isHorizontal = style()->isHorizontalWritingMode();
 970     for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
 971         if (curr->isFloatingOrOutOfFlowPositioned())
 972             continue;
 973
 974         // For overflow we just have to propagate by hand and recompute it all.
 975         if (curr->isBox()) {
 976             RenderBox* currBox = toRenderBox(curr);
 977             if (!currBox->hasSelfPaintingLayer() && currBox->inlineBoxWrapper()) {
 978                 LayoutRect logicalRect = currBox->logicalVisualOverflowRectForPropagation(style());
 979                 if (isHorizontal) {
 980                     logicalRect.moveBy(currBox->location());
 981                     result.uniteIfNonZero(logicalRect);
 982                 } else {
 983                     logicalRect.moveBy(currBox->location());
 984                     result.uniteIfNonZero(logicalRect.transposedRect());
 985                 }
 986             }
 987         } else if (curr->isRenderInline()) {
 988             // If the child doesn't need line boxes either, then we can recur.
 989             RenderInline* currInline = toRenderInline(curr);
 990             if (!currInline->alwaysCreateLineBoxes())
 991                 result.uniteIfNonZero(currInline->culledInlineVisualOverflowBoundingBox());
 992             else if (!currInline->hasSelfPaintingLayer())
 993                 result.uniteIfNonZero(currInline->linesVisualOverflowBoundingBox());
 994         } else if (curr->isText()) {
 995             // FIXME; Overflow from text boxes is lost. We will need to cache this information in
 996             // InlineTextBoxes.
 997             RenderText* currText = toRenderText(curr);
 998             result.uniteIfNonZero(currText->linesVisualOverflowBoundingBox());
 999         }
1000     }
1001     return result;
1002 }
1003
1004 LayoutRect RenderInline::linesVisualOverflowBoundingBox() const
1005 {
1006     if (!alwaysCreateLineBoxes())
1007         return culledInlineVisualOverflowBoundingBox();
1008
1009     if (!firstLineBox() || !lastLineBox())
1010         return LayoutRect();
1011
1012     // Return the width of the minimal left side and the maximal right side.
1013     LayoutUnit logicalLeftSide = LayoutUnit::max();
1014     LayoutUnit logicalRightSide = LayoutUnit::min();
1015     for (InlineFlowBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) {
1016         logicalLeftSide = std::min(logicalLeftSide, curr->logicalLeftVisualOverflow());
1017         logicalRightSide = std::max(logicalRightSide, curr->logicalRightVisualOverflow());
1018     }
1019
1020     RootInlineBox& firstRootBox = firstLineBox()->root();
1021     RootInlineBox& lastRootBox = lastLineBox()->root();
1022
1023     LayoutUnit logicalTop = firstLineBox()->logicalTopVisualOverflow(firstRootBox.lineTop());
1024     LayoutUnit logicalWidth = logicalRightSide - logicalLeftSide;
1025     LayoutUnit logicalHeight = lastLineBox()->logicalBottomVisualOverflow(lastRootBox.lineBottom()) - logicalTop;
1026
1027     LayoutRect rect(logicalLeftSide, logicalTop, logicalWidth, logicalHeight);
1028     if (!style()->isHorizontalWritingMode())
1029         rect = rect.transposedRect();
1030     return rect;
1031 }
1032
1033 LayoutRect RenderInline::clippedOverflowRectForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
1034 {
1035     if ((!firstLineBoxIncludingCulling() && !continuation()) || style()->visibility() != VISIBLE)
1036         return LayoutRect();
1037
1038     LayoutRect paintInvalidationRect(linesVisualOverflowBoundingBox());
1039
1040     LayoutUnit outlineSize = style()->outlineSize();
1041     paintInvalidationRect.inflate(outlineSize);
1042
1043     mapRectToPaintInvalidationBacking(paintInvalidationContainer, paintInvalidationRect, paintInvalidationState);
1044
1045     if (outlineSize) {
1046         for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
1047             if (!curr->isText())
1048                 paintInvalidationRect.unite(curr->rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineSize));
1049         }
1050
1051         if (continuation() && !continuation()->isInline() && continuation()->parent())
1052             paintInvalidationRect.unite(continuation()->rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineSize));
1053     }
1054
1055     return paintInvalidationRect;
1056 }
1057
1058 LayoutRect RenderInline::rectWithOutlineForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, LayoutUnit outlineWidth, const PaintInvalidationState* paintInvalidationState) const
1059 {
1060     LayoutRect r(RenderBoxModelObject::rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineWidth, paintInvalidationState));
1061     for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
1062         if (!curr->isText())
1063             r.unite(curr->rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineWidth, paintInvalidationState));
1064     }
1065     return r;
1066 }
1067
1068 void RenderInline::mapRectToPaintInvalidationBacking(const RenderLayerModelObject* paintInvalidationContainer, LayoutRect& rect, const PaintInvalidationState* paintInvalidationState) const
1069 {
1070     if (paintInvalidationState && paintInvalidationState->canMapToContainer(paintInvalidationContainer)) {
1071         if (style()->hasInFlowPosition() && layer())
1072             rect.move(layer()->offsetForInFlowPosition());
1073         rect.move(paintInvalidationState->paintOffset());
1074         if (paintInvalidationState->isClipped())
1075             rect.intersect(paintInvalidationState->clipRect());
1076         return;
1077     }
1078
1079     if (paintInvalidationContainer == this)
1080         return;
1081
1082     bool containerSkipped;
1083     RenderObject* o = container(paintInvalidationContainer, &containerSkipped);
1084     if (!o)
1085         return;
1086
1087     LayoutPoint topLeft = rect.location();
1088
1089     if (o->isRenderBlockFlow() && !style()->hasOutOfFlowPosition()) {
1090         RenderBlock* cb = toRenderBlock(o);
1091         if (cb->hasColumns()) {
1092             LayoutRect paintInvalidationRect(topLeft, rect.size());
1093             cb->adjustRectForColumns(paintInvalidationRect);
1094             topLeft = paintInvalidationRect.location();
1095             rect = paintInvalidationRect;
1096         }
1097     }
1098
1099     if (style()->hasInFlowPosition() && layer()) {
1100         // Apply the in-flow position offset when invalidating a rectangle. The layer
1101         // is translated, but the render box isn't, so we need to do this to get the
1102         // right dirty rect. Since this is called from RenderObject::setStyle, the relative position
1103         // flag on the RenderObject has been cleared, so use the one on the style().
1104         topLeft += layer()->offsetForInFlowPosition();
1105     }
1106
1107     // FIXME: We ignore the lightweight clipping rect that controls use, since if |o| is in mid-layout,
1108     // its controlClipRect will be wrong. For overflow clip we use the values cached by the layer.
1109     rect.setLocation(topLeft);
1110     if (o->hasOverflowClip()) {
1111         RenderBox* containerBox = toRenderBox(o);
1112         containerBox->applyCachedClipAndScrollOffsetForPaintInvalidation(rect);
1113         if (rect.isEmpty())
1114             return;
1115     }
1116
1117     if (containerSkipped) {
1118         // If the paintInvalidationContainer is below o, then we need to map the rect into paintInvalidationContainer's coordinates.
1119         LayoutSize containerOffset = paintInvalidationContainer->offsetFromAncestorContainer(o);
1120         rect.move(-containerOffset);
1121         return;
1122     }
1123
1124     o->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
1125 }
1126
1127 LayoutSize RenderInline::offsetFromContainer(const RenderObject* container, const LayoutPoint& point, bool* offsetDependsOnPoint) const
1128 {
1129     ASSERT(container == this->container());
1130
1131     LayoutSize offset;
1132     if (isRelPositioned())
1133         offset += offsetForInFlowPosition();
1134
1135     offset += container->columnOffset(point);
1136
1137     if (container->hasOverflowClip())
1138         offset -= toRenderBox(container)->scrolledContentOffset();
1139
1140     if (offsetDependsOnPoint) {
1141         *offsetDependsOnPoint = container->hasColumns()
1142             || (container->isBox() && container->style()->isFlippedBlocksWritingMode())
1143             || container->isRenderFlowThread();
1144     }
1145
1146     return offset;
1147 }
1148
1149 void RenderInline::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed, const PaintInvalidationState* paintInvalidationState) const
1150 {
1151     if (paintInvalidationContainer == this)
1152         return;
1153
1154     if (paintInvalidationState && paintInvalidationState->canMapToContainer(paintInvalidationContainer)) {
1155         LayoutSize offset = paintInvalidationState->paintOffset();
1156         if (style()->hasInFlowPosition() && layer())
1157             offset += layer()->offsetForInFlowPosition();
1158         transformState.move(offset);
1159         return;
1160     }
1161
1162     bool containerSkipped;
1163     RenderObject* o = container(paintInvalidationContainer, &containerSkipped);
1164     if (!o)
1165         return;
1166
1167     if (mode & ApplyContainerFlip && o->isBox()) {
1168         if (o->style()->isFlippedBlocksWritingMode()) {
1169             IntPoint centerPoint = roundedIntPoint(transformState.mappedPoint());
1170             transformState.move(toRenderBox(o)->flipForWritingModeIncludingColumns(centerPoint) - centerPoint);
1171         }
1172         mode &= ~ApplyContainerFlip;
1173     }
1174
1175     LayoutSize containerOffset = offsetFromContainer(o, roundedLayoutPoint(transformState.mappedPoint()));
1176
1177     bool preserve3D = mode & UseTransforms && (o->style()->preserves3D() || style()->preserves3D());
1178     if (mode & UseTransforms && shouldUseTransformFromContainer(o)) {
1179         TransformationMatrix t;
1180         getTransformFromContainer(o, containerOffset, t);
1181         transformState.applyTransform(t, preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
1182     } else
1183         transformState.move(containerOffset.width(), containerOffset.height(), preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
1184
1185     if (containerSkipped) {
1186         // There can't be a transform between paintInvalidationContainer and o, because transforms create containers, so it should be safe
1187         // to just subtract the delta between the paintInvalidationContainer and o.
1188         LayoutSize containerOffset = paintInvalidationContainer->offsetFromAncestorContainer(o);
1189         transformState.move(-containerOffset.width(), -containerOffset.height(), preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
1190         return;
1191     }
1192
1193     o->mapLocalToContainer(paintInvalidationContainer, transformState, mode, wasFixed, paintInvalidationState);
1194 }
1195
1196 void RenderInline::updateDragState(bool dragOn)
1197 {
1198     RenderBoxModelObject::updateDragState(dragOn);
1199     if (continuation())
1200         continuation()->updateDragState(dragOn);
1201 }
1202
1203 void RenderInline::childBecameNonInline(RenderObject* child)
1204 {
1205     // We have to split the parent flow.
1206     RenderBlock* newBox = containingBlock()->createAnonymousBlock();
1207     RenderBoxModelObject* oldContinuation = continuation();
1208     setContinuation(newBox);
1209     RenderObject* beforeChild = child->nextSibling();
1210     children()->removeChildNode(this, child);
1211     splitFlow(beforeChild, newBox, child, oldContinuation);
1212 }
1213
1214 void RenderInline::updateHitTestResult(HitTestResult& result, const LayoutPoint& point)
1215 {
1216     if (result.innerNode())
1217         return;
1218
1219     Node* n = node();
1220     LayoutPoint localPoint(point);
1221     if (n) {
1222         if (isInlineElementContinuation()) {
1223             // We're in the continuation of a split inline.  Adjust our local point to be in the coordinate space
1224             // of the principal renderer's containing block.  This will end up being the innerNonSharedNode.
1225             RenderBlock* firstBlock = n->renderer()->containingBlock();
1226
1227             // Get our containing block.
1228             RenderBox* block = containingBlock();
1229             localPoint.moveBy(block->location() - firstBlock->locationOffset());
1230         }
1231
1232         result.setInnerNode(n);
1233         if (!result.innerNonSharedNode())
1234             result.setInnerNonSharedNode(n);
1235         result.setLocalPoint(localPoint);
1236     }
1237 }
1238
1239 void RenderInline::dirtyLineBoxes(bool fullLayout)
1240 {
1241     if (fullLayout) {
1242         m_lineBoxes.deleteLineBoxes();
1243         return;
1244     }
1245
1246     if (!alwaysCreateLineBoxes()) {
1247         // We have to grovel into our children in order to dirty the appropriate lines.
1248         for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
1249             if (curr->isFloatingOrOutOfFlowPositioned())
1250                 continue;
1251             if (curr->isBox() && !curr->needsLayout()) {
1252                 RenderBox* currBox = toRenderBox(curr);
1253                 if (currBox->inlineBoxWrapper())
1254                     currBox->inlineBoxWrapper()->root().markDirty();
1255             } else if (!curr->selfNeedsLayout()) {
1256                 if (curr->isRenderInline()) {
1257                     RenderInline* currInline = toRenderInline(curr);
1258                     for (InlineFlowBox* childLine = currInline->firstLineBox(); childLine; childLine = childLine->nextLineBox())
1259                         childLine->root().markDirty();
1260                 } else if (curr->isText()) {
1261                     RenderText* currText = toRenderText(curr);
1262                     for (InlineTextBox* childText = currText->firstTextBox(); childText; childText = childText->nextTextBox())
1263                         childText->root().markDirty();
1264                 }
1265             }
1266         }
1267     } else
1268         m_lineBoxes.dirtyLineBoxes();
1269 }
1270
1271 void RenderInline::deleteLineBoxTree()
1272 {
1273     m_lineBoxes.deleteLineBoxTree();
1274 }
1275
1276 InlineFlowBox* RenderInline::createInlineFlowBox()
1277 {
1278     return new InlineFlowBox(*this);
1279 }
1280
1281 InlineFlowBox* RenderInline::createAndAppendInlineFlowBox()
1282 {
1283     setAlwaysCreateLineBoxes();
1284     InlineFlowBox* flowBox = createInlineFlowBox();
1285     m_lineBoxes.appendLineBox(flowBox);
1286     return flowBox;
1287 }
1288
1289 LayoutUnit RenderInline::lineHeight(bool firstLine, LineDirectionMode /*direction*/, LinePositionMode /*linePositionMode*/) const
1290 {
1291     if (firstLine && document().styleEngine()->usesFirstLineRules()) {
1292         RenderStyle* s = style(firstLine);
1293         if (s != style())
1294             return s->computedLineHeight();
1295     }
1296
1297     return style()->computedLineHeight();
1298 }
1299
1300 int RenderInline::baselinePosition(FontBaseline baselineType, bool firstLine, LineDirectionMode direction, LinePositionMode linePositionMode) const
1301 {
1302     ASSERT(linePositionMode == PositionOnContainingLine);
1303     const FontMetrics& fontMetrics = style(firstLine)->fontMetrics();
1304     return fontMetrics.ascent(baselineType) + (lineHeight(firstLine, direction, linePositionMode) - fontMetrics.height()) / 2;
1305 }
1306
1307 LayoutSize RenderInline::offsetForInFlowPositionedInline(const RenderBox& child) const
1308 {
1309     // FIXME: This function isn't right with mixed writing modes.
1310
1311     ASSERT(isRelPositioned());
1312     if (!isRelPositioned())
1313         return LayoutSize();
1314
1315     // When we have an enclosing relpositioned inline, we need to add in the offset of the first line
1316     // box from the rest of the content, but only in the cases where we know we're positioned
1317     // relative to the inline itself.
1318
1319     LayoutSize logicalOffset;
1320     LayoutUnit inlinePosition;
1321     LayoutUnit blockPosition;
1322     if (firstLineBox()) {
1323         inlinePosition = LayoutUnit::fromFloatRound(firstLineBox()->logicalLeft());
1324         blockPosition = firstLineBox()->logicalTop();
1325     } else {
1326         inlinePosition = layer()->staticInlinePosition();
1327         blockPosition = layer()->staticBlockPosition();
1328     }
1329
1330     // Per http://www.w3.org/TR/CSS2/visudet.html#abs-non-replaced-width an absolute positioned box
1331     // with a static position should locate itself as though it is a normal flow box in relation to
1332     // its containing block. If this relative-positioned inline has a negative offset we need to
1333     // compensate for it so that we align the positioned object with the edge of its containing block.
1334     if (child.style()->hasStaticInlinePosition(style()->isHorizontalWritingMode()))
1335         logicalOffset.setWidth(std::max(LayoutUnit(), -offsetForInFlowPosition().width()));
1336     else
1337         logicalOffset.setWidth(inlinePosition);
1338
1339     if (!child.style()->hasStaticBlockPosition(style()->isHorizontalWritingMode()))
1340         logicalOffset.setHeight(blockPosition);
1341
1342     return style()->isHorizontalWritingMode() ? logicalOffset : logicalOffset.transposedSize();
1343 }
1344
1345 void RenderInline::imageChanged(WrappedImagePtr, const IntRect*)
1346 {
1347     if (!parent())
1348         return;
1349
1350     // FIXME: We can do better.
1351     setShouldDoFullPaintInvalidation(true);
1352 }
1353
1354 namespace {
1355
1356 class AbsoluteLayoutRectsGeneratorContext {
1357 public:
1358     AbsoluteLayoutRectsGeneratorContext(Vector<LayoutRect>& rects, const LayoutPoint& accumulatedOffset)
1359         : m_rects(rects)
1360         , m_accumulatedOffset(accumulatedOffset) { }
1361
1362     void operator()(const FloatRect& rect)
1363     {
1364         LayoutRect layoutRect(rect);
1365         layoutRect.move(m_accumulatedOffset.x(), m_accumulatedOffset.y());
1366         m_rects.append(layoutRect);
1367     }
1368 private:
1369     Vector<LayoutRect>& m_rects;
1370     const LayoutPoint& m_accumulatedOffset;
1371 };
1372
1373 class AbsoluteLayoutRectsIgnoringEmptyRectsGeneratorContext : public AbsoluteLayoutRectsGeneratorContext {
1374 public:
1375     AbsoluteLayoutRectsIgnoringEmptyRectsGeneratorContext(Vector<LayoutRect>& rects, const LayoutPoint& accumulatedOffset)
1376         : AbsoluteLayoutRectsGeneratorContext(rects, accumulatedOffset) { }
1377
1378     void operator()(const FloatRect& rect)
1379     {
1380         if (!rect.isEmpty())
1381             AbsoluteLayoutRectsGeneratorContext::operator()(rect);
1382     }
1383 };
1384
1385 } // unnamed namespace
1386
1387 void RenderInline::addFocusRingRects(Vector<LayoutRect>& rects, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer) const
1388 {
1389     AbsoluteLayoutRectsIgnoringEmptyRectsGeneratorContext context(rects, additionalOffset);
1390     generateLineBoxRects(context);
1391
1392     addChildFocusRingRects(rects, additionalOffset, paintContainer);
1393
1394     if (continuation()) {
1395         // If the continuation doesn't paint into the same container, let its paint invalidation container handle it.
1396         if (paintContainer != continuation()->containerForPaintInvalidation())
1397             return;
1398         if (continuation()->isInline())
1399             continuation()->addFocusRingRects(rects, additionalOffset + (continuation()->containingBlock()->location() - containingBlock()->location()), paintContainer);
1400         else
1401             continuation()->addFocusRingRects(rects, additionalOffset + (toRenderBox(continuation())->location() - containingBlock()->location()), paintContainer);
1402     }
1403 }
1404
1405 void RenderInline::computeSelfHitTestRects(Vector<LayoutRect>& rects, const LayoutPoint& layerOffset) const
1406 {
1407     AbsoluteLayoutRectsGeneratorContext context(rects, layerOffset);
1408     generateLineBoxRects(context);
1409 }
1410
1411 void RenderInline::addAnnotatedRegions(Vector<AnnotatedRegionValue>& regions)
1412 {
1413     // Convert the style regions to absolute coordinates.
1414     if (style()->visibility() != VISIBLE)
1415         return;
1416
1417     if (style()->getDraggableRegionMode() == DraggableRegionNone)
1418         return;
1419
1420     AnnotatedRegionValue region;
1421     region.draggable = style()->getDraggableRegionMode() == DraggableRegionDrag;
1422     region.bounds = linesBoundingBox();
1423
1424     RenderObject* container = containingBlock();
1425     if (!container)
1426         container = this;
1427
1428     FloatPoint absPos = container->localToAbsolute();
1429     region.bounds.setX(absPos.x() + region.bounds.x());
1430     region.bounds.setY(absPos.y() + region.bounds.y());
1431
1432     regions.append(region);
1433 }
1434
1435 } // namespace blink