reflow comments in core/layout/[M-Z]*.{cpp,h}

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 28 matching lines @@
 
 void MultiColumnFragmentainerGroup::resetColumnHeight() {
   m_maxColumnHeight = calculateMaxColumnHeight();
 
   LayoutMultiColumnFlowThread* flowThread = m_columnSet.multiColumnFlowThread();
   if (m_columnSet.heightIsAuto()) {
     FragmentationContext* enclosingFragmentationContext =
         flowThread->enclosingFragmentationContext();
     if (enclosingFragmentationContext &&
         enclosingFragmentationContext->isFragmentainerLogicalHeightKnown()) {
-      // Even if height is auto, we set an initial height, in order to tell how much content
-      // this MultiColumnFragmentainerGroup can hold, and when we need to append a new one.
+      // Even if height is auto, we set an initial height, in order to tell how
+      // much content this MultiColumnFragmentainerGroup can hold, and when we
+      // need to append a new one.
       m_columnHeight = m_maxColumnHeight;
     } else {
       m_columnHeight = LayoutUnit();
     }
   } else {
     setAndConstrainColumnHeight(
         heightAdjustedForRowOffset(flowThread->columnHeightAvailable()));
   }
 }
 
 bool MultiColumnFragmentainerGroup::recalculateColumnHeight(
     LayoutMultiColumnSet& columnSet) {
   LayoutUnit oldColumnHeight = m_columnHeight;
 
   m_maxColumnHeight = 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.
+  // 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() && columnSet.heightIsAuto()) {
     LayoutUnit newColumnHeight;
     if (!columnSet.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 max-height). Propagate this to our
-      // containing column set, in case there is an outer multicol container that also needs
-      // to balance. After having calculated the initial column height, the multicol container
-      // needs another layout pass with the column height that we just calculated.
+      // 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
+      // max-height). Propagate this to our containing column set, in case there
+      // is an outer multicol container that also needs to balance. After having
+      // calculated the initial column height, the multicol container needs
+      // another layout pass with the column height that we just calculated.
       InitialColumnHeightFinder initialHeightFinder(
           columnSet, logicalTopInFlowThread(), logicalBottomInFlowThread());
       LayoutUnit tallestUnbreakableLogicalHeight =
           initialHeightFinder.tallestUnbreakableLogicalHeight();
       columnSet.propagateTallestUnbreakableLogicalHeight(
           tallestUnbreakableLogicalHeight);
       newColumnHeight =
           std::max(initialHeightFinder.initialMinimalBalancedHeight(),
                    tallestUnbreakableLogicalHeight);
     } else {
-      // 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.
+      // 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.
       newColumnHeight = rebalanceColumnHeightIfNeeded();
     }
     setAndConstrainColumnHeight(newColumnHeight);
   } else {
-    // The position of the column set may have changed, in which case height available for
-    // columns may have changed as well.
+    // The position of the column set may have changed, in which case height
+    // available for columns may have changed as well.
     setAndConstrainColumnHeight(m_columnHeight);
   }
 
   if (m_columnHeight == oldColumnHeight)
     return false;  // No change. We're done.
 
   return true;  // Need another pass.
 }
 
 LayoutSize MultiColumnFragmentainerGroup::flowThreadTranslationAtOffset(
     LayoutUnit offsetInFlowThread,
     LayoutBox::PageBoundaryRule rule,
     CoordinateSpaceConversion mode) const {
   LayoutMultiColumnFlowThread* flowThread = m_columnSet.multiColumnFlowThread();
 
-  // A column out of range doesn't have a flow thread portion, so we need to clamp to make sure
-  // that we stay within the actual columns. This means that content in the overflow area will be
-  // mapped to the last actual column, instead of being mapped to an imaginary column further
-  // ahead.
+  // A column out of range doesn't have a flow thread portion, so we need to
+  // clamp to make sure that we stay within the actual columns. This means that
+  // content in the overflow area will be mapped to the last actual column,
+  // instead of being mapped to an imaginary column further ahead.
   unsigned columnIndex = offsetInFlowThread >= logicalBottomInFlowThread()
                              ? actualColumnCount() - 1
                              : columnIndexAtOffset(offsetInFlowThread, rule);
 
   LayoutRect portionRect(flowThreadPortionRectAt(columnIndex));
   flowThread->flipForWritingMode(portionRect);
   portionRect.moveBy(flowThread->topLeftLocation());
 
   LayoutRect columnRect(columnRectAt(columnIndex));
   columnRect.move(offsetFromColumnSet());
   m_columnSet.flipForWritingMode(columnRect);
   columnRect.moveBy(m_columnSet.topLeftLocation());
 
   LayoutSize translationRelativeToFlowThread =
       columnRect.location() - portionRect.location();
   if (mode == CoordinateSpaceConversion::Containing)
     return translationRelativeToFlowThread;
 
   LayoutSize enclosingTranslation;
   if (LayoutMultiColumnFlowThread* enclosingFlowThread =
           flowThread->enclosingFlowThread()) {
     const MultiColumnFragmentainerGroup& firstRow =
         flowThread->firstMultiColumnSet()->firstFragmentainerGroup();
-    // Translation that would map points in the coordinate space of the outermost flow thread to
-    // visual points in the first column in the first fragmentainer group (row) in our multicol
-    // container.
+    // Translation that would map points in the coordinate space of the
+    // outermost flow thread to visual points in the first column in the first
+    // fragmentainer group (row) in our multicol container.
     LayoutSize enclosingTranslationOrigin =
         enclosingFlowThread->flowThreadTranslationAtOffset(
             firstRow.blockOffsetInEnclosingFragmentationContext(),
             LayoutBox::AssociateWithLatterPage, mode);
 
-    // Translation that would map points in the coordinate space of the outermost flow thread to
-    // visual points in the first column in this fragmentainer group.
+    // Translation that would map points in the coordinate space of the
+    // outermost flow thread to visual points in the first column in this
+    // fragmentainer group.
     enclosingTranslation = enclosingFlowThread->flowThreadTranslationAtOffset(
         blockOffsetInEnclosingFragmentationContext(),
         LayoutBox::AssociateWithLatterPage, mode);
 
-    // What we ultimately return from this method is a translation that maps points in the
-    // coordinate space of our flow thread to a visual point in a certain column in this
-    // fragmentainer group. We had to go all the way up to the outermost flow thread, since this
-    // fragmentainer group may be in a different outer column than the first outer column that
-    // this multicol container lives in. It's the visual distance between the first
-    // fragmentainer group and this fragmentainer group that we need to add to the translation.
+    // What we ultimately return from this method is a translation that maps
+    // points in the coordinate space of our flow thread to a visual point in a
+    // certain column in this fragmentainer group. We had to go all the way up
+    // to the outermost flow thread, since this fragmentainer group may be in a
+    // different outer column than the first outer column that this multicol
+    // container lives in. It's the visual distance between the first
+    // fragmentainer group and this fragmentainer group that we need to add to
+    // the translation.
     enclosingTranslation -= enclosingTranslationOrigin;
   }
 
   return enclosingTranslation + translationRelativeToFlowThread;
 }
 
 LayoutUnit MultiColumnFragmentainerGroup::columnLogicalTopForOffset(
     LayoutUnit offsetInFlowThread) const {
   unsigned columnIndex = columnIndexAtOffset(
       offsetInFlowThread, LayoutBox::AssociateWithLatterPage);
   return logicalTopInFlowThreadAt(columnIndex);
 }
 
 LayoutPoint MultiColumnFragmentainerGroup::visualPointToFlowThreadPoint(
     const LayoutPoint& visualPoint) const {
   unsigned columnIndex = columnIndexAtVisualPoint(visualPoint);
   LayoutRect columnRect = columnRectAt(columnIndex);
   LayoutPoint localPoint(visualPoint);
   localPoint.moveBy(-columnRect.location());
-  // Before converting to a flow thread position, if the block direction coordinate is outside the
-  // column, snap to the bounds of the column, and reset the inline direction coordinate to the
-  // start position in the column. The effect of this is that if the block position is before the
-  // column rectangle, we'll get to the beginning of this column, while if the block position is
-  // after the column rectangle, we'll get to the beginning of the next column.
+  // Before converting to a flow thread position, if the block direction
+  // coordinate is outside the column, snap to the bounds of the column, and
+  // reset the inline direction coordinate to the start position in the column.
+  // The effect of this is that if the block position is before the column
+  // rectangle, we'll get to the beginning of this column, while if the block
+  // position is after the column rectangle, we'll get to the beginning of the
+  // next column.
   if (!m_columnSet.isHorizontalWritingMode()) {
     LayoutUnit columnStart = m_columnSet.style()->isLeftToRightDirection()
                                  ? LayoutUnit()
                                  : columnRect.height();
     if (localPoint.x() < 0)
       localPoint = LayoutPoint(LayoutUnit(), columnStart);
     else if (localPoint.x() > logicalHeight())
       localPoint = LayoutPoint(logicalHeight(), columnStart);
     return LayoutPoint(localPoint.x() + logicalTopInFlowThreadAt(columnIndex),
                        localPoint.y());
@@ skipping 16 matching lines @@
   LayoutFlowThread* flowThread = m_columnSet.flowThread();
   flowThread->flipForWritingMode(flippedBoundingBoxInFlowThread);
   bool isHorizontalWritingMode = m_columnSet.isHorizontalWritingMode();
   LayoutUnit boundingBoxLogicalTop = isHorizontalWritingMode
                                          ? flippedBoundingBoxInFlowThread.y()
                                          : flippedBoundingBoxInFlowThread.x();
   LayoutUnit boundingBoxLogicalBottom =
       isHorizontalWritingMode ? flippedBoundingBoxInFlowThread.maxY()
                               : flippedBoundingBoxInFlowThread.maxX();
   if (boundingBoxLogicalBottom <= logicalTopInFlowThread() ||
-      boundingBoxLogicalTop >= logicalBottomInFlowThread())
-    return LayoutRect();  // The bounding box doesn't intersect this fragmentainer group.
+      boundingBoxLogicalTop >= logicalBottomInFlowThread()) {
+    // The bounding box doesn't intersect this fragmentainer group.
+    return LayoutRect();
+  }
   unsigned startColumn;
   unsigned endColumn;
   columnIntervalForBlockRangeInFlowThread(
       boundingBoxLogicalTop, boundingBoxLogicalBottom, startColumn, endColumn);
 
   LayoutRect startColumnFlowThreadOverflowPortion =
       flowThreadPortionOverflowRectAt(startColumn);
   flowThread->flipForWritingMode(startColumnFlowThreadOverflowPortion);
   LayoutRect startColumnRect(boundingBoxInFlowThread);
   startColumnRect.intersect(startColumnFlowThreadOverflowPortion);
   startColumnRect.move(flowThreadTranslationAtOffset(
       logicalTopInFlowThreadAt(startColumn), LayoutBox::AssociateWithLatterPage,
       CoordinateSpaceConversion::Containing));
   if (startColumn == endColumn)
     return startColumnRect;  // It all takes place in one column. We're done.
 
   LayoutRect endColumnFlowThreadOverflowPortion =
       flowThreadPortionOverflowRectAt(endColumn);
   flowThread->flipForWritingMode(endColumnFlowThreadOverflowPortion);
   LayoutRect endColumnRect(boundingBoxInFlowThread);
   endColumnRect.intersect(endColumnFlowThreadOverflowPortion);
   endColumnRect.move(flowThreadTranslationAtOffset(
       logicalTopInFlowThreadAt(endColumn), LayoutBox::AssociateWithLatterPage,
       CoordinateSpaceConversion::Containing));
   return unionRect(startColumnRect, endColumnRect);
 }
 
 LayoutRect MultiColumnFragmentainerGroup::calculateOverflow() const {
-  // Note that we just return the bounding rectangle of the column boxes here. We currently don't
-  // examine overflow caused by the actual content that ends up in each column.
+  // Note that we just return the bounding rectangle of the column boxes here.
+  // We currently don't examine overflow caused by the actual content that ends
+  // up in each column.
   LayoutRect overflowRect;
   if (unsigned columnCount = actualColumnCount()) {
     overflowRect = columnRectAt(0);
     if (columnCount > 1)
       overflowRect.uniteEvenIfEmpty(columnRectAt(columnCount - 1));
   }
   return overflowRect;
 }
 
 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.
+  // 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 (!m_columnHeight)
     return 1;
 
-  // Our flow thread portion determines our column count. We have as many columns as needed to fit
-  // all the content.
+  // Our flow thread portion determines our column count. We have as many
+  // columns as needed to fit all the content.
   LayoutUnit flowThreadPortionHeight = logicalHeightInFlowThread();
   if (!flowThreadPortionHeight)
     return 1;
 
   unsigned count = (flowThreadPortionHeight / m_columnHeight).floor();
   // flowThreadPortionHeight may be saturated, so detect the remainder manually.
   if (count * m_columnHeight < flowThreadPortionHeight)
     count++;
   ASSERT(count >= 1);
   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.
+  // Let's avoid zero height, as that would cause an infinite amount of columns
+  // to be created.
   return std::max(
       height - logicalTop() - m_columnSet.logicalTopFromMulticolContentEdge(),
       LayoutUnit(1));
 }
 
 LayoutUnit MultiColumnFragmentainerGroup::calculateMaxColumnHeight() const {
   LayoutMultiColumnFlowThread* flowThread = m_columnSet.multiColumnFlowThread();
   LayoutUnit maxColumnHeight = flowThread->maxColumnLogicalHeight();
   LayoutUnit maxHeight = heightAdjustedForRowOffset(maxColumnHeight);
   if (FragmentationContext* enclosingFragmentationContext =
           flowThread->enclosingFragmentationContext()) {
     if (enclosingFragmentationContext->isFragmentainerLogicalHeightKnown()) {
-      // We're nested inside another fragmentation context whose fragmentainer heights are
-      // known. This constrains the max height.
+      // We're nested inside another fragmentation context whose fragmentainer
+      // heights are known. This constrains the max height.
       LayoutUnit remainingOuterLogicalHeight =
           enclosingFragmentationContext->remainingLogicalHeightAt(
               blockOffsetInEnclosingFragmentationContext());
       ASSERT(remainingOuterLogicalHeight > 0);
       if (maxHeight > remainingOuterLogicalHeight)
         maxHeight = remainingOuterLogicalHeight;
     }
   }
   return maxHeight;
 }
 
 void MultiColumnFragmentainerGroup::setAndConstrainColumnHeight(
     LayoutUnit newHeight) {
   m_columnHeight = newHeight;
   if (m_columnHeight > m_maxColumnHeight)
     m_columnHeight = m_maxColumnHeight;
 }
 
 LayoutUnit MultiColumnFragmentainerGroup::rebalanceColumnHeightIfNeeded()
     const {
   if (actualColumnCount() <= m_columnSet.usedColumnCount()) {
-    // With the current column height, the content fits without creating overflowing columns. We're done.
+    // With the current column height, the content fits without creating
+    // overflowing columns. We're done.
     return m_columnHeight;
   }
 
   if (m_columnHeight >= m_maxColumnHeight) {
-    // 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).
+    // 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 m_columnHeight;
   }
 
   MinimumSpaceShortageFinder shortageFinder(
       columnSet(), logicalTopInFlowThread(), logicalBottomInFlowThread());
 
   if (shortageFinder.forcedBreaksCount() + 1 >= m_columnSet.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.
+    // 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 m_columnHeight;
   }
 
-  // If the initial guessed column height wasn't enough, stretch it now. Stretch by the lowest
-  // amount of space.
+  // If the initial guessed column height wasn't enough, stretch it now. Stretch
+  // by the lowest amount of space.
   LayoutUnit minSpaceShortage = shortageFinder.minimumSpaceShortage();
 
   ASSERT(minSpaceShortage > 0);  // We should never _shrink_ the height!
   ASSERT(minSpaceShortage !=
          LayoutUnit::max());  // If this happens, we probably have a bug.
   if (minSpaceShortage == LayoutUnit::max())
     return m_columnHeight;  // So bail out rather than looping infinitely.
 
   return m_columnHeight + minSpaceShortage;
 }
@@ skipping 46 matching lines @@
   LayoutUnit portionLogicalHeight = logicalBottom - logicalTop;
   if (m_columnSet.isHorizontalWritingMode())
     return LayoutRect(LayoutUnit(), logicalTop, m_columnSet.pageLogicalWidth(),
                       portionLogicalHeight);
   return LayoutRect(logicalTop, LayoutUnit(), portionLogicalHeight,
                     m_columnSet.pageLogicalWidth());
 }
 
 LayoutRect MultiColumnFragmentainerGroup::flowThreadPortionOverflowRectAt(
     unsigned columnIndex) const {
-  // This function determines the portion of the flow thread that paints for the column. Along the inline axis, columns are
-  // unclipped at outside edges (i.e., the first and last column in the set), and they clip to half the column
-  // gap along interior edges.
+  // This function determines the portion of the flow thread that paints for the
+  // column. Along the inline axis, columns are unclipped at outside edges
+  // (i.e., the first and last column in the set), and they clip to half the
+  // column gap along interior edges.
   //
-  // In the block direction, we will not clip overflow out of the top of the first column, or out of the bottom of
-  // the last column. This applies only to the true first column and last column across all column sets.
+  // In the block direction, we will not clip overflow out of the top of the
+  // first column, or out of the bottom of the last column. This applies only to
+  // the true first column and last column across all column sets.
   //
-  // FIXME: Eventually we will know overflow on a per-column basis, but we can't do this until we have a painting
-  // mode that understands not to paint contents from a previous column in the overflow area of a following column.
+  // FIXME: Eventually we will know overflow on a per-column basis, but we can't
+  // do this until we have a painting mode that understands not to paint
+  // contents from a previous column in the overflow area of a following column.
   bool isFirstColumnInRow = !columnIndex;
   bool isLastColumnInRow = columnIndex == actualColumnCount() - 1;
   bool isLTR = m_columnSet.style()->isLeftToRightDirection();
   bool isLeftmostColumn = isLTR ? isFirstColumnInRow : isLastColumnInRow;
   bool isRightmostColumn = isLTR ? isLastColumnInRow : isFirstColumnInRow;
 
   LayoutRect portionRect = flowThreadPortionRectAt(columnIndex);
   bool isFirstColumnInMulticolContainer =
       isFirstColumnInRow && this == &m_columnSet.firstFragmentainerGroup() &&
       !m_columnSet.previousSiblingMultiColumnSet();
   bool isLastColumnInMulticolContainer =
       isLastColumnInRow && this == &m_columnSet.lastFragmentainerGroup() &&
       !m_columnSet.nextSiblingMultiColumnSet();
-  // Calculate the overflow rectangle, based on the flow thread's, clipped at column logical
-  // top/bottom unless it's the first/last column.
+  // Calculate the overflow rectangle, based on the flow thread's, clipped at
+  // column logical top/bottom unless it's the first/last column.
   LayoutRect overflowRect = m_columnSet.overflowRectForFlowThreadPortion(
       portionRect, isFirstColumnInMulticolContainer,
       isLastColumnInMulticolContainer);
 
-  // Avoid overflowing into neighboring columns, by clipping in the middle of adjacent column
-  // gaps. Also make sure that we avoid rounding errors.
+  // Avoid overflowing into neighboring columns, by clipping in the middle of
+  // adjacent column gaps. Also make sure that we avoid rounding errors.
   LayoutUnit columnGap = m_columnSet.columnGap();
   if (m_columnSet.isHorizontalWritingMode()) {
     if (!isLeftmostColumn)
       overflowRect.shiftXEdgeTo(portionRect.x() - columnGap / 2);
     if (!isRightmostColumn)
       overflowRect.shiftMaxXEdgeTo(portionRect.maxX() + columnGap -
                                    columnGap / 2);
   } else {
     if (!isLeftmostColumn)
       overflowRect.shiftYEdgeTo(portionRect.y() - columnGap / 2);
@@ skipping 12 matching lines @@
     return 0;
 
   if (!m_columnHeight)
     return 0;
   unsigned columnIndex =
       ((offsetInFlowThread - m_logicalTopInFlowThread) / m_columnHeight)
           .floor();
   if (pageBoundaryRule == LayoutBox::AssociateWithFormerPage &&
       columnIndex > 0 &&
       logicalTopInFlowThreadAt(columnIndex) == offsetInFlowThread) {
-    // 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.
+    // 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.
     columnIndex--;
   }
   return columnIndex;
 }
 
 unsigned MultiColumnFragmentainerGroup::columnIndexAtVisualPoint(
     const LayoutPoint& visualPoint) const {
   bool isColumnProgressionInline =
       m_columnSet.multiColumnFlowThread()->progressionIsInline();
   bool isHorizontalWritingMode = m_columnSet.isHorizontalWritingMode();
@@ skipping 25 matching lines @@
     unsigned& firstColumn,
     unsigned& lastColumn) const {
   logicalTopInFlowThread =
       std::max(logicalTopInFlowThread, this->logicalTopInFlowThread());
   logicalBottomInFlowThread =
       std::min(logicalBottomInFlowThread, this->logicalBottomInFlowThread());
   ASSERT(logicalTopInFlowThread <= logicalBottomInFlowThread);
   firstColumn = columnIndexAtOffset(logicalTopInFlowThread,
                                     LayoutBox::AssociateWithLatterPage);
   if (logicalBottomInFlowThread == logicalTopInFlowThread) {
-    // Zero-height block range. There'll be one column in the interval. Set it right away. This
-    // is important if we're at a column boundary, since calling columnIndexAtOffset() with the
-    // end-exclusive bottom offset would actually give us the *previous* column.
+    // Zero-height block range. There'll be one column in the interval. Set it
+    // right away. This is important if we're at a column boundary, since
+    // calling columnIndexAtOffset() with the end-exclusive bottom offset would
+    // actually give us the *previous* column.
     lastColumn = firstColumn;
   } else {
     lastColumn = columnIndexAtOffset(logicalBottomInFlowThread,
                                      LayoutBox::AssociateWithFormerPage);
   }
 }
 
 void MultiColumnFragmentainerGroup::columnIntervalForVisualRect(
     const LayoutRect& rect,
     unsigned& firstColumn,
@@ skipping 22 matching lines @@
   }
   ASSERT(firstColumn <= lastColumn);
 }
 
 MultiColumnFragmentainerGroupList::MultiColumnFragmentainerGroupList(
     LayoutMultiColumnSet& columnSet)
     : m_columnSet(columnSet) {
   append(MultiColumnFragmentainerGroup(m_columnSet));
 }
 
-// An explicit empty destructor of MultiColumnFragmentainerGroupList should be in
-// MultiColumnFragmentainerGroup.cpp, because if an implicit destructor is used,
-// msvc 2015 tries to generate its destructor (because the class is dll-exported class)
-// and causes a compile error because of lack of MultiColumnFragmentainerGroup::operator=.
-// Since MultiColumnFragmentainerGroup is non-copyable, we cannot define the operator=.
+// An explicit empty destructor of MultiColumnFragmentainerGroupList should be
+// in MultiColumnFragmentainerGroup.cpp, because if an implicit destructor is
+// used, msvc 2015 tries to generate its destructor (because the class is
+// dll-exported class) and causes a compile error because of lack of
+// MultiColumnFragmentainerGroup::operator=.  Since
+// MultiColumnFragmentainerGroup is non-copyable, we cannot define the
+// operator=.

[dcheng, 2016/10/07 20:42:01]

o.O

 MultiColumnFragmentainerGroupList::~MultiColumnFragmentainerGroupList() {}
 
 MultiColumnFragmentainerGroup&
 MultiColumnFragmentainerGroupList::addExtraGroup() {
   append(MultiColumnFragmentainerGroup(m_columnSet));
   return last();
 }
 
 void MultiColumnFragmentainerGroupList::deleteExtraGroups() {
   shrink(1);
 }
 
 }  // namespace blink