[LayoutNG] PODify NGLayoutInputNode and sub-classes.

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

 // Copyright 2017 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_floats_utils.h"
 
 #include "core/layout/ng/ng_box_fragment.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_layout_opportunity_iterator.h"
 #include "core/layout/ng/ng_layout_result.h"
@@ skipping 90 matching lines @@
   DCHECK(unpositioned_float.parent_bfc_block_offset);
   LayoutUnit top_offset = unpositioned_float.from_offset.block_offset -
                           unpositioned_float.parent_bfc_block_offset.value() +
                           float_logical_offset.block_offset;
   return {left_offset, top_offset};
 }
 
 WTF::Optional<LayoutUnit> CalculateFragmentationOffset(
     const NGUnpositionedFloat& unpositioned_float,
     const NGConstraintSpace& parent_space) {
-  const ComputedStyle& style = unpositioned_float.node->Style();
+  const ComputedStyle& style = unpositioned_float.node.Style();
   DCHECK(FromPlatformWritingMode(style.GetWritingMode()) ==
          parent_space.WritingMode());
 
   if (parent_space.HasBlockFragmentation()) {
     return parent_space.FragmentainerSpaceAvailable() -
            unpositioned_float.origin_offset.block_offset;
   }
 
   return WTF::nullopt;
 }
 
 // Creates a constraint space for an unpositioned float.
 RefPtr<NGConstraintSpace> CreateConstraintSpaceForFloat(
     const NGUnpositionedFloat& unpositioned_float,
     NGConstraintSpace* parent_space,
     WTF::Optional<LayoutUnit> fragmentation_offset = WTF::nullopt) {
-  const ComputedStyle& style = unpositioned_float.node->Style();
+  const ComputedStyle& style = unpositioned_float.node.Style();
 
   NGConstraintSpaceBuilder builder(parent_space);
 
   if (fragmentation_offset) {
     builder.SetFragmentainerSpaceAvailable(fragmentation_offset.value())
         .SetFragmentationType(parent_space->BlockFragmentationType());
   } else {
     builder.SetFragmentationType(NGFragmentationType::kFragmentNone);
   }
 
   return builder.SetPercentageResolutionSize(unpositioned_float.percentage_size)
       .SetAvailableSize(unpositioned_float.available_size)
       .SetIsNewFormattingContext(true)
       .SetIsShrinkToFit(true)
       .SetTextDirection(style.Direction())
       .ToConstraintSpace(FromPlatformWritingMode(style.GetWritingMode()));
 }
 
 }  // namespace
 
 LayoutUnit ComputeInlineSizeForUnpositionedFloat(
     NGConstraintSpace* parent_space,
     NGUnpositionedFloat* unpositioned_float) {
   DCHECK(unpositioned_float);
 
-  const ComputedStyle& style = unpositioned_float->node->Style();
+  const ComputedStyle& style = unpositioned_float->node.Style();
 
   bool is_same_writing_mode = FromPlatformWritingMode(style.GetWritingMode()) ==
                               parent_space->WritingMode();
 
   // If we've already performed layout on the unpositioned float, just return
   // the cached value.
   if (unpositioned_float->fragment) {
     DCHECK(!is_same_writing_mode);
     return NGBoxFragment(parent_space->WritingMode(),
                          unpositioned_float->fragment.value().Get())
         .InlineSize();
   }
 
   const RefPtr<NGConstraintSpace> space =
       CreateConstraintSpaceForFloat(*unpositioned_float, parent_space);
 
   // If the float has the same writing mode as the block formatting context we
   // shouldn't perform a full layout just yet. Our position may determine where
   // we fragment.
   if (is_same_writing_mode) {
     WTF::Optional<MinMaxContentSize> min_max_size;
     if (NeedMinMaxContentSize(*space.Get(), style))
-      min_max_size = unpositioned_float->node->ComputeMinMaxContentSize();
+      min_max_size = unpositioned_float->node.ComputeMinMaxContentSize();
     return ComputeInlineSizeForFragment(*space.Get(), style, min_max_size);
   }
 
   // If we are performing layout on a float to determine its inline size it
   // should never have fragmented.
   DCHECK(!unpositioned_float->token);
 
   // A float which has a different writing mode can't fragment, and we
   // (probably) need to perform a full layout in order to correctly determine
   // its inline size. We are able to cache this result on the
   // unpositioned_float at this stage.
   RefPtr<NGLayoutResult> layout_result =
-      unpositioned_float->node->Layout(space.Get());
+      unpositioned_float->node.Layout(space.Get());
 
   RefPtr<NGPhysicalBoxFragment> fragment =
       ToNGPhysicalBoxFragment(layout_result->PhysicalFragment().Get());
   unpositioned_float->fragment = fragment;
 
   DCHECK(fragment->BreakToken()->IsFinished());
 
   return NGBoxFragment(parent_space->WritingMode(), fragment.Get())
       .InlineSize();
 }
 
 NGPositionedFloat PositionFloat(NGUnpositionedFloat* unpositioned_float,
                                 NGConstraintSpace* new_parent_space) {
   DCHECK(unpositioned_float);
   LayoutUnit inline_size = ComputeInlineSizeForUnpositionedFloat(
       new_parent_space, unpositioned_float);
 
   // Find a layout opportunity that will fit our float.
   NGLayoutOpportunity opportunity = FindLayoutOpportunityForFloat(
       *new_parent_space, *unpositioned_float, inline_size);
 
 #if DCHECK_IS_ON()
   bool is_same_writing_mode =
       FromPlatformWritingMode(
-          unpositioned_float->node->Style().GetWritingMode()) ==
+          unpositioned_float->node.Style().GetWritingMode()) ==
       new_parent_space->WritingMode();
 #endif
 
   RefPtr<NGPhysicalBoxFragment> physical_fragment;
   // We should only have a fragment if its writing mode is different, i.e. it
   // can't fragment.
   if (unpositioned_float->fragment) {
 #if DCHECK_IS_ON()
     DCHECK(!is_same_writing_mode);
 #endif
     physical_fragment = unpositioned_float->fragment.value();
   } else {
 #if DCHECK_IS_ON()
     DCHECK(is_same_writing_mode);
 #endif
     WTF::Optional<LayoutUnit> fragmentation_offset =
         CalculateFragmentationOffset(*unpositioned_float, *new_parent_space);
 
     RefPtr<NGConstraintSpace> space = CreateConstraintSpaceForFloat(
         *unpositioned_float, new_parent_space, fragmentation_offset);
-    RefPtr<NGLayoutResult> layout_result = unpositioned_float->node->Layout(
+    RefPtr<NGLayoutResult> layout_result = unpositioned_float->node.Layout(
         space.Get(), unpositioned_float->token.Get());
     physical_fragment =
         ToNGPhysicalBoxFragment(layout_result->PhysicalFragment().Get());
   }
 
   NGBoxFragment float_fragment(new_parent_space->WritingMode(),
                                physical_fragment.Get());
 
   // TODO(glebl): This should check for infinite opportunity instead.
   if (opportunity.IsEmpty()) {
@@ skipping 43 matching lines @@
     unpositioned_float->origin_offset.block_offset = origin_block_offset;
     unpositioned_float->from_offset.block_offset = from_block_offset;
     unpositioned_float->parent_bfc_block_offset = parent_bfc_offset;
     positioned_floats.push_back(PositionFloat(unpositioned_float.Get(), space));
   }
 
   return positioned_floats;
 }
 
 }  // namespace blink