CSS 2.1 failure: vertical-align-boxes-001 fails
[WebKit-https.git] / Source / WebCore / rendering / RootInlineBox.cpp
1 /*
2  * Copyright (C) 2003, 2006, 2008 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 "RootInlineBox.h"
22
23 #include "BidiResolver.h"
24 #include "Chrome.h"
25 #include "ChromeClient.h"
26 #include "Document.h"
27 #include "EllipsisBox.h"
28 #include "Frame.h"
29 #include "GraphicsContext.h"
30 #include "HitTestResult.h"
31 #include "InlineTextBox.h"
32 #include "Page.h"
33 #include "PaintInfo.h"
34 #include "RenderArena.h"
35 #include "RenderBlock.h"
36 #include "RenderView.h"
37 #include "VerticalPositionCache.h"
38 #include <wtf/unicode/Unicode.h>
39
40 using namespace std;
41
42 namespace WebCore {
43     
44 typedef WTF::HashMap<const RootInlineBox*, EllipsisBox*> EllipsisBoxMap;
45 static EllipsisBoxMap* gEllipsisBoxMap = 0;
46
47 RootInlineBox::RootInlineBox(RenderBlock* block)
48     : InlineFlowBox(block)
49     , m_lineBreakPos(0)
50     , m_lineBreakObj(0)
51     , m_lineTop(0)
52     , m_lineBottom(0)
53     , m_lineTopWithLeading(0)
54     , m_lineBottomWithLeading(0)
55     , m_paginationStrut(0)
56     , m_paginatedLineWidth(0)
57 {
58     setIsHorizontal(block->isHorizontalWritingMode());
59 }
60
61
62 void RootInlineBox::destroy(RenderArena* arena)
63 {
64     detachEllipsisBox(arena);
65     InlineFlowBox::destroy(arena);
66 }
67
68 void RootInlineBox::detachEllipsisBox(RenderArena* arena)
69 {
70     if (hasEllipsisBox()) {
71         EllipsisBox* box = gEllipsisBoxMap->take(this);
72         box->setParent(0);
73         box->destroy(arena);
74         setHasEllipsisBox(false);
75     }
76 }
77
78 RenderLineBoxList* RootInlineBox::rendererLineBoxes() const
79 {
80     return block()->lineBoxes();
81 }
82
83 void RootInlineBox::clearTruncation()
84 {
85     if (hasEllipsisBox()) {
86         detachEllipsisBox(renderer()->renderArena());
87         InlineFlowBox::clearTruncation();
88     }
89 }
90
91 bool RootInlineBox::isHyphenated() const
92 {
93     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
94         if (box->isInlineTextBox()) {
95             if (toInlineTextBox(box)->hasHyphen())
96                 return true;
97         }
98     }
99
100     return false;
101 }
102
103 LayoutUnit RootInlineBox::baselinePosition(FontBaseline baselineType) const
104 {
105     return boxModelObject()->baselinePosition(baselineType, isFirstLineStyle(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOfInteriorLineBoxes);
106 }
107
108 LayoutUnit RootInlineBox::lineHeight() const
109 {
110     return boxModelObject()->lineHeight(isFirstLineStyle(), isHorizontal() ? HorizontalLine : VerticalLine, PositionOfInteriorLineBoxes);
111 }
112
113 bool RootInlineBox::lineCanAccommodateEllipsis(bool ltr, int blockEdge, int lineBoxEdge, int ellipsisWidth)
114 {
115     // First sanity-check the unoverflowed width of the whole line to see if there is sufficient room.
116     int delta = ltr ? lineBoxEdge - blockEdge : blockEdge - lineBoxEdge;
117     if (logicalWidth() - delta < ellipsisWidth)
118         return false;
119
120     // Next iterate over all the line boxes on the line.  If we find a replaced element that intersects
121     // then we refuse to accommodate the ellipsis.  Otherwise we're ok.
122     return InlineFlowBox::canAccommodateEllipsis(ltr, blockEdge, ellipsisWidth);
123 }
124
125 float RootInlineBox::placeEllipsis(const AtomicString& ellipsisStr,  bool ltr, float blockLeftEdge, float blockRightEdge, float ellipsisWidth,
126                                   InlineBox* markupBox)
127 {
128     // Create an ellipsis box.
129     EllipsisBox* ellipsisBox = new (renderer()->renderArena()) EllipsisBox(renderer(), ellipsisStr, this,
130                                                               ellipsisWidth - (markupBox ? markupBox->logicalWidth() : 0), logicalHeight(),
131                                                               y(), !prevRootBox(), isHorizontal(), markupBox);
132     
133     if (!gEllipsisBoxMap)
134         gEllipsisBoxMap = new EllipsisBoxMap();
135     gEllipsisBoxMap->add(this, ellipsisBox);
136     setHasEllipsisBox(true);
137
138     // FIXME: Do we need an RTL version of this?
139     if (ltr && (x() + logicalWidth() + ellipsisWidth) <= blockRightEdge) {
140         ellipsisBox->setX(x() + logicalWidth());
141         return logicalWidth() + ellipsisWidth;
142     }
143
144     // Now attempt to find the nearest glyph horizontally and place just to the right (or left in RTL)
145     // of that glyph.  Mark all of the objects that intersect the ellipsis box as not painting (as being
146     // truncated).
147     bool foundBox = false;
148     float truncatedWidth = 0;
149     float position = placeEllipsisBox(ltr, blockLeftEdge, blockRightEdge, ellipsisWidth, truncatedWidth, foundBox);
150     ellipsisBox->setX(position);
151     return truncatedWidth;
152 }
153
154 float RootInlineBox::placeEllipsisBox(bool ltr, float blockLeftEdge, float blockRightEdge, float ellipsisWidth, float &truncatedWidth, bool& foundBox)
155 {
156     float result = InlineFlowBox::placeEllipsisBox(ltr, blockLeftEdge, blockRightEdge, ellipsisWidth, truncatedWidth, foundBox);
157     if (result == -1) {
158         result = ltr ? blockRightEdge - ellipsisWidth : blockLeftEdge;
159         truncatedWidth = blockRightEdge - blockLeftEdge;
160     }
161     return result;
162 }
163
164 void RootInlineBox::paintEllipsisBox(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit lineTop, LayoutUnit lineBottom) const
165 {
166     if (hasEllipsisBox() && paintInfo.shouldPaintWithinRoot(renderer()) && renderer()->style()->visibility() == VISIBLE
167             && paintInfo.phase == PaintPhaseForeground)
168         ellipsisBox()->paint(paintInfo, paintOffset, lineTop, lineBottom);
169 }
170
171 #if PLATFORM(MAC)
172
173 void RootInlineBox::addHighlightOverflow()
174 {
175     Frame* frame = renderer()->frame();
176     if (!frame)
177         return;
178     Page* page = frame->page();
179     if (!page)
180         return;
181
182     // Highlight acts as a selection inflation.
183     FloatRect rootRect(0, selectionTop(), logicalWidth(), selectionHeight());
184     IntRect inflatedRect = enclosingIntRect(page->chrome()->client()->customHighlightRect(renderer()->node(), renderer()->style()->highlight(), rootRect));
185     setOverflowFromLogicalRects(inflatedRect, inflatedRect, lineTop(), lineBottom());
186 }
187
188 void RootInlineBox::paintCustomHighlight(PaintInfo& paintInfo, const LayoutPoint& paintOffset, const AtomicString& highlightType)
189 {
190     if (!paintInfo.shouldPaintWithinRoot(renderer()) || renderer()->style()->visibility() != VISIBLE || paintInfo.phase != PaintPhaseForeground)
191         return;
192
193     Frame* frame = renderer()->frame();
194     if (!frame)
195         return;
196     Page* page = frame->page();
197     if (!page)
198         return;
199
200     // Get the inflated rect so that we can properly hit test.
201     FloatRect rootRect(paintOffset.x() + x(), paintOffset.y() + selectionTop(), logicalWidth(), selectionHeight());
202     FloatRect inflatedRect = page->chrome()->client()->customHighlightRect(renderer()->node(), highlightType, rootRect);
203     if (inflatedRect.intersects(paintInfo.rect))
204         page->chrome()->client()->paintCustomHighlight(renderer()->node(), highlightType, rootRect, rootRect, false, true);
205 }
206
207 #endif
208
209 void RootInlineBox::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset, LayoutUnit lineTop, LayoutUnit lineBottom)
210 {
211     InlineFlowBox::paint(paintInfo, paintOffset, lineTop, lineBottom);
212     paintEllipsisBox(paintInfo, paintOffset, lineTop, lineBottom);
213 #if PLATFORM(MAC)
214     RenderStyle* styleToUse = renderer()->style(isFirstLineStyle());
215     if (styleToUse->highlight() != nullAtom && !paintInfo.context->paintingDisabled())
216         paintCustomHighlight(paintInfo, paintOffset, styleToUse->highlight());
217 #endif
218 }
219
220 bool RootInlineBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestPoint& pointInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit lineTop, LayoutUnit lineBottom)
221 {
222     if (hasEllipsisBox() && visibleToHitTesting()) {
223         if (ellipsisBox()->nodeAtPoint(request, result, pointInContainer, accumulatedOffset, lineTop, lineBottom)) {
224             renderer()->updateHitTestResult(result, pointInContainer.point() - toLayoutSize(accumulatedOffset));
225             return true;
226         }
227     }
228     return InlineFlowBox::nodeAtPoint(request, result, pointInContainer, accumulatedOffset, lineTop, lineBottom);
229 }
230
231 void RootInlineBox::adjustPosition(float dx, float dy)
232 {
233     InlineFlowBox::adjustPosition(dx, dy);
234     LayoutUnit blockDirectionDelta = isHorizontal() ? dy : dx; // The block direction delta is a LayoutUnit.
235     m_lineTop += blockDirectionDelta;
236     m_lineBottom += blockDirectionDelta;
237     m_lineTopWithLeading += blockDirectionDelta;
238     m_lineBottomWithLeading += blockDirectionDelta;
239     if (hasEllipsisBox())
240         ellipsisBox()->adjustPosition(dx, dy);
241 }
242
243 void RootInlineBox::childRemoved(InlineBox* box)
244 {
245     if (box->renderer() == m_lineBreakObj)
246         setLineBreakInfo(0, 0, BidiStatus());
247
248     for (RootInlineBox* prev = prevRootBox(); prev && prev->lineBreakObj() == box->renderer(); prev = prev->prevRootBox()) {
249         prev->setLineBreakInfo(0, 0, BidiStatus());
250         prev->markDirty();
251     }
252 }
253
254 LayoutUnit RootInlineBox::alignBoxesInBlockDirection(LayoutUnit heightOfBlock, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, VerticalPositionCache& verticalPositionCache)
255 {
256 #if ENABLE(SVG)
257     // SVG will handle vertical alignment on its own.
258     if (isSVGRootInlineBox())
259         return 0;
260 #endif
261
262     LayoutUnit maxPositionTop = 0;
263     LayoutUnit maxPositionBottom = 0;
264     LayoutUnit maxAscent = 0;
265     LayoutUnit maxDescent = 0;
266     bool setMaxAscent = false;
267     bool setMaxDescent = false;
268
269     // Figure out if we're in no-quirks mode.
270     bool noQuirksMode = renderer()->document()->inNoQuirksMode();
271
272     m_baselineType = requiresIdeographicBaseline(textBoxDataMap) ? IdeographicBaseline : AlphabeticBaseline;
273
274     computeLogicalBoxHeights(this, maxPositionTop, maxPositionBottom, maxAscent, maxDescent, setMaxAscent, setMaxDescent, noQuirksMode,
275                              textBoxDataMap, baselineType(), verticalPositionCache);
276
277     if (maxAscent + maxDescent < max(maxPositionTop, maxPositionBottom))
278         adjustMaxAscentAndDescent(maxAscent, maxDescent, maxPositionTop, maxPositionBottom);
279
280     LayoutUnit maxHeight = maxAscent + maxDescent;
281     LayoutUnit lineTop = heightOfBlock;
282     LayoutUnit lineBottom = heightOfBlock;
283     LayoutUnit lineTopIncludingMargins = heightOfBlock;
284     LayoutUnit lineBottomIncludingMargins = heightOfBlock;
285     bool setLineTop = false;
286     bool hasAnnotationsBefore = false;
287     bool hasAnnotationsAfter = false;
288     placeBoxesInBlockDirection(heightOfBlock, maxHeight, maxAscent, noQuirksMode, lineTop, lineBottom, setLineTop,
289                                lineTopIncludingMargins, lineBottomIncludingMargins, hasAnnotationsBefore, hasAnnotationsAfter, baselineType());
290     m_hasAnnotationsBefore = hasAnnotationsBefore;
291     m_hasAnnotationsAfter = hasAnnotationsAfter;
292     
293     maxHeight = max<LayoutUnit>(0, maxHeight); // FIXME: Is this really necessary?
294
295     setLineTopBottomPositions(lineTop, lineBottom, heightOfBlock, heightOfBlock + maxHeight);
296     setPaginatedLineWidth(block()->availableLogicalWidthForContent(heightOfBlock));
297
298     LayoutUnit annotationsAdjustment = beforeAnnotationsAdjustment();
299     if (annotationsAdjustment) {
300         // FIXME: Need to handle pagination here. We might have to move to the next page/column as a result of the
301         // ruby expansion.
302         adjustBlockDirectionPosition(annotationsAdjustment);
303         heightOfBlock += annotationsAdjustment;
304     }
305
306     LayoutUnit gridSnapAdjustment = lineSnapAdjustment();
307     if (gridSnapAdjustment) {
308         adjustBlockDirectionPosition(gridSnapAdjustment);
309         heightOfBlock += gridSnapAdjustment;
310     }
311
312     return heightOfBlock + maxHeight;
313 }
314
315 LayoutUnit RootInlineBox::beforeAnnotationsAdjustment() const
316 {
317     LayoutUnit result = 0;
318
319     if (!renderer()->style()->isFlippedLinesWritingMode()) {
320         // Annotations under the previous line may push us down.
321         if (prevRootBox() && prevRootBox()->hasAnnotationsAfter())
322             result = prevRootBox()->computeUnderAnnotationAdjustment(lineTop());
323
324         if (!hasAnnotationsBefore())
325             return result;
326
327         // Annotations over this line may push us further down.
328         LayoutUnit highestAllowedPosition = prevRootBox() ? min(prevRootBox()->lineBottom(), lineTop()) + result : static_cast<LayoutUnit>(block()->borderBefore());
329         result = computeOverAnnotationAdjustment(highestAllowedPosition);
330     } else {
331         // Annotations under this line may push us up.
332         if (hasAnnotationsBefore())
333             result = computeUnderAnnotationAdjustment(prevRootBox() ? prevRootBox()->lineBottom() : static_cast<LayoutUnit>(block()->borderBefore()));
334
335         if (!prevRootBox() || !prevRootBox()->hasAnnotationsAfter())
336             return result;
337
338         // We have to compute the expansion for annotations over the previous line to see how much we should move.
339         LayoutUnit lowestAllowedPosition = max(prevRootBox()->lineBottom(), lineTop()) - result;
340         result = prevRootBox()->computeOverAnnotationAdjustment(lowestAllowedPosition);
341     }
342
343     return result;
344 }
345
346 LayoutUnit RootInlineBox::lineSnapAdjustment(LayoutUnit delta) const
347 {
348     // If our block doesn't have snapping turned on, do nothing.
349     // FIXME: Implement bounds snapping.
350     if (block()->style()->lineSnap() == LineSnapNone)
351         return 0;
352
353     // Get the current line grid and offset.
354     LayoutState* layoutState = block()->view()->layoutState();
355     RenderBlock* lineGrid = layoutState->lineGrid();
356     LayoutSize lineGridOffset = layoutState->lineGridOffset();
357     if (!lineGrid || lineGrid->style()->writingMode() != block()->style()->writingMode())
358         return 0;
359
360     // Get the hypothetical line box used to establish the grid.
361     RootInlineBox* lineGridBox = lineGrid->lineGridBox();
362     if (!lineGridBox)
363         return 0;
364     
365     LayoutUnit lineGridBlockOffset = lineGrid->isHorizontalWritingMode() ? lineGridOffset.height() : lineGridOffset.width();
366     LayoutUnit blockOffset = block()->isHorizontalWritingMode() ? layoutState->layoutOffset().height() : layoutState->layoutOffset().width();
367
368     // Now determine our position on the grid. Our baseline needs to be adjusted to the nearest baseline multiple
369     // as established by the line box.
370     // FIXME: Need to handle crazy line-box-contain values that cause the root line box to not be considered. I assume
371     // the grid should honor line-box-contain.
372     LayoutUnit gridLineHeight = lineGridBox->lineBottomWithLeading() - lineGridBox->lineTopWithLeading();
373     if (!gridLineHeight)
374         return 0;
375
376     LayoutUnit lineGridFontAscent = lineGrid->style()->fontMetrics().ascent(baselineType());
377     LayoutUnit lineGridFontHeight = lineGridBox->logicalHeight();
378     LayoutUnit firstTextTop = lineGridBlockOffset + lineGridBox->logicalTop();
379     LayoutUnit firstLineTopWithLeading = lineGridBlockOffset + lineGridBox->lineTopWithLeading();
380     LayoutUnit firstBaselinePosition = firstTextTop + lineGridFontAscent;
381
382     LayoutUnit currentTextTop = blockOffset + logicalTop() + delta;
383     LayoutUnit currentFontAscent = block()->style()->fontMetrics().ascent(baselineType());
384     LayoutUnit currentBaselinePosition = currentTextTop + currentFontAscent;
385
386     LayoutUnit lineGridPaginationOrigin = isHorizontal() ? layoutState->lineGridPaginationOrigin().height() : layoutState->lineGridPaginationOrigin().width();
387
388     // If we're paginated, see if we're on a page after the first one. If so, the grid resets on subsequent pages.
389     // FIXME: If the grid is an ancestor of the pagination establisher, then this is incorrect.
390     LayoutUnit pageLogicalTop = 0;
391     if (layoutState->isPaginated() && layoutState->pageLogicalHeight()) {
392         pageLogicalTop = block()->pageLogicalTopForOffset(lineTopWithLeading() + delta);
393         if (pageLogicalTop > firstLineTopWithLeading)
394             firstTextTop = pageLogicalTop + lineGridBox->logicalTop() - lineGrid->borderBefore() - lineGrid->paddingBefore() + lineGridPaginationOrigin;
395     }
396
397     if (block()->style()->lineSnap() == LineSnapContain) {
398         // Compute the desired offset from the text-top of a grid line.
399         // Look at our height (logicalHeight()).
400         // Look at the total available height. It's going to be (textBottom - textTop) + (n-1)*(multiple with leading)
401         // where n is number of grid lines required to enclose us.
402         if (logicalHeight() <= lineGridFontHeight)
403             firstTextTop += (lineGridFontHeight - logicalHeight()) / 2;
404         else {
405             LayoutUnit numberOfLinesWithLeading = ceilf(static_cast<float>(logicalHeight() - lineGridFontHeight) / gridLineHeight);
406             LayoutUnit totalHeight = lineGridFontHeight + numberOfLinesWithLeading * gridLineHeight;
407             firstTextTop += (totalHeight - logicalHeight()) / 2;
408         }
409         firstBaselinePosition = firstTextTop + currentFontAscent;
410     } else
411         firstBaselinePosition = firstTextTop + lineGridFontAscent;
412
413     // If we're above the first line, just push to the first line.
414     if (currentBaselinePosition < firstBaselinePosition)
415         return delta + firstBaselinePosition - currentBaselinePosition;
416
417     // Otherwise we're in the middle of the grid somewhere. Just push to the next line.
418     LayoutUnit baselineOffset = currentBaselinePosition - firstBaselinePosition;
419     LayoutUnit remainder = roundToInt(baselineOffset) % roundToInt(gridLineHeight);
420     LayoutUnit result = delta;
421     if (remainder)
422         result += gridLineHeight - remainder;
423
424     // If we aren't paginated we can return the result.
425     if (!layoutState->isPaginated() || !layoutState->pageLogicalHeight() || result == delta)
426         return result;
427     
428     // We may end up shifted to a new page. We need to do a re-snap when that happens.
429     LayoutUnit newPageLogicalTop = block()->pageLogicalTopForOffset(lineBottomWithLeading() + result);
430     if (newPageLogicalTop == pageLogicalTop)
431         return result;
432     
433     // Put ourselves at the top of the next page to force a snap onto the new grid established by that page.
434     return lineSnapAdjustment(newPageLogicalTop - (blockOffset + lineTopWithLeading()));
435 }
436
437 GapRects RootInlineBox::lineSelectionGap(RenderBlock* rootBlock, const LayoutPoint& rootBlockPhysicalPosition, const LayoutSize& offsetFromRootBlock, 
438                                          LayoutUnit selTop, LayoutUnit selHeight, const PaintInfo* paintInfo)
439 {
440     RenderObject::SelectionState lineState = selectionState();
441
442     bool leftGap, rightGap;
443     block()->getSelectionGapInfo(lineState, leftGap, rightGap);
444
445     GapRects result;
446
447     InlineBox* firstBox = firstSelectedBox();
448     InlineBox* lastBox = lastSelectedBox();
449     if (leftGap)
450         result.uniteLeft(block()->logicalLeftSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock,
451                                                           firstBox->parent()->renderer(), firstBox->logicalLeft(), selTop, selHeight, paintInfo));
452     if (rightGap)
453         result.uniteRight(block()->logicalRightSelectionGap(rootBlock, rootBlockPhysicalPosition, offsetFromRootBlock,
454                                                             lastBox->parent()->renderer(), lastBox->logicalRight(), selTop, selHeight, paintInfo));
455
456     // When dealing with bidi text, a non-contiguous selection region is possible.
457     // e.g. The logical text aaaAAAbbb (capitals denote RTL text and non-capitals LTR) is layed out
458     // visually as 3 text runs |aaa|bbb|AAA| if we select 4 characters from the start of the text the
459     // selection will look like (underline denotes selection):
460     // |aaa|bbb|AAA|
461     //  ___       _
462     // We can see that the |bbb| run is not part of the selection while the runs around it are.
463     if (firstBox && firstBox != lastBox) {
464         // Now fill in any gaps on the line that occurred between two selected elements.
465         LayoutUnit lastLogicalLeft = firstBox->logicalRight();
466         bool isPreviousBoxSelected = firstBox->selectionState() != RenderObject::SelectionNone;
467         for (InlineBox* box = firstBox->nextLeafChild(); box; box = box->nextLeafChild()) {
468             if (box->selectionState() != RenderObject::SelectionNone) {
469                 LayoutRect logicalRect(lastLogicalLeft, selTop, box->logicalLeft() - lastLogicalLeft, selHeight);
470                 logicalRect.move(renderer()->isHorizontalWritingMode() ? offsetFromRootBlock : LayoutSize(offsetFromRootBlock.height(), offsetFromRootBlock.width()));
471                 LayoutRect gapRect = rootBlock->logicalRectToPhysicalRect(rootBlockPhysicalPosition, logicalRect);
472                 if (isPreviousBoxSelected && gapRect.width() > 0 && gapRect.height() > 0) {
473                     if (paintInfo && box->parent()->renderer()->style()->visibility() == VISIBLE)
474                         paintInfo->context->fillRect(gapRect, box->parent()->renderer()->selectionBackgroundColor(), box->parent()->renderer()->style()->colorSpace());
475                     // VisibleSelection may be non-contiguous, see comment above.
476                     result.uniteCenter(gapRect);
477                 }
478                 lastLogicalLeft = box->logicalRight();
479             }
480             if (box == lastBox)
481                 break;
482             isPreviousBoxSelected = box->selectionState() != RenderObject::SelectionNone;
483         }
484     }
485
486     return result;
487 }
488
489 RenderObject::SelectionState RootInlineBox::selectionState()
490 {
491     // Walk over all of the selected boxes.
492     RenderObject::SelectionState state = RenderObject::SelectionNone;
493     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
494         RenderObject::SelectionState boxState = box->selectionState();
495         if ((boxState == RenderObject::SelectionStart && state == RenderObject::SelectionEnd) ||
496             (boxState == RenderObject::SelectionEnd && state == RenderObject::SelectionStart))
497             state = RenderObject::SelectionBoth;
498         else if (state == RenderObject::SelectionNone ||
499                  ((boxState == RenderObject::SelectionStart || boxState == RenderObject::SelectionEnd) &&
500                   (state == RenderObject::SelectionNone || state == RenderObject::SelectionInside)))
501             state = boxState;
502         if (state == RenderObject::SelectionBoth)
503             break;
504     }
505
506     return state;
507 }
508
509 InlineBox* RootInlineBox::firstSelectedBox()
510 {
511     for (InlineBox* box = firstLeafChild(); box; box = box->nextLeafChild()) {
512         if (box->selectionState() != RenderObject::SelectionNone)
513             return box;
514     }
515
516     return 0;
517 }
518
519 InlineBox* RootInlineBox::lastSelectedBox()
520 {
521     for (InlineBox* box = lastLeafChild(); box; box = box->prevLeafChild()) {
522         if (box->selectionState() != RenderObject::SelectionNone)
523             return box;
524     }
525
526     return 0;
527 }
528
529 LayoutUnit RootInlineBox::selectionTop() const
530 {
531     LayoutUnit selectionTop = m_lineTop;
532
533     if (m_hasAnnotationsBefore)
534         selectionTop -= !renderer()->style()->isFlippedLinesWritingMode() ? computeOverAnnotationAdjustment(m_lineTop) : computeUnderAnnotationAdjustment(m_lineTop);
535
536     if (renderer()->style()->isFlippedLinesWritingMode())
537         return selectionTop;
538
539     LayoutUnit prevBottom = prevRootBox() ? prevRootBox()->selectionBottom() : block()->borderBefore() + block()->paddingBefore();
540     if (prevBottom < selectionTop && block()->containsFloats()) {
541         // This line has actually been moved further down, probably from a large line-height, but possibly because the
542         // line was forced to clear floats.  If so, let's check the offsets, and only be willing to use the previous
543         // line's bottom if the offsets are greater on both sides.
544         LayoutUnit prevLeft = block()->logicalLeftOffsetForLine(prevBottom, false);
545         LayoutUnit prevRight = block()->logicalRightOffsetForLine(prevBottom, false);
546         LayoutUnit newLeft = block()->logicalLeftOffsetForLine(selectionTop, false);
547         LayoutUnit newRight = block()->logicalRightOffsetForLine(selectionTop, false);
548         if (prevLeft > newLeft || prevRight < newRight)
549             return selectionTop;
550     }
551
552     return prevBottom;
553 }
554
555 LayoutUnit RootInlineBox::selectionTopAdjustedForPrecedingBlock() const
556 {
557     LayoutUnit top = selectionTop();
558
559     RenderObject::SelectionState blockSelectionState = root()->block()->selectionState();
560     if (blockSelectionState != RenderObject::SelectionInside && blockSelectionState != RenderObject::SelectionEnd)
561         return top;
562
563     LayoutSize offsetToBlockBefore;
564     if (RenderBlock* block = root()->block()->blockBeforeWithinSelectionRoot(offsetToBlockBefore)) {
565         if (RootInlineBox* lastLine = block->lastRootBox()) {
566             RenderObject::SelectionState lastLineSelectionState = lastLine->selectionState();
567             if (lastLineSelectionState != RenderObject::SelectionInside && lastLineSelectionState != RenderObject::SelectionStart)
568                 return top;
569
570             LayoutUnit lastLineSelectionBottom = lastLine->selectionBottom() + offsetToBlockBefore.height();
571             top = max(top, lastLineSelectionBottom);
572         }
573     }
574
575     return top;
576 }
577
578 LayoutUnit RootInlineBox::selectionBottom() const
579 {
580     LayoutUnit selectionBottom = m_lineBottom;
581
582     if (m_hasAnnotationsAfter)
583         selectionBottom += !renderer()->style()->isFlippedLinesWritingMode() ? computeUnderAnnotationAdjustment(m_lineBottom) : computeOverAnnotationAdjustment(m_lineBottom);
584
585     if (!renderer()->style()->isFlippedLinesWritingMode() || !nextRootBox())
586         return selectionBottom;
587
588     LayoutUnit nextTop = nextRootBox()->selectionTop();
589     if (nextTop > selectionBottom && block()->containsFloats()) {
590         // The next line has actually been moved further over, probably from a large line-height, but possibly because the
591         // line was forced to clear floats.  If so, let's check the offsets, and only be willing to use the next
592         // line's top if the offsets are greater on both sides.
593         LayoutUnit nextLeft = block()->logicalLeftOffsetForLine(nextTop, false);
594         LayoutUnit nextRight = block()->logicalRightOffsetForLine(nextTop, false);
595         LayoutUnit newLeft = block()->logicalLeftOffsetForLine(selectionBottom, false);
596         LayoutUnit newRight = block()->logicalRightOffsetForLine(selectionBottom, false);
597         if (nextLeft > newLeft || nextRight < newRight)
598             return selectionBottom;
599     }
600
601     return nextTop;
602 }
603
604 RenderBlock* RootInlineBox::block() const
605 {
606     return toRenderBlock(renderer());
607 }
608
609 static bool isEditableLeaf(InlineBox* leaf)
610 {
611     return leaf && leaf->renderer() && leaf->renderer()->node() && leaf->renderer()->node()->rendererIsEditable();
612 }
613
614 InlineBox* RootInlineBox::closestLeafChildForPoint(const IntPoint& pointInContents, bool onlyEditableLeaves)
615 {
616     return closestLeafChildForLogicalLeftPosition(block()->isHorizontalWritingMode() ? pointInContents.x() : pointInContents.y(), onlyEditableLeaves);
617 }
618
619 InlineBox* RootInlineBox::closestLeafChildForLogicalLeftPosition(int leftPosition, bool onlyEditableLeaves)
620 {
621     InlineBox* firstLeaf = firstLeafChild();
622     InlineBox* lastLeaf = lastLeafChild();
623
624     if (firstLeaf != lastLeaf) {
625         if (firstLeaf->isLineBreak())
626             firstLeaf = firstLeaf->nextLeafChildIgnoringLineBreak();
627         else if (lastLeaf->isLineBreak())
628             lastLeaf = lastLeaf->prevLeafChildIgnoringLineBreak();
629     }
630
631     if (firstLeaf == lastLeaf && (!onlyEditableLeaves || isEditableLeaf(firstLeaf)))
632         return firstLeaf;
633
634     // Avoid returning a list marker when possible.
635     if (leftPosition <= firstLeaf->logicalLeft() && !firstLeaf->renderer()->isListMarker() && (!onlyEditableLeaves || isEditableLeaf(firstLeaf)))
636         // The leftPosition coordinate is less or equal to left edge of the firstLeaf.
637         // Return it.
638         return firstLeaf;
639
640     if (leftPosition >= lastLeaf->logicalRight() && !lastLeaf->renderer()->isListMarker() && (!onlyEditableLeaves || isEditableLeaf(lastLeaf)))
641         // The leftPosition coordinate is greater or equal to right edge of the lastLeaf.
642         // Return it.
643         return lastLeaf;
644
645     InlineBox* closestLeaf = 0;
646     for (InlineBox* leaf = firstLeaf; leaf; leaf = leaf->nextLeafChildIgnoringLineBreak()) {
647         if (!leaf->renderer()->isListMarker() && (!onlyEditableLeaves || isEditableLeaf(leaf))) {
648             closestLeaf = leaf;
649             if (leftPosition < leaf->logicalRight())
650                 // The x coordinate is less than the right edge of the box.
651                 // Return it.
652                 return leaf;
653         }
654     }
655
656     return closestLeaf ? closestLeaf : lastLeaf;
657 }
658
659 BidiStatus RootInlineBox::lineBreakBidiStatus() const
660
661     return BidiStatus(static_cast<WTF::Unicode::Direction>(m_lineBreakBidiStatusEor), static_cast<WTF::Unicode::Direction>(m_lineBreakBidiStatusLastStrong), static_cast<WTF::Unicode::Direction>(m_lineBreakBidiStatusLast), m_lineBreakContext);
662 }
663
664 void RootInlineBox::setLineBreakInfo(RenderObject* obj, unsigned breakPos, const BidiStatus& status)
665 {
666     m_lineBreakObj = obj;
667     m_lineBreakPos = breakPos;
668     m_lineBreakBidiStatusEor = status.eor;
669     m_lineBreakBidiStatusLastStrong = status.lastStrong;
670     m_lineBreakBidiStatusLast = status.last;
671     m_lineBreakContext = status.context;
672 }
673
674 EllipsisBox* RootInlineBox::ellipsisBox() const
675 {
676     if (!hasEllipsisBox())
677         return 0;
678     return gEllipsisBoxMap->get(this);
679 }
680
681 void RootInlineBox::removeLineBoxFromRenderObject()
682 {
683     block()->lineBoxes()->removeLineBox(this);
684 }
685
686 void RootInlineBox::extractLineBoxFromRenderObject()
687 {
688     block()->lineBoxes()->extractLineBox(this);
689 }
690
691 void RootInlineBox::attachLineBoxToRenderObject()
692 {
693     block()->lineBoxes()->attachLineBox(this);
694 }
695
696 LayoutRect RootInlineBox::paddedLayoutOverflowRect(LayoutUnit endPadding) const
697 {
698     LayoutRect lineLayoutOverflow = layoutOverflowRect(lineTop(), lineBottom());
699     if (!endPadding)
700         return lineLayoutOverflow;
701     
702     // FIXME: Audit whether to use pixel snapped values when not using integers for layout: https://bugs.webkit.org/show_bug.cgi?id=63656
703     if (isHorizontal()) {
704         if (isLeftToRightDirection())
705             lineLayoutOverflow.shiftMaxXEdgeTo(max<LayoutUnit>(lineLayoutOverflow.maxX(), pixelSnappedLogicalRight() + endPadding));
706         else
707             lineLayoutOverflow.shiftXEdgeTo(min<LayoutUnit>(lineLayoutOverflow.x(), pixelSnappedLogicalLeft() - endPadding));
708     } else {
709         if (isLeftToRightDirection())
710             lineLayoutOverflow.shiftMaxYEdgeTo(max<LayoutUnit>(lineLayoutOverflow.maxY(), pixelSnappedLogicalRight() + endPadding));
711         else
712             lineLayoutOverflow.shiftYEdgeTo(min<LayoutUnit>(lineLayoutOverflow.y(), pixelSnappedLogicalLeft() - endPadding));
713     }
714     
715     return lineLayoutOverflow;
716 }
717
718 static void setAscentAndDescent(int& ascent, int& descent, int newAscent, int newDescent, bool& ascentDescentSet)
719 {
720     if (!ascentDescentSet) {
721         ascentDescentSet = true;
722         ascent = newAscent;
723         descent = newDescent;
724     } else {
725         ascent = max(ascent, newAscent);
726         descent = max(descent, newDescent);
727     }
728 }
729
730 void RootInlineBox::ascentAndDescentForBox(InlineBox* box, GlyphOverflowAndFallbackFontsMap& textBoxDataMap, int& ascent, int& descent,
731                                            bool& affectsAscent, bool& affectsDescent) const
732 {
733     bool ascentDescentSet = false;
734
735     // Replaced boxes will return 0 for the line-height if line-box-contain says they are
736     // not to be included.
737     if (box->renderer()->isReplaced()) {
738         if (renderer()->style(isFirstLineStyle())->lineBoxContain() & LineBoxContainReplaced) {
739             ascent = box->baselinePosition(baselineType());
740             descent = box->lineHeight() - ascent;
741             
742             // Replaced elements always affect both the ascent and descent.
743             affectsAscent = true;
744             affectsDescent = true;
745         }
746         return;
747     }
748
749     Vector<const SimpleFontData*>* usedFonts = 0;
750     GlyphOverflow* glyphOverflow = 0;
751     if (box->isText()) {
752         GlyphOverflowAndFallbackFontsMap::iterator it = textBoxDataMap.find(toInlineTextBox(box));
753         usedFonts = it == textBoxDataMap.end() ? 0 : &it->second.first;
754         glyphOverflow = it == textBoxDataMap.end() ? 0 : &it->second.second;
755     }
756         
757     bool includeLeading = includeLeadingForBox(box);
758     bool includeFont = includeFontForBox(box);
759     
760     bool setUsedFont = false;
761     bool setUsedFontWithLeading = false;
762
763     if (usedFonts && !usedFonts->isEmpty() && (includeFont || (box->renderer()->style(isFirstLineStyle())->lineHeight().isNegative() && includeLeading))) {
764         usedFonts->append(box->renderer()->style(isFirstLineStyle())->font().primaryFont());
765         for (size_t i = 0; i < usedFonts->size(); ++i) {
766             const FontMetrics& fontMetrics = usedFonts->at(i)->fontMetrics();
767             int usedFontAscent = fontMetrics.ascent(baselineType());
768             int usedFontDescent = fontMetrics.descent(baselineType());
769             int halfLeading = (fontMetrics.lineSpacing() - fontMetrics.height()) / 2;
770             int usedFontAscentAndLeading = usedFontAscent + halfLeading;
771             int usedFontDescentAndLeading = fontMetrics.lineSpacing() - usedFontAscentAndLeading;
772             if (includeFont) {
773                 setAscentAndDescent(ascent, descent, usedFontAscent, usedFontDescent, ascentDescentSet);
774                 setUsedFont = true;
775             }
776             if (includeLeading) {
777                 setAscentAndDescent(ascent, descent, usedFontAscentAndLeading, usedFontDescentAndLeading, ascentDescentSet);
778                 setUsedFontWithLeading = true;
779             }
780             if (!affectsAscent)
781                 affectsAscent = usedFontAscent - box->logicalTop() > 0;
782             if (!affectsDescent)
783                 affectsDescent = usedFontDescent + box->logicalTop() > 0;
784         }
785     }
786
787     // If leading is included for the box, then we compute that box.
788     if (includeLeading && !setUsedFontWithLeading) {
789         int ascentWithLeading = box->baselinePosition(baselineType());
790         int descentWithLeading = box->lineHeight() - ascentWithLeading;
791         setAscentAndDescent(ascent, descent, ascentWithLeading, descentWithLeading, ascentDescentSet);
792         
793         // Examine the font box for inline flows and text boxes to see if any part of it is above the baseline.
794         // If the top of our font box relative to the root box baseline is above the root box baseline, then
795         // we are contributing to the maxAscent value. Descent is similar. If any part of our font box is below
796         // the root box's baseline, then we contribute to the maxDescent value.
797         affectsAscent = ascentWithLeading - box->logicalTop() > 0;
798         affectsDescent = descentWithLeading + box->logicalTop() > 0; 
799     }
800     
801     if (includeFontForBox(box) && !setUsedFont) {
802         int fontAscent = box->renderer()->style(isFirstLineStyle())->fontMetrics().ascent();
803         int fontDescent = box->renderer()->style(isFirstLineStyle())->fontMetrics().descent();
804         setAscentAndDescent(ascent, descent, fontAscent, fontDescent, ascentDescentSet);
805         affectsAscent = fontAscent - box->logicalTop() > 0;
806         affectsDescent = fontDescent + box->logicalTop() > 0; 
807     }
808
809     if (includeGlyphsForBox(box) && glyphOverflow && glyphOverflow->computeBounds) {
810         setAscentAndDescent(ascent, descent, glyphOverflow->top, glyphOverflow->bottom, ascentDescentSet);
811         affectsAscent = glyphOverflow->top - box->logicalTop() > 0;
812         affectsDescent = glyphOverflow->bottom + box->logicalTop() > 0; 
813         glyphOverflow->top = min(glyphOverflow->top, max(0, glyphOverflow->top - box->renderer()->style(isFirstLineStyle())->fontMetrics().ascent()));
814         glyphOverflow->bottom = min(glyphOverflow->bottom, max(0, glyphOverflow->bottom - box->renderer()->style(isFirstLineStyle())->fontMetrics().descent()));
815     }
816
817     if (includeMarginForBox(box)) {
818         LayoutUnit ascentWithMargin = box->renderer()->style(isFirstLineStyle())->fontMetrics().ascent();
819         LayoutUnit descentWithMargin = box->renderer()->style(isFirstLineStyle())->fontMetrics().descent();
820         if (box->parent() && !box->renderer()->isText()) {
821             ascentWithMargin += box->boxModelObject()->borderBefore() + box->boxModelObject()->paddingBefore() + box->boxModelObject()->marginBefore();
822             descentWithMargin += box->boxModelObject()->borderAfter() + box->boxModelObject()->paddingAfter() + box->boxModelObject()->marginAfter();
823         }
824         setAscentAndDescent(ascent, descent, ascentWithMargin, descentWithMargin, ascentDescentSet);
825         
826         // Treat like a replaced element, since we're using the margin box.
827         affectsAscent = true;
828         affectsDescent = true;
829     }
830 }
831
832 LayoutUnit RootInlineBox::verticalPositionForBox(InlineBox* box, VerticalPositionCache& verticalPositionCache)
833 {
834     if (box->renderer()->isText())
835         return box->parent()->logicalTop();
836     
837     RenderBoxModelObject* renderer = box->boxModelObject();
838     ASSERT(renderer->isInline());
839     if (!renderer->isInline())
840         return 0;
841
842     // This method determines the vertical position for inline elements.
843     bool firstLine = isFirstLineStyle();
844     if (firstLine && !renderer->document()->usesFirstLineRules())
845         firstLine = false;
846
847     // Check the cache.
848     bool isRenderInline = renderer->isRenderInline();
849     if (isRenderInline && !firstLine) {
850         LayoutUnit verticalPosition = verticalPositionCache.get(renderer, baselineType());
851         if (verticalPosition != PositionUndefined)
852             return verticalPosition;
853     }
854
855     LayoutUnit verticalPosition = 0;
856     EVerticalAlign verticalAlign = renderer->style()->verticalAlign();
857     if (verticalAlign == TOP || verticalAlign == BOTTOM)
858         return 0;
859    
860     RenderObject* parent = renderer->parent();
861     if (parent->isRenderInline() && parent->style()->verticalAlign() != TOP && parent->style()->verticalAlign() != BOTTOM)
862         verticalPosition = box->parent()->logicalTop();
863     
864     if (verticalAlign != BASELINE) {
865         const Font& font = parent->style(firstLine)->font();
866         const FontMetrics& fontMetrics = font.fontMetrics();
867         int fontSize = font.pixelSize();
868
869         LineDirectionMode lineDirection = parent->isHorizontalWritingMode() ? HorizontalLine : VerticalLine;
870
871         if (verticalAlign == SUB)
872             verticalPosition += fontSize / 5 + 1;
873         else if (verticalAlign == SUPER)
874             verticalPosition -= fontSize / 3 + 1;
875         else if (verticalAlign == TEXT_TOP)
876             verticalPosition += renderer->baselinePosition(baselineType(), firstLine, lineDirection) - fontMetrics.ascent(baselineType());
877         else if (verticalAlign == MIDDLE)
878             verticalPosition += -static_cast<int>(fontMetrics.xHeight() / 2) - renderer->lineHeight(firstLine, lineDirection) / 2 + renderer->baselinePosition(baselineType(), firstLine, lineDirection);
879         else if (verticalAlign == TEXT_BOTTOM) {
880             verticalPosition += fontMetrics.descent(baselineType());
881             // lineHeight - baselinePosition is always 0 for replaced elements (except inline blocks), so don't bother wasting time in that case.
882             if (!renderer->isReplaced() || renderer->isInlineBlockOrInlineTable())
883                 verticalPosition -= (renderer->lineHeight(firstLine, lineDirection) - renderer->baselinePosition(baselineType(), firstLine, lineDirection));
884         } else if (verticalAlign == BASELINE_MIDDLE)
885             verticalPosition += -renderer->lineHeight(firstLine, lineDirection) / 2 + renderer->baselinePosition(baselineType(), firstLine, lineDirection);
886         else if (verticalAlign == LENGTH) {
887             LayoutUnit lineHeight;
888             //Per http://www.w3.org/TR/CSS21/visudet.html#propdef-vertical-align: 'Percentages: refer to the 'line-height' of the element itself'.
889             if (renderer->style()->verticalAlignLength().isPercent())
890                 lineHeight = renderer->style()->computedLineHeight();
891             else
892                 lineHeight = renderer->lineHeight(firstLine, lineDirection);
893             verticalPosition -= valueForLength(renderer->style()->verticalAlignLength(), lineHeight, renderer->view());
894         }
895     }
896
897     // Store the cached value.
898     if (isRenderInline && !firstLine)
899         verticalPositionCache.set(renderer, baselineType(), verticalPosition);
900
901     return verticalPosition;
902 }
903
904 bool RootInlineBox::includeLeadingForBox(InlineBox* box) const
905 {
906     if (box->renderer()->isReplaced() || (box->renderer()->isText() && !box->isText()))
907         return false;
908
909     LineBoxContain lineBoxContain = renderer()->style()->lineBoxContain();
910     return (lineBoxContain & LineBoxContainInline) || (box == this && (lineBoxContain & LineBoxContainBlock));
911 }
912
913 bool RootInlineBox::includeFontForBox(InlineBox* box) const
914 {
915     if (box->renderer()->isReplaced() || (box->renderer()->isText() && !box->isText()))
916         return false;
917     
918     if (!box->isText() && box->isInlineFlowBox() && !toInlineFlowBox(box)->hasTextChildren())
919         return false;
920
921     // For now map "glyphs" to "font" in vertical text mode until the bounds returned by glyphs aren't garbage.
922     LineBoxContain lineBoxContain = renderer()->style()->lineBoxContain();
923     return (lineBoxContain & LineBoxContainFont) || (!isHorizontal() && (lineBoxContain & LineBoxContainGlyphs));
924 }
925
926 bool RootInlineBox::includeGlyphsForBox(InlineBox* box) const
927 {
928     if (box->renderer()->isReplaced() || (box->renderer()->isText() && !box->isText()))
929         return false;
930     
931     if (!box->isText() && box->isInlineFlowBox() && !toInlineFlowBox(box)->hasTextChildren())
932         return false;
933
934     // FIXME: We can't fit to glyphs yet for vertical text, since the bounds returned are garbage.
935     LineBoxContain lineBoxContain = renderer()->style()->lineBoxContain();
936     return isHorizontal() && (lineBoxContain & LineBoxContainGlyphs);
937 }
938
939 bool RootInlineBox::includeMarginForBox(InlineBox* box) const
940 {
941     if (box->renderer()->isReplaced() || (box->renderer()->isText() && !box->isText()))
942         return false;
943
944     LineBoxContain lineBoxContain = renderer()->style()->lineBoxContain();
945     return lineBoxContain & LineBoxContainInlineBox;
946 }
947
948
949 bool RootInlineBox::fitsToGlyphs() const
950 {
951     // FIXME: We can't fit to glyphs yet for vertical text, since the bounds returned are garbage.
952     LineBoxContain lineBoxContain = renderer()->style()->lineBoxContain();
953     return isHorizontal() && (lineBoxContain & LineBoxContainGlyphs);
954 }
955
956 bool RootInlineBox::includesRootLineBoxFontOrLeading() const
957 {
958     LineBoxContain lineBoxContain = renderer()->style()->lineBoxContain();
959     return (lineBoxContain & LineBoxContainBlock) || (lineBoxContain & LineBoxContainInline) || (lineBoxContain & LineBoxContainFont);
960 }
961
962 Node* RootInlineBox::getLogicalStartBoxWithNode(InlineBox*& startBox) const
963 {
964     Vector<InlineBox*> leafBoxesInLogicalOrder;
965     collectLeafBoxesInLogicalOrder(leafBoxesInLogicalOrder);
966     for (size_t i = 0; i < leafBoxesInLogicalOrder.size(); ++i) {
967         if (leafBoxesInLogicalOrder[i]->renderer()->node()) {
968             startBox = leafBoxesInLogicalOrder[i];
969             return startBox->renderer()->node();
970         }
971     }
972     startBox = 0;
973     return 0;
974 }
975     
976 Node* RootInlineBox::getLogicalEndBoxWithNode(InlineBox*& endBox) const
977 {
978     Vector<InlineBox*> leafBoxesInLogicalOrder;
979     collectLeafBoxesInLogicalOrder(leafBoxesInLogicalOrder);
980     for (size_t i = leafBoxesInLogicalOrder.size(); i > 0; --i) { 
981         if (leafBoxesInLogicalOrder[i - 1]->renderer()->node()) {
982             endBox = leafBoxesInLogicalOrder[i - 1];
983             return endBox->renderer()->node();
984         }
985     }
986     endBox = 0;
987     return 0;
988 }
989
990 #ifndef NDEBUG
991 const char* RootInlineBox::boxName() const
992 {
993     return "RootInlineBox";
994 }
995 #endif
996
997 } // namespace WebCore