[LayoutNG] PODify NGLayoutInputNode and sub-classes.

third_party/WebKit/Source/core/layout/ng/inline/ng_inline_node.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_node.h"
 
 #include "core/layout/BidiRun.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutText.h"
 #include "core/layout/line/LineInfo.h"
 #include "core/layout/line/RootInlineBox.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_item.h"
 #include "core/layout/ng/inline/ng_inline_items_builder.h"
 #include "core/layout/ng/inline/ng_inline_layout_algorithm.h"
 #include "core/layout/ng/inline/ng_line_box_fragment.h"
 #include "core/layout/ng/inline/ng_line_breaker.h"
 #include "core/layout/ng/inline/ng_physical_line_box_fragment.h"
 #include "core/layout/ng/inline/ng_physical_text_fragment.h"
 #include "core/layout/ng/inline/ng_text_fragment.h"
+#include "core/layout/ng/layout_ng_block_flow.h"
 #include "core/layout/ng/ng_box_fragment.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_fragment_builder.h"
 #include "core/layout/ng/ng_layout_result.h"
 #include "core/layout/ng/ng_physical_box_fragment.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/fonts/shaping/HarfBuzzShaper.h"
 #include "platform/wtf/text/CharacterNames.h"
 
 namespace blink {
@@ skipping 111 matching lines @@
     parent->SetLogicalLeft(logical_left);
     parent->SetLogicalWidth(logical_right - logical_left);
     parent->SetLogicalTop(logical_top);
   }
 
   return text_index;
 }
 
 }  // namespace
 
-NGInlineNode::NGInlineNode(LayoutObject* start_inline, LayoutNGBlockFlow* block)
-    : NGLayoutInputNode(NGLayoutInputNodeType::kLegacyInline),
-      start_inline_(start_inline),
-      block_(block) {
+NGInlineNode::NGInlineNode(LayoutNGBlockFlow* block, LayoutObject* start_inline)
+    : NGLayoutInputNode(block) {
   DCHECK(start_inline);
   DCHECK(block);
-  block->ResetNGInlineNodeData();
+  block->SetLayoutNGInline(true);
+  if (!block->HasNGInlineNodeData()) {
+    block->ResetNGInlineNodeData();
+  }
+  MutableData().start_inline_ = start_inline;
 }
 
-NGInlineNode::NGInlineNode()
-    : NGLayoutInputNode(NGLayoutInputNodeType::kLegacyInline),
-      start_inline_(nullptr),
-      block_(nullptr) {}
-
-NGInlineNode::~NGInlineNode() {}
-
 NGInlineItemRange NGInlineNode::Items(unsigned start, unsigned end) {
   return NGInlineItemRange(&MutableData().items_, start, end);
 }
 
 void NGInlineNode::InvalidatePrepareLayout() {
+  LayoutObject* start_inline = Data().start_inline_;
+  ToLayoutNGBlockFlow(GetLayoutBlockFlow())->ResetNGInlineNodeData();
+  MutableData().start_inline_ = start_inline;
   MutableData().text_content_ = String();
   MutableData().items_.clear();
 }
 
 void NGInlineNode::PrepareLayout() {
   // Scan list of siblings collecting all in-flow non-atomic inlines. A single
   // NGInlineNode represent a collection of adjacent non-atomic inlines.
-  CollectInlines(start_inline_, block_);
+  CollectInlines(Data().start_inline_, GetLayoutBlockFlow());
   if (Data().is_bidi_enabled_)
     SegmentText();
   ShapeText();
 }
 
 // Depth-first-scan of all LayoutInline and LayoutText nodes that make up this
 // NGInlineNode object. Collects LayoutText items, merging them up into the
 // parent LayoutInline where possible, and joining all text content in a single
 // string to allow bidi resolution and shaping of the entire block.
 void NGInlineNode::CollectInlines(LayoutObject* start, LayoutBlockFlow* block) {
   DCHECK(Data().text_content_.IsNull());
   DCHECK(Data().items_.IsEmpty());
   NGInlineItemsBuilder builder(&MutableData().items_);
   builder.EnterBlock(block->Style());
   LayoutObject* next_sibling = CollectInlines(start, block, &builder);
   builder.ExitBlock();
 
   MutableData().text_content_ = builder.ToString();
   DCHECK(!next_sibling || !next_sibling->IsInline());
-  next_sibling_ = next_sibling ? new NGBlockNode(next_sibling) : nullptr;
+  MutableData().next_sibling_ = ToLayoutBox(next_sibling);
   MutableData().is_bidi_enabled_ =
       !Data().text_content_.IsEmpty() &&
       !(Data().text_content_.Is8Bit() && !builder.HasBidiControls());
 }
 
 LayoutObject* NGInlineNode::CollectInlines(LayoutObject* start,
                                            LayoutBlockFlow* block,
                                            NGInlineItemsBuilder* builder) {
   LayoutObject* node = start;
   while (node) {
@@ skipping 99 matching lines @@
                      item.StartOffset(), item.EndOffset());
   }
 }
 
 RefPtr<NGLayoutResult> NGInlineNode::Layout(NGConstraintSpace* constraint_space,
                                             NGBreakToken* break_token) {
   // TODO(kojii): Invalidate PrepareLayout() more efficiently.
   InvalidatePrepareLayout();
   PrepareLayout();
 
-  NGInlineLayoutAlgorithm algorithm(this, constraint_space,
+  NGInlineLayoutAlgorithm algorithm(*this, constraint_space,
                                     ToNGInlineBreakToken(break_token));
   RefPtr<NGLayoutResult> result = algorithm.Layout();
   CopyFragmentDataToLayoutBox(*constraint_space, result.Get());
   return result;
 }
 
 enum class ContentSizeMode { Max, Sum };
 
-static LayoutUnit ComputeContentSize(NGInlineNode* node,
+static LayoutUnit ComputeContentSize(NGInlineNode node,
                                      ContentSizeMode mode,
-                                     LayoutUnit available_inline_size,
-                                     NGConstraintSpaceBuilder* space_builder,
-                                     NGWritingMode writing_mode) {
-  space_builder->SetAvailableSize({available_inline_size, NGSizeIndefinite});
+                                     LayoutUnit available_inline_size) {
+  const ComputedStyle& style = node.Style();
+  NGWritingMode writing_mode = FromPlatformWritingMode(style.GetWritingMode());
+
   RefPtr<NGConstraintSpace> space =
-      space_builder->ToConstraintSpace(writing_mode);
+      NGConstraintSpaceBuilder(writing_mode)
+          .SetTextDirection(style.Direction())
+          .SetAvailableSize({available_inline_size, NGSizeIndefinite})
+          .ToConstraintSpace(writing_mode);
   NGLineBreaker line_breaker(node, space.Get());
   NGInlineLayoutAlgorithm algorithm(node, space.Get());
   NGInlineItemResults item_results;
   LayoutUnit result;
   while (true) {
     line_breaker.NextLine(&item_results, &algorithm);
     if (item_results.IsEmpty())
       break;
     LayoutUnit inline_size;
     for (const NGInlineItemResult item_result : item_results)
@@ skipping 13 matching lines @@
     PrepareLayout();
 
   // Run line breaking with 0 and indefinite available width.
 
   // TODO(kojii): There are several ways to make this more efficient and faster
   // than runnning two line breaking.
 
   // Compute the max of inline sizes of all line boxes with 0 available inline
   // size. This gives the min-content, the width where lines wrap at every
   // break opportunity.
-  const ComputedStyle& style = Style();
-  NGWritingMode writing_mode = FromPlatformWritingMode(style.GetWritingMode());
-  NGConstraintSpaceBuilder space_builder(writing_mode);
-  space_builder.SetTextDirection(style.Direction());
-  space_builder.SetAvailableSize({LayoutUnit(), NGSizeIndefinite});
-  RefPtr<NGConstraintSpace> space =
-      space_builder.ToConstraintSpace(writing_mode);
   MinMaxContentSize sizes;
-  sizes.min_content = ComputeContentSize(
-      this, ContentSizeMode::Max, LayoutUnit(), &space_builder, writing_mode);
+  sizes.min_content =
+      ComputeContentSize(*this, ContentSizeMode::Max, LayoutUnit());
 
   // Compute the sum of inline sizes of all inline boxes with no line breaks.
   // TODO(kojii): NGConstraintSpaceBuilder does not allow NGSizeIndefinite
   // inline available size. We can allow it, or make this more efficient
   // without using NGLineBreaker.
   sizes.max_content =
-      ComputeContentSize(this, ContentSizeMode::Sum, LayoutUnit::Max(),
-                         &space_builder, writing_mode);
+      ComputeContentSize(*this, ContentSizeMode::Sum, LayoutUnit::Max());
 
   return sizes;
 }
 
-NGLayoutInputNode* NGInlineNode::NextSibling() {
+NGLayoutInputNode NGInlineNode::NextSibling() {
   if (!IsPrepareLayoutFinished())
     PrepareLayout();
-  return next_sibling_;
-}
-
-LayoutObject* NGInlineNode::GetLayoutObject() const {
-  return GetLayoutBlockFlow();
+  return NGBlockNode(Data().next_sibling_);
 }
 
 void NGInlineNode::CopyFragmentDataToLayoutBox(
     const NGConstraintSpace& constraint_space,
     NGLayoutResult* layout_result) {
   LayoutBlockFlow* block_flow = GetLayoutBlockFlow();
   block_flow->DeleteLineBoxTree();
 
   const Vector<NGInlineItem>& items = Data().items_;
   Vector<unsigned, 32> text_offsets(items.size());
@@ skipping 85 matching lines @@
                           Data().text_content_.length() - current_offset) {
     current_text->SetTextInternal(
         Text(current_offset, Data().text_content_.length()).ToString().Impl());
   }
 }
 
 String NGInlineNode::ToString() const {
   return String::Format("NGInlineNode");
 }
 
-DEFINE_TRACE(NGInlineNode) {
-  visitor->Trace(next_sibling_);
-  NGLayoutInputNode::Trace(visitor);
-}
-
 }  // namespace blink