Reset constraint space's BFC offset if block creates a new FC

third_party/WebKit/Source/core/layout/ng/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/ng_inline_layout_algorithm.h"
 
 #include "core/layout/BidiRun.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/line/LineInfo.h"
 #include "core/layout/line/RootInlineBox.h"
@@ skipping 35 matching lines @@
       .SetIsShrinkToFit(ShouldShrinkToFit(parent_style, style))
       .ToConstraintSpace(FromPlatformWritingMode(style.getWritingMode()));
 }
 
 NGLogicalOffset GetOriginPointForFloats(const NGConstraintSpace& space,
                                         LayoutUnit content_size) {
   NGLogicalOffset origin_point = space.BfcOffset();
   origin_point.block_offset += content_size;
   return origin_point;
 }
-
-void PositionPendingFloats(const NGLogicalOffset& origin_point,
-                           NGConstraintSpace* space,
-                           NGFragmentBuilder* builder) {
-  DCHECK(builder) << "Builder cannot be null here";
-
-  for (auto& floating_object : builder->UnpositionedFloats()) {
-    NGLogicalOffset offset = PositionFloat(origin_point, space->BfcOffset(),
-                                           floating_object.get(), space);
-    builder->AddFloatingObject(floating_object, offset);
-  }
-  builder->MutableUnpositionedFloats().clear();
-}
-
 }  // namespace
 
 NGInlineLayoutAlgorithm::NGInlineLayoutAlgorithm(
     NGInlineNode* inline_node,
     NGConstraintSpace* space,
     NGInlineBreakToken* break_token)
     : NGLayoutAlgorithm(inline_node, space, break_token),
       container_builder_(NGPhysicalFragment::kFragmentBox, inline_node),
       is_horizontal_writing_mode_(
           blink::IsHorizontalWritingMode(space->WritingMode())),
       space_builder_(space)
 #if DCHECK_IS_ON()
       ,
       is_bidi_reordered_(false)
 #endif
 {
   if (!is_horizontal_writing_mode_)
     baseline_type_ = FontBaseline::IdeographicBaseline;
   if (break_token)
     Initialize(break_token->ItemIndex(), break_token->TextOffset());
   else
     Initialize(0, 0);
+
+  // BFC offset is known for inline fragments.
+  container_builder_.SetBfcOffset(space->BfcOffset());
 }
 
 bool NGInlineLayoutAlgorithm::CanFitOnLine() const {
   LayoutUnit available_size = current_opportunity_.InlineSize();
   if (available_size == NGSizeIndefinite)
     return true;
   return end_position_ <= available_size;
 }
 
 bool NGInlineLayoutAlgorithm::HasItems() const {
@@ skipping 170 matching lines @@
   start_offset_ = last_break_opportunity_offset_;
   DCHECK_GE(end_position_, last_break_opportunity_position_);
   end_position_ -= last_break_opportunity_position_;
   last_break_opportunity_position_ = LayoutUnit();
 #if DCHECK_IS_ON()
   is_bidi_reordered_ = false;
 #endif
 
   NGLogicalOffset origin_point =
       GetOriginPointForFloats(ConstraintSpace(), content_size_);
-  PositionPendingFloats(origin_point, MutableConstraintSpace(),
+  PositionPendingFloats(origin_point.block_offset, MutableConstraintSpace(),
                         &container_builder_);
   FindNextLayoutOpportunity();
   return true;
 }
 
 void NGInlineLayoutAlgorithm::BidiReorder(
     Vector<LineItemChunk, 32>* line_item_chunks) {
 #if DCHECK_IS_ON()
   DCHECK(!is_bidi_reordered_);
   is_bidi_reordered_ = true;
@@ skipping 39 matching lines @@
   // same writing mode - get the inline size ComputeInlineSizeForFragment to
   // determine if it fits on this line, then perform layout with the correct
   // fragmentation line.
   // diff writing mode - get the inline size from performing layout.
   RefPtr<NGLayoutResult> layout_result = node->Layout(float_space.get());
 
   NGBoxFragment float_fragment(
       float_space->WritingMode(),
       toNGPhysicalBoxFragment(layout_result->PhysicalFragment().get()));
 
+  NGLogicalOffset origin_offset =
+      GetOriginPointForFloats(ConstraintSpace(), content_size_);
+  NGLogicalOffset from_offset = ConstraintSpace().BfcOffset();
+  // TODO(glebl): add margins calculation.
+  NGBoxStrut margins;
   RefPtr<NGFloatingObject> floating_object = NGFloatingObject::Create(
-      float_space.get(), MutableConstraintSpace(), node->Style(), NGBoxStrut(),
-      current_opportunity_.size, layout_result->PhysicalFragment().get());
+      node->Style(), float_space->WritingMode(), current_opportunity_.size,
+      origin_offset, from_offset, margins,
+      layout_result->PhysicalFragment().get());
 
   bool float_does_not_fit = end_position + float_fragment.InlineSize() >
                             current_opportunity_.InlineSize();
   // Check if we already have a pending float. That's because a float cannot be
   // higher than any block or floated box generated before.
   if (!container_builder_.UnpositionedFloats().isEmpty() ||
       float_does_not_fit) {
     container_builder_.AddUnpositionedFloat(floating_object);
   } else {
-    NGLogicalOffset origin_point =
-        GetOriginPointForFloats(ConstraintSpace(), content_size_);
     NGLogicalOffset offset =
-        PositionFloat(origin_point, ConstraintSpace().BfcOffset(),
-                      floating_object.get(), MutableConstraintSpace());
+        PositionFloat(floating_object.get(), MutableConstraintSpace());
     container_builder_.AddFloatingObject(floating_object, offset);
     FindNextLayoutOpportunity();
   }
 }
 
 bool NGInlineLayoutAlgorithm::PlaceItems(
     const Vector<LineItemChunk, 32>& line_item_chunks) {
   const Vector<NGLayoutInlineItem>& items = Node()->Items();
 
   NGLineBoxFragmentBuilder line_box(Node());
@@ skipping 274 matching lines @@
     LayoutUnit baseline = line_top_with_leading + metrics.ascent_and_leading;
     root_line_box->setLineTopBottomPositions(
         baseline - metrics.ascent, baseline + metrics.descent,
         line_top_with_leading, baseline + metrics.descent_and_leading);
 
     bidi_runs.deleteRuns();
     fragments_for_bidi_runs.clear();
   }
 }
 }  // namespace blink