Distinguish between row (fragmentainer group) height and column (fragmentainer) height.

third_party/WebKit/Source/core/layout/LayoutMultiColumnSet.cpp

 /*
  * Copyright (C) 2012 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 61 matching lines @@
 }
 
 const MultiColumnFragmentainerGroup&
 LayoutMultiColumnSet::FragmentainerGroupAtVisualPoint(
     const LayoutPoint& visual_point) const {
   DCHECK_GT(fragmentainer_groups_.size(), 0u);
   LayoutUnit block_offset =
       IsHorizontalWritingMode() ? visual_point.Y() : visual_point.X();
   for (unsigned index = 0; index < fragmentainer_groups_.size(); index++) {
     const auto& row = fragmentainer_groups_[index];
-    if (row.LogicalTop() + row.LogicalHeight() > block_offset)
+    if (row.LogicalTop() + row.GroupLogicalHeight() > block_offset)
       return row;
   }
   return fragmentainer_groups_.Last();
 }
 
 LayoutUnit LayoutMultiColumnSet::PageLogicalHeightForOffset(
     LayoutUnit offset_in_flow_thread) const {
   const MultiColumnFragmentainerGroup& last_row = LastFragmentainerGroup();
-  if (!last_row.LogicalHeight() && fragmentainer_groups_.size() == 1) {
+  if (!last_row.GroupLogicalHeight() && fragmentainer_groups_.size() == 1) {
     // In the first layout pass of an auto-height multicol container, height
     // isn't set. No need to perform the series of complicated dance steps below
     // to figure out that we should simply return 0. Bail now.
     return LayoutUnit();
   }
   if (offset_in_flow_thread >= last_row.LogicalTopInFlowThread() +
                                    FragmentainerGroupCapacity(last_row)) {
     // The offset is outside the bounds of the fragmentainer groups that we have
     // established at this point. If we're nested inside another fragmentation
     // context, we need to calculate the height on our own.
     const LayoutMultiColumnFlowThread* flow_thread = MultiColumnFlowThread();
     if (FragmentationContext* enclosing_fragmentation_context =
             flow_thread->EnclosingFragmentationContext()) {
       // We'd ideally like to translate |offsetInFlowThread| to an offset in the
       // coordinate space of the enclosing fragmentation context here, but
       // that's hard, since the offset is out of bounds. So just use the bottom
       // we have found so far.
       LayoutUnit enclosing_context_bottom =
           last_row.BlockOffsetInEnclosingFragmentationContext() +
-          last_row.LogicalHeight();
+          last_row.GroupLogicalHeight();
       LayoutUnit enclosing_fragmentainer_height =
           enclosing_fragmentation_context->FragmentainerLogicalHeightAt(
               enclosing_context_bottom);
       // Constrain against specified height / max-height.
       LayoutUnit current_multicol_height = LogicalTopFromMulticolContentEdge() +
                                            last_row.LogicalTop() +
-                                           last_row.LogicalHeight();
+                                           last_row.GroupLogicalHeight();
       LayoutUnit multicol_height_with_extra_row =
           current_multicol_height + enclosing_fragmentainer_height;
       multicol_height_with_extra_row =
           std::min(multicol_height_with_extra_row,
                    flow_thread->MaxColumnLogicalHeight());
       return std::max(LayoutUnit(1),
                       multicol_height_with_extra_row - current_multicol_height);
     }
   }
   return FragmentainerGroupAtFlowThreadOffset(offset_in_flow_thread,
                                               kAssociateWithLatterPage)
-      .LogicalHeight();
+      .ColumnLogicalHeight();
 }
 
 LayoutUnit LayoutMultiColumnSet::PageRemainingLogicalHeightForOffset(
     LayoutUnit offset_in_flow_thread,
     PageBoundaryRule page_boundary_rule) const {
   const MultiColumnFragmentainerGroup& row =
       FragmentainerGroupAtFlowThreadOffset(offset_in_flow_thread,
                                            page_boundary_rule);
-  LayoutUnit page_logical_height = row.LogicalHeight();
+  LayoutUnit page_logical_height = row.ColumnLogicalHeight();
   LayoutUnit page_logical_bottom =
       row.ColumnLogicalTopForOffset(offset_in_flow_thread) +
       page_logical_height;
   LayoutUnit remaining_logical_height =
       page_logical_bottom - offset_in_flow_thread;
 
   if (page_boundary_rule == kAssociateWithFormerPage) {
     // An offset exactly at a column boundary will act as being part of the
     // former column in question (i.e. no remaining space), rather than being
     // part of the latter (i.e. one whole column length of remaining space).
     remaining_logical_height =
         IntMod(remaining_logical_height, page_logical_height);
   } else if (!remaining_logical_height) {
     // When pageBoundaryRule is AssociateWithLatterPage, we shouldn't just
     // return 0 if there's no space left, because in that case we're at a
     // column boundary, in which case we should return the amount of space
     // remaining in the *next* column. Note that the page height itself may be
     // 0, though.
     remaining_logical_height = page_logical_height;
   }
   return remaining_logical_height;
 }
 
 bool LayoutMultiColumnSet::IsPageLogicalHeightKnown() const {
-  return FirstFragmentainerGroup().LogicalHeight();
+  return FirstFragmentainerGroup().ColumnLogicalHeight();
 }
 
 bool LayoutMultiColumnSet::NewFragmentainerGroupsAllowed() const {
   if (!IsPageLogicalHeightKnown()) {
     // If we have no clue about the height of the multicol container, bail. This
     // situation occurs initially when an auto-height multicol container is
     // nested inside another auto-height multicol container. We need at least an
     // estimated height of the outer multicol container before we can check what
     // an inner fragmentainer group has room for.
     // Its height is indefinite for now.
@@ skipping 32 matching lines @@
   // multicol), we need to look beyond the first row here.
   const MultiColumnFragmentainerGroup& first_row = FirstFragmentainerGroup();
   LayoutUnit first_row_logical_bottom_in_flow_thread =
       first_row.LogicalTopInFlowThread() +
       FragmentainerGroupCapacity(first_row);
   if (flow_thread_offset >= first_row_logical_bottom_in_flow_thread)
     return flow_thread_offset;  // We're not in the first row. Give up.
   LayoutUnit new_logical_height =
       enclosing_fragmentation_context->FragmentainerLogicalHeightAt(
           first_row.BlockOffsetInEnclosingFragmentationContext() +
-          first_row.LogicalHeight());
+          first_row.GroupLogicalHeight());
   if (content_logical_height > new_logical_height) {
     // The next outer column or page doesn't have enough space either. Give up
     // and stay where we are.
     return flow_thread_offset;
   }
   return first_row_logical_bottom_in_flow_thread;
 }
 
 LayoutMultiColumnSet* LayoutMultiColumnSet::NextSiblingMultiColumnSet() const {
   for (LayoutObject* sibling = NextSibling(); sibling;
@@ skipping 48 matching lines @@
   // multicol container. When setting up a new fragmentainer group, we always
   // constrain against the remaining portion of any specified
   // height/max-height. This means that we shouldn't allow creation of
   // fragmentainer groups below the bottom of the multicol container, or we'd
   // end up with zero-height fragmentainer groups (or actually 1px; see
   // heightAdjustedForRowOffset() in MultiColumnFragmentainerGroup, which
   // guards against zero-height groups), i.e. potentially a lot of pretty
   // useless fragmentainer groups, and possibly broken layout too. Instead,
   // we'll just allow additional (overflowing) columns to be created in the
   // last fragmentainer group, similar to what we do when we're not nested.
-  LayoutUnit logical_bottom = last_row.LogicalTop() + last_row.LogicalHeight();
+  LayoutUnit logical_bottom =
+      last_row.LogicalTop() + last_row.GroupLogicalHeight();
   LayoutUnit space_used = logical_bottom + LogicalTopFromMulticolContentEdge();
   LayoutUnit max_column_height =
       MultiColumnFlowThread()->MaxColumnLogicalHeight();
   return max_column_height - space_used > LayoutUnit();
 }
 
 MultiColumnFragmentainerGroup&
 LayoutMultiColumnSet::AppendNewFragmentainerGroup() {
   MultiColumnFragmentainerGroup new_group(*this);
   {  // Extra scope here for previousGroup; it's potentially invalid once we
      // modify the m_fragmentainerGroups Vector.
     MultiColumnFragmentainerGroup& previous_group =
         fragmentainer_groups_.Last();
 
     // This is the flow thread block offset where |previousGroup| ends and
     // |newGroup| takes over.
     LayoutUnit block_offset_in_flow_thread =
         previous_group.LogicalTopInFlowThread() +
         FragmentainerGroupCapacity(previous_group);
     previous_group.SetLogicalBottomInFlowThread(block_offset_in_flow_thread);
     new_group.SetLogicalTopInFlowThread(block_offset_in_flow_thread);
     new_group.SetLogicalTop(previous_group.LogicalTop() +
-                            previous_group.LogicalHeight());
+                            previous_group.GroupLogicalHeight());
     new_group.ResetColumnHeight();
   }
   fragmentainer_groups_.Append(new_group);
   return fragmentainer_groups_.Last();
 }
 
 LayoutUnit LayoutMultiColumnSet::LogicalTopFromMulticolContentEdge() const {
   // We subtract the position of the first column set or spanner placeholder,
   // rather than the "before" border+padding of the multicol container. This
   // distinction doesn't matter after layout, but during layout it does:
@@ skipping 135 matching lines @@
   min_logical_width = flow_thread_->MinPreferredLogicalWidth();
   max_logical_width = flow_thread_->MaxPreferredLogicalWidth();
 }
 
 void LayoutMultiColumnSet::ComputeLogicalHeight(
     LayoutUnit,
     LayoutUnit logical_top,
     LogicalExtentComputedValues& computed_values) const {
   LayoutUnit logical_height;
   for (const auto& group : fragmentainer_groups_)
-    logical_height += group.LogicalHeight();
+    logical_height += group.GroupLogicalHeight();
   computed_values.extent_ = logical_height;
   computed_values.position_ = logical_top;
 }
 
 PositionWithAffinity LayoutMultiColumnSet::PositionForPoint(
     const LayoutPoint& point) {
   // Convert the visual point to a flow thread point.
   const MultiColumnFragmentainerGroup& row =
       FragmentainerGroupAtVisualPoint(point);
   LayoutPoint flow_thread_point = row.VisualPointToFlowThreadPoint(
@@ skipping 149 matching lines @@
   // Now add in column rule bounds, if present.
   Vector<LayoutRect> column_rule_bounds;
   if (ComputeColumnRuleBounds(LayoutPoint(), column_rule_bounds)) {
     for (auto& bound : column_rule_bounds)
       block_flow_bounds.Unite(bound);
   }
   return block_flow_bounds;
 }
 
 }  // namespace blink