[LayoutNG] Make NGBlockLayoutAlgorithm accept a NGBlockNode.

third_party/WebKit/Source/core/layout/ng/ng_block_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/ng_block_layout_algorithm.h"
 
 #include "core/layout/ng/ng_absolute_utils.h"
 #include "core/layout/ng/ng_block_break_token.h"
 #include "core/layout/ng/ng_box_fragment.h"
 #include "core/layout/ng/ng_column_mapper.h"
@@ skipping 282 matching lines @@
 
   if (space.WritingMode() != FromPlatformWritingMode(style.getWritingMode()))
     return true;
 
   return false;
 }
 
 }  // namespace
 
 NGBlockLayoutAlgorithm::NGBlockLayoutAlgorithm(
-    LayoutObject* layout_object,
-    PassRefPtr<const ComputedStyle> style,
-    NGLayoutInputNode* first_child,
+    NGBlockNode* node,
     NGConstraintSpace* constraint_space,
     NGBreakToken* break_token)
-    : style_(style),
-      first_child_(first_child),
+    : node_(node),
       constraint_space_(constraint_space),
       break_token_(break_token),
       builder_(WTF::wrapUnique(
-          new NGFragmentBuilder(NGPhysicalFragment::kFragmentBox,
-                                layout_object))) {
-  DCHECK(style_);
-}
+          new NGFragmentBuilder(NGPhysicalFragment::kFragmentBox, node))) {}
 
 Optional<MinAndMaxContentSizes>
 NGBlockLayoutAlgorithm::ComputeMinAndMaxContentSizes() const {
   MinAndMaxContentSizes sizes;
 
   // Size-contained elements don't consider their contents for intrinsic sizing.
   if (Style().containsSize())
     return sizes;
 
   // TODO: handle floats & orthogonal children.
-  for (NGLayoutInputNode* node = first_child_; node;
+  for (NGLayoutInputNode* node = node_->FirstChild(); node;
        node = node->NextSibling()) {
     Optional<MinAndMaxContentSizes> child_minmax;
     if (node->Type() == NGLayoutInputNode::kLegacyInline) {
       // TODO(kojii): Implement when there are inline children.
       return child_minmax;
     }
     NGBlockNode* block_child = toNGBlockNode(node);
     if (NeedMinAndMaxContentSizesForContentContribution(block_child->Style())) {
       child_minmax = block_child->ComputeMinAndMaxContentSizes();
     }
@@ skipping 64 matching lines @@
   builder_->SetInlineSize(inline_size).SetBlockSize(block_size);
 
   // TODO(glebl): fix multicol after the new margin collapsing/floats algorithm
   // based on BFCOffset is checked in.
   if (NGBlockBreakToken* token = CurrentBlockBreakToken()) {
     // Resume after a previous break.
     content_size_ = token->BreakOffset();
     current_child_ = token->InputNode();
   } else {
     content_size_ = border_and_padding_.block_start;
-    current_child_ = first_child_;
+    current_child_ = node_->FirstChild();
   }
 
   curr_margin_strut_ = ConstraintSpace().MarginStrut();
   curr_bfc_offset_ = ConstraintSpace().BfcOffset();
 
   // Margins collapsing:
   //   Do not collapse margins between parent and its child if there is
   //   border/padding between them.
   if (border_and_padding_.block_start ||
       ConstraintSpace().IsNewFormattingContext()) {
@@ skipping 78 matching lines @@
 }
 
 void NGBlockLayoutAlgorithm::LayoutInlineChildren(NGInlineNode* current_child) {
   // TODO(kojii): This logic does not handle when children are mix of
   // inline/block. We need to detect the case and setup appropriately; e.g.,
   // constraint space, margin collapsing, next siblings, etc.
   NGLineBuilder line_builder(current_child, space_for_current_child_);
   current_child->LayoutInline(space_for_current_child_, &line_builder);
   // TODO(kojii): The wrapper fragment should not be needed.
   NGFragmentBuilder wrapper_fragment_builder(NGPhysicalFragment::kFragmentBox,
-                                             current_child->GetLayoutObject());
+                                             current_child);
   line_builder.CreateFragments(&wrapper_fragment_builder);
   RefPtr<NGPhysicalBoxFragment> child_fragment =
       wrapper_fragment_builder.ToBoxFragment();
   line_builder.CopyFragmentDataToLayoutBlockFlow();
   FinishCurrentChildLayout(child_fragment.get());
   current_child_ = nullptr;
 }
 
 void NGBlockLayoutAlgorithm::FinishCurrentChildLayout(
     RefPtr<NGPhysicalBoxFragment> physical_fragment) {
@@ skipping 291 matching lines @@
     curr_bfc_offset_.inline_offset += curr_child_margins_.inline_start;
   }
 
   space_builder_->SetBfcOffset(curr_bfc_offset_);
 
   return space_builder_->ToConstraintSpace(
       FromPlatformWritingMode(current_child_style.getWritingMode()));
 }
 
 }  // namespace blink