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

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

 // Copyright 2015 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/MultiColumnFragmentainerGroup.h"
 
 #include "core/layout/ColumnBalancer.h"
 #include "core/layout/FragmentationContext.h"
 #include "core/layout/LayoutMultiColumnSet.h"
 
@@ skipping 21 matching lines @@
 LayoutUnit
 MultiColumnFragmentainerGroup::BlockOffsetInEnclosingFragmentationContext()
     const {
   return LogicalTop() + column_set_.LogicalTopFromMulticolContentEdge() +
          column_set_.MultiColumnFlowThread()
              ->BlockOffsetInEnclosingFragmentationContext();
 }
 
 LayoutUnit MultiColumnFragmentainerGroup::LogicalHeightInFlowThreadAt(
     unsigned column_index) const {
-  if (!column_height_)
+  LayoutUnit column_height = ColumnLogicalHeight();
+  if (!column_height)
     return LayoutUnit();
   LayoutUnit logical_top = LogicalTopInFlowThreadAt(column_index);
-  LayoutUnit logical_bottom = logical_top + column_height_;
+  LayoutUnit logical_bottom = logical_top + column_height;
   if (logical_bottom > LogicalBottomInFlowThread()) {
     DCHECK_EQ(column_index + 1, ActualColumnCount());
     logical_bottom = LogicalBottomInFlowThread();
   }
   return (logical_bottom - logical_top).ClampNegativeToZero();
 }
 
 void MultiColumnFragmentainerGroup::ResetColumnHeight() {
-  max_column_height_ = CalculateMaxColumnHeight();
+  max_logical_height_ = CalculateMaxColumnHeight();
 
   LayoutMultiColumnFlowThread* flow_thread =
       column_set_.MultiColumnFlowThread();
   if (column_set_.HeightIsAuto()) {
     FragmentationContext* enclosing_fragmentation_context =
         flow_thread->EnclosingFragmentationContext();
     if (enclosing_fragmentation_context &&
         enclosing_fragmentation_context->IsFragmentainerLogicalHeightKnown()) {
       // Set an initial height, based on the fragmentainer height in the outer
       // fragmentation context, in order to tell how much content this
       // MultiColumnFragmentainerGroup can hold, and when we need to append a
       // new one.
-      column_height_ = max_column_height_;
+      logical_height_ = max_logical_height_;
       return;
     }
   }
   // If the multicol container has a definite height, use it as the column
   // height. This even applies when we are to balance the columns. We'll still
   // use the definite height as an initial height, and lay out once at that
   // column height. If it turns out that the content needs less than this
   // height, we have to balance and shrink the height and lay out the columns
   // over again.
   if (LayoutUnit logical_height = flow_thread->ColumnHeightAvailable()) {
     SetAndConstrainColumnHeight(HeightAdjustedForRowOffset(logical_height));
   } else {
-    column_height_ = LayoutUnit();
+    logical_height_ = LayoutUnit();
   }
 }
 
 bool MultiColumnFragmentainerGroup::RecalculateColumnHeight(
     LayoutMultiColumnSet& column_set) {
-  LayoutUnit old_column_height = column_height_;
+  LayoutUnit old_column_height = logical_height_;
 
-  max_column_height_ = CalculateMaxColumnHeight();
+  max_logical_height_ = CalculateMaxColumnHeight();
 
   // Only the last row may have auto height, and thus be balanced. There are no
   // good reasons to balance the preceding rows, and that could potentially lead
   // to an insane number of layout passes as well.
   if (IsLastGroup() && column_set.HeightIsAuto()) {
     LayoutUnit new_column_height;
     if (!column_set.IsInitialHeightCalculated()) {
       // Initial balancing: Start with the lowest imaginable column height. Also
       // calculate the height of the tallest piece of unbreakable content.
       // Columns should never get any shorter than that (unless constrained by
@@ skipping 10 matching lines @@
       // Rebalancing: After having laid out again, we'll need to rebalance if
       // the height wasn't enough and we're allowed to stretch it, and then
       // re-lay out.  There are further details on the column balancing
       // machinery in ColumnBalancer and its derivates.
       new_column_height = RebalanceColumnHeightIfNeeded();
     }
     SetAndConstrainColumnHeight(new_column_height);
   } else {
     // The position of the column set may have changed, in which case height
     // available for columns may have changed as well.
-    SetAndConstrainColumnHeight(column_height_);
+    SetAndConstrainColumnHeight(logical_height_);
   }
 
-  if (column_height_ == old_column_height)
+  if (logical_height_ == old_column_height)
     return false;  // No change. We're done.
 
   return true;  // Need another pass.
 }
 
 LayoutSize MultiColumnFragmentainerGroup::FlowThreadTranslationAtOffset(
     LayoutUnit offset_in_flow_thread,
     LayoutBox::PageBoundaryRule rule,
     CoordinateSpaceConversion mode) const {
   LayoutMultiColumnFlowThread* flow_thread =
@@ skipping 71 matching lines @@
   LayoutRect column_rect = ColumnRectAt(column_index);
   LayoutPoint local_point(visual_point);
   local_point.MoveBy(-column_rect.Location());
   if (!column_set_.IsHorizontalWritingMode()) {
     if (snap == kSnapToColumn) {
       LayoutUnit column_start = column_set_.Style()->IsLeftToRightDirection()
                                     ? LayoutUnit()
                                     : column_rect.Height();
       if (local_point.X() < 0)
         local_point = LayoutPoint(LayoutUnit(), column_start);
-      else if (local_point.X() > LogicalHeight())
-        local_point = LayoutPoint(LogicalHeight(), column_start);
+      else if (local_point.X() > ColumnLogicalHeight())
+        local_point = LayoutPoint(ColumnLogicalHeight(), column_start);
     }
     return LayoutPoint(local_point.X() + LogicalTopInFlowThreadAt(column_index),
                        local_point.Y());
   }
   if (snap == kSnapToColumn) {
     LayoutUnit column_start = column_set_.Style()->IsLeftToRightDirection()
                                   ? LayoutUnit()
                                   : column_rect.Width();
     if (local_point.Y() < 0)
       local_point = LayoutPoint(column_start, LayoutUnit());
-    else if (local_point.Y() > LogicalHeight())
-      local_point = LayoutPoint(column_start, LogicalHeight());
+    else if (local_point.Y() > ColumnLogicalHeight())
+      local_point = LayoutPoint(column_start, ColumnLogicalHeight());
   }
   return LayoutPoint(local_point.X(),
                      local_point.Y() + LogicalTopInFlowThreadAt(column_index));
 }
 
 LayoutRect MultiColumnFragmentainerGroup::FragmentsBoundingBox(
     const LayoutRect& bounding_box_in_flow_thread) const {
   // Find the start and end column intersected by the bounding box.
   LayoutRect flipped_bounding_box_in_flow_thread(bounding_box_in_flow_thread);
   LayoutFlowThread* flow_thread = column_set_.FlowThread();
@@ skipping 49 matching lines @@
     if (column_count > 1)
       overflow_rect.UniteEvenIfEmpty(ColumnRectAt(column_count - 1));
   }
   return overflow_rect;
 }
 
 unsigned MultiColumnFragmentainerGroup::ActualColumnCount() const {
   // We must always return a value of 1 or greater. Column count = 0 is a
   // meaningless situation, and will confuse and cause problems in other parts
   // of the code.
-  if (!column_height_)
+  LayoutUnit column_height = ColumnLogicalHeight();
+  if (!column_height)
     return 1;
 
   // Our flow thread portion determines our column count. We have as many
   // columns as needed to fit all the content.
   LayoutUnit flow_thread_portion_height = LogicalHeightInFlowThread();
   if (!flow_thread_portion_height)
     return 1;
 
-  unsigned count = (flow_thread_portion_height / column_height_).Floor();
+  unsigned count = (flow_thread_portion_height / column_height).Floor();
   // flowThreadPortionHeight may be saturated, so detect the remainder manually.
-  if (count * column_height_ < flow_thread_portion_height)
+  if (count * column_height < flow_thread_portion_height)
     count++;
   DCHECK_GE(count, 1u);
   return count;
 }
 
 LayoutUnit MultiColumnFragmentainerGroup::HeightAdjustedForRowOffset(
     LayoutUnit height) const {
   // Let's avoid zero height, as that would cause an infinite amount of columns
   // to be created.
   return std::max(
@@ skipping 16 matching lines @@
               BlockOffsetInEnclosingFragmentationContext());
       if (max_height > remaining_outer_logical_height)
         max_height = remaining_outer_logical_height;
     }
   }
   return max_height;
 }
 
 void MultiColumnFragmentainerGroup::SetAndConstrainColumnHeight(
     LayoutUnit new_height) {
-  column_height_ = new_height;
-  if (column_height_ > max_column_height_)
-    column_height_ = max_column_height_;
+  logical_height_ = new_height;
+  if (logical_height_ > max_logical_height_)
+    logical_height_ = max_logical_height_;
 }
 
 LayoutUnit MultiColumnFragmentainerGroup::RebalanceColumnHeightIfNeeded()
     const {
   if (ActualColumnCount() <= column_set_.UsedColumnCount()) {
     // With the current column height, the content fits without creating
     // overflowing columns. We're done.
-    return column_height_;
+    return logical_height_;
   }
 
-  if (column_height_ >= max_column_height_) {
+  if (logical_height_ >= max_logical_height_) {
     // We cannot stretch any further. We'll just have to live with the
     // overflowing columns. This typically happens if the max column height is
     // less than the height of the tallest piece of unbreakable content (e.g.
     // lines).
-    return column_height_;
+    return logical_height_;
   }
 
   MinimumSpaceShortageFinder shortage_finder(
       ColumnSet(), LogicalTopInFlowThread(), LogicalBottomInFlowThread());
 
   if (shortage_finder.ForcedBreaksCount() + 1 >=
       column_set_.UsedColumnCount()) {
     // Too many forced breaks to allow any implicit breaks. Initial balancing
     // should already have set a good height. There's nothing more we should do.
-    return column_height_;
+    return logical_height_;
   }
 
   // If the initial guessed column height wasn't enough, stretch it now. Stretch
   // by the lowest amount of space.
   LayoutUnit min_space_shortage = shortage_finder.MinimumSpaceShortage();
 
   DCHECK_GT(min_space_shortage, 0);  // We should never _shrink_ the height!
   DCHECK_NE(min_space_shortage,
             LayoutUnit::Max());  // If this happens, we probably have a bug.
   if (min_space_shortage == LayoutUnit::Max())
-    return column_height_;  // So bail out rather than looping infinitely.
+    return logical_height_;  // So bail out rather than looping infinitely.
 
-  return column_height_ + min_space_shortage;
+  return logical_height_ + min_space_shortage;
 }
 
 LayoutRect MultiColumnFragmentainerGroup::ColumnRectAt(
     unsigned column_index) const {
   LayoutUnit column_logical_width = column_set_.PageLogicalWidth();
   LayoutUnit column_logical_height = LogicalHeightInFlowThreadAt(column_index);
   LayoutUnit column_logical_top;
   LayoutUnit column_logical_left;
   LayoutUnit column_gap = column_set_.ColumnGap();
 
   if (column_set_.MultiColumnFlowThread()->ProgressionIsInline()) {
     if (column_set_.Style()->IsLeftToRightDirection())
       column_logical_left += column_index * (column_logical_width + column_gap);
     else
       column_logical_left += column_set_.ContentLogicalWidth() -
                              column_logical_width -
                              column_index * (column_logical_width + column_gap);
   } else {
-    column_logical_top += column_index * (column_height_ + column_gap);
+    column_logical_top += column_index * (ColumnLogicalHeight() + column_gap);
   }
 
   LayoutRect column_rect(column_logical_left, column_logical_top,
                          column_logical_width, column_logical_height);
   if (!column_set_.IsHorizontalWritingMode())
     return column_rect.TransposedRect();
   return column_rect;
 }
 
 LayoutRect MultiColumnFragmentainerGroup::FlowThreadPortionRectAt(
@@ skipping 75 matching lines @@
   return overflow_rect;
 }
 
 unsigned MultiColumnFragmentainerGroup::ColumnIndexAtOffset(
     LayoutUnit offset_in_flow_thread,
     LayoutBox::PageBoundaryRule page_boundary_rule) const {
   // Handle the offset being out of range.
   if (offset_in_flow_thread < logical_top_in_flow_thread_)
     return 0;
 
-  if (!column_height_)
+  LayoutUnit column_height = ColumnLogicalHeight();
+  if (!column_height)
     return 0;
   unsigned column_index =
-      ((offset_in_flow_thread - logical_top_in_flow_thread_) / column_height_)
+      ((offset_in_flow_thread - logical_top_in_flow_thread_) / column_height)
           .Floor();
   if (page_boundary_rule == LayoutBox::kAssociateWithFormerPage &&
       column_index > 0 &&
       LogicalTopInFlowThreadAt(column_index) == offset_in_flow_thread) {
     // We are exactly at a column boundary, and we've been told to associate
     // offsets at column boundaries with the former column, not the latter.
     column_index--;
   }
   return column_index;
 }
 
 unsigned MultiColumnFragmentainerGroup::ColumnIndexAtVisualPoint(
     const LayoutPoint& visual_point) const {
   bool is_column_progression_inline =
       column_set_.MultiColumnFlowThread()->ProgressionIsInline();
   bool is_horizontal_writing_mode = column_set_.IsHorizontalWritingMode();
   LayoutUnit column_length_in_column_progression_direction =
       is_column_progression_inline ? column_set_.PageLogicalWidth()
-                                   : LogicalHeight();
+                                   : ColumnLogicalHeight();
   LayoutUnit offset_in_column_progression_direction =
       is_horizontal_writing_mode == is_column_progression_inline
           ? visual_point.X()
           : visual_point.Y();
   if (!column_set_.Style()->IsLeftToRightDirection() &&
       is_column_progression_inline)
     offset_in_column_progression_direction =
         column_set_.LogicalWidth() - offset_in_column_progression_direction;
   LayoutUnit column_gap = column_set_.ColumnGap();
   if (column_length_in_column_progression_direction + column_gap <= 0)
@@ skipping 78 matching lines @@
 MultiColumnFragmentainerGroupList::AddExtraGroup() {
   Append(MultiColumnFragmentainerGroup(column_set_));
   return Last();
 }
 
 void MultiColumnFragmentainerGroupList::DeleteExtraGroups() {
   Shrink(1);
 }
 
 }  // namespace blink