[LayoutNG] PODify NGLayoutInputNode and sub-classes.

third_party/WebKit/Source/core/layout/ng/inline/ng_line_breaker.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_line_breaker.h"
 
 #include "core/layout/ng/inline/ng_inline_break_token.h"
 #include "core/layout/ng/inline/ng_inline_layout_algorithm.h"
 #include "core/layout/ng/inline/ng_inline_node.h"
 #include "core/layout/ng/inline/ng_text_fragment.h"
@@ skipping 38 matching lines @@
       return std::make_pair(next_break, next_inline_size);
     offset = next_break;
     inline_size = next_inline_size;
     has_break_opportunities = true;
   }
 }
 #endif
 
 }  // namespace
 
-NGLineBreaker::NGLineBreaker(NGInlineNode* node,
+NGLineBreaker::NGLineBreaker(NGInlineNode node,
                              const NGConstraintSpace* space,
                              NGInlineBreakToken* break_token)
     : node_(node),
       constraint_space_(space),
       item_index_(0),
       offset_(0),
-      break_iterator_(node->Text()) {
+      break_iterator_(node.Text()) {
   if (break_token) {
     item_index_ = break_token->ItemIndex();
     offset_ = break_token->TextOffset();
-    node->AssertOffset(item_index_, offset_);
+    node.AssertOffset(item_index_, offset_);
   }
 }
 
 void NGLineBreaker::NextLine(NGInlineItemResults* item_results,
                              NGInlineLayoutAlgorithm* algorithm) {
   BreakLine(item_results, algorithm);
 
   // TODO(kojii): When editing, or caret is enabled, trailing spaces at wrap
   // point should not be removed. For other cases, we can a) remove, b) leave
   // characters without glyphs, or c) leave both characters and glyphs without
   // measuring. Need to decide which one works the best.
   SkipCollapsibleWhitespaces();
 }
 
 void NGLineBreaker::BreakLine(NGInlineItemResults* item_results,
                               NGInlineLayoutAlgorithm* algorithm) {
   DCHECK(item_results->IsEmpty());
-  const Vector<NGInlineItem>& items = node_->Items();
-  const ComputedStyle& style = node_->Style();
+  const Vector<NGInlineItem>& items = node_.Items();
+  const ComputedStyle& style = node_.Style();
   UpdateBreakIterator(style);
 #if !defined(MOCK_SHAPE_LINE)
   // TODO(kojii): Instantiate in the constructor.
   HarfBuzzShaper shaper(text.Characters16(), text.length());
 #endif
   available_width_ = algorithm->AvailableWidth();
   position_ = LayoutUnit(0);
   LineBreakState state = LineBreakState::kNotBreakable;
 
   while (item_index_ < items.size()) {
@@ skipping 123 matching lines @@
     item_result->end_offset = item.EndOffset();
   }
 }
 
 // Measure control items; new lines and tab, that are similar to text, affect
 // layout, but do not need shaping/painting.
 NGLineBreaker::LineBreakState NGLineBreaker::HandleControlItem(
     const NGInlineItem& item,
     NGInlineItemResult* item_result) {
   DCHECK_EQ(item.Length(), 1u);
-  UChar character = node_->Text()[item.StartOffset()];
+  UChar character = node_.Text()[item.StartOffset()];
   if (character == kNewlineCharacter) {
     MoveToNextOf(item);
     return LineBreakState::kForcedBreak;
   }
   DCHECK_EQ(character, kTabulationCharacter);
   DCHECK(item.Style());
   const ComputedStyle& style = *item.Style();
   const Font& font = style.GetFont();
   item_result->inline_size = font.TabWidth(style.GetTabSize(), position_);
   position_ += item_result->inline_size;
   MoveToNextOf(item);
   // TODO(kojii): Implement break around the tab character.
   return LineBreakState::kIsBreakable;
 }
 
 NGLineBreaker::LineBreakState NGLineBreaker::HandleAtomicInline(
     const NGInlineItem& item,
     NGInlineItemResult* item_result) {
   DCHECK_EQ(item.Type(), NGInlineItem::kAtomicInline);
-  NGBlockNode* node = new NGBlockNode(item.GetLayoutObject());
-  const ComputedStyle& style = node->Style();
+  NGBlockNode node = NGBlockNode(ToLayoutBox(item.GetLayoutObject()));
+  const ComputedStyle& style = node.Style();
   NGConstraintSpaceBuilder constraint_space_builder(constraint_space_);
   RefPtr<NGConstraintSpace> constraint_space =
       constraint_space_builder.SetIsNewFormattingContext(true)
           .SetIsShrinkToFit(true)
           .SetTextDirection(style.Direction())
           .ToConstraintSpace(FromPlatformWritingMode(style.GetWritingMode()));
-  item_result->layout_result = node->Layout(constraint_space.Get());
+  item_result->layout_result = node.Layout(constraint_space.Get());
 
   item_result->inline_size =
       NGBoxFragment(constraint_space_->WritingMode(),
                     ToNGPhysicalBoxFragment(
                         item_result->layout_result->PhysicalFragment().Get()))
           .InlineSize();
 
   item_result->margins =
       ComputeMargins(*constraint_space_, style,
                      constraint_space_->WritingMode(), style.Direction());
@@ skipping 52 matching lines @@
   }
   DCHECK(item.GetLayoutObject() && item.GetLayoutObject()->Parent());
   UpdateBreakIterator(item.GetLayoutObject()->Parent()->StyleRef());
   MoveToNextOf(item);
 }
 
 // Handles when the last item overflows.
 // At this point, item_results does not fit into the current line, and there
 // are no break opportunities in item_results.back().
 void NGLineBreaker::HandleOverflow(NGInlineItemResults* item_results) {
-  const Vector<NGInlineItem>& items = node_->Items();
+  const Vector<NGInlineItem>& items = node_.Items();
   LayoutUnit rewind_width = available_width_ - position_;
   DCHECK_LT(rewind_width, 0);
 
   // Search for a break opportunity that can fit.
   // Also keep track of the first break opportunity in case of overflow.
   unsigned break_before = 0;
   unsigned break_before_if_before_allow = 0;
   LayoutUnit rewind_width_if_before_allow;
   bool last_item_prohibits_break_before = true;
   for (unsigned i = item_results->size(); i;) {
@@ skipping 73 matching lines @@
       break_iterator_.SetBreakType(LineBreakType::kKeepAll);
     } else {
       break_iterator_.SetBreakType(LineBreakType::kNormal);
     }
 
     // TODO(kojii): Implement word-wrap/overflow-wrap property
   }
 }
 
 void NGLineBreaker::MoveToNextOf(const NGInlineItem& item) {
-  DCHECK_EQ(&item, &node_->Items()[item_index_]);
+  DCHECK_EQ(&item, &node_.Items()[item_index_]);
   offset_ = item.EndOffset();
   item_index_++;
 }
 
 void NGLineBreaker::MoveToNextOf(const NGInlineItemResult& item_result) {
   offset_ = item_result.end_offset;
   item_index_ = item_result.item_index;
-  const NGInlineItem& item = node_->Items()[item_result.item_index];
+  const NGInlineItem& item = node_.Items()[item_result.item_index];
   if (offset_ == item.EndOffset())
     item_index_++;
 }
 
 void NGLineBreaker::SkipCollapsibleWhitespaces() {
-  const Vector<NGInlineItem>& items = node_->Items();
+  const Vector<NGInlineItem>& items = node_.Items();
   if (item_index_ >= items.size())
     return;
   const NGInlineItem& item = items[item_index_];
   if (item.Type() != NGInlineItem::kText || !item.Style()->CollapseWhiteSpace())
     return;
 
   DCHECK_LT(offset_, item.EndOffset());
-  if (node_->Text()[offset_] == kSpaceCharacter) {
+  if (node_.Text()[offset_] == kSpaceCharacter) {
     // Skip one whitespace. Collapsible spaces are collapsed to single space in
     // NGInlineItemBuilder, so this removes all collapsible spaces.
     offset_++;
     if (offset_ == item.EndOffset())
       item_index_++;
   }
 }
 
 RefPtr<NGInlineBreakToken> NGLineBreaker::CreateBreakToken() const {
-  const Vector<NGInlineItem>& items = node_->Items();
+  const Vector<NGInlineItem>& items = node_.Items();
   if (item_index_ >= items.size())
     return nullptr;
   return NGInlineBreakToken::Create(node_, item_index_, offset_);
 }
 
 }  // namespace blink