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