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