[LayoutNG] Abort a layout once the BFC offset is resolved.

third_party/WebKit/Source/core/layout/ng/inline/ng_inline_layout_algorithm.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/inline/ng_inline_layout_algorithm.h"
 
 #include "core/layout/ng/inline/ng_bidi_paragraph.h"
 #include "core/layout/ng/inline/ng_inline_break_token.h"
 #include "core/layout/ng/inline/ng_inline_node.h"
 #include "core/layout/ng/inline/ng_line_box_fragment.h"
@@ skipping 38 matching lines @@
 }  // namespace
 
 NGInlineLayoutAlgorithm::NGInlineLayoutAlgorithm(
     NGInlineNode inline_node,
     NGConstraintSpace* space,
     NGInlineBreakToken* break_token)
     : NGLayoutAlgorithm(inline_node, space, break_token),
       is_horizontal_writing_mode_(
           blink::IsHorizontalWritingMode(space->WritingMode())),
       space_builder_(space) {
-  container_builder_.MutableUnpositionedFloats() = space->UnpositionedFloats();
+  unpositioned_floats_ = ConstraintSpace().UnpositionedFloats();
 
   if (!is_horizontal_writing_mode_)
     baseline_type_ = FontBaseline::kIdeographicBaseline;
 }
 
 bool NGInlineLayoutAlgorithm::CreateLine(
     NGLineInfo* line_info,
     RefPtr<NGInlineBreakToken> break_token) {
   if (Node().IsBidiEnabled())
     BidiReorder(&line_info->Results());
 
   if (!PlaceItems(line_info, break_token))
     return false;
 
   // If something has resolved our BFC offset we can place all of the
   // unpositioned floats below the current line.
   if (container_builder_.BfcOffset()) {
     NGLogicalOffset origin_point =
         GetOriginPointForFloats(ContainerBfcOffset(), content_size_);
     PositionPendingFloats(origin_point.block_offset, &container_builder_,
-                          MutableConstraintSpace());
+                          &unpositioned_floats_, MutableConstraintSpace());
   }
 
   return true;
 }
 
 void NGInlineLayoutAlgorithm::BidiReorder(NGInlineItemResults* line_items) {
   // TODO(kojii): UAX#9 L1 is not supported yet. Supporting L1 may change
   // embedding levels of parts of runs, which requires to split items.
   // http://unicode.org/reports/tr9/#L1
   // BidiResolver does not support L1 crbug.com/316409.
@@ skipping 314 matching lines @@
 
   return content_size;
 }
 
 RefPtr<NGLayoutResult> NGInlineLayoutAlgorithm::Layout() {
   // Line boxes should start at (0,0).
   // The parent NGBlockLayoutAlgorithm places the anonymous wrapper using the
   // border and padding of the container block.
   content_size_ = LayoutUnit();
 
-  // Check if we can resolve the BFC offset.
+  // We can resolve our BFC offset if we aren't an empty inline.
   if (!Node().IsEmptyInline()) {
     DCHECK(!container_builder_.BfcOffset());
     LayoutUnit bfc_block_offset = constraint_space_->BfcOffset().block_offset +
                                   constraint_space_->MarginStrut().Sum();
     MaybeUpdateFragmentBfcOffset(*constraint_space_, bfc_block_offset,
                                  &container_builder_);
-    PositionPendingFloats(bfc_block_offset, &container_builder_,
-                          constraint_space_);
+
+    // If we have unpositioned floats from a previous sibling, we need to abort
+    // our layout, and tell our parent that we now know our BFC offset.
+    if (!unpositioned_floats_.IsEmpty()) {
+      // TODO(ikilpatrick): This should be swapping in its unpositioned floats
+      // before aborting, but as because NGLayoutInputNode::IsInline isn't
+      // stable, we can't do this yet.
+      // container_builder_.SwapUnpositionedFloats(&unpositioned_floats_);
+      return container_builder_.Abort(NGLayoutResult::kBfcOffsetResolved);
+    }
   }
 
   NGLineBreaker line_breaker(Node(), constraint_space_, &container_builder_,
-                             BreakToken());
+                             &unpositioned_floats_, BreakToken());
   NGLineInfo line_info;
   while (line_breaker.NextLine(&line_info, {LayoutUnit(), content_size_}))
     CreateLine(&line_info, line_breaker.CreateBreakToken());
 
+  // Place any remaining floats which couldn't fit on the previous line.
+  // TODO(ikilpatrick): This is duplicated from CreateLine, but flushes any
+  // floats if we didn't create a line-box. Refactor this such that this isn't
+  // needed.
+  if (container_builder_.BfcOffset()) {
+    NGLogicalOffset origin_point =
+        GetOriginPointForFloats(ContainerBfcOffset(), content_size_);
+    PositionPendingFloats(origin_point.block_offset, &container_builder_,
+                          &unpositioned_floats_, MutableConstraintSpace());
+  }
+
   // TODO(kojii): Check if the line box width should be content or available.
   NGLogicalSize size(max_inline_size_, content_size_);
   container_builder_.SetSize(size).SetOverflowSize(size);
 
   // TODO(crbug.com/716930): We may be an empty LayoutInline due to splitting.
   // Margin struts shouldn't need to be passed through like this once we've
   // removed LayoutInline splitting.
   if (!container_builder_.BfcOffset()) {
     container_builder_.SetEndMarginStrut(ConstraintSpace().MarginStrut());
   }
 
+  // If we've got any unpositioned floats here, we must be an empty inline
+  // without a BFC offset. We need to pass our unpositioned floats to our next
+  // sibling.
+  if (!unpositioned_floats_.IsEmpty()) {
+    DCHECK(Node().IsEmptyInline());
+    DCHECK(!container_builder_.BfcOffset());
+    container_builder_.SwapUnpositionedFloats(&unpositioned_floats_);

[eae, 2017/07/10 23:27:49]

This is really neat.

[ikilpatrick, 2017/07/11 17:20:41]

Acknowledged.

+  }
+
   return container_builder_.ToBoxFragment();
 }
 
 }  // namespace blink