[LayoutNG] Handle floats/OOF at the beginning of inline in inline context

third_party/WebKit/Source/core/layout/ng/ng_block_node.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/ng/ng_block_node.h"
 
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutMultiColumnFlowThread.h"
 #include "core/layout/LayoutMultiColumnSet.h"
 #include "core/layout/api/LineLayoutAPIShim.h"
@@ skipping 185 matching lines @@
 
 const ComputedStyle& NGBlockNode::Style() const {
   return layout_box_->StyleRef();
 }
 
 NGLayoutInputNode* NGBlockNode::NextSibling() {
   if (!next_sibling_) {
     LayoutObject* next_sibling = layout_box_->NextSibling();
     if (next_sibling) {
       if (next_sibling->IsInline()) {
+        // As long as we traverse LayoutObject tree, this should not happen.
+        // See ShouldHandleByInlineContext() for more context.
+        // Also this leads to incorrect layout because we create two
+        // NGLayoutInputNode for one LayoutBlockFlow.
+        NOTREACHED();
         next_sibling_ = new NGInlineNode(
             next_sibling, ToLayoutBlockFlow(layout_box_->Parent()));
       } else {
         next_sibling_ = new NGBlockNode(next_sibling);
       }
     }
   }
   return next_sibling_;
 }
 
 LayoutObject* NGBlockNode::GetLayoutObject() {
   return layout_box_;
 }
 
+static bool ShouldHandleByInlineContext(LayoutObject* child) {
+  DCHECK(child);
+  // The spec isn't clear about whether floats/OOF should be in inline
+  // formatting context or in block formatting context.
+  // Prefer inline formatting context because 1) floats/OOF at the beginning
+  // and in the middle of inline should be handled in the same code, and 2)
+  // it matches to the LayoutObject tree.
+  for (; child; child = child->NextSibling()) {
+    if (child->IsInline())
+      return true;
+    if (child->IsFloating() || child->IsOutOfFlowPositioned())
+      continue;
+    return false;
+  }
+  // All children are either float or OOF.
+  // TODO(kojii): Should this be handled in block context or inline context?
+  // If we handle in inline, we can remove all code for floats/OOF from block
+  // layout, but it may change semantics and causes incorrectness?
+  return false;
+}
+
 NGLayoutInputNode* NGBlockNode::FirstChild() {
   if (!first_child_) {
     LayoutObject* child = layout_box_->SlowFirstChild();
     if (child) {
-      if (child->IsInline()) {
+      if (ShouldHandleByInlineContext(child)) {
         first_child_ = new NGInlineNode(child, ToLayoutBlockFlow(layout_box_));
       } else {
         first_child_ = new NGBlockNode(child);
       }
     }
   }
   return first_child_;
 }
 
 DEFINE_TRACE(NGBlockNode) {
@@ skipping 126 matching lines @@
 
 // Save static position for legacy AbsPos layout.
 void NGBlockNode::SaveStaticOffsetForLegacy(const NGLogicalOffset& offset) {
   DCHECK(layout_box_->IsOutOfFlowPositioned());
   DCHECK(layout_box_->Layer());
   layout_box_->Layer()->SetStaticBlockPosition(offset.block_offset);
   layout_box_->Layer()->SetStaticInlinePosition(offset.inline_offset);
 }
 
 }  // namespace blink