Restore behaviour of middle anonymous blocks inheriting style from inline parents

third_party/WebKit/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 328 matching lines @@
     beforeChild = lastChild();
 
   if (!newChild->isInline() && !newChild->isFloatingOrOutOfFlowPositioned() &&
       !newChild->isTablePart()) {
     // We are placing a block inside an inline. We have to perform a split of
     // this 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(
-            containingBlock()->styleRef(), EDisplay::kBlock);
+        ComputedStyle::createAnonymousStyleWithDisplay(styleRef(),
+                                                       EDisplay::kBlock);
+    // Block elements in the anon block must use the direction set by the
+    // anon block's containing block, so we need to prevent the anon block
+    // from inheriting direction from the inline. If there are any other
+    // inheritable properties that apply to block and inline elements
+    // but only affect the layout of children we will want to special-case
+    // them here too. Writing-mode would be one if it didn't create a
+    // formatting context of its own, removing the need for continuations.

[mstensho (USE GERRIT), 2017/04/19 09:32:48]

Great comment. Could you also add that this anonymous block doesn't exist in the
spec, and that that's the reason why we have to make sure that it has absolutely
no effect?

+    newStyle->setDirection(containingBlock()->styleRef().direction());
 
     // 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());
 
     LayoutBlockFlow* newBox = LayoutBlockFlow::createAnonymous(&document());
     newBox->setStyle(std::move(newStyle));
     LayoutBoxModelObject* oldContinuation = continuation();
@@ skipping 1174 matching lines @@
     paintInvalidator.invalidateDisplayItemClient(*box, invalidationReason);
 }
 
 // TODO(lunalu): Not to just dump 0, 0 as the x and y here
 LayoutRect LayoutInline::debugRect() const {
   IntRect linesBox = enclosingIntRect(linesBoundingBox());
   return LayoutRect(IntRect(0, 0, linesBox.width(), linesBox.height()));
 }
 
 }  // namespace blink