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