Cleanup RenderInline style propagation to continuations

Source/core/rendering/RenderInline.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 144 matching lines @@
     }
     return 0;
 }
 
 static void updateStyleOfAnonymousBlockContinuations(RenderObject* block, const RenderStyle* newStyle, const RenderStyle* oldStyle)
 {
     for (;block && block->isAnonymousBlock(); block = block->nextSibling()) {
         if (!toRenderBlock(block)->isAnonymousBlockContinuation())
             continue;
 
+        RefPtr<RenderStyle> newBlockStyle;
+
         if (!block->style()->isOutlineEquivalent(newStyle)) {
-            RefPtr<RenderStyle> blockStyle = RenderStyle::clone(block->style());
-            blockStyle->setOutlineFromStyle(*newStyle);
-            block->setStyle(blockStyle);
+            newBlockStyle = RenderStyle::clone(block->style());
+            newBlockStyle->setOutlineFromStyle(*newStyle);
         }
 
         if (block->style()->position() != newStyle->position()) {
             // 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(toRenderBlock(block)->inlineElementContinuation()))
                 continue;
-            // FIXME: We should share blockStyle with the outline case, but it fails layout tests
-            // for dynamic position change of inlines containing block continuations. crbug.com/405222.
-            RefPtr<RenderStyle> blockStyle = RenderStyle::createAnonymousStyleWithDisplay(block->style(), BLOCK);
-            blockStyle->setPosition(newStyle->position());
-            block->setStyle(blockStyle);
+            if (!newBlockStyle)
+                newBlockStyle = RenderStyle::clone(block->style());
+            newBlockStyle->setPosition(newStyle->position());
         }
+
+        if (newBlockStyle)
+            block->setStyle(newBlockStyle);
     }
 }
 
 void RenderInline::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 {
     RenderBoxModelObject::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.
     RenderStyle* newStyle = style();
     RenderInline* continuation = inlineElementContinuation();
     for (RenderInline* currCont = continuation; currCont; currCont = currCont->inlineElementContinuation()) {
         RenderBoxModelObject* nextCont = currCont->continuation();
         currCont->setContinuation(0);
         currCont->setStyle(newStyle);
         currCont->setContinuation(nextCont);
     }
 
-    // If an inline's in-flow positioning has changed then any descendant blocks will need to change their in-flow positioning accordingly.
-    // Do this by updating the position of the descendant blocks' containing anonymous blocks - there may be more than one.
+    // 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.
         RenderObject* block = containingBlock()->nextSibling();
         if (block && block->isAnonymousBlock())
             updateStyleOfAnonymousBlockContinuations(block, newStyle, oldStyle);
     }
 
     if (!alwaysCreateLineBoxes()) {
         bool alwaysCreateLineBoxesNew = hasSelfPaintingLayer() || hasBoxDecorationBackground() || newStyle->hasPadding() || newStyle->hasMargin() || newStyle->hasOutline();
         if (oldStyle && alwaysCreateLineBoxesNew) {
             dirtyLineBoxes(false);
             setNeedsLayoutAndFullPaintInvalidation();
         }
         setAlwaysCreateLineBoxes(alwaysCreateLineBoxesNew);
     }
 }
 
-void RenderInline::setContinuation(RenderBoxModelObject* continuation)
-{
-    RenderBoxModelObject::setContinuation(continuation);
-    if (continuation && continuation->isAnonymousBlock() && !continuation->style()->isOutlineEquivalent(style())) {
-        // Push outline style to the block continuation.
-        RefPtr<RenderStyle> blockStyle = RenderStyle::clone(continuation->style());
-        blockStyle->setOutlineFromStyle(*style());
-        continuation->setStyle(blockStyle);
-    }
-    // FIXME: What if continuation is added when the inline has relative position? crbug.com/405222.
-}
-
 void RenderInline::updateAlwaysCreateLineBoxes(bool fullLayout)
 {
     // Once we have been tainted once, just assume it will happen again. This way effects like hover highlighting that change the
     // background color will only cause a layout on the first rollover.
     if (alwaysCreateLineBoxes())
         return;
 
     RenderStyle* parentStyle = parent()->style();
     RenderInline* parentRenderInline = parent()->isRenderInline() ? toRenderInline(parent()) : 0;
     bool checkFonts = document().inNoQuirksMode();
@@ skipping 94 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<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), 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 (RenderObject* positionedAncestor = inFlowPositionedInlineAncestor(this))
             newStyle->setPosition(positionedAncestor->style()->position());
 
+        if (!newStyle->isOutlineEquivalent(style()))

[Julien - ping for review, 2014/09/05 19:57:35]

I would put a comment here to explain why this is needed.

[Xianzhu, 2014/09/05 22:04:16]

Done.

+            newStyle->setOutlineFromStyle(*style());
+
         RenderBlockFlow* newBox = RenderBlockFlow::createAnonymous(&document());
         newBox->setStyle(newStyle.release());
         RenderBoxModelObject* oldContinuation = continuation();
         setContinuation(newBox);
 
         splitFlow(beforeChild, newBox, newChild, oldContinuation);
         return;
     }
 
     RenderBoxModelObject::addChild(newChild, beforeChild);
@@ skipping 1245 matching lines @@
         container = this;
 
     FloatPoint absPos = container->localToAbsolute();
     region.bounds.setX(absPos.x() + region.bounds.x());
     region.bounds.setY(absPos.y() + region.bounds.y());
 
     regions.append(region);
 }
 
 } // namespace blink