[LayoutNG] Move NGFloatingObject off Oilpan

third_party/WebKit/Source/core/layout/ng/ng_block_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_block_layout_algorithm.h"
 
 #include "core/layout/ng/ng_absolute_utils.h"
 #include "core/layout/ng/ng_block_break_token.h"
 #include "core/layout/ng/ng_block_child_iterator.h"
 #include "core/layout/ng/ng_box_fragment.h"
@@ skipping 145 matching lines @@
   }
   return opportunity;
 }
 
 // Calculates the logical offset for opportunity.
 NGLogicalOffset CalculateLogicalOffsetForOpportunity(
     const NGLayoutOpportunity& opportunity,
     const LayoutUnit float_offset,
     const NGLogicalOffset& from_offset,
     NGFloatingObject* floating_object) {
+  DCHECK(floating_object);
   auto margins = floating_object->margins;
   // Adjust to child's margin.
   LayoutUnit inline_offset = margins.inline_start;
   LayoutUnit block_offset = margins.block_start;
 
   // Offset from the opportunity's block/inline start.
   inline_offset += opportunity.offset.inline_offset;
   block_offset += opportunity.offset.block_offset;
 
   // Adjust to float: right offset if needed.
   inline_offset += float_offset;
 
   block_offset -= from_offset.block_offset;
   inline_offset -= from_offset.inline_offset;
 
   return NGLogicalOffset(inline_offset, block_offset);
 }
 
 // Calculates the relative position from {@code from_offset} of the
 // floating object that is requested to be positioned from {@code origin_point}.
 NGLogicalOffset PositionFloat(const NGLogicalOffset& origin_point,
                               const NGLogicalOffset& from_offset,
                               NGFloatingObject* floating_object,
                               NGConstraintSpace* new_parent_space) {
+  DCHECK(floating_object);
   const auto* float_space = floating_object->space.get();
   DCHECK(floating_object->fragment) << "Fragment cannot be null here";
 
   // TODO(ikilpatrick): The writing mode switching here looks wrong.
   NGBoxFragment float_fragment(
       float_space->WritingMode(),
       toNGPhysicalBoxFragment(floating_object->fragment.get()));
 
   // Find a layout opportunity that will fit our float.
   const NGLayoutOpportunity opportunity = FindLayoutOpportunityForFragment(
@@ skipping 13 matching lines @@
       float_fragment, opportunity, float_offset, floating_object->margins,
       floating_object->exclusion_type);
   new_parent_space->AddExclusion(exclusion);
 
   return CalculateLogicalOffsetForOpportunity(opportunity, float_offset,
                                               from_offset, floating_object);
 }
 
 // Updates the Floating Object's left offset from the provided parent_space
 // and {@code floating_object}'s space and margins.
-void UpdateFloatingObjectLeftOffset(
-    const NGConstraintSpace& new_parent_space,
-    const Persistent<NGFloatingObject>& floating_object,
-    const NGLogicalOffset& float_logical_offset) {
+void UpdateFloatingObjectLeftOffset(const NGConstraintSpace& new_parent_space,
+                                    const NGLogicalOffset& float_logical_offset,
+                                    NGFloatingObject* floating_object) {
+  DCHECK(floating_object);
   // TODO(glebl): We should use physical offset here.
   floating_object->left_offset =
       floating_object->original_parent_space->BfcOffset().inline_offset -
       new_parent_space.BfcOffset().inline_offset +
       float_logical_offset.inline_offset;
 }
 
 // Positions pending floats stored on the fragment builder starting from
 // {@code origin_point_block_offset}.
 void PositionPendingFloats(const LayoutUnit origin_point_block_offset,
                            NGConstraintSpace* new_parent_space,
                            NGFragmentBuilder* builder) {
   DCHECK(builder->BfcOffset()) << "Parent BFC offset should be known here";
   LayoutUnit bfc_block_offset = builder->BfcOffset().value().block_offset;
 
   for (auto& floating_object : builder->UnpositionedFloats()) {
     const auto* float_space = floating_object->space.get();
     const NGConstraintSpace* original_parent_space =
         floating_object->original_parent_space.get();
 
     NGLogicalOffset origin_point = {float_space->BfcOffset().inline_offset,
                                     origin_point_block_offset};
     NGLogicalOffset from_offset = {
         original_parent_space->BfcOffset().inline_offset, bfc_block_offset};
 
     NGLogicalOffset float_fragment_offset = PositionFloat(
-        origin_point, from_offset, floating_object, new_parent_space);
+        origin_point, from_offset, floating_object.get(), new_parent_space);
     builder->AddFloatingObject(floating_object, float_fragment_offset);
-    UpdateFloatingObjectLeftOffset(*new_parent_space, floating_object,
-                                   float_fragment_offset);
+    UpdateFloatingObjectLeftOffset(*new_parent_space, float_fragment_offset,
+                                   floating_object.get());
   }
   builder->MutableUnpositionedFloats().clear();
 }
 
 // Whether an in-flow block-level child creates a new formatting context.
 //
 // This will *NOT* check the following cases:
 //  - The child is out-of-flow, e.g. floating or abs-pos.
 //  - The child is a inline-level, e.g. "display: inline-block".
 //  - The child establishes a new formatting context, but should be a child of
@@ skipping 260 matching lines @@
       toNGPhysicalBoxFragment(layout_result->PhysicalFragment().get()));
 
   // Pull out unpositioned floats to the current fragment. This may needed if
   // for example the child fragment could not position its floats because it's
   // empty and therefore couldn't determine its position in space.
   builder_.MutableUnpositionedFloats().appendVector(
       layout_result->UnpositionedFloats());
 
   if (child->Type() == NGLayoutInputNode::kLegacyBlock &&
       toNGBlockNode(child)->Style().isFloating()) {
     NGFloatingObject* floating_object = new NGFloatingObject(

[ikilpatrick, 2017/03/15 23:39:18]

this should have an adoptRef instead of AddUnpositionedFloat.

Typically for these we add a NGFloatingObject::create static factory function.

[Gleb Lanbin, 2017/03/16 01:14:34]

Done.

         child_space, constraint_space_, toNGBlockNode(child)->Style(),
         curr_child_margins_, layout_result->PhysicalFragment().get());
     builder_.AddUnpositionedFloat(floating_object);
     // No need to postpone the positioning if we know the correct offset.
     if (builder_.BfcOffset()) {
       NGLogicalOffset origin_point = curr_bfc_offset_;
       // Adjust origin point to the margins of the last child.
       // Example: <div style="margin-bottom: 20px"><float></div>
       //          <div style="margin-bottom: 30px"></div>
       origin_point.block_offset += curr_margin_strut_.Sum();
@@ skipping 196 matching lines @@
       DCHECK(builder_.BfcOffset());
       space_available -= curr_bfc_offset_.block_offset;
     }
   }
   space_builder_.SetFragmentainerSpaceAvailable(space_available);
 
   return space_builder_.ToConstraintSpace(
       FromPlatformWritingMode(child_style.getWritingMode()));
 }
 }  // namespace blink