Introduce NGFloatingObject

third_party/WebKit/Source/core/layout/ng/ng_fragment_builder.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_fragment_builder.h"
 
 #include "core/layout/ng/ng_block_node.h"
 #include "core/layout/ng/ng_break_token.h"
 #include "core/layout/ng/ng_fragment.h"
 #include "core/layout/ng/ng_physical_box_fragment.h"
@@ skipping 51 matching lines @@
   size_t oof_index = 0;
   for (auto& oof_node : physical_fragment->OutOfFlowDescendants()) {
     NGStaticPosition oof_position = oof_positions[oof_index++];
     out_of_flow_descendant_candidates_.add(oof_node);
     out_of_flow_candidate_placements_.push_back(
         OutOfFlowPlacement{child_offset, oof_position});
   }
   return *this;
 }
 
+NGFragmentBuilder& NGFragmentBuilder::AddFloatingObject(
+    NGFloatingObject* floating_object,
+    const NGLogicalOffset& floating_object_offset) {
+  positioned_floats_.append(floating_object);
+  floating_object_offsets_.append(floating_object_offset);
+  return *this;
+}
+
 NGFragmentBuilder& NGFragmentBuilder::AddOutOfFlowChildCandidate(
     NGBlockNode* child,
     NGLogicalOffset child_offset) {
   out_of_flow_descendant_candidates_.add(child);
   NGStaticPosition child_position =
       NGStaticPosition::Create(writing_mode_, direction_, NGPhysicalOffset());
   out_of_flow_candidate_placements_.push_back(
       OutOfFlowPlacement{child_offset, child_position});
   child->SaveStaticOffsetForLegacy(child_offset);
   return *this;
 }
 
+NGFragmentBuilder& NGFragmentBuilder::AddUnpositionedFloat(
+    NGFloatingObject* floating_object) {
+  unpositioned_floats_.append(floating_object);
+  return *this;
+}
+
 void NGFragmentBuilder::GetAndClearOutOfFlowDescendantCandidates(
     WeakBoxList* descendants,
     Vector<NGStaticPosition>* descendant_positions) {
   DCHECK(descendants->isEmpty());
   DCHECK(descendant_positions->isEmpty());
 
   DCHECK_GE(size_.inline_size, LayoutUnit());
   DCHECK_GE(size_.block_size, LayoutUnit());
   NGPhysicalSize builder_physical_size{size_.ConvertToPhysical(writing_mode_)};
 
@@ skipping 50 matching lines @@
   NGPhysicalSize physical_size = size_.ConvertToPhysical(writing_mode_);
   HeapVector<Member<const NGPhysicalFragment>> children;
   children.reserveCapacity(children_.size());
 
   for (size_t i = 0; i < children_.size(); ++i) {
     NGPhysicalFragment* child = children_[i].get();
     child->SetOffset(offsets_[i].ConvertToPhysical(
         writing_mode_, direction_, physical_size, child->Size()));
     children.push_back(child);
   }
+
+  HeapVector<Member<NGFloatingObject>> positioned_floats;
+  positioned_floats.reserveCapacity(positioned_floats_.size());
+
+  for (size_t i = 0; i < positioned_floats_.size(); ++i) {
+    Member<NGFloatingObject>& floating_object = positioned_floats_[i];
+    NGPhysicalFragment* floating_fragment = floating_object->fragment;
+    floating_fragment->SetOffset(floating_object_offsets_[i].ConvertToPhysical(
+        writing_mode_, direction_, physical_size, floating_fragment->Size()));
+    positioned_floats.append(floating_object);
+  }
+
   return new NGPhysicalBoxFragment(
       physical_size, overflow_.ConvertToPhysical(writing_mode_), children,
       out_of_flow_descendants_, out_of_flow_positions_, margin_strut_,
-      break_token);
+      unpositioned_floats_, positioned_floats_, break_token);
 }
 
 NGPhysicalTextFragment* NGFragmentBuilder::ToTextFragment(NGInlineNode* node,
                                                           unsigned start_index,
                                                           unsigned end_index) {
   DCHECK_EQ(type_, NGPhysicalFragment::kFragmentText);
   DCHECK(children_.isEmpty());
   DCHECK(offsets_.isEmpty());
+
+  HeapVector<Member<NGFloatingObject>> empty_unpositioned_floats;
+  HeapVector<Member<NGFloatingObject>> empty_positioned_floats;
+
   return new NGPhysicalTextFragment(
       node, start_index, end_index, size_.ConvertToPhysical(writing_mode_),
       overflow_.ConvertToPhysical(writing_mode_), out_of_flow_descendants_,
-      out_of_flow_positions_);
+      out_of_flow_positions_, empty_unpositioned_floats,
+      empty_positioned_floats);
 }
 
 DEFINE_TRACE(NGFragmentBuilder) {
   visitor->trace(children_);
   visitor->trace(out_of_flow_descendant_candidates_);
   visitor->trace(out_of_flow_descendants_);
   visitor->trace(break_token_);

[ikilpatrick, 2017/01/20 18:11:14]

.nit ordering if changed in header.

[Gleb Lanbin, 2017/01/20 21:21:59]

Done.

+  visitor->trace(positioned_floats_);
+  visitor->trace(unpositioned_floats_);
 }
 
 }  // namespace blink