[LayoutNG] Make NGBlockLayoutAlgorithm accept a NGBlockNode.

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 68 matching lines @@
 RefPtr<NGPhysicalFragment> NGBlockNode::Layout(
     NGConstraintSpace* constraint_space) {
   // Use the old layout code and synthesize a fragment.
   if (!CanUseNewLayout()) {
     DCHECK(layout_box_);
     fragment_ = RunOldLayout(*constraint_space);
     return fragment_;
   }
 
   RefPtr<NGPhysicalFragment> fragment =
-      NGBlockLayoutAlgorithm(GetLayoutObject(), &Style(), FirstChild(),
-                             constraint_space, CurrentBreakToken())
+      NGBlockLayoutAlgorithm(this, constraint_space, CurrentBreakToken())
           .Layout();
 
   fragment_ = toNGPhysicalBoxFragment(fragment.get());
   CopyFragmentDataToLayoutBox(*constraint_space);
   return fragment_;
 }
 
 MinAndMaxContentSizes NGBlockNode::ComputeMinAndMaxContentSizes() {
   MinAndMaxContentSizes sizes;
   if (!CanUseNewLayout()) {
@@ skipping 13 matching lines @@
     return sizes;
   }
 
   NGConstraintSpace* constraint_space =
       NGConstraintSpaceBuilder(
           FromPlatformWritingMode(Style().getWritingMode()))
           .SetTextDirection(Style().direction())
           .ToConstraintSpace(FromPlatformWritingMode(Style().getWritingMode()));
 
   // TODO(cbiesinger): For orthogonal children, we need to always synthesize.
-  NGBlockLayoutAlgorithm minmax_algorithm(layout_box_, &Style(), FirstChild(),
-                                          constraint_space);
+  NGBlockLayoutAlgorithm minmax_algorithm(this, constraint_space);
   Optional<MinAndMaxContentSizes> maybe_sizes =
       minmax_algorithm.ComputeMinAndMaxContentSizes();
   if (maybe_sizes.has_value())
     return *maybe_sizes;
 
   // Have to synthesize this value.
   RefPtr<NGPhysicalFragment> physical_fragment = Layout(constraint_space);
   NGBoxFragment min_fragment(FromPlatformWritingMode(Style().getWritingMode()),
                              toNGPhysicalBoxFragment(physical_fragment.get()));
   sizes.min_content = min_fragment.InlineOverflow();
@@ skipping 162 matching lines @@
   }
 
   if (layout_box_->isLayoutNGBlockFlow() && layout_box_->needsLayout()) {
     toLayoutNGBlockFlow(layout_box_)->LayoutBlockFlow::layoutBlock(true);
   } else {
     layout_box_->forceLayout();
   }
   LayoutRect overflow = layout_box_->layoutOverflowRect();
   // TODO(layout-ng): This does not handle writing modes correctly (for
   // overflow)
-  NGFragmentBuilder builder(NGPhysicalFragment::kFragmentBox, layout_box_);
+  NGFragmentBuilder builder(NGPhysicalFragment::kFragmentBox, this);
   builder.SetInlineSize(layout_box_->logicalWidth())
       .SetBlockSize(layout_box_->logicalHeight())
       .SetDirection(layout_box_->styleRef().direction())
       .SetWritingMode(
           FromPlatformWritingMode(layout_box_->styleRef().getWritingMode()))
       .SetInlineOverflow(overflow.width())
       .SetBlockOverflow(overflow.height());
   return builder.ToBoxFragment();
 }
 
 void NGBlockNode::UseOldOutOfFlowPositioning() {
   DCHECK(layout_box_);
   DCHECK(layout_box_->isOutOfFlowPositioned());
   layout_box_->containingBlock()->insertPositionedObject(layout_box_);
 }
 
 // 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