Remove NGBlockNode constructor, SetFirstChild, SetNextSibling methods

third_party/WebKit/Source/core/layout/ng/ng_block_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/ng_block_node.h"
 
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/api/LineLayoutAPIShim.h"
 #include "core/layout/line/InlineIterator.h"
 #include "core/layout/ng/layout_ng_block_flow.h"
@@ skipping 57 matching lines @@
 }
 
 }  // namespace
 
 NGBlockNode::NGBlockNode(LayoutObject* layout_object)
     : NGLayoutInputNode(NGLayoutInputNodeType::kLegacyBlock),
       layout_box_(toLayoutBox(layout_object)) {
   DCHECK(layout_box_);
 }
 
-NGBlockNode::NGBlockNode(ComputedStyle* style)
-    : NGLayoutInputNode(NGLayoutInputNodeType::kLegacyBlock),
-      layout_box_(nullptr),
-      style_(style) {
-  DCHECK(style_);
-}
-
 // Need an explicit destructor in the .cc file, or the MSWIN compiler will
 // produce an error when attempting to generate a default one, if the .h file is
 // included from a compilation unit that lacks the ComputedStyle definition.
 NGBlockNode::~NGBlockNode() {}
 
 RefPtr<NGLayoutResult> NGBlockNode::Layout(NGConstraintSpace* constraint_space,
                                            NGBreakToken* break_token) {
   // Use the old layout code and synthesize a fragment.
   if (!CanUseNewLayout()) {
     DCHECK(layout_box_);
@@ skipping 72 matching lines @@
   DCHECK(layout_box_);
   return layout_box_->styleRef();
 }
 
 NGLayoutInputNode* NGBlockNode::NextSibling() {
   if (!next_sibling_) {
     LayoutObject* next_sibling =
         layout_box_ ? layout_box_->nextSibling() : nullptr;
     if (next_sibling) {
       if (next_sibling->isInline())
-        SetNextSibling(new NGInlineNode(next_sibling, &Style()));
+        next_sibling_ = new NGInlineNode(next_sibling, &Style());
       else
-        SetNextSibling(new NGBlockNode(next_sibling));
+        next_sibling_ = new NGBlockNode(next_sibling);
     }
   }
   return next_sibling_;
 }
 
 LayoutObject* NGBlockNode::GetLayoutObject() {
   return layout_box_;
 }
 
 NGLayoutInputNode* NGBlockNode::FirstChild() {
   if (!first_child_) {
     LayoutObject* child = layout_box_ ? layout_box_->slowFirstChild() : nullptr;
     if (child) {
       if (child->isInline()) {
-        SetFirstChild(new NGInlineNode(child, &Style()));
+        first_child_ = new NGInlineNode(child, &Style());
       } else {
-        SetFirstChild(new NGBlockNode(child));
+        first_child_ = new NGBlockNode(child);
       }
     }
   }
   return first_child_;
 }
 
-void NGBlockNode::SetNextSibling(NGLayoutInputNode* sibling) {
-  next_sibling_ = sibling;
-}
-
-void NGBlockNode::SetFirstChild(NGLayoutInputNode* child) {
-  first_child_ = child;
-}
-
 DEFINE_TRACE(NGBlockNode) {
   visitor->trace(next_sibling_);
   visitor->trace(first_child_);
   NGLayoutInputNode::trace(visitor);
 }
 
 bool NGBlockNode::CanUseNewLayout() {
   if (!layout_box_)
     return true;
   if (!layout_box_->isLayoutBlockFlow())
@@ skipping 144 matching lines @@
 // Save static position for legacy AbsPos layout.
 void NGBlockNode::SaveStaticOffsetForLegacy(const NGLogicalOffset& offset) {
   DCHECK(layout_box_);
   DCHECK(layout_box_->isOutOfFlowPositioned());
   DCHECK(layout_box_->layer());
   layout_box_->layer()->setStaticBlockPosition(offset.block_offset);
   layout_box_->layer()->setStaticInlinePosition(offset.inline_offset);
 }
 
 }  // namespace blink