Include the whole outline into visual overflow

Source/core/layout/LayoutBlockFlowLine.cpp

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All right reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 1474 matching lines @@
         oldAutoWrap = autoWrap;
     }
 
     if (styleToUse.collapseWhiteSpace())
         stripTrailingSpace(inlineMax, inlineMin, trailingSpaceChild);
 
     minLogicalWidth = std::max(minLogicalWidth, inlineMin);
     maxLogicalWidth = std::max(maxLogicalWidth, inlineMax);
 }
 
+static bool isInlineWithOutlineAndContinuation(const LayoutObject& o)
+{
+    return o.isLayoutInline() && o.styleRef().hasOutline() && !o.isElementContinuation() && toLayoutInline(o).continuation();
+}
+
 void LayoutBlockFlow::layoutInlineChildren(bool relayoutChildren, LayoutUnit& paintInvalidationLogicalTop, LayoutUnit& paintInvalidationLogicalBottom, LayoutUnit afterEdge)
 {
     LayoutFlowThread* flowThread = flowThreadContainingBlock();
     bool clearLinesForPagination = firstLineBox() && flowThread && !flowThread->hasColumnSets();
 
     // Figure out if we should clear out our line boxes.
     // FIXME: Handle resize eventually!
     bool isFullLayout = !firstLineBox() || selfNeedsLayout() || relayoutChildren || clearLinesForPagination;
     LineLayoutState layoutState(isFullLayout, paintInvalidationLogicalTop, paintInvalidationLogicalBottom, flowThread);
 
@@ skipping 54 matching lines @@
                     else
                         o->layoutIfNeeded();
                 }
             } else if (o->isText() || (o->isLayoutInline() && !walker.atEndOfInline())) {
                 if (!o->isText())
                     toLayoutInline(o)->updateAlwaysCreateLineBoxes(layoutState.isFullLayout());
                 if (layoutState.isFullLayout() || o->selfNeedsLayout())
                     dirtyLineBoxesForObject(o, layoutState.isFullLayout());
                 o->clearNeedsLayout();
             }
+
+            if (isInlineWithOutlineAndContinuation(*o))
+                setContainsInlineWithOutlineAndContinuation(true);
         }
 
         for (size_t i = 0; i < replacedChildren.size(); i++)
             replacedChildren[i]->layoutIfNeeded();
 
         layoutRunsAndFloats(layoutState);
     }
 
     // Expand the last line to accommodate Ruby and emphasis marks.
     int lastLineAnnotationsAdjustment = 0;
@@ skipping 268 matching lines @@
 }
 
 void LayoutBlockFlow::addOverflowFromInlineChildren()
 {
     LayoutUnit endPadding = hasOverflowClip() ? paddingEnd() : LayoutUnit();
     for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) {
         addLayoutOverflow(curr->paddedLayoutOverflowRect(endPadding));
         LayoutRect visualOverflow = curr->visualOverflowRect(curr->lineTop(), curr->lineBottom());
         addContentsVisualOverflow(visualOverflow);
     }
+
+    if (!containsInlineWithOutlineAndContinuation())
+        return;
+
+    // Add outline rects of continuations of descendant inlines into visual overflow of this block.
+    LayoutRect outlineBoundsOfAllContinuations;
+    for (InlineWalker walker(this); !walker.atEnd(); walker.advance()) {
+        const LayoutObject& o = *walker.current();
+        if (!isInlineWithOutlineAndContinuation(o))
+            continue;
+
+        Vector<LayoutRect> outlineRects;
+        toLayoutInline(o).addOutlineRectsForContinuations(outlineRects, LayoutPoint());
+        LayoutRect outlineBounds = unionRect(outlineRects);
+        outlineBounds.inflate(o.styleRef().outlineOutsetExtent());

[chrishtr, 2015/08/27 23:14:52]

Why do you need to include the outset extent of the inline?

[Xianzhu, 2015/08/27 23:40:15]

The contents visual overflow of a block should cover all visual overflows of all
descendants, so should also cover outlines of descendant inlines.

Line 1859-1864 accumulates visual overflows of line boxes. The visual overflow
of a line boxe includes outline outsets as if they have the outline of the
intersecting LayoutInlines, but doesn't include outlines of LayoutInline
continuations, so line 1865-1882 accumulates visual overflow of continuations of
LayoutInlines.

Previously we propagated outline style to LayoutInline continuations and let the
continuation paint their own outlines. This didn't require the visual overflow
to include outline of continuations, but caused complex logic of continuation
outline painting. (You can see how https://codereview.chromium.org/1224933002/
simplifies continuation outline painting. The CL description also mentions
this.)

[chrishtr, 2015/08/28 00:10:05]

Sure, but why is o.styleRef().outlineOutsetExtent() part of the overflow of a
continuation?

[Xianzhu, 2015/08/28 00:24:09]

It's the visual outset of the outline outside of the outline rects. Outline
rects are just the rects that the outline will be drawn around of, doesn't
include the outline outset.

Added part of above as comment of LayoutObject::addOutlineRects().

+        outlineBoundsOfAllContinuations.unite(outlineBounds);
+    }
+    addContentsVisualOverflow(outlineBoundsOfAllContinuations);
 }
 
 void LayoutBlockFlow::deleteEllipsisLineBoxes()
 {
     ETextAlign textAlign = style()->textAlign();
     bool firstLine = true;
     for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) {
         if (curr->hasEllipsisBox()) {
             curr->clearTruncation();
 
@@ skipping 146 matching lines @@
     LayoutUnit logicalLeft = logicalLeftOffsetForLine(logicalHeight(), false);
     LayoutUnit availableLogicalWidth = logicalRightOffsetForLine(logicalHeight(), false) - logicalLeft;
     updateLogicalWidthForAlignment(textAlign, 0, 0, logicalLeft, totalLogicalWidth, availableLogicalWidth, 0);
 
     if (!style()->isLeftToRightDirection())
         return logicalWidth() - logicalLeft;
     return logicalLeft;
 }
 
 }