src/third_party/WebKit/Source/core/rendering/InlineFlowBox.cpp

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