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 34 matching lines @@
 #include "platform/text/BidiResolver.h"
 #include "wtf/RefCountedLeakCounter.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
 #include "wtf/text/CharacterNames.h"
 
 namespace blink {
 
 using namespace WTF::Unicode;
 
+typedef WTF::HashMap<LayoutBlockFlow*, HashSet<LayoutInline*>> InlinesWithOutlineAndContinuationMap;
+static InlinesWithOutlineAndContinuationMap* gInlinesWithOutlineAndContinuationMap = nullptr;
+
 static inline InlineBox* createInlineBoxForLayoutObject(LayoutObject* obj, bool isRootLineBox, bool isOnlyRun = false)
 {
     // Callers should handle text themselves.
     ASSERT(!obj->isText());
 
     if (isRootLineBox)
         return toLayoutBlockFlow(obj)->createAndAppendRootInlineBox();
 
     if (obj->isBox())
         return toLayoutBox(obj)->createInlineBox();
@@ skipping 1417 matching lines @@
         oldAutoWrap = autoWrap;
     }
 
     if (styleToUse.collapseWhiteSpace())
         stripTrailingSpace(inlineMax, inlineMin, trailingSpaceChild);
 
     minLogicalWidth = std::max(minLogicalWidth, inlineMin);
     maxLogicalWidth = std::max(maxLogicalWidth, inlineMax);
 }
 
+void LayoutBlockFlow::removeInlinesWithOutlineAndContinuation()
+{
+    if (gInlinesWithOutlineAndContinuationMap)
+        gInlinesWithOutlineAndContinuationMap->remove(this);
+}
+
+void LayoutBlockFlow::addInlineWithOutlineAndContinuation(LayoutInline* layoutInline)
+{
+    if (!gInlinesWithOutlineAndContinuationMap)
+        gInlinesWithOutlineAndContinuationMap = new InlinesWithOutlineAndContinuationMap;
+    gInlinesWithOutlineAndContinuationMap->add(this, HashSet<LayoutInline*>()).storedValue->value.add(layoutInline);
+}
+
 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 13 matching lines @@
     // difficult to figure out in general (especially in the middle of doing layout), so we only handle the
     // simple case of an anonymous block truncating when it's parent is clipped.
     bool hasTextOverflow = (style()->textOverflow() && hasOverflowClip())
         || (isAnonymousBlock() && parent() && parent()->isLayoutBlock() && toLayoutBlock(parent())->canCollapseAnonymousBlockChild()
             && parent()->style()->textOverflow() && parent()->hasOverflowClip());
 
     // Walk all the lines and delete our ellipsis line boxes if they exist.
     if (hasTextOverflow)
         deleteEllipsisLineBoxes();
 
+    removeInlinesWithOutlineAndContinuation();
+
     if (firstChild()) {
         // In full layout mode, clear the line boxes of children upfront. Otherwise,
         // siblings can run into stale root lineboxes during layout. Then layout
         // the replaced elements later. In partial layout mode, line boxes are not
         // deleted and only dirtied. In that case, we can layout the replaced
         // elements at the same time.
         Vector<LayoutBox*> replacedChildren;
         LayoutObject* lastChild = nullptr;
         for (InlineWalker walker(this); !walker.atEnd(); walker.advance()) {
             LayoutObject* o = walker.current();
@@ skipping 24 matching lines @@
                 }
             } 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 (!o->isText() || !toLayoutText(o)->isAllCollapsibleWhitespace())
                 lastChild = o;
+
+            if (o->isLayoutInline() && o->styleRef().hasOutline() && !o->isElementContinuation() && toLayoutInline(o)->continuation())
+                addInlineWithOutlineAndContinuation(toLayoutInline(o));
         }
         // If there is a trailing float on the line that will possibly occur after a natural line break
         // then dirty its adjacent lineboxes to ensure it gets placed.
         if (lastChild && lastChild->isFloating())
             dirtyLinesFromChangedChild(lastChild);
 
         for (size_t i = 0; i < replacedChildren.size(); i++)
             replacedChildren[i]->layoutIfNeeded();
 
         layoutRunsAndFloats(layoutState);
@@ skipping 277 matching lines @@
 {
     LayoutUnit endPadding = hasOverflowClip() ? paddingEnd() : LayoutUnit();
     // FIXME: Need to find another way to do this, since scrollbars could show when we don't want them to.
     if (hasOverflowClip() && !endPadding && node() && node()->isRootEditableElement() && style()->isLeftToRightDirection())
         endPadding = 1;
     for (RootInlineBox* curr = firstRootBox(); curr; curr = curr->nextRootBox()) {
         addLayoutOverflow(curr->paddedLayoutOverflowRect(endPadding));
         LayoutRect visualOverflow = curr->visualOverflowRect(curr->lineTop(), curr->lineBottom());
         addContentsVisualOverflow(visualOverflow);
     }
+
+    if (!gInlinesWithOutlineAndContinuationMap)
+        return;
+    InlinesWithOutlineAndContinuationMap::const_iterator it = gInlinesWithOutlineAndContinuationMap->find(this);
+    if (it == gInlinesWithOutlineAndContinuationMap->end() || it->value.isEmpty())
+        return;
+
+    // Add outline rects of continuations of descendant inlines into visual overflow of this block.
+    LayoutRect outlineBoundsOfAllContinuations;
+    for (LayoutInline* flow : it->value) {
+        Vector<LayoutRect> outlineRects;
+        flow->addOutlineRectsForContinuations(outlineRects, LayoutPoint());
+        LayoutRect outlineBounds = unionRect(outlineRects);
+        outlineBounds.inflate(flow->styleRef().outlineOutsetExtent());
+        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;
 }
 
 }