Fix style propagation to continuations

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 133 matching lines @@
 static LayoutObject* inFlowPositionedInlineAncestor(LayoutObject* p)
 {
     while (p && p->isLayoutInline()) {
         if (p->isRelPositioned())
             return p;
         p = p->parent();
     }
     return nullptr;
 }
 
-static void updateStyleOfAnonymousBlockContinuations(LayoutObject* block, const ComputedStyle& newStyle, const ComputedStyle& oldStyle)
+static void updateStyleOfAnonymousBlockContinuations(LayoutObject* block, const ComputedStyle& newStyle, const ComputedStyle& oldStyle, LayoutObject* containingBlockOfEndOfContinuation)
 {
-    for (;block && block->isAnonymousBlock(); block = block->nextSibling()) {
+    // 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;
 
-        RefPtr<ComputedStyle> newBlockStyle;
+        RefPtr<ComputedStyle> newBlockStyle = ComputedStyle::clone(block->styleRef());
 
-        if (!block->style()->isOutlineEquivalent(&newStyle)) {
-            newBlockStyle = ComputedStyle::clone(block->styleRef());
+        if (updateOutline)
             newBlockStyle->setOutlineFromStyle(newStyle);
-        }
 
-        if (block->style()->position() != newStyle.position()) {
+        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()))
+            if (oldStyle.hasInFlowPosition() && inFlowPositionedInlineAncestor(toLayoutBlock(block)->inlineElementContinuation()))
                 continue;
-            if (!newBlockStyle)
-                newBlockStyle = ComputedStyle::clone(block->styleRef());
             newBlockStyle->setPosition(newStyle.position());
         }
 
-        if (newBlockStyle)
-            block->setStyle(newBlockStyle);
+        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 an inline's outline or in-flow positioning has changed then any descendant blocks will need to change their styles accordingly.
-    // Do this by updating the styles of the descendant blocks' containing anonymous blocks - there may be more than one.
-    if (continuation && oldStyle
-        && (!newStyle.isOutlineEquivalent(oldStyle)
-            || (newStyle.position() != oldStyle->position() && (newStyle.hasInFlowPosition() || oldStyle->hasInFlowPosition())))) {
-        // If any descendant blocks exist then they will be in the next anonymous block and its siblings.
+    if (continuation && oldStyle) {
+        ASSERT(endOfContinuation);
         LayoutObject* block = containingBlock()->nextSibling();
         if (block && block->isAnonymousBlock())
-            updateStyleOfAnonymousBlockContinuations(block, newStyle, *oldStyle);
+            updateStyleOfAnonymousBlockContinuations(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 1207 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