[LayoutNG] PODify NGLayoutInputNode and sub-classes.

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 22 matching lines @@
     const NGLogicalOffset& container_bfc_offset,
     LayoutUnit content_size) {
   NGLogicalOffset origin_point = container_bfc_offset;
   origin_point.block_offset += content_size;
   return origin_point;
 }
 
 }  // namespace
 
 NGInlineLayoutAlgorithm::NGInlineLayoutAlgorithm(
-    NGInlineNode* inline_node,
+    NGInlineNode inline_node,
     NGConstraintSpace* space,
     NGInlineBreakToken* break_token)
     : NGLayoutAlgorithm(inline_node, space, break_token),
       is_horizontal_writing_mode_(
           blink::IsHorizontalWritingMode(space->WritingMode())),
       disallow_first_line_rules_(false),
-      space_builder_(space)
-{
+      space_builder_(space) {
   container_builder_.MutableUnpositionedFloats() = space->UnpositionedFloats();
 
   // TODO(crbug.com/716930): We may be an empty LayoutInline due to splitting.
   // Only resolve our BFC offset if we know that we are non-empty as we may
   // need to pass through our margin strut.
-  if (!inline_node->Items().IsEmpty()) {
+  if (!inline_node.Items().IsEmpty()) {
     LayoutUnit bfc_block_offset = ConstraintSpace().BfcOffset().block_offset;
     bfc_block_offset += ConstraintSpace().MarginStrut().Sum();
     MaybeUpdateFragmentBfcOffset(ConstraintSpace(), bfc_block_offset,
                                  &container_builder_);
     PositionPendingFloats(bfc_block_offset, &container_builder_,
                           MutableConstraintSpace());
   }
 
   if (!is_horizontal_writing_mode_)
     baseline_type_ = FontBaseline::kIdeographicBaseline;
 
   border_and_padding_ = ComputeBorders(ConstraintSpace(), Style()) +
                         ComputePadding(ConstraintSpace(), Style());
 
   if (break_token) {
     // If a break_token is given, we're re-starting layout for 2nd or later
     // lines, and that the first line we create should not use the first line
     // rules.
     DCHECK(!break_token->IsFinished());
     DCHECK(break_token->TextOffset() || break_token->ItemIndex());
     disallow_first_line_rules_ = true;
   } else {
-    auto& engine = Node()->GetLayoutObject()->GetDocument().GetStyleEngine();
+    auto& engine = Node().GetLayoutObject()->GetDocument().GetStyleEngine();
     disallow_first_line_rules_ = !engine.UsesFirstLineRules();
   }
 
   FindNextLayoutOpportunity();
 }
 
 bool NGInlineLayoutAlgorithm::IsFirstLine() const {
   return !disallow_first_line_rules_ && container_builder_.Children().IsEmpty();
 }
 
 const ComputedStyle& NGInlineLayoutAlgorithm::FirstLineStyle() const {
-  return Node()->GetLayoutObject()->FirstLineStyleRef();
+  return Node().GetLayoutObject()->FirstLineStyleRef();
 }
 
 const ComputedStyle& NGInlineLayoutAlgorithm::LineStyle() const {
   return IsFirstLine() ? FirstLineStyle() : Style();
 }
 
 LayoutUnit NGInlineLayoutAlgorithm::AvailableWidth() const {
   return current_opportunity_.InlineSize();
 }
 
 // The offset of 'line-left' side.
 // https://drafts.csswg.org/css-writing-modes/#line-left
 LayoutUnit NGInlineLayoutAlgorithm::LogicalLeftOffset() const {
   // TODO(kojii): We need to convert 'line start' to 'line left'. They're
   // different in RTL. Maybe there are more where start and left are misused.
   return current_opportunity_.InlineStartOffset() -
          ConstraintSpace().BfcOffset().inline_offset;
 }
 
 bool NGInlineLayoutAlgorithm::CreateLine(
     NGInlineItemResults* item_results,
     RefPtr<NGInlineBreakToken> break_token) {
-  if (Node()->IsBidiEnabled())
+  if (Node().IsBidiEnabled())
     BidiReorder(item_results);
 
   if (!PlaceItems(item_results, break_token))
     return false;
 
   // Prepare for the next line.
   NGLogicalOffset origin_point =
       GetOriginPointForFloats(ContainerBfcOffset(), content_size_);
   PositionPendingFloats(origin_point.block_offset, &container_builder_,
                         MutableConstraintSpace());
   FindNextLayoutOpportunity();
   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.
 
   // Create a list of chunk indices in the visual order.
   // ICU |ubidi_getVisualMap()| works for a run of characters. Since we can
   // handle the direction of each run, we use |ubidi_reorderVisual()| to reorder
   // runs instead of characters.
   Vector<UBiDiLevel, 32> levels;
   levels.ReserveInitialCapacity(line_items->size());
-  const Vector<NGInlineItem>& items = Node()->Items();
+  const Vector<NGInlineItem>& items = Node().Items();
   for (const auto& item_result : *line_items)
     levels.push_back(items[item_result.item_index].BidiLevel());
   Vector<int32_t, 32> indices_in_visual_order(line_items->size());
   NGBidiParagraph::IndicesInVisualOrder(levels, &indices_in_visual_order);
 
   // Reorder to the visual order.
   NGInlineItemResults line_items_in_visual_order(line_items->size());
   for (unsigned visual_index = 0; visual_index < indices_in_visual_order.size();
        visual_index++) {
     unsigned logical_index = indices_in_visual_order[visual_index];
@@ skipping 17 matching lines @@
     }
   }
 
   line_items->swap(line_items_in_visual_order);
 }
 
 // TODO(glebl): Add the support of clearance for inline floats.
 void NGInlineLayoutAlgorithm::LayoutAndPositionFloat(
     LayoutUnit end_position,
     LayoutObject* layout_object) {
-  NGBlockNode* node = new NGBlockNode(layout_object);
+  NGBlockNode node(ToLayoutBox(layout_object));
 
   NGLogicalOffset origin_offset =
       GetOriginPointForFloats(ContainerBfcOffset(), content_size_);
-  const ComputedStyle& float_style = node->Style();
+  const ComputedStyle& float_style = node.Style();
   NGBoxStrut margins = ComputeMargins(ConstraintSpace(), float_style,
                                       ConstraintSpace().WritingMode(),
                                       ConstraintSpace().Direction());
 
   // TODO(ikilpatrick): Add support for float break tokens inside an inline
   // layout context.
   RefPtr<NGUnpositionedFloat> unpositioned_float = NGUnpositionedFloat::Create(
       current_opportunity_.size, ConstraintSpace().PercentageResolutionSize(),
       origin_offset, ContainerBfcOffset(), margins, node,
       /* break_token */ nullptr);
@@ skipping 13 matching lines @@
   } else {
     container_builder_.AddPositionedFloat(
         PositionFloat(unpositioned_float.Get(), MutableConstraintSpace()));
     FindNextLayoutOpportunity();
   }
 }
 
 bool NGInlineLayoutAlgorithm::PlaceItems(
     NGInlineItemResults* line_items,
     RefPtr<NGInlineBreakToken> break_token) {
-  const Vector<NGInlineItem>& items = Node()->Items();
+  const Vector<NGInlineItem>& items = Node().Items();
 
   const ComputedStyle& line_style = LineStyle();
   NGLineHeightMetrics line_metrics(line_style, baseline_type_);
   NGLineHeightMetrics line_metrics_with_leading = line_metrics;
   line_metrics_with_leading.AddLeading(line_style.ComputedLineHeightAsFixed());
   NGLineBoxFragmentBuilder line_box(Node());
   line_box.SetWritingMode(ConstraintSpace().WritingMode());
 
   // Compute heights of all inline items by placing the dominant baseline at 0.
   // The baseline is adjusted after the height of the line box is computed.
@@ skipping 49 matching lines @@
     } else if (item.Type() == NGInlineItem::kAtomicInline) {
       box = PlaceAtomicInline(item, &item_result, position, &line_box,
                               &text_builder);
     } else if (item.Type() == NGInlineItem::kOutOfFlowPositioned) {
       // TODO(layout-dev): Report the correct static position for the out of
       // flow descendant. We can't do this here yet as it doesn't know the
       // size of the line box.
       container_builder_.AddOutOfFlowDescendant(
           // Absolute positioning blockifies the box's display type.
           // https://drafts.csswg.org/css-display/#transformations
-          new NGBlockNode(item.GetLayoutObject()),
+          NGBlockNode(ToLayoutBox(item.GetLayoutObject())),
           NGStaticPosition::Create(ConstraintSpace().WritingMode(),
                                    ConstraintSpace().Direction(),
                                    NGPhysicalOffset()));
       continue;
     } else {
       continue;
     }
 
     position += item_result.inline_size;
   }
@@ skipping 157 matching lines @@
   // 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());
   }
 
   return container_builder_.ToBoxFragment();
 }
 
 }  // namespace blink