Add NGColumnLayoutAlgorithm skeleton implementation.

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_block_child_iterator.h"
 #include "core/layout/ng/ng_box_fragment.h"
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_floats_utils.h"
 #include "core/layout/ng/ng_fragment.h"
 #include "core/layout/ng/ng_fragment_builder.h"
 #include "core/layout/ng/ng_inline_node.h"
 #include "core/layout/ng/ng_layout_opportunity_iterator.h"
 #include "core/layout/ng/ng_length_utils.h"
@@ skipping 33 matching lines @@
 
 // Whether we've run out of space in this flow. If so, there will be no work
 // left to do for this block in this fragmentainer.
 bool IsOutOfSpace(const NGConstraintSpace& space, LayoutUnit content_size) {
   return space.HasBlockFragmentation() &&
          content_size >= space.FragmentainerSpaceAvailable();
 }
 
 }  // namespace
 
-NGBlockLayoutAlgorithm::NGBlockLayoutAlgorithm(
-    NGBlockNode* node,
-    NGConstraintSpace* constraint_space,
-    NGBlockBreakToken* break_token)
-    : node_(node),
-      constraint_space_(constraint_space),
-      break_token_(break_token),
+NGBlockLayoutAlgorithm::NGBlockLayoutAlgorithm(NGBlockNode* node,
+                                               NGConstraintSpace* space,
+                                               NGBlockBreakToken* break_token)
+    : NGLayoutAlgorithm(node, space, break_token),
       builder_(NGPhysicalFragment::kFragmentBox, node),
       space_builder_(constraint_space_) {}
 
 Optional<MinMaxContentSize> NGBlockLayoutAlgorithm::ComputeMinMaxContentSize()
     const {
   MinMaxContentSize 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 = node_->FirstChild(); node;
+  for (NGLayoutInputNode* node = Node()->FirstChild(); node;
        node = node->NextSibling()) {
     MinMaxContentSize child_sizes;
     if (node->Type() == NGLayoutInputNode::kLegacyInline) {
       // From |NGBlockLayoutAlgorithm| perspective, we can handle |NGInlineNode|
       // almost the same as |NGBlockNode|, because an |NGInlineNode| includes
       // all inline nodes following |node| and their descendants, and produces
       // an anonymous box that contains all line boxes.
       // |NextSibling| returns the next block sibling, or nullptr, skipping all
       // following inline siblings and descendants.
       child_sizes = toNGInlineNode(node)->ComputeMinMaxContentSize();
@@ skipping 66 matching lines @@
   space_builder_
       .SetAvailableSize(
           NGLogicalSize(adjusted_inline_size, adjusted_block_size))
       .SetPercentageResolutionSize(
           NGLogicalSize(adjusted_inline_size, adjusted_block_size));
 
   builder_.SetDirection(constraint_space_->Direction());
   builder_.SetWritingMode(constraint_space_->WritingMode());
   builder_.SetInlineSize(inline_size).SetBlockSize(block_size);
 
-  NGBlockChildIterator child_iterator(node_->FirstChild(), break_token_);
+  NGBlockChildIterator child_iterator(Node()->FirstChild(), BreakToken());
   NGBlockChildIterator::Entry entry = child_iterator.NextChild();
   NGLayoutInputNode* child = entry.node;
   NGBreakToken* child_break_token = entry.token;
 
   // If we are resuming from a break token our start border and padding is
   // within a previous fragment.
-  content_size_ = break_token_ ? LayoutUnit() : border_and_padding_.block_start;
+  content_size_ = BreakToken() ? LayoutUnit() : border_and_padding_.block_start;
 
   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) {
     curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
     UpdateFragmentBfcOffset(curr_bfc_offset_);
@@ skipping 222 matching lines @@
   max_inline_size_ =
       std::max(max_inline_size_, fragment.InlineSize() +
                                      curr_child_margins_.InlineSum() +
                                      border_and_padding_.InlineSum());
 
   builder_.AddChild(layout_result, logical_offset);
 }
 
 void NGBlockLayoutAlgorithm::FinalizeForFragmentation() {
   LayoutUnit used_block_size =
-      break_token_ ? break_token_->UsedBlockSize() : LayoutUnit();
+      BreakToken() ? BreakToken()->UsedBlockSize() : LayoutUnit();
   LayoutUnit block_size = ComputeBlockSizeForFragment(
       ConstraintSpace(), Style(), used_block_size + content_size_);
 
   block_size -= used_block_size;
   DCHECK_GE(block_size, LayoutUnit())
       << "Adding and subtracting the used_block_size shouldn't leave the "
          "block_size for this fragment smaller than zero.";
 
   DCHECK(builder_.BfcOffset()) << "We must have our BfcOffset by this point "
                                   "to determine the space left in the flow.";
@@ skipping 86 matching lines @@
       // started handling the fragmentation for floats.
       space_builder_.SetBfcOffset(NGLogicalOffset());
     }
   }
   space_builder_.SetFragmentainerSpaceAvailable(space_available);
 
   return space_builder_.ToConstraintSpace(
       FromPlatformWritingMode(child_style.getWritingMode()));
 }
 }  // namespace blink