1/*
2 * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public License
15 * along with this library; see the file COPYING.LIB.  If not, write to
16 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17 * Boston, MA 02110-1301, USA.
18 */
19
20#include "config.h"
21#include "core/rendering/InlineFlowBox.h"
22
23#include "CSSPropertyNames.h"
24#include "core/dom/Document.h"
25#include "core/rendering/HitTestResult.h"
26#include "core/rendering/InlineTextBox.h"
27#include "core/rendering/RenderBlock.h"
28#include "core/rendering/RenderInline.h"
29#include "core/rendering/RenderLayer.h"
30#include "core/rendering/RenderListMarker.h"
31#include "core/rendering/RenderRubyBase.h"
32#include "core/rendering/RenderRubyRun.h"
33#include "core/rendering/RenderRubyText.h"
34#include "core/rendering/RenderView.h"
35#include "core/rendering/RootInlineBox.h"
36#include "platform/fonts/Font.h"
37#include "platform/graphics/GraphicsContextStateSaver.h"
38
39#include <math.h>
40
41using namespace std;
42
43namespace WebCore {
44
45struct SameSizeAsInlineFlowBox : public InlineBox {
46    void* pointers[5];
47    uint32_t bitfields : 23;
48};
49
50COMPILE_ASSERT(sizeof(InlineFlowBox) == sizeof(SameSizeAsInlineFlowBox), InlineFlowBox_should_stay_small);
51
52#ifndef NDEBUG
53
54InlineFlowBox::~InlineFlowBox()
55{
56    if (!m_hasBadChildList)
57        for (InlineBox* child = firstChild(); child; child = child->nextOnLine())
58            child->setHasBadParent();
59}
60
61#endif
62
63LayoutUnit InlineFlowBox::getFlowSpacingLogicalWidth()
64{
65    LayoutUnit totWidth = marginBorderPaddingLogicalLeft() + marginBorderPaddingLogicalRight();
66    for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
67        if (curr->isInlineFlowBox())
68            totWidth += toInlineFlowBox(curr)->getFlowSpacingLogicalWidth();
69    }
70    return totWidth;
71}
72
73IntRect InlineFlowBox::roundedFrameRect() const
74{
75    // Begin by snapping the x and y coordinates to the nearest pixel.
76    int snappedX = lroundf(x());
77    int snappedY = lroundf(y());
78
79    int snappedMaxX = lroundf(x() + width());
80    int snappedMaxY = lroundf(y() + height());
81
82    return IntRect(snappedX, snappedY, snappedMaxX - snappedX, snappedMaxY - snappedY);
83}
84
85static void setHasTextDescendantsOnAncestors(InlineFlowBox* box)
86{
87    while (box && !box->hasTextDescendants()) {
88        box->setHasTextDescendants();
89        box = box->parent();
90    }
91}
92
93void InlineFlowBox::addToLine(InlineBox* child)
94{
95    ASSERT(!child->parent());
96    ASSERT(!child->nextOnLine());
97    ASSERT(!child->prevOnLine());
98    checkConsistency();
99
100    child->setParent(this);
101    if (!m_firstChild) {
102        m_firstChild = child;
103        m_lastChild = child;
104    } else {
105        m_lastChild->setNextOnLine(child);
106        child->setPrevOnLine(m_lastChild);
107        m_lastChild = child;
108    }
109    child->setFirstLineStyleBit(isFirstLineStyle());
110    child->setIsHorizontal(isHorizontal());
111    if (child->isText()) {
112        if (child->renderer()->parent() == renderer())
113            m_hasTextChildren = true;
114        setHasTextDescendantsOnAncestors(this);
115    } else if (child->isInlineFlowBox()) {
116        if (toInlineFlowBox(child)->hasTextDescendants())
117            setHasTextDescendantsOnAncestors(this);
118    }
119
120    if (descendantsHaveSameLineHeightAndBaseline() && !child->renderer()->isOutOfFlowPositioned()) {
121        RenderStyle* parentStyle = renderer()->style(isFirstLineStyle());
122        RenderStyle* childStyle = child->renderer()->style(isFirstLineStyle());
123        bool shouldClearDescendantsHaveSameLineHeightAndBaseline = false;
124        if (child->renderer()->isReplaced())
125            shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
126        else if (child->isText()) {
127            if (child->renderer()->isBR() || child->renderer()->parent() != renderer()) {
128                if (!parentStyle->font().fontMetrics().hasIdenticalAscentDescentAndLineGap(childStyle->font().fontMetrics())
129                    || parentStyle->lineHeight() != childStyle->lineHeight()
130                    || (parentStyle->verticalAlign() != BASELINE && !isRootInlineBox()) || childStyle->verticalAlign() != BASELINE)
131                    shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
132            }
133            if (childStyle->hasTextCombine() || childStyle->textEmphasisMark() != TextEmphasisMarkNone)
134                shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
135        } else {
136            if (child->renderer()->isBR()) {
137                // FIXME: This is dumb. We only turn off because current layout test results expect the <br> to be 0-height on the baseline.
138                // Other than making a zillion tests have to regenerate results, there's no reason to ditch the optimization here.
139                shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
140            } else {
141                ASSERT(isInlineFlowBox());
142                InlineFlowBox* childFlowBox = toInlineFlowBox(child);
143                // Check the child's bit, and then also check for differences in font, line-height, vertical-align
144                if (!childFlowBox->descendantsHaveSameLineHeightAndBaseline()
145                    || !parentStyle->font().fontMetrics().hasIdenticalAscentDescentAndLineGap(childStyle->font().fontMetrics())
146                    || parentStyle->lineHeight() != childStyle->lineHeight()
147                    || (parentStyle->verticalAlign() != BASELINE && !isRootInlineBox()) || childStyle->verticalAlign() != BASELINE
148                    || childStyle->hasBorder() || childStyle->hasPadding() || childStyle->hasTextCombine())
149                    shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
150            }
151        }
152
153        if (shouldClearDescendantsHaveSameLineHeightAndBaseline)
154            clearDescendantsHaveSameLineHeightAndBaseline();
155    }
156
157    if (!child->renderer()->isOutOfFlowPositioned()) {
158        if (child->isText()) {
159            RenderStyle* childStyle = child->renderer()->style(isFirstLineStyle());
160            if (childStyle->letterSpacing() < 0 || childStyle->textShadow() || childStyle->textEmphasisMark() != TextEmphasisMarkNone || childStyle->textStrokeWidth())
161                child->clearKnownToHaveNoOverflow();
162        } else if (child->renderer()->isReplaced()) {
163            RenderBox* box = toRenderBox(child->renderer());
164            if (box->hasRenderOverflow() || box->hasSelfPaintingLayer())
165                child->clearKnownToHaveNoOverflow();
166        } else if (!child->renderer()->isBR() && (child->renderer()->style(isFirstLineStyle())->boxShadow() || child->boxModelObject()->hasSelfPaintingLayer()
167                   || (child->renderer()->isListMarker() && !toRenderListMarker(child->renderer())->isInside())
168                   || child->renderer()->style(isFirstLineStyle())->hasBorderImageOutsets()))
169            child->clearKnownToHaveNoOverflow();
170
171        if (knownToHaveNoOverflow() && child->isInlineFlowBox() && !toInlineFlowBox(child)->knownToHaveNoOverflow())
172            clearKnownToHaveNoOverflow();
173    }
174
175    checkConsistency();
176}
177
178void InlineFlowBox::removeChild(InlineBox* child)
179{
180    checkConsistency();
181
182    if (!isDirty())
183        dirtyLineBoxes();
184
185    root()->childRemoved(child);
186
187    if (child == m_firstChild)
188        m_firstChild = child->nextOnLine();
189    if (child == m_lastChild)
190        m_lastChild = child->prevOnLine();
191    if (child->nextOnLine())
192        child->nextOnLine()->setPrevOnLine(child->prevOnLine());
193    if (child->prevOnLine())
194        child->prevOnLine()->setNextOnLine(child->nextOnLine());
195
196    child->setParent(0);
197
198    checkConsistency();
199}
200
201void InlineFlowBox::deleteLine()
202{
203    InlineBox* child = firstChild();
204    InlineBox* next = 0;
205    while (child) {
206        ASSERT(this == child->parent());
207        next = child->nextOnLine();
208#ifndef NDEBUG
209        child->setParent(0);
210#endif
211        child->deleteLine();
212        child = next;
213    }
214#ifndef NDEBUG
215    m_firstChild = 0;
216    m_lastChild = 0;
217#endif
218
219    removeLineBoxFromRenderObject();
220    destroy();
221}
222
223void InlineFlowBox::removeLineBoxFromRenderObject()
224{
225    toRenderInline(renderer())->lineBoxes()->removeLineBox(this);
226}
227
228void InlineFlowBox::extractLine()
229{
230    if (!extracted())
231        extractLineBoxFromRenderObject();
232    for (InlineBox* child = firstChild(); child; child = child->nextOnLine())
233        child->extractLine();
234}
235
236void InlineFlowBox::extractLineBoxFromRenderObject()
237{
238    toRenderInline(renderer())->lineBoxes()->extractLineBox(this);
239}
240
241void InlineFlowBox::attachLine()
242{
243    if (extracted())
244        attachLineBoxToRenderObject();
245    for (InlineBox* child = firstChild(); child; child = child->nextOnLine())
246        child->attachLine();
247}
248
249void InlineFlowBox::attachLineBoxToRenderObject()
250{
251    toRenderInline(renderer())->lineBoxes()->attachLineBox(this);
252}
253
254void InlineFlowBox::adjustPosition(float dx, float dy)
255{
256    InlineBox::adjustPosition(dx, dy);
257    for (InlineBox* child = firstChild(); child; child = child->nextOnLine())
258        child->adjustPosition(dx, dy);
259    if (m_overflow)
260        m_overflow->move(dx, dy); // FIXME: Rounding error here since overflow was pixel snapped, but nobody other than list markers passes non-integral values here.
261}
262
263RenderLineBoxList* InlineFlowBox::rendererLineBoxes() const
264{
265    return toRenderInline(renderer())->lineBoxes();
266}
267
268static inline bool isLastChildForRenderer(RenderObject* ancestor, RenderObject* child)
269{
270    if (!child)
271        return false;
272
273    if (child == ancestor)
274        return true;
275
276    RenderObject* curr = child;
277    RenderObject* parent = curr->parent();
278    while (parent && (!parent->isRenderBlock() || parent->isInline())) {
279        if (parent->lastChild() != curr)
280            return false;
281        if (parent == ancestor)
282            return true;
283
284        curr = parent;
285        parent = curr->parent();
286    }
287
288    return true;
289}
290
291static bool isAnsectorAndWithinBlock(RenderObject* ancestor, RenderObject* child)
292{
293    RenderObject* object = child;
294    while (object && (!object->isRenderBlock() || object->isInline())) {
295        if (object == ancestor)
296            return true;
297        object = object->parent();
298    }
299    return false;
300}
301
302void InlineFlowBox::determineSpacingForFlowBoxes(bool lastLine, bool isLogicallyLastRunWrapped, RenderObject* logicallyLastRunRenderer)
303{
304    // All boxes start off open.  They will not apply any margins/border/padding on
305    // any side.
306    bool includeLeftEdge = false;
307    bool includeRightEdge = false;
308
309    // The root inline box never has borders/margins/padding.
310    if (parent()) {
311        bool ltr = renderer()->style()->isLeftToRightDirection();
312
313        // Check to see if all initial lines are unconstructed.  If so, then
314        // we know the inline began on this line (unless we are a continuation).
315        RenderLineBoxList* lineBoxList = rendererLineBoxes();
316        if (!lineBoxList->firstLineBox()->isConstructed() && !renderer()->isInlineElementContinuation()) {
317            if (renderer()->style()->boxDecorationBreak() == DCLONE)
318                includeLeftEdge = includeRightEdge = true;
319            else if (ltr && lineBoxList->firstLineBox() == this)
320                includeLeftEdge = true;
321            else if (!ltr && lineBoxList->lastLineBox() == this)
322                includeRightEdge = true;
323        }
324
325        if (!lineBoxList->lastLineBox()->isConstructed()) {
326            RenderInline* inlineFlow = toRenderInline(renderer());
327            bool isLastObjectOnLine = !isAnsectorAndWithinBlock(renderer(), logicallyLastRunRenderer) || (isLastChildForRenderer(renderer(), logicallyLastRunRenderer) && !isLogicallyLastRunWrapped);
328
329            // We include the border under these conditions:
330            // (1) The next line was not created, or it is constructed. We check the previous line for rtl.
331            // (2) The logicallyLastRun is not a descendant of this renderer.
332            // (3) The logicallyLastRun is a descendant of this renderer, but it is the last child of this renderer and it does not wrap to the next line.
333            // (4) The decoration break is set to clone therefore there will be borders on every sides.
334            if (renderer()->style()->boxDecorationBreak() == DCLONE)
335                includeLeftEdge = includeRightEdge = true;
336            else if (ltr) {
337                if (!nextLineBox()
338                    && ((lastLine || isLastObjectOnLine) && !inlineFlow->continuation()))
339                    includeRightEdge = true;
340            } else {
341                if ((!prevLineBox() || prevLineBox()->isConstructed())
342                    && ((lastLine || isLastObjectOnLine) && !inlineFlow->continuation()))
343                    includeLeftEdge = true;
344            }
345        }
346    }
347
348    setEdges(includeLeftEdge, includeRightEdge);
349
350    // Recur into our children.
351    for (InlineBox* currChild = firstChild(); currChild; currChild = currChild->nextOnLine()) {
352        if (currChild->isInlineFlowBox()) {
353            InlineFlowBox* currFlow = toInlineFlowBox(currChild);
354            currFlow->determineSpacingForFlowBoxes(lastLine, isLogicallyLastRunWrapped, logicallyLastRunRenderer);
355        }
356    }
357}
358
359float InlineFlowBox::placeBoxesInInlineDirection(float logicalLeft, bool& needsWordSpacing, GlyphOverflowAndFallbackFontsMap& textBoxDataMap)
360{
361    // Set our x position.
362    beginPlacingBoxRangesInInlineDirection(logicalLeft);
363
364    float startLogicalLeft = logicalLeft;
365    logicalLeft += borderLogicalLeft() + paddingLogicalLeft();
366
367    float minLogicalLeft = startLogicalLeft;
368    float maxLogicalRight = logicalLeft;
369
370    placeBoxRangeInInlineDirection(firstChild(), 0, logicalLeft, minLogicalLeft, maxLogicalRight, needsWordSpacing, textBoxDataMap);
371
372    logicalLeft += borderLogicalRight() + paddingLogicalRight();
373    endPlacingBoxRangesInInlineDirection(startLogicalLeft, logicalLeft, minLogicalLeft, maxLogicalRight);
374    return logicalLeft;
375}
376
377float InlineFlowBox::placeBoxRangeInInlineDirection(InlineBox* firstChild, InlineBox* lastChild, float& logicalLeft, float& minLogicalLeft, float& maxLogicalRight, bool& needsWordSpacing, GlyphOverflowAndFallbackFontsMap& textBoxDataMap)
378{
379    for (InlineBox* curr = firstChild; curr && curr != lastChild; curr = curr->nextOnLine()) {
380        if (curr->renderer()->isText()) {
381            InlineTextBox* text = toInlineTextBox(curr);
382            RenderText* rt = toRenderText(text->renderer());
383            if (rt->textLength()) {
384                if (needsWordSpacing && isSpaceOrNewline(rt->characterAt(text->start())))
385                    logicalLeft += rt->style(isFirstLineStyle())->font().wordSpacing();
386                needsWordSpacing = !isSpaceOrNewline(rt->characterAt(text->end()));
387            }
388            text->setLogicalLeft(logicalLeft);
389            if (knownToHaveNoOverflow())
390                minLogicalLeft = min(logicalLeft, minLogicalLeft);
391            logicalLeft += text->logicalWidth();
392            if (knownToHaveNoOverflow())
393                maxLogicalRight = max(logicalLeft, maxLogicalRight);
394        } else {
395            if (curr->renderer()->isOutOfFlowPositioned()) {
396                if (curr->renderer()->parent()->style()->isLeftToRightDirection())
397                    curr->setLogicalLeft(logicalLeft);
398                else
399                    // Our offset that we cache needs to be from the edge of the right border box and
400                    // not the left border box.  We have to subtract |x| from the width of the block
401                    // (which can be obtained from the root line box).
402                    curr->setLogicalLeft(root()->block()->logicalWidth() - logicalLeft);
403                continue; // The positioned object has no effect on the width.
404            }
405            if (curr->renderer()->isRenderInline()) {
406                InlineFlowBox* flow = toInlineFlowBox(curr);
407                logicalLeft += flow->marginLogicalLeft();
408                if (knownToHaveNoOverflow())
409                    minLogicalLeft = min(logicalLeft, minLogicalLeft);
410                logicalLeft = flow->placeBoxesInInlineDirection(logicalLeft, needsWordSpacing, textBoxDataMap);
411                if (knownToHaveNoOverflow())
412                    maxLogicalRight = max(logicalLeft, maxLogicalRight);
413                logicalLeft += flow->marginLogicalRight();
414            } else if (!curr->renderer()->isListMarker() || toRenderListMarker(curr->renderer())->isInside()) {
415                // The box can have a different writing-mode than the overall line, so this is a bit complicated.
416                // Just get all the physical margin and overflow values by hand based off |isVertical|.
417                LayoutUnit logicalLeftMargin = isHorizontal() ? curr->boxModelObject()->marginLeft() : curr->boxModelObject()->marginTop();
418                LayoutUnit logicalRightMargin = isHorizontal() ? curr->boxModelObject()->marginRight() : curr->boxModelObject()->marginBottom();
419
420                logicalLeft += logicalLeftMargin;
421                curr->setLogicalLeft(logicalLeft);
422                if (knownToHaveNoOverflow())
423                    minLogicalLeft = min(logicalLeft, minLogicalLeft);
424                logicalLeft += curr->logicalWidth();
425                if (knownToHaveNoOverflow())
426                    maxLogicalRight = max(logicalLeft, maxLogicalRight);
427                logicalLeft += logicalRightMargin;
428                // If we encounter any space after this inline block then ensure it is treated as the space between two words.
429                needsWordSpacing = true;
430            }
431        }
432    }
433    return logicalLeft;
434}
435
436bool InlineFlowBox::requiresIdeographicBaseline(const GlyphOverflowAndFallbackFontsMap& textBoxDataMap) const
437{
438    if (isHorizontal())
439        return false;
440
441    if (renderer()->style(isFirstLineStyle())->fontDescription().nonCJKGlyphOrientation() == NonCJKGlyphOrientationUpright
442        || renderer()->style(isFirstLineStyle())->font().primaryFont()->hasVerticalGlyphs())
443        return true;
444
445    for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
446        if (curr->renderer()->isOutOfFlowPositioned())
447            continue; // Positioned placeholders don't affect calculations.
448
449        if (curr->isInlineFlowBox()) {
450            if (toInlineFlowBox(curr)->requiresIdeographicBaseline(textBoxDataMap))
451                return true;
452        } else {
453            if (curr->renderer()->style(isFirstLineStyle())->font().primaryFont()->hasVerticalGlyphs())
454                return true;
455
456            const Vector<const SimpleFontData*>* usedFonts = 0;
457            if (curr->isInlineTextBox()) {
458                GlyphOverflowAndFallbackFontsMap::const_iterator it = textBoxDataMap.find(toInlineTextBox(curr));
459                usedFonts = it == textBoxDataMap.end() ? 0 : &it->value.first;
460            }
461
462            if (usedFonts) {
463                for (size_t i = 0; i < usedFonts->size(); ++i) {
464                    if (usedFonts->at(i)->hasVerticalGlyphs())
465                        return true;
466                }
467            }
468        }
469    }
470
471    return false;
472}
473
474void InlineFlowBox::adjustMaxAscentAndDescent(int& maxAscent, int& maxDescent, int maxPositionTop, int maxPositionBottom)
475{
476    for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
477        // The computed lineheight needs to be extended for the
478        // positioned elements
479        if (curr->renderer()->isOutOfFlowPositioned())
480            continue; // Positioned placeholders don't affect calculations.
481        if (curr->verticalAlign() == TOP || curr->verticalAlign() == BOTTOM) {
482            int lineHeight = curr->lineHeight();
483            if (curr->verticalAlign() == TOP) {
484                if (maxAscent + maxDescent < lineHeight)
485                    maxDescent = lineHeight - maxAscent;
486            }
487            else {
488                if (maxAscent + maxDescent < lineHeight)
489                    maxAscent = lineHeight - maxDescent;
490            }
491
492            if (maxAscent + maxDescent >= max(maxPositionTop, maxPositionBottom))
493                break;
494        }
495
496        if (curr->isInlineFlowBox())
497            toInlineFlowBox(curr)->adjustMaxAscentAndDescent(maxAscent, maxDescent, maxPositionTop, maxPositionBottom);
498    }
499}
500
501void InlineFlowBox::computeLogicalBoxHeights(RootInlineBox* rootBox, LayoutUnit& maxPositionTop, LayoutUnit& maxPositionBottom,
502                                             int& maxAscent, int& maxDescent, bool& setMaxAscent, bool& setMaxDescent,
503                                             bool strictMode, GlyphOverflowAndFallbackFontsMap& textBoxDataMap,
504                                             FontBaseline baselineType, VerticalPositionCache& verticalPositionCache)
505{
506    // The primary purpose of this function is to compute the maximal ascent and descent values for
507    // a line. These values are computed based off the block's line-box-contain property, which indicates
508    // what parts of descendant boxes have to fit within the line.
509    //
510    // The maxAscent value represents the distance of the highest point of any box (typically including line-height) from
511    // the root box's baseline. The maxDescent value represents the distance of the lowest point of any box
512    // (also typically including line-height) from the root box baseline. These values can be negative.
513    //
514    // A secondary purpose of this function is to store the offset of every box's baseline from the root box's
515    // baseline. This information is cached in the logicalTop() of every box. We're effectively just using
516    // the logicalTop() as scratch space.
517    //
518    // Because a box can be positioned such that it ends up fully above or fully below the
519    // root line box, we only consider it to affect the maxAscent and maxDescent values if some
520    // part of the box (EXCLUDING leading) is above (for ascent) or below (for descent) the root box's baseline.
521    bool affectsAscent = false;
522    bool affectsDescent = false;
523    bool checkChildren = !descendantsHaveSameLineHeightAndBaseline();
524
525    if (isRootInlineBox()) {
526        // Examine our root box.
527        int ascent = 0;
528        int descent = 0;
529        rootBox->ascentAndDescentForBox(rootBox, textBoxDataMap, ascent, descent, affectsAscent, affectsDescent);
530        if (strictMode || hasTextChildren() || (!checkChildren && hasTextDescendants())) {
531            if (maxAscent < ascent || !setMaxAscent) {
532                maxAscent = ascent;
533                setMaxAscent = true;
534            }
535            if (maxDescent < descent || !setMaxDescent) {
536                maxDescent = descent;
537                setMaxDescent = true;
538            }
539        }
540    }
541
542    if (!checkChildren)
543        return;
544
545    for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
546        if (curr->renderer()->isOutOfFlowPositioned())
547            continue; // Positioned placeholders don't affect calculations.
548
549        InlineFlowBox* inlineFlowBox = curr->isInlineFlowBox() ? toInlineFlowBox(curr) : 0;
550
551        bool affectsAscent = false;
552        bool affectsDescent = false;
553
554        // The verticalPositionForBox function returns the distance between the child box's baseline
555        // and the root box's baseline.  The value is negative if the child box's baseline is above the
556        // root box's baseline, and it is positive if the child box's baseline is below the root box's baseline.
557        curr->setLogicalTop(rootBox->verticalPositionForBox(curr, verticalPositionCache));
558
559        int ascent = 0;
560        int descent = 0;
561        rootBox->ascentAndDescentForBox(curr, textBoxDataMap, ascent, descent, affectsAscent, affectsDescent);
562
563        LayoutUnit boxHeight = ascent + descent;
564        if (curr->verticalAlign() == TOP) {
565            if (maxPositionTop < boxHeight)
566                maxPositionTop = boxHeight;
567        } else if (curr->verticalAlign() == BOTTOM) {
568            if (maxPositionBottom < boxHeight)
569                maxPositionBottom = boxHeight;
570        } else if (!inlineFlowBox || strictMode || inlineFlowBox->hasTextChildren() || (inlineFlowBox->descendantsHaveSameLineHeightAndBaseline() && inlineFlowBox->hasTextDescendants())
571                   || inlineFlowBox->boxModelObject()->hasInlineDirectionBordersOrPadding()) {
572            // Note that these values can be negative.  Even though we only affect the maxAscent and maxDescent values
573            // if our box (excluding line-height) was above (for ascent) or below (for descent) the root baseline, once you factor in line-height
574            // the final box can end up being fully above or fully below the root box's baseline!  This is ok, but what it
575            // means is that ascent and descent (including leading), can end up being negative.  The setMaxAscent and
576            // setMaxDescent booleans are used to ensure that we're willing to initially set maxAscent/Descent to negative
577            // values.
578            ascent -= curr->logicalTop();
579            descent += curr->logicalTop();
580            if (affectsAscent && (maxAscent < ascent || !setMaxAscent)) {
581                maxAscent = ascent;
582                setMaxAscent = true;
583            }
584
585            if (affectsDescent && (maxDescent < descent || !setMaxDescent)) {
586                maxDescent = descent;
587                setMaxDescent = true;
588            }
589        }
590
591        if (inlineFlowBox)
592            inlineFlowBox->computeLogicalBoxHeights(rootBox, maxPositionTop, maxPositionBottom, maxAscent, maxDescent,
593                                                    setMaxAscent, setMaxDescent, strictMode, textBoxDataMap,
594                                                    baselineType, verticalPositionCache);
595    }
596}
597
598void InlineFlowBox::placeBoxesInBlockDirection(LayoutUnit top, LayoutUnit maxHeight, int maxAscent, bool strictMode, LayoutUnit& lineTop, LayoutUnit& lineBottom, bool& setLineTop,
599                                               LayoutUnit& lineTopIncludingMargins, LayoutUnit& lineBottomIncludingMargins, bool& hasAnnotationsBefore, bool& hasAnnotationsAfter, FontBaseline baselineType)
600{
601    bool isRootBox = isRootInlineBox();
602    if (isRootBox) {
603        const FontMetrics& fontMetrics = renderer()->style(isFirstLineStyle())->fontMetrics();
604        // RootInlineBoxes are always placed on at pixel boundaries in their logical y direction. Not doing
605        // so results in incorrect rendering of text decorations, most notably underlines.
606        setLogicalTop(roundToInt(top + maxAscent - fontMetrics.ascent(baselineType)));
607    }
608
609    LayoutUnit adjustmentForChildrenWithSameLineHeightAndBaseline = 0;
610    if (descendantsHaveSameLineHeightAndBaseline()) {
611        adjustmentForChildrenWithSameLineHeightAndBaseline = logicalTop();
612        if (parent())
613            adjustmentForChildrenWithSameLineHeightAndBaseline += (boxModelObject()->borderBefore() + boxModelObject()->paddingBefore());
614    }
615
616    for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
617        if (curr->renderer()->isOutOfFlowPositioned())
618            continue; // Positioned placeholders don't affect calculations.
619
620        if (descendantsHaveSameLineHeightAndBaseline()) {
621            curr->adjustBlockDirectionPosition(adjustmentForChildrenWithSameLineHeightAndBaseline);
622            continue;
623        }
624
625        InlineFlowBox* inlineFlowBox = curr->isInlineFlowBox() ? toInlineFlowBox(curr) : 0;
626        bool childAffectsTopBottomPos = true;
627        if (curr->verticalAlign() == TOP)
628            curr->setLogicalTop(top);
629        else if (curr->verticalAlign() == BOTTOM)
630            curr->setLogicalTop(top + maxHeight - curr->lineHeight());
631        else {
632            if (!strictMode && inlineFlowBox && !inlineFlowBox->hasTextChildren() && !curr->boxModelObject()->hasInlineDirectionBordersOrPadding()
633                && !(inlineFlowBox->descendantsHaveSameLineHeightAndBaseline() && inlineFlowBox->hasTextDescendants()))
634                childAffectsTopBottomPos = false;
635            LayoutUnit posAdjust = maxAscent - curr->baselinePosition(baselineType);
636            curr->setLogicalTop(curr->logicalTop() + top + posAdjust);
637        }
638
639        LayoutUnit newLogicalTop = curr->logicalTop();
640        LayoutUnit newLogicalTopIncludingMargins = newLogicalTop;
641        LayoutUnit boxHeight = curr->logicalHeight();
642        LayoutUnit boxHeightIncludingMargins = boxHeight;
643
644        if (curr->isText() || curr->isInlineFlowBox()) {
645            const FontMetrics& fontMetrics = curr->renderer()->style(isFirstLineStyle())->fontMetrics();
646            newLogicalTop += curr->baselinePosition(baselineType) - fontMetrics.ascent(baselineType);
647            if (curr->isInlineFlowBox()) {
648                RenderBoxModelObject* boxObject = toRenderBoxModelObject(curr->renderer());
649                newLogicalTop -= boxObject->style(isFirstLineStyle())->isHorizontalWritingMode() ? boxObject->borderTop() + boxObject->paddingTop() :
650                                 boxObject->borderRight() + boxObject->paddingRight();
651            }
652            newLogicalTopIncludingMargins = newLogicalTop;
653        } else if (!curr->renderer()->isBR()) {
654            RenderBox* box = toRenderBox(curr->renderer());
655            newLogicalTopIncludingMargins = newLogicalTop;
656            LayoutUnit overSideMargin = curr->isHorizontal() ? box->marginTop() : box->marginRight();
657            LayoutUnit underSideMargin = curr->isHorizontal() ? box->marginBottom() : box->marginLeft();
658            newLogicalTop += overSideMargin;
659            boxHeightIncludingMargins += overSideMargin + underSideMargin;
660        }
661
662        curr->setLogicalTop(newLogicalTop);
663
664        if (childAffectsTopBottomPos) {
665            if (curr->renderer()->isRubyRun()) {
666                // Treat the leading on the first and last lines of ruby runs as not being part of the overall lineTop/lineBottom.
667                // Really this is a workaround hack for the fact that ruby should have been done as line layout and not done using
668                // inline-block.
669                if (renderer()->style()->isFlippedLinesWritingMode() == (curr->renderer()->style()->rubyPosition() == RubyPositionAfter))
670                    hasAnnotationsBefore = true;
671                else
672                    hasAnnotationsAfter = true;
673
674                RenderRubyRun* rubyRun = toRenderRubyRun(curr->renderer());
675                if (RenderRubyBase* rubyBase = rubyRun->rubyBase()) {
676                    LayoutUnit bottomRubyBaseLeading = (curr->logicalHeight() - rubyBase->logicalBottom()) + rubyBase->logicalHeight() - (rubyBase->lastRootBox() ? rubyBase->lastRootBox()->lineBottom() : LayoutUnit());
677                    LayoutUnit topRubyBaseLeading = rubyBase->logicalTop() + (rubyBase->firstRootBox() ? rubyBase->firstRootBox()->lineTop() : LayoutUnit());
678                    newLogicalTop += !renderer()->style()->isFlippedLinesWritingMode() ? topRubyBaseLeading : bottomRubyBaseLeading;
679                    boxHeight -= (topRubyBaseLeading + bottomRubyBaseLeading);
680                }
681            }
682            if (curr->isInlineTextBox()) {
683                TextEmphasisPosition emphasisMarkPosition;
684                if (toInlineTextBox(curr)->getEmphasisMarkPosition(curr->renderer()->style(isFirstLineStyle()), emphasisMarkPosition)) {
685                    bool emphasisMarkIsOver = emphasisMarkPosition == TextEmphasisPositionOver;
686                    if (emphasisMarkIsOver != curr->renderer()->style(isFirstLineStyle())->isFlippedLinesWritingMode())
687                        hasAnnotationsBefore = true;
688                    else
689                        hasAnnotationsAfter = true;
690                }
691            }
692
693            if (!setLineTop) {
694                setLineTop = true;
695                lineTop = newLogicalTop;
696                lineTopIncludingMargins = min(lineTop, newLogicalTopIncludingMargins);
697            } else {
698                lineTop = min(lineTop, newLogicalTop);
699                lineTopIncludingMargins = min(lineTop, min(lineTopIncludingMargins, newLogicalTopIncludingMargins));
700            }
701            lineBottom = max(lineBottom, newLogicalTop + boxHeight);
702            lineBottomIncludingMargins = max(lineBottom, max(lineBottomIncludingMargins, newLogicalTopIncludingMargins + boxHeightIncludingMargins));
703        }
704
705        // Adjust boxes to use their real box y/height and not the logical height (as dictated by
706        // line-height).
707        if (inlineFlowBox)
708            inlineFlowBox->placeBoxesInBlockDirection(top, maxHeight, maxAscent, strictMode, lineTop, lineBottom, setLineTop,
709                                                      lineTopIncludingMargins, lineBottomIncludingMargins, hasAnnotationsBefore, hasAnnotationsAfter, baselineType);
710    }
711
712    if (isRootBox) {
713        if (strictMode || hasTextChildren() || (descendantsHaveSameLineHeightAndBaseline() && hasTextDescendants())) {
714            if (!setLineTop) {
715                setLineTop = true;
716                lineTop = pixelSnappedLogicalTop();
717                lineTopIncludingMargins = lineTop;
718            } else {
719                lineTop = min<LayoutUnit>(lineTop, pixelSnappedLogicalTop());
720                lineTopIncludingMargins = min(lineTop, lineTopIncludingMargins);
721            }
722            lineBottom = max<LayoutUnit>(lineBottom, pixelSnappedLogicalBottom());
723            lineBottomIncludingMargins = max(lineBottom, lineBottomIncludingMargins);
724        }
725
726        if (renderer()->style()->isFlippedLinesWritingMode())
727            flipLinesInBlockDirection(lineTopIncludingMargins, lineBottomIncludingMargins);
728    }
729}
730
731void InlineFlowBox::computeMaxLogicalTop(float& maxLogicalTop) const
732{
733    for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
734        if (curr->renderer()->isOutOfFlowPositioned())
735            continue; // Positioned placeholders don't affect calculations.
736
737        if (descendantsHaveSameLineHeightAndBaseline())
738            continue;
739
740        maxLogicalTop = max<float>(maxLogicalTop, curr->y());
741        float localMaxLogicalTop = 0;
742        if (curr->isInlineFlowBox())
743            toInlineFlowBox(curr)->computeMaxLogicalTop(localMaxLogicalTop);
744        maxLogicalTop = max<float>(maxLogicalTop, localMaxLogicalTop);
745    }
746}
747
748void InlineFlowBox::flipLinesInBlockDirection(LayoutUnit lineTop, LayoutUnit lineBottom)
749{
750    // Flip the box on the line such that the top is now relative to the lineBottom instead of the lineTop.
751    setLogicalTop(lineBottom - (logicalTop() - lineTop) - logicalHeight());
752
753    for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
754        if (curr->renderer()->isOutOfFlowPositioned())
755            continue; // Positioned placeholders aren't affected here.
756
757        if (curr->isInlineFlowBox())
758            toInlineFlowBox(curr)->flipLinesInBlockDirection(lineTop, lineBottom);
759        else
760            curr->setLogicalTop(lineBottom - (curr->logicalTop() - lineTop) - curr->logicalHeight());
761    }
762}
763
764inline void InlineFlowBox::addBoxShadowVisualOverflow(LayoutRect& logicalVisualOverflow)
765{
766    // box-shadow on root line boxes is applying to the block and not to the lines.
767    if (!parent())
768        return;
769
770    RenderStyle* style = renderer()->style(isFirstLineStyle());
771    if (!style->boxShadow())
772        return;
773
774    LayoutUnit boxShadowLogicalTop;
775    LayoutUnit boxShadowLogicalBottom;
776    style->getBoxShadowBlockDirectionExtent(boxShadowLogicalTop, boxShadowLogicalBottom);
777
778    // Similar to how glyph overflow works, if our lines are flipped, then it's actually the opposite shadow that applies, since
779    // the line is "upside down" in terms of block coordinates.
780    LayoutUnit shadowLogicalTop = style->isFlippedLinesWritingMode() ? -boxShadowLogicalBottom : boxShadowLogicalTop;
781    LayoutUnit shadowLogicalBottom = style->isFlippedLinesWritingMode() ? -boxShadowLogicalTop : boxShadowLogicalBottom;
782
783    LayoutUnit logicalTopVisualOverflow = min(pixelSnappedLogicalTop() + shadowLogicalTop, logicalVisualOverflow.y());
784    LayoutUnit logicalBottomVisualOverflow = max(pixelSnappedLogicalBottom() + shadowLogicalBottom, logicalVisualOverflow.maxY());
785
786    LayoutUnit boxShadowLogicalLeft;
787    LayoutUnit boxShadowLogicalRight;
788    style->getBoxShadowInlineDirectionExtent(boxShadowLogicalLeft, boxShadowLogicalRight);
789
790    LayoutUnit logicalLeftVisualOverflow = min(pixelSnappedLogicalLeft() + boxShadowLogicalLeft, logicalVisualOverflow.x());
791    LayoutUnit logicalRightVisualOverflow = max(pixelSnappedLogicalRight() + boxShadowLogicalRight, logicalVisualOverflow.maxX());
792
793    logicalVisualOverflow = LayoutRect(logicalLeftVisualOverflow, logicalTopVisualOverflow,
794                                       logicalRightVisualOverflow - logicalLeftVisualOverflow, logicalBottomVisualOverflow - logicalTopVisualOverflow);
795}
796
797inline void InlineFlowBox::addBorderOutsetVisualOverflow(LayoutRect& logicalVisualOverflow)
798{
799    // border-image-outset on root line boxes is applying to the block and not to the lines.
800    if (!parent())
801        return;
802
803    RenderStyle* style = renderer()->style(isFirstLineStyle());
804    if (!style->hasBorderImageOutsets())
805        return;
806
807    LayoutBoxExtent borderOutsets = style->borderImageOutsets();
808
809    LayoutUnit borderOutsetLogicalTop = borderOutsets.logicalTop(style->writingMode());
810    LayoutUnit borderOutsetLogicalBottom = borderOutsets.logicalBottom(style->writingMode());
811    LayoutUnit borderOutsetLogicalLeft = borderOutsets.logicalLeft(style->writingMode());
812    LayoutUnit borderOutsetLogicalRight = borderOutsets.logicalRight(style->writingMode());
813
814    // Similar to how glyph overflow works, if our lines are flipped, then it's actually the opposite border that applies, since
815    // the line is "upside down" in terms of block coordinates. vertical-rl and horizontal-bt are the flipped line modes.
816    LayoutUnit outsetLogicalTop = style->isFlippedLinesWritingMode() ? borderOutsetLogicalBottom : borderOutsetLogicalTop;
817    LayoutUnit outsetLogicalBottom = style->isFlippedLinesWritingMode() ? borderOutsetLogicalTop : borderOutsetLogicalBottom;
818
819    LayoutUnit logicalTopVisualOverflow = min(pixelSnappedLogicalTop() - outsetLogicalTop, logicalVisualOverflow.y());
820    LayoutUnit logicalBottomVisualOverflow = max(pixelSnappedLogicalBottom() + outsetLogicalBottom, logicalVisualOverflow.maxY());
821
822    LayoutUnit outsetLogicalLeft = includeLogicalLeftEdge() ? borderOutsetLogicalLeft : LayoutUnit();
823    LayoutUnit outsetLogicalRight = includeLogicalRightEdge() ? borderOutsetLogicalRight : LayoutUnit();
824
825    LayoutUnit logicalLeftVisualOverflow = min(pixelSnappedLogicalLeft() - outsetLogicalLeft, logicalVisualOverflow.x());
826    LayoutUnit logicalRightVisualOverflow = max(pixelSnappedLogicalRight() + outsetLogicalRight, logicalVisualOverflow.maxX());
827
828    logicalVisualOverflow = LayoutRect(logicalLeftVisualOverflow, logicalTopVisualOverflow,
829                                       logicalRightVisualOverflow - logicalLeftVisualOverflow, logicalBottomVisualOverflow - logicalTopVisualOverflow);
830}
831
832inline void InlineFlowBox::addTextBoxVisualOverflow(InlineTextBox* textBox, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, LayoutRect& logicalVisualOverflow)
833{
834    if (textBox->knownToHaveNoOverflow())
835        return;
836
837    RenderStyle* style = textBox->renderer()->style(isFirstLineStyle());
838
839    GlyphOverflowAndFallbackFontsMap::iterator it = textBoxDataMap.find(textBox);
840    GlyphOverflow* glyphOverflow = it == textBoxDataMap.end() ? 0 : &it->value.second;
841    bool isFlippedLine = style->isFlippedLinesWritingMode();
842
843    int topGlyphEdge = glyphOverflow ? (isFlippedLine ? glyphOverflow->bottom : glyphOverflow->top) : 0;
844    int bottomGlyphEdge = glyphOverflow ? (isFlippedLine ? glyphOverflow->top : glyphOverflow->bottom) : 0;
845    int leftGlyphEdge = glyphOverflow ? glyphOverflow->left : 0;
846    int rightGlyphEdge = glyphOverflow ? glyphOverflow->right : 0;
847
848    int strokeOverflow = static_cast<int>(ceilf(style->textStrokeWidth() / 2.0f));
849    int topGlyphOverflow = -strokeOverflow - topGlyphEdge;
850    int bottomGlyphOverflow = strokeOverflow + bottomGlyphEdge;
851    int leftGlyphOverflow = -strokeOverflow - leftGlyphEdge;
852    int rightGlyphOverflow = strokeOverflow + rightGlyphEdge;
853
854    TextEmphasisPosition emphasisMarkPosition;
855    if (style->textEmphasisMark() != TextEmphasisMarkNone && textBox->getEmphasisMarkPosition(style, emphasisMarkPosition)) {
856        int emphasisMarkHeight = style->font().emphasisMarkHeight(style->textEmphasisMarkString());
857        if ((emphasisMarkPosition == TextEmphasisPositionOver) == (!style->isFlippedLinesWritingMode()))
858            topGlyphOverflow = min(topGlyphOverflow, -emphasisMarkHeight);
859        else
860            bottomGlyphOverflow = max(bottomGlyphOverflow, emphasisMarkHeight);
861    }
862
863    // If letter-spacing is negative, we should factor that into right layout overflow. (Even in RTL, letter-spacing is
864    // applied to the right, so this is not an issue with left overflow.
865    rightGlyphOverflow -= min(0, (int)style->font().letterSpacing());
866
867    LayoutUnit textShadowLogicalTop;
868    LayoutUnit textShadowLogicalBottom;
869    style->getTextShadowBlockDirectionExtent(textShadowLogicalTop, textShadowLogicalBottom);
870
871    LayoutUnit childOverflowLogicalTop = min<LayoutUnit>(textShadowLogicalTop + topGlyphOverflow, topGlyphOverflow);
872    LayoutUnit childOverflowLogicalBottom = max<LayoutUnit>(textShadowLogicalBottom + bottomGlyphOverflow, bottomGlyphOverflow);
873
874    LayoutUnit textShadowLogicalLeft;
875    LayoutUnit textShadowLogicalRight;
876    style->getTextShadowInlineDirectionExtent(textShadowLogicalLeft, textShadowLogicalRight);
877
878    LayoutUnit childOverflowLogicalLeft = min<LayoutUnit>(textShadowLogicalLeft + leftGlyphOverflow, leftGlyphOverflow);
879    LayoutUnit childOverflowLogicalRight = max<LayoutUnit>(textShadowLogicalRight + rightGlyphOverflow, rightGlyphOverflow);
880
881    LayoutUnit logicalTopVisualOverflow = min(textBox->pixelSnappedLogicalTop() + childOverflowLogicalTop, logicalVisualOverflow.y());
882    LayoutUnit logicalBottomVisualOverflow = max(textBox->pixelSnappedLogicalBottom() + childOverflowLogicalBottom, logicalVisualOverflow.maxY());
883    LayoutUnit logicalLeftVisualOverflow = min(textBox->pixelSnappedLogicalLeft() + childOverflowLogicalLeft, logicalVisualOverflow.x());
884    LayoutUnit logicalRightVisualOverflow = max(textBox->pixelSnappedLogicalRight() + childOverflowLogicalRight, logicalVisualOverflow.maxX());
885
886    logicalVisualOverflow = LayoutRect(logicalLeftVisualOverflow, logicalTopVisualOverflow,
887                                       logicalRightVisualOverflow - logicalLeftVisualOverflow, logicalBottomVisualOverflow - logicalTopVisualOverflow);
888
889    textBox->setLogicalOverflowRect(logicalVisualOverflow);
890}
891
892inline void InlineFlowBox::addReplacedChildOverflow(const InlineBox* inlineBox, LayoutRect& logicalLayoutOverflow, LayoutRect& logicalVisualOverflow)
893{
894    RenderBox* box = toRenderBox(inlineBox->renderer());
895
896    // Visual overflow only propagates if the box doesn't have a self-painting layer.  This rectangle does not include
897    // transforms or relative positioning (since those objects always have self-painting layers), but it does need to be adjusted
898    // for writing-mode differences.
899    if (!box->hasSelfPaintingLayer()) {
900        LayoutRect childLogicalVisualOverflow = box->logicalVisualOverflowRectForPropagation(renderer()->style());
901        childLogicalVisualOverflow.move(inlineBox->logicalLeft(), inlineBox->logicalTop());
902        logicalVisualOverflow.unite(childLogicalVisualOverflow);
903    }
904
905    // Layout overflow internal to the child box only propagates if the child box doesn't have overflow clip set.
906    // Otherwise the child border box propagates as layout overflow.  This rectangle must include transforms and relative positioning
907    // and be adjusted for writing-mode differences.
908    LayoutRect childLogicalLayoutOverflow = box->logicalLayoutOverflowRectForPropagation(renderer()->style());
909    childLogicalLayoutOverflow.move(inlineBox->logicalLeft(), inlineBox->logicalTop());
910    logicalLayoutOverflow.unite(childLogicalLayoutOverflow);
911}
912
913void InlineFlowBox::computeOverflow(LayoutUnit lineTop, LayoutUnit lineBottom, GlyphOverflowAndFallbackFontsMap& textBoxDataMap)
914{
915    // If we know we have no overflow, we can just bail.
916    if (knownToHaveNoOverflow())
917        return;
918
919    // Visual overflow just includes overflow for stuff we need to repaint ourselves.  Self-painting layers are ignored.
920    // Layout overflow is used to determine scrolling extent, so it still includes child layers and also factors in
921    // transforms, relative positioning, etc.
922    LayoutRect logicalLayoutOverflow(enclosingLayoutRect(logicalFrameRectIncludingLineHeight(lineTop, lineBottom)));
923    LayoutRect logicalVisualOverflow(logicalLayoutOverflow);
924
925    addBoxShadowVisualOverflow(logicalVisualOverflow);
926    addBorderOutsetVisualOverflow(logicalVisualOverflow);
927
928    for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
929        if (curr->renderer()->isOutOfFlowPositioned())
930            continue; // Positioned placeholders don't affect calculations.
931
932        if (curr->renderer()->isText()) {
933            InlineTextBox* text = toInlineTextBox(curr);
934            RenderText* rt = toRenderText(text->renderer());
935            if (rt->isBR())
936                continue;
937            LayoutRect textBoxOverflow(enclosingLayoutRect(text->logicalFrameRect()));
938            addTextBoxVisualOverflow(text, textBoxDataMap, textBoxOverflow);
939            logicalVisualOverflow.unite(textBoxOverflow);
940        } else  if (curr->renderer()->isRenderInline()) {
941            InlineFlowBox* flow = toInlineFlowBox(curr);
942            flow->computeOverflow(lineTop, lineBottom, textBoxDataMap);
943            if (!flow->boxModelObject()->hasSelfPaintingLayer())
944                logicalVisualOverflow.unite(flow->logicalVisualOverflowRect(lineTop, lineBottom));
945            LayoutRect childLayoutOverflow = flow->logicalLayoutOverflowRect(lineTop, lineBottom);
946            childLayoutOverflow.move(flow->boxModelObject()->relativePositionLogicalOffset());
947            logicalLayoutOverflow.unite(childLayoutOverflow);
948        } else
949            addReplacedChildOverflow(curr, logicalLayoutOverflow, logicalVisualOverflow);
950    }
951
952    setOverflowFromLogicalRects(logicalLayoutOverflow, logicalVisualOverflow, lineTop, lineBottom);
953}
954
955void InlineFlowBox::setLayoutOverflow(const LayoutRect& rect, LayoutUnit lineTop, LayoutUnit lineBottom)
956{
957    LayoutRect frameBox = enclosingLayoutRect(frameRectIncludingLineHeight(lineTop, lineBottom));
958    if (frameBox.contains(rect) || rect.isEmpty())
959        return;
960
961    if (!m_overflow)
962        m_overflow = adoptPtr(new RenderOverflow(frameBox, frameBox));
963
964    m_overflow->setLayoutOverflow(rect);
965}
966
967void InlineFlowBox::setVisualOverflow(const LayoutRect& rect, LayoutUnit lineTop, LayoutUnit lineBottom)
968{
969    LayoutRect frameBox = enclosingLayoutRect(frameRectIncludingLineHeight(lineTop, lineBottom));
970    if (frameBox.contains(rect) || rect.isEmpty())
971        return;
972
973    if (!m_overflow)
974        m_overflow = adoptPtr(new RenderOverflow(frameBox, frameBox));
975
976    m_overflow->setVisualOverflow(rect);
977}
978
979void InlineFlowBox::setOverflowFromLogicalRects(const LayoutRect& logicalLayoutOverflow, const LayoutRect& logicalVisualOverflow, LayoutUnit lineTop, LayoutUnit lineBottom)
980{
981    LayoutRect layoutOverflow(isHorizontal() ? logicalLayoutOverflow : logicalLayoutOverflow.transposedRect());
982    setLayoutOverflow(layoutOverflow, lineTop, lineBottom);
983
984    LayoutRect visualOverflow(isHorizontal() ? logicalVisualOverflow : logicalVisualOverflow.transposedRect());
985    setVisualOverflow(visualOverflow, lineTop, lineBottom);
986}
987
988bool InlineFlowBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit lineTop, LayoutUnit lineBottom)
989{
990    LayoutRect overflowRect(visualOverflowRect(lineTop, lineBottom));
991    flipForWritingMode(overflowRect);
992    overflowRect.moveBy(accumulatedOffset);
993    if (!locationInContainer.intersects(overflowRect))
994        return false;
995
996    // Check children first.
997    // We need to account for culled inline parents of the hit-tested nodes, so that they may also get included in area-based hit-tests.
998    RenderObject* culledParent = 0;
999    for (InlineBox* curr = lastChild(); curr; curr = curr->prevOnLine()) {
1000        if (curr->renderer()->isText() || !curr->boxModelObject()->hasSelfPaintingLayer()) {
1001            RenderObject* newParent = 0;
1002            // Culled parents are only relevant for area-based hit-tests, so ignore it in point-based ones.
1003            if (locationInContainer.isRectBasedTest()) {
1004                newParent = curr->renderer()->parent();
1005                if (newParent == renderer())
1006                    newParent = 0;
1007            }
1008            // Check the culled parent after all its children have been checked, to do this we wait until
1009            // we are about to test an element with a different parent.
1010            if (newParent != culledParent) {
1011                if (!newParent || !newParent->isDescendantOf(culledParent)) {
1012                    while (culledParent && culledParent != renderer() && culledParent != newParent) {
1013                        if (culledParent->isRenderInline() && toRenderInline(culledParent)->hitTestCulledInline(request, result, locationInContainer, accumulatedOffset))
1014                            return true;
1015                        culledParent = culledParent->parent();
1016                    }
1017                }
1018                culledParent = newParent;
1019            }
1020            if (curr->nodeAtPoint(request, result, locationInContainer, accumulatedOffset, lineTop, lineBottom)) {
1021                renderer()->updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));
1022                return true;
1023            }
1024        }
1025    }
1026    // Check any culled ancestor of the final children tested.
1027    while (culledParent && culledParent != renderer()) {
1028        if (culledParent->isRenderInline() && toRenderInline(culledParent)->hitTestCulledInline(request, result, locationInContainer, accumulatedOffset))
1029            return true;
1030        culledParent = culledParent->parent();
1031    }
1032
1033    // Now check ourselves. Pixel snap hit testing.
1034    LayoutRect frameRect = roundedFrameRect();
1035    LayoutUnit minX = frameRect.x();
1036    LayoutUnit minY = frameRect.y();
1037    LayoutUnit width = frameRect.width();
1038    LayoutUnit height = frameRect.height();
1039
1040    // Constrain our hit testing to the line top and bottom if necessary.
1041    bool noQuirksMode = renderer()->document().inNoQuirksMode();
1042    if (!noQuirksMode && !hasTextChildren() && !(descendantsHaveSameLineHeightAndBaseline() && hasTextDescendants())) {
1043        RootInlineBox* rootBox = root();
1044        LayoutUnit& top = isHorizontal() ? minY : minX;
1045        LayoutUnit& logicalHeight = isHorizontal() ? height : width;
1046        LayoutUnit bottom = min(rootBox->lineBottom(), top + logicalHeight);
1047        top = max(rootBox->lineTop(), top);
1048        logicalHeight = bottom - top;
1049    }
1050
1051    // Move x/y to our coordinates.
1052    LayoutRect rect(minX, minY, width, height);
1053    flipForWritingMode(rect);
1054    rect.moveBy(accumulatedOffset);
1055
1056    if (visibleToHitTestRequest(request) && locationInContainer.intersects(rect)) {
1057        renderer()->updateHitTestResult(result, flipForWritingMode(locationInContainer.point() - toLayoutSize(accumulatedOffset))); // Don't add in m_x or m_y here, we want coords in the containing block's space.
1058        if (!result.addNodeToRectBasedTestResult(renderer()->node(), request, locationInContainer, rect))
1059            return true;
1060    }
1061
1062    return false;
1063}
1064
1065void InlineFlowBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit lineTop, LayoutUnit lineBottom)
1066{
1067    LayoutRect overflowRect(visualOverflowRect(lineTop, lineBottom));
1068    overflowRect.inflate(renderer()->maximalOutlineSize(paintInfo.phase));
1069    flipForWritingMode(overflowRect);
1070    overflowRect.moveBy(paintOffset);
1071
1072    if (!paintInfo.rect.intersects(pixelSnappedIntRect(overflowRect)))
1073        return;
1074
1075    if (paintInfo.phase != PaintPhaseChildOutlines) {
1076        if (paintInfo.phase == PaintPhaseOutline || paintInfo.phase == PaintPhaseSelfOutline) {
1077            // Add ourselves to the paint info struct's list of inlines that need to paint their
1078            // outlines.
1079            if (renderer()->style()->visibility() == VISIBLE && renderer()->hasOutline() && !isRootInlineBox()) {
1080                RenderInline* inlineFlow = toRenderInline(renderer());
1081
1082                RenderBlock* cb = 0;
1083                bool containingBlockPaintsContinuationOutline = inlineFlow->continuation() || inlineFlow->isInlineElementContinuation();
1084                if (containingBlockPaintsContinuationOutline) {
1085                    // FIXME: See https://bugs.webkit.org/show_bug.cgi?id=54690. We currently don't reconnect inline continuations
1086                    // after a child removal. As a result, those merged inlines do not get seperated and hence not get enclosed by
1087                    // anonymous blocks. In this case, it is better to bail out and paint it ourself.
1088                    RenderBlock* enclosingAnonymousBlock = renderer()->containingBlock();
1089                    if (!enclosingAnonymousBlock->isAnonymousBlock())
1090                        containingBlockPaintsContinuationOutline = false;
1091                    else {
1092                        cb = enclosingAnonymousBlock->containingBlock();
1093                        for (RenderBoxModelObject* box = boxModelObject(); box != cb; box = box->parent()->enclosingBoxModelObject()) {
1094                            if (box->hasSelfPaintingLayer()) {
1095                                containingBlockPaintsContinuationOutline = false;
1096                                break;
1097                            }
1098                        }
1099                    }
1100                }
1101
1102                if (containingBlockPaintsContinuationOutline) {
1103                    // Add ourselves to the containing block of the entire continuation so that it can
1104                    // paint us atomically.
1105                    cb->addContinuationWithOutline(toRenderInline(renderer()->node()->renderer()));
1106                } else if (!inlineFlow->isInlineElementContinuation()) {
1107                    paintInfo.outlineObjects()->add(inlineFlow);
1108                }
1109            }
1110        } else if (paintInfo.phase == PaintPhaseMask) {
1111            paintMask(paintInfo, paintOffset);
1112            return;
1113        } else {
1114            // Paint our background, border and box-shadow.
1115            paintBoxDecorations(paintInfo, paintOffset);
1116        }
1117    }
1118
1119    if (paintInfo.phase == PaintPhaseMask)
1120        return;
1121
1122    PaintPhase paintPhase = paintInfo.phase == PaintPhaseChildOutlines ? PaintPhaseOutline : paintInfo.phase;
1123    PaintInfo childInfo(paintInfo);
1124    childInfo.phase = paintPhase;
1125    childInfo.updatePaintingRootForChildren(renderer());
1126
1127    // Paint our children.
1128    if (paintPhase != PaintPhaseSelfOutline) {
1129        for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
1130            if (curr->renderer()->isText() || !curr->boxModelObject()->hasSelfPaintingLayer())
1131                curr->paint(childInfo, paintOffset, lineTop, lineBottom);
1132        }
1133    }
1134}
1135
1136void InlineFlowBox::paintFillLayers(const PaintInfo& paintInfo, const Color& c, const FillLayer* fillLayer, const LayoutRect& rect, CompositeOperator op)
1137{
1138    if (!fillLayer)
1139        return;
1140    paintFillLayers(paintInfo, c, fillLayer->next(), rect, op);
1141    paintFillLayer(paintInfo, c, fillLayer, rect, op);
1142}
1143
1144bool InlineFlowBox::boxShadowCanBeAppliedToBackground(const FillLayer& lastBackgroundLayer) const
1145{
1146    // The checks here match how paintFillLayer() decides whether to clip (if it does, the shadow
1147    // would be clipped out, so it has to be drawn separately).
1148    StyleImage* image = lastBackgroundLayer.image();
1149    bool hasFillImage = image && image->canRender(renderer(), renderer()->style()->effectiveZoom());
1150    return (!hasFillImage && !renderer()->style()->hasBorderRadius()) || (!prevLineBox() && !nextLineBox()) || !parent();
1151}
1152
1153void InlineFlowBox::paintFillLayer(const PaintInfo& paintInfo, const Color& c, const FillLayer* fillLayer, const LayoutRect& rect, CompositeOperator op)
1154{
1155    StyleImage* img = fillLayer->image();
1156    bool hasFillImage = img && img->canRender(renderer(), renderer()->style()->effectiveZoom());
1157    if ((!hasFillImage && !renderer()->style()->hasBorderRadius()) || (!prevLineBox() && !nextLineBox()) || !parent())
1158        boxModelObject()->paintFillLayerExtended(paintInfo, c, fillLayer, rect, BackgroundBleedNone, this, rect.size(), op);
1159    else if (renderer()->style()->boxDecorationBreak() == DCLONE) {
1160        GraphicsContextStateSaver stateSaver(*paintInfo.context);
1161        paintInfo.context->clip(LayoutRect(rect.x(), rect.y(), width(), height()));
1162        boxModelObject()->paintFillLayerExtended(paintInfo, c, fillLayer, rect, BackgroundBleedNone, this, rect.size(), op);
1163    } else {
1164        // We have a fill image that spans multiple lines.
1165        // We need to adjust tx and ty by the width of all previous lines.
1166        // Think of background painting on inlines as though you had one long line, a single continuous
1167        // strip.  Even though that strip has been broken up across multiple lines, you still paint it
1168        // as though you had one single line.  This means each line has to pick up the background where
1169        // the previous line left off.
1170        LayoutUnit logicalOffsetOnLine = 0;
1171        LayoutUnit totalLogicalWidth;
1172        if (renderer()->style()->direction() == LTR) {
1173            for (InlineFlowBox* curr = prevLineBox(); curr; curr = curr->prevLineBox())
1174                logicalOffsetOnLine += curr->logicalWidth();
1175            totalLogicalWidth = logicalOffsetOnLine;
1176            for (InlineFlowBox* curr = this; curr; curr = curr->nextLineBox())
1177                totalLogicalWidth += curr->logicalWidth();
1178        } else {
1179            for (InlineFlowBox* curr = nextLineBox(); curr; curr = curr->nextLineBox())
1180                logicalOffsetOnLine += curr->logicalWidth();
1181            totalLogicalWidth = logicalOffsetOnLine;
1182            for (InlineFlowBox* curr = this; curr; curr = curr->prevLineBox())
1183                totalLogicalWidth += curr->logicalWidth();
1184        }
1185        LayoutUnit stripX = rect.x() - (isHorizontal() ? logicalOffsetOnLine : LayoutUnit());
1186        LayoutUnit stripY = rect.y() - (isHorizontal() ? LayoutUnit() : logicalOffsetOnLine);
1187        LayoutUnit stripWidth = isHorizontal() ? totalLogicalWidth : static_cast<LayoutUnit>(width());
1188        LayoutUnit stripHeight = isHorizontal() ? static_cast<LayoutUnit>(height()) : totalLogicalWidth;
1189
1190        GraphicsContextStateSaver stateSaver(*paintInfo.context);
1191        paintInfo.context->clip(LayoutRect(rect.x(), rect.y(), width(), height()));
1192        boxModelObject()->paintFillLayerExtended(paintInfo, c, fillLayer, LayoutRect(stripX, stripY, stripWidth, stripHeight), BackgroundBleedNone, this, rect.size(), op);
1193    }
1194}
1195
1196void InlineFlowBox::paintBoxShadow(const PaintInfo& info, RenderStyle* s, ShadowStyle shadowStyle, const LayoutRect& paintRect)
1197{
1198    if ((!prevLineBox() && !nextLineBox()) || !parent())
1199        boxModelObject()->paintBoxShadow(info, paintRect, s, shadowStyle);
1200    else {
1201        // FIXME: We can do better here in the multi-line case. We want to push a clip so that the shadow doesn't
1202        // protrude incorrectly at the edges, and we want to possibly include shadows cast from the previous/following lines
1203        boxModelObject()->paintBoxShadow(info, paintRect, s, shadowStyle, includeLogicalLeftEdge(), includeLogicalRightEdge());
1204    }
1205}
1206
1207void InlineFlowBox::constrainToLineTopAndBottomIfNeeded(LayoutRect& rect) const
1208{
1209    bool noQuirksMode = renderer()->document().inNoQuirksMode();
1210    if (!noQuirksMode && !hasTextChildren() && !(descendantsHaveSameLineHeightAndBaseline() && hasTextDescendants())) {
1211        const RootInlineBox* rootBox = root();
1212        LayoutUnit logicalTop = isHorizontal() ? rect.y() : rect.x();
1213        LayoutUnit logicalHeight = isHorizontal() ? rect.height() : rect.width();
1214        LayoutUnit bottom = min(rootBox->lineBottom(), logicalTop + logicalHeight);
1215        logicalTop = max(rootBox->lineTop(), logicalTop);
1216        logicalHeight = bottom - logicalTop;
1217        if (isHorizontal()) {
1218            rect.setY(logicalTop);
1219            rect.setHeight(logicalHeight);
1220        } else {
1221            rect.setX(logicalTop);
1222            rect.setWidth(logicalHeight);
1223        }
1224    }
1225}
1226
1227static LayoutRect clipRectForNinePieceImageStrip(InlineFlowBox* box, const NinePieceImage& image, const LayoutRect& paintRect)
1228{
1229    LayoutRect clipRect(paintRect);
1230    RenderStyle* style = box->renderer()->style();
1231    LayoutBoxExtent outsets = style->imageOutsets(image);
1232    if (box->isHorizontal()) {
1233        clipRect.setY(paintRect.y() - outsets.top());
1234        clipRect.setHeight(paintRect.height() + outsets.top() + outsets.bottom());
1235        if (box->includeLogicalLeftEdge()) {
1236            clipRect.setX(paintRect.x() - outsets.left());
1237            clipRect.setWidth(paintRect.width() + outsets.left());
1238        }
1239        if (box->includeLogicalRightEdge())
1240            clipRect.setWidth(clipRect.width() + outsets.right());
1241    } else {
1242        clipRect.setX(paintRect.x() - outsets.left());
1243        clipRect.setWidth(paintRect.width() + outsets.left() + outsets.right());
1244        if (box->includeLogicalLeftEdge()) {
1245            clipRect.setY(paintRect.y() - outsets.top());
1246            clipRect.setHeight(paintRect.height() + outsets.top());
1247        }
1248        if (box->includeLogicalRightEdge())
1249            clipRect.setHeight(clipRect.height() + outsets.bottom());
1250    }
1251    return clipRect;
1252}
1253
1254void InlineFlowBox::paintBoxDecorations(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
1255{
1256    if (!paintInfo.shouldPaintWithinRoot(renderer()) || renderer()->style()->visibility() != VISIBLE || paintInfo.phase != PaintPhaseForeground)
1257        return;
1258
1259    // Pixel snap background/border painting.
1260    LayoutRect frameRect = roundedFrameRect();
1261
1262    constrainToLineTopAndBottomIfNeeded(frameRect);
1263
1264    // Move x/y to our coordinates.
1265    LayoutRect localRect(frameRect);
1266    flipForWritingMode(localRect);
1267    LayoutPoint adjustedPaintoffset = paintOffset + localRect.location();
1268
1269    GraphicsContext* context = paintInfo.context;
1270
1271    // You can use p::first-line to specify a background. If so, the root line boxes for
1272    // a line may actually have to paint a background.
1273    RenderStyle* styleToUse = renderer()->style(isFirstLineStyle());
1274    if ((!parent() && isFirstLineStyle() && styleToUse != renderer()->style()) || (parent() && renderer()->hasBoxDecorations())) {
1275        LayoutRect paintRect = LayoutRect(adjustedPaintoffset, frameRect.size());
1276        // Shadow comes first and is behind the background and border.
1277        if (!boxModelObject()->boxShadowShouldBeAppliedToBackground(BackgroundBleedNone, this))
1278            paintBoxShadow(paintInfo, styleToUse, Normal, paintRect);
1279
1280        Color c = renderer()->resolveColor(styleToUse, CSSPropertyBackgroundColor);
1281        paintFillLayers(paintInfo, c, styleToUse->backgroundLayers(), paintRect);
1282        paintBoxShadow(paintInfo, styleToUse, Inset, paintRect);
1283
1284        // :first-line cannot be used to put borders on a line. Always paint borders with our
1285        // non-first-line style.
1286        if (parent() && renderer()->style()->hasBorder()) {
1287            const NinePieceImage& borderImage = renderer()->style()->borderImage();
1288            StyleImage* borderImageSource = borderImage.image();
1289            bool hasBorderImage = borderImageSource && borderImageSource->canRender(renderer(), styleToUse->effectiveZoom());
1290            if (hasBorderImage && !borderImageSource->isLoaded())
1291                return; // Don't paint anything while we wait for the image to load.
1292
1293            // The simple case is where we either have no border image or we are the only box for this object.  In those
1294            // cases only a single call to draw is required.
1295            if (!hasBorderImage || (!prevLineBox() && !nextLineBox()))
1296                boxModelObject()->paintBorder(paintInfo, paintRect, renderer()->style(isFirstLineStyle()), BackgroundBleedNone, includeLogicalLeftEdge(), includeLogicalRightEdge());
1297            else {
1298                // We have a border image that spans multiple lines.
1299                // We need to adjust tx and ty by the width of all previous lines.
1300                // Think of border image painting on inlines as though you had one long line, a single continuous
1301                // strip.  Even though that strip has been broken up across multiple lines, you still paint it
1302                // as though you had one single line.  This means each line has to pick up the image where
1303                // the previous line left off.
1304                // FIXME: What the heck do we do with RTL here? The math we're using is obviously not right,
1305                // but it isn't even clear how this should work at all.
1306                LayoutUnit logicalOffsetOnLine = 0;
1307                for (InlineFlowBox* curr = prevLineBox(); curr; curr = curr->prevLineBox())
1308                    logicalOffsetOnLine += curr->logicalWidth();
1309                LayoutUnit totalLogicalWidth = logicalOffsetOnLine;
1310                for (InlineFlowBox* curr = this; curr; curr = curr->nextLineBox())
1311                    totalLogicalWidth += curr->logicalWidth();
1312                LayoutUnit stripX = adjustedPaintoffset.x() - (isHorizontal() ? logicalOffsetOnLine : LayoutUnit());
1313                LayoutUnit stripY = adjustedPaintoffset.y() - (isHorizontal() ? LayoutUnit() : logicalOffsetOnLine);
1314                LayoutUnit stripWidth = isHorizontal() ? totalLogicalWidth : frameRect.width();
1315                LayoutUnit stripHeight = isHorizontal() ? frameRect.height() : totalLogicalWidth;
1316
1317                LayoutRect clipRect = clipRectForNinePieceImageStrip(this, borderImage, paintRect);
1318                GraphicsContextStateSaver stateSaver(*context);
1319                context->clip(clipRect);
1320                boxModelObject()->paintBorder(paintInfo, LayoutRect(stripX, stripY, stripWidth, stripHeight), renderer()->style(isFirstLineStyle()));
1321            }
1322        }
1323    }
1324}
1325
1326void InlineFlowBox::paintMask(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
1327{
1328    if (!paintInfo.shouldPaintWithinRoot(renderer()) || renderer()->style()->visibility() != VISIBLE || paintInfo.phase != PaintPhaseMask)
1329        return;
1330
1331    // Pixel snap mask painting.
1332    LayoutRect frameRect = roundedFrameRect();
1333
1334    constrainToLineTopAndBottomIfNeeded(frameRect);
1335
1336    // Move x/y to our coordinates.
1337    LayoutRect localRect(frameRect);
1338    flipForWritingMode(localRect);
1339    LayoutPoint adjustedPaintOffset = paintOffset + localRect.location();
1340
1341    const NinePieceImage& maskNinePieceImage = renderer()->style()->maskBoxImage();
1342    StyleImage* maskBoxImage = renderer()->style()->maskBoxImage().image();
1343
1344    // Figure out if we need to push a transparency layer to render our mask.
1345    bool pushTransparencyLayer = false;
1346    bool compositedMask = renderer()->hasLayer() && boxModelObject()->layer()->hasCompositedMask();
1347    bool flattenCompositingLayers = renderer()->view()->frameView() && renderer()->view()->frameView()->paintBehavior() & PaintBehaviorFlattenCompositingLayers;
1348    CompositeOperator compositeOp = CompositeSourceOver;
1349    if (!compositedMask || flattenCompositingLayers) {
1350        if ((maskBoxImage && renderer()->style()->maskLayers()->hasImage()) || renderer()->style()->maskLayers()->next())
1351            pushTransparencyLayer = true;
1352
1353        compositeOp = CompositeDestinationIn;
1354        if (pushTransparencyLayer) {
1355            paintInfo.context->setCompositeOperation(CompositeDestinationIn);
1356            paintInfo.context->beginTransparencyLayer(1.0f);
1357            compositeOp = CompositeSourceOver;
1358        }
1359    }
1360
1361    LayoutRect paintRect = LayoutRect(adjustedPaintOffset, frameRect.size());
1362    paintFillLayers(paintInfo, Color(), renderer()->style()->maskLayers(), paintRect, compositeOp);
1363
1364    bool hasBoxImage = maskBoxImage && maskBoxImage->canRender(renderer(), renderer()->style()->effectiveZoom());
1365    if (!hasBoxImage || !maskBoxImage->isLoaded()) {
1366        if (pushTransparencyLayer)
1367            paintInfo.context->endLayer();
1368        return; // Don't paint anything while we wait for the image to load.
1369    }
1370
1371    // The simple case is where we are the only box for this object.  In those
1372    // cases only a single call to draw is required.
1373    if (!prevLineBox() && !nextLineBox()) {
1374        boxModelObject()->paintNinePieceImage(paintInfo.context, LayoutRect(adjustedPaintOffset, frameRect.size()), renderer()->style(), maskNinePieceImage, compositeOp);
1375    } else {
1376        // We have a mask image that spans multiple lines.
1377        // We need to adjust _tx and _ty by the width of all previous lines.
1378        LayoutUnit logicalOffsetOnLine = 0;
1379        for (InlineFlowBox* curr = prevLineBox(); curr; curr = curr->prevLineBox())
1380            logicalOffsetOnLine += curr->logicalWidth();
1381        LayoutUnit totalLogicalWidth = logicalOffsetOnLine;
1382        for (InlineFlowBox* curr = this; curr; curr = curr->nextLineBox())
1383            totalLogicalWidth += curr->logicalWidth();
1384        LayoutUnit stripX = adjustedPaintOffset.x() - (isHorizontal() ? logicalOffsetOnLine : LayoutUnit());
1385        LayoutUnit stripY = adjustedPaintOffset.y() - (isHorizontal() ? LayoutUnit() : logicalOffsetOnLine);
1386        LayoutUnit stripWidth = isHorizontal() ? totalLogicalWidth : frameRect.width();
1387        LayoutUnit stripHeight = isHorizontal() ? frameRect.height() : totalLogicalWidth;
1388
1389        LayoutRect clipRect = clipRectForNinePieceImageStrip(this, maskNinePieceImage, paintRect);
1390        GraphicsContextStateSaver stateSaver(*paintInfo.context);
1391        paintInfo.context->clip(clipRect);
1392        boxModelObject()->paintNinePieceImage(paintInfo.context, LayoutRect(stripX, stripY, stripWidth, stripHeight), renderer()->style(), maskNinePieceImage, compositeOp);
1393    }
1394
1395    if (pushTransparencyLayer)
1396        paintInfo.context->endLayer();
1397}
1398
1399InlineBox* InlineFlowBox::firstLeafChild() const
1400{
1401    InlineBox* leaf = 0;
1402    for (InlineBox* child = firstChild(); child && !leaf; child = child->nextOnLine())
1403        leaf = child->isLeaf() ? child : toInlineFlowBox(child)->firstLeafChild();
1404    return leaf;
1405}
1406
1407InlineBox* InlineFlowBox::lastLeafChild() const
1408{
1409    InlineBox* leaf = 0;
1410    for (InlineBox* child = lastChild(); child && !leaf; child = child->prevOnLine())
1411        leaf = child->isLeaf() ? child : toInlineFlowBox(child)->lastLeafChild();
1412    return leaf;
1413}
1414
1415RenderObject::SelectionState InlineFlowBox::selectionState()
1416{
1417    return RenderObject::SelectionNone;
1418}
1419
1420bool InlineFlowBox::canAccommodateEllipsis(bool ltr, int blockEdge, int ellipsisWidth) const
1421{
1422    for (InlineBox *box = firstChild(); box; box = box->nextOnLine()) {
1423        if (!box->canAccommodateEllipsis(ltr, blockEdge, ellipsisWidth))
1424            return false;
1425    }
1426    return true;
1427}
1428
1429float InlineFlowBox::placeEllipsisBox(bool ltr, float blockLeftEdge, float blockRightEdge, float ellipsisWidth, float &truncatedWidth, bool& foundBox)
1430{
1431    float result = -1;
1432    // We iterate over all children, the foundBox variable tells us when we've found the
1433    // box containing the ellipsis.  All boxes after that one in the flow are hidden.
1434    // If our flow is ltr then iterate over the boxes from left to right, otherwise iterate
1435    // from right to left. Varying the order allows us to correctly hide the boxes following the ellipsis.
1436    InlineBox* box = ltr ? firstChild() : lastChild();
1437
1438    // NOTE: these will cross after foundBox = true.
1439    int visibleLeftEdge = blockLeftEdge;
1440    int visibleRightEdge = blockRightEdge;
1441
1442    while (box) {
1443        int currResult = box->placeEllipsisBox(ltr, visibleLeftEdge, visibleRightEdge, ellipsisWidth, truncatedWidth, foundBox);
1444        if (currResult != -1 && result == -1)
1445            result = currResult;
1446
1447        if (ltr) {
1448            visibleLeftEdge += box->logicalWidth();
1449            box = box->nextOnLine();
1450        }
1451        else {
1452            visibleRightEdge -= box->logicalWidth();
1453            box = box->prevOnLine();
1454        }
1455    }
1456    return result;
1457}
1458
1459void InlineFlowBox::clearTruncation()
1460{
1461    for (InlineBox *box = firstChild(); box; box = box->nextOnLine())
1462        box->clearTruncation();
1463}
1464
1465LayoutUnit InlineFlowBox::computeOverAnnotationAdjustment(LayoutUnit allowedPosition) const
1466{
1467    LayoutUnit result = 0;
1468    for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
1469        if (curr->renderer()->isOutOfFlowPositioned())
1470            continue; // Positioned placeholders don't affect calculations.
1471
1472        if (curr->isInlineFlowBox())
1473            result = max(result, toInlineFlowBox(curr)->computeOverAnnotationAdjustment(allowedPosition));
1474
1475        if (curr->renderer()->isReplaced() && curr->renderer()->isRubyRun() && curr->renderer()->style()->rubyPosition() == RubyPositionBefore) {
1476            RenderRubyRun* rubyRun = toRenderRubyRun(curr->renderer());
1477            RenderRubyText* rubyText = rubyRun->rubyText();
1478            if (!rubyText)
1479                continue;
1480
1481            if (!rubyRun->style()->isFlippedLinesWritingMode()) {
1482                LayoutUnit topOfFirstRubyTextLine = rubyText->logicalTop() + (rubyText->firstRootBox() ? rubyText->firstRootBox()->lineTop() : LayoutUnit());
1483                if (topOfFirstRubyTextLine >= 0)
1484                    continue;
1485                topOfFirstRubyTextLine += curr->logicalTop();
1486                result = max(result, allowedPosition - topOfFirstRubyTextLine);
1487            } else {
1488                LayoutUnit bottomOfLastRubyTextLine = rubyText->logicalTop() + (rubyText->lastRootBox() ? rubyText->lastRootBox()->lineBottom() : rubyText->logicalHeight());
1489                if (bottomOfLastRubyTextLine <= curr->logicalHeight())
1490                    continue;
1491                bottomOfLastRubyTextLine += curr->logicalTop();
1492                result = max(result, bottomOfLastRubyTextLine - allowedPosition);
1493            }
1494        }
1495
1496        if (curr->isInlineTextBox()) {
1497            RenderStyle* style = curr->renderer()->style(isFirstLineStyle());
1498            TextEmphasisPosition emphasisMarkPosition;
1499            if (style->textEmphasisMark() != TextEmphasisMarkNone && toInlineTextBox(curr)->getEmphasisMarkPosition(style, emphasisMarkPosition) && emphasisMarkPosition == TextEmphasisPositionOver) {
1500                if (!style->isFlippedLinesWritingMode()) {
1501                    int topOfEmphasisMark = curr->logicalTop() - style->font().emphasisMarkHeight(style->textEmphasisMarkString());
1502                    result = max(result, allowedPosition - topOfEmphasisMark);
1503                } else {
1504                    int bottomOfEmphasisMark = curr->logicalBottom() + style->font().emphasisMarkHeight(style->textEmphasisMarkString());
1505                    result = max(result, bottomOfEmphasisMark - allowedPosition);
1506                }
1507            }
1508        }
1509    }
1510    return result;
1511}
1512
1513LayoutUnit InlineFlowBox::computeUnderAnnotationAdjustment(LayoutUnit allowedPosition) const
1514{
1515    LayoutUnit result = 0;
1516    for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
1517        if (curr->renderer()->isOutOfFlowPositioned())
1518            continue; // Positioned placeholders don't affect calculations.
1519
1520        if (curr->isInlineFlowBox())
1521            result = max(result, toInlineFlowBox(curr)->computeUnderAnnotationAdjustment(allowedPosition));
1522
1523        if (curr->renderer()->isReplaced() && curr->renderer()->isRubyRun() && curr->renderer()->style()->rubyPosition() == RubyPositionAfter) {
1524            RenderRubyRun* rubyRun = toRenderRubyRun(curr->renderer());
1525            RenderRubyText* rubyText = rubyRun->rubyText();
1526            if (!rubyText)
1527                continue;
1528
1529            if (rubyRun->style()->isFlippedLinesWritingMode()) {
1530                LayoutUnit topOfFirstRubyTextLine = rubyText->logicalTop() + (rubyText->firstRootBox() ? rubyText->firstRootBox()->lineTop() : LayoutUnit());
1531                if (topOfFirstRubyTextLine >= 0)
1532                    continue;
1533                topOfFirstRubyTextLine += curr->logicalTop();
1534                result = max(result, allowedPosition - topOfFirstRubyTextLine);
1535            } else {
1536                LayoutUnit bottomOfLastRubyTextLine = rubyText->logicalTop() + (rubyText->lastRootBox() ? rubyText->lastRootBox()->lineBottom() : rubyText->logicalHeight());
1537                if (bottomOfLastRubyTextLine <= curr->logicalHeight())
1538                    continue;
1539                bottomOfLastRubyTextLine += curr->logicalTop();
1540                result = max(result, bottomOfLastRubyTextLine - allowedPosition);
1541            }
1542        }
1543
1544        if (curr->isInlineTextBox()) {
1545            RenderStyle* style = curr->renderer()->style(isFirstLineStyle());
1546            if (style->textEmphasisMark() != TextEmphasisMarkNone && style->textEmphasisPosition() == TextEmphasisPositionUnder) {
1547                if (!style->isFlippedLinesWritingMode()) {
1548                    LayoutUnit bottomOfEmphasisMark = curr->logicalBottom() + style->font().emphasisMarkHeight(style->textEmphasisMarkString());
1549                    result = max(result, bottomOfEmphasisMark - allowedPosition);
1550                } else {
1551                    LayoutUnit topOfEmphasisMark = curr->logicalTop() - style->font().emphasisMarkHeight(style->textEmphasisMarkString());
1552                    result = max(result, allowedPosition - topOfEmphasisMark);
1553                }
1554            }
1555        }
1556    }
1557    return result;
1558}
1559
1560void InlineFlowBox::collectLeafBoxesInLogicalOrder(Vector<InlineBox*>& leafBoxesInLogicalOrder, CustomInlineBoxRangeReverse customReverseImplementation, void* userData) const
1561{
1562    InlineBox* leaf = firstLeafChild();
1563
1564    // FIXME: The reordering code is a copy of parts from BidiResolver::createBidiRunsForLine, operating directly on InlineBoxes, instead of BidiRuns.
1565    // Investigate on how this code could possibly be shared.
1566    unsigned char minLevel = 128;
1567    unsigned char maxLevel = 0;
1568
1569    // First find highest and lowest levels, and initialize leafBoxesInLogicalOrder with the leaf boxes in visual order.
1570    for (; leaf; leaf = leaf->nextLeafChild()) {
1571        minLevel = min(minLevel, leaf->bidiLevel());
1572        maxLevel = max(maxLevel, leaf->bidiLevel());
1573        leafBoxesInLogicalOrder.append(leaf);
1574    }
1575
1576    if (renderer()->style()->rtlOrdering() == VisualOrder)
1577        return;
1578
1579    // Reverse of reordering of the line (L2 according to Bidi spec):
1580    // L2. From the highest level found in the text to the lowest odd level on each line,
1581    // reverse any contiguous sequence of characters that are at that level or higher.
1582
1583    // Reversing the reordering of the line is only done up to the lowest odd level.
1584    if (!(minLevel % 2))
1585        ++minLevel;
1586
1587    Vector<InlineBox*>::iterator end = leafBoxesInLogicalOrder.end();
1588    while (minLevel <= maxLevel) {
1589        Vector<InlineBox*>::iterator it = leafBoxesInLogicalOrder.begin();
1590        while (it != end) {
1591            while (it != end) {
1592                if ((*it)->bidiLevel() >= minLevel)
1593                    break;
1594                ++it;
1595            }
1596            Vector<InlineBox*>::iterator first = it;
1597            while (it != end) {
1598                if ((*it)->bidiLevel() < minLevel)
1599                    break;
1600                ++it;
1601            }
1602            Vector<InlineBox*>::iterator last = it;
1603            if (customReverseImplementation) {
1604                ASSERT(userData);
1605                (*customReverseImplementation)(userData, first, last);
1606            } else
1607                std::reverse(first, last);
1608        }
1609        ++minLevel;
1610    }
1611}
1612
1613#ifndef NDEBUG
1614
1615const char* InlineFlowBox::boxName() const
1616{
1617    return "InlineFlowBox";
1618}
1619
1620void InlineFlowBox::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const RenderObject* obj, int depth) const
1621{
1622    InlineBox::showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, depth);
1623    for (const InlineBox* box = firstChild(); box; box = box->nextOnLine())
1624        box->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, depth + 1);
1625}
1626
1627void InlineFlowBox::checkConsistency() const
1628{
1629#ifdef CHECK_CONSISTENCY
1630    ASSERT(!m_hasBadChildList);
1631    const InlineBox* prev = 0;
1632    for (const InlineBox* child = m_firstChild; child; child = child->nextOnLine()) {
1633        ASSERT(child->parent() == this);
1634        ASSERT(child->prevOnLine() == prev);
1635        prev = child;
1636    }
1637    ASSERT(prev == m_lastChild);
1638#endif
1639}
1640
1641#endif
1642
1643} // namespace WebCore
1644