Combine outline and focus ring code paths

Source/core/layout/LayoutInline.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple 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 50 matching lines @@
 
 LayoutInline* LayoutInline::createAnonymous(Document* document)
 {
     LayoutInline* layoutObject = new LayoutInline(nullptr);
     layoutObject->setDocumentForAnonymous(document);
     return layoutObject;
 }
 
 void LayoutInline::willBeDestroyed()
 {
-#if ENABLE(ASSERT)
-    // Make sure we do not retain "this" in the continuation outline table map of our containing blocks.
-    if (parent() && style()->visibility() == VISIBLE && style()->hasOutline()) {
-        bool containingBlockPaintsContinuationOutline = continuation() || isInlineElementContinuation();
-        if (containingBlockPaintsContinuationOutline) {
-            if (LayoutBlock* cb = containingBlock()) {
-                if (LayoutBlock* cbCb = cb->containingBlock())
-                    ASSERT(!cbCb->paintsContinuationOutline(this));
-            }
-        }
-    }
-#endif
-
     // Make sure to destroy anonymous children first while they are still connected to the rest of the tree, so that they will
     // properly dirty line boxes that they are removed from.  Effects that do :before/:after only on hover could crash otherwise.
     children()->destroyLeftoverChildren();
 
     // Destroy our continuation before anything other than anonymous children.
     // The reason we don't destroy it before anonymous children is that they may
     // have continuations of their own that are anonymous children of our continuation.
     LayoutBoxModelObject* continuation = this->continuation();
     if (continuation) {
         continuation->destroy();
@@ skipping 51 matching lines @@
 static LayoutObject* inFlowPositionedInlineAncestor(LayoutObject* p)
 {
     while (p && p->isLayoutInline()) {
         if (p->isInFlowPositioned())
             return p;
         p = p->parent();
     }
     return nullptr;
 }
 
-static void updateStyleOfAnonymousBlockContinuations(LayoutObject* block, const ComputedStyle& newStyle, const ComputedStyle& oldStyle, LayoutObject* containingBlockOfEndOfContinuation)
+static void updateInFlowPositionOfAnonymousBlockContinuations(LayoutObject* block, const ComputedStyle& newStyle, const ComputedStyle& oldStyle, LayoutObject* containingBlockOfEndOfContinuation)
 {
-    // If an inline's outline or in-flow positioning has changed then any descendant blocks will need to change their styles accordingly.
-    bool updateOutline = !newStyle.isOutlineEquivalent(&oldStyle);
-    bool updatePosition = newStyle.position() != oldStyle.position() && (newStyle.hasInFlowPosition() || oldStyle.hasInFlowPosition());
-    if (!updateOutline && !updatePosition)
-        return;
-
     for (; block && block != containingBlockOfEndOfContinuation && block->isAnonymousBlock(); block = block->nextSibling()) {
         if (!toLayoutBlock(block)->isAnonymousBlockContinuation())
             continue;
 
+        // If we are no longer in-flow positioned but our descendant block(s) still have an in-flow positioned ancestor then
+        // their containing anonymous block should keep its in-flow positioning.
+        if (oldStyle.hasInFlowPosition() && inFlowPositionedInlineAncestor(toLayoutBlock(block)->inlineElementContinuation()))
+            continue;
+
         RefPtr<ComputedStyle> newBlockStyle = ComputedStyle::clone(block->styleRef());
-
-        if (updateOutline)
-            newBlockStyle->setOutlineFromStyle(newStyle);
-
-        if (updatePosition) {
-            // If we are no longer in-flow positioned but our descendant block(s) still have an in-flow positioned ancestor then
-            // their containing anonymous block should keep its in-flow positioning.
-            if (oldStyle.hasInFlowPosition() && inFlowPositionedInlineAncestor(toLayoutBlock(block)->inlineElementContinuation()))
-                continue;
-            newBlockStyle->setPosition(newStyle.position());
-        }
-
+        newBlockStyle->setPosition(newStyle.position());
         block->setStyle(newBlockStyle);
     }
 }
 
 void LayoutInline::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     LayoutBoxModelObject::styleDidChange(diff, oldStyle);
 
     // Ensure that all of the split inlines pick up the new style. We
     // only do this if we're an inline, since we don't want to propagate
     // a block's style to the other inlines.
     // e.g., <font>foo <h4>goo</h4> moo</font>.  The <font> inlines before
     // and after the block share the same style, but the block doesn't
     // need to pass its style on to anyone else.
     const ComputedStyle& newStyle = styleRef();
     LayoutInline* continuation = inlineElementContinuation();
     LayoutInline* endOfContinuation = nullptr;
     for (LayoutInline* currCont = continuation; currCont; currCont = currCont->inlineElementContinuation()) {
         LayoutBoxModelObject* nextCont = currCont->continuation();
         currCont->setContinuation(nullptr);
         currCont->setStyle(mutableStyle());
         currCont->setContinuation(nextCont);
         endOfContinuation = currCont;
     }
 
     if (continuation && oldStyle) {
         ASSERT(endOfContinuation);
         LayoutObject* block = containingBlock()->nextSibling();
-        if (block && block->isAnonymousBlock())
-            updateStyleOfAnonymousBlockContinuations(block, newStyle, *oldStyle, endOfContinuation->containingBlock());
+        // If an inline's in-flow positioning has changed then any descendant blocks will need to change their styles accordingly.
+        if (block && block->isAnonymousBlock()
+            && newStyle.position() != oldStyle->position()
+            && (newStyle.hasInFlowPosition() || oldStyle->hasInFlowPosition()))
+            updateInFlowPositionOfAnonymousBlockContinuations(block, newStyle, *oldStyle, endOfContinuation->containingBlock());
     }
 
     if (!alwaysCreateLineBoxes()) {
         bool alwaysCreateLineBoxesNew = hasSelfPaintingLayer() || hasBoxDecorationBackground() || newStyle.hasPadding() || newStyle.hasMargin() || newStyle.hasOutline();
         if (oldStyle && alwaysCreateLineBoxesNew) {
             dirtyLineBoxes(false);
             setNeedsLayoutAndFullPaintInvalidation(LayoutInvalidationReason::StyleChange);
         }
         setAlwaysCreateLineBoxes(alwaysCreateLineBoxesNew);
     }
@@ skipping 109 matching lines @@
         // inline into continuations.  This involves creating an anonymous block box to hold
         // |newChild|.  We then make that block box a continuation of this inline.  We take all of
         // the children after |beforeChild| and put them in a clone of this object.
         RefPtr<ComputedStyle> newStyle = ComputedStyle::createAnonymousStyleWithDisplay(styleRef(), BLOCK);
 
         // If inside an inline affected by in-flow positioning the block needs to be affected by it too.
         // Giving the block a layer like this allows it to collect the x/y offsets from inline parents later.
         if (LayoutObject* positionedAncestor = inFlowPositionedInlineAncestor(this))
             newStyle->setPosition(positionedAncestor->style()->position());
 
-        // Push outline style to the block continuation.
-        if (!newStyle->isOutlineEquivalent(style()))
-            newStyle->setOutlineFromStyle(*style());
-
         LayoutBlockFlow* newBox = LayoutBlockFlow::createAnonymous(&document());
         newBox->setStyle(newStyle.release());
         LayoutBoxModelObject* oldContinuation = continuation();
         setContinuation(newBox);
 
         splitFlow(beforeChild, newBox, newChild, oldContinuation);
         return;
     }
 
     LayoutBoxModelObject::addChild(newChild, beforeChild);
@@ skipping 1088 matching lines @@
 }
 
 void LayoutInline::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer) const
 {
     LayoutBoxModelObject::invalidateDisplayItemClients(paintInvalidationContainer);
     for (InlineFlowBox* box = firstLineBox(); box; box = box->nextLineBox())
         paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box);
 }
 
 } // namespace blink