third_party/WebKit/Source/core/layout/ColumnBalancer.cpp - Issue 2391893004: Reformat comments in core/layout up until LayoutBox

Unified Diff: third_party/WebKit/Source/core/layout/ColumnBalancer.cpp

Issue 2391893004: Reformat comments in core/layout up until LayoutBox (Closed)

Patch Set: Created 4 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

« no previous file with comments | « third_party/WebKit/Source/core/layout/ColumnBalancer.h ('k') | third_party/WebKit/Source/core/layout/CounterNode.h » ('j') | third_party/WebKit/Source/core/layout/CounterNode.cpp » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: third_party/WebKit/Source/core/layout/ColumnBalancer.cpp

diff --git a/third_party/WebKit/Source/core/layout/ColumnBalancer.cpp b/third_party/WebKit/Source/core/layout/ColumnBalancer.cpp

index cf0ed98f1c676f5d240305917a64a8b2d2d20fc7..52a2c1da3f4a39138cf721b12f095b92af20df4d 100644

--- a/third_party/WebKit/Source/core/layout/ColumnBalancer.cpp

+++ b/third_party/WebKit/Source/core/layout/ColumnBalancer.cpp

@@ -29,10 +29,8 @@ void ColumnBalancer::traverseSubtree(const LayoutBox& box) {

line; line = line->nextRootBox()) {

LayoutUnit lineTopInFlowThread =

m_flowThreadOffset + line->lineTopWithLeading();

- if (lineTopInFlowThread < logicalTopInFlowThread())

- continue;

- if (lineTopInFlowThread >= logicalBottomInFlowThread())

- break;

+ if (lineTopInFlowThread < logicalTopInFlowThread()) continue;

+ if (lineTopInFlowThread >= logicalBottomInFlowThread()) break;

examineLine(*line);

}

@@ -40,16 +38,17 @@ void ColumnBalancer::traverseSubtree(const LayoutBox& box) {

const LayoutFlowThread* flowThread = columnSet().flowThread();

bool isHorizontalWritingMode = flowThread->isHorizontalWritingMode();

- // The break-after value from the previous in-flow block-level object to be joined with the

+ // The break-after value from the previous in-flow block-level object to be

+ // joined with the

// break-before value of the next in-flow block-level sibling.

ikilpatrick 2016/10/04 16:39:02 bad.

EBreak previousBreakAfterValue = BreakAuto;

- // Look for breaks between and inside block-level children. Even if this is a block flow with

+ // Look for breaks between and inside block-level children. Even if this is a

+ // block flow with

// inline children, there may be interesting floats to examine here.

for (const LayoutObject* child = box.slowFirstChild(); child;

child = child->nextSibling()) {

- if (!child->isBox() || child->isInline())

- continue;

+ if (!child->isBox() || child->isInline()) continue;

const LayoutBox& childBox = toLayoutBox(*child);

LayoutRect overflowRect = childBox.layoutOverflowRect();

LayoutUnit childLogicalBottomWithOverflow =

@@ -65,20 +64,23 @@ void ColumnBalancer::traverseSubtree(const LayoutBox& box) {

(isHorizontalWritingMode ? overflowRect.y() : overflowRect.x());

if (m_flowThreadOffset + childLogicalTopWithOverflow >=

logicalBottomInFlowThread()) {

- // This child is fully below the flow thread portion we're examining. We cannot just

+ // This child is fully below the flow thread portion we're examining. We

+ // cannot just

ikilpatrick 2016/10/04 16:39:02 bad.

// stop here, though, thanks to negative margins. So keep looking.

continue;

}

if (childBox.isOutOfFlowPositioned() || childBox.isColumnSpanAll())

continue;

- // Tables are wicked. Both table rows and table cells are relative to their table section.

+ // Tables are wicked. Both table rows and table cells are relative to their

+ // table section.

LayoutUnit offsetForThisChild =

childBox.isTableRow() ? LayoutUnit() : childBox.logicalTop();

m_flowThreadOffset += offsetForThisChild;

examineBoxAfterEntering(childBox, previousBreakAfterValue);

- // Unless the child is unsplittable, or if the child establishes an inner multicol

+ // Unless the child is unsplittable, or if the child establishes an inner

+ // multicol

ikilpatrick 2016/10/04 16:39:02 bad.

// container, we descend into its subtree for further examination.

if (childBox.getPaginationBreakability() != LayoutBox::ForbidBreaks &&

(!childBox.isLayoutBlockFlow() ||

@@ -92,18 +94,16 @@ void ColumnBalancer::traverseSubtree(const LayoutBox& box) {

}

InitialColumnHeightFinder::InitialColumnHeightFinder(

- const LayoutMultiColumnSet& columnSet,

- LayoutUnit logicalTopInFlowThread,

+ const LayoutMultiColumnSet& columnSet, LayoutUnit logicalTopInFlowThread,

LayoutUnit logicalBottomInFlowThread)

- : ColumnBalancer(columnSet,

- logicalTopInFlowThread,

+ : ColumnBalancer(columnSet, logicalTopInFlowThread,

logicalBottomInFlowThread) {

m_shortestStruts.resize(columnSet.usedColumnCount());

- for (auto& strut : m_shortestStruts)

- strut = LayoutUnit::max();

+ for (auto& strut : m_shortestStruts) strut = LayoutUnit::max() { }

traverse();

- // We have now found each explicit / forced break, and their location. Now we need to figure out

- // how many additional implicit / soft breaks we need and guess where they will occur, in order

+ // We have now found each explicit / forced break, and their location. Now we

+ // need to figure out how many additional implicit / soft breaks we need and

+ // guess where they will occur, in order

// to provide an initial column height.

distributeImplicitBreaks();

}

@@ -116,8 +116,7 @@ LayoutUnit InitialColumnHeightFinder::initialMinimalBalancedHeight() const {

}

void InitialColumnHeightFinder::examineBoxAfterEntering(

- const LayoutBox& box,

- EBreak previousBreakAfterValue) {

+ const LayoutBox& box, EBreak previousBreakAfterValue) {

if (isLogicalTopWithinBounds(flowThreadOffset() - box.paginationStrut())) {

if (box.needsForcedBreakBefore(previousBreakAfterValue)) {

addContentRun(flowThreadOffset());

@@ -138,13 +137,12 @@ void InitialColumnHeightFinder::examineBoxAfterEntering(

std::max(m_tallestUnbreakableLogicalHeight, unsplittableLogicalHeight);

return;

}

- // Need to examine inner multicol containers to find their tallest unbreakable piece of content.

- if (!box.isLayoutBlockFlow())

- return;

+ // Need to examine inner multicol containers to find their tallest unbreakable

+ // piece of content.

+ if (!box.isLayoutBlockFlow()) return;

LayoutMultiColumnFlowThread* innerFlowThread =

toLayoutBlockFlow(box).multiColumnFlowThread();

- if (!innerFlowThread || innerFlowThread->isLayoutPagedFlowThread())

- return;

+ if (!innerFlowThread || innerFlowThread->isLayoutPagedFlowThread()) return;

LayoutUnit offsetInInnerFlowThread =

flowThreadOffset() -

innerFlowThread->blockOffsetInEnclosingFragmentationContext();

@@ -157,9 +155,9 @@ void InitialColumnHeightFinder::examineBoxAfterEntering(

void InitialColumnHeightFinder::examineBoxBeforeLeaving(const LayoutBox& box) {}

static inline LayoutUnit columnLogicalHeightRequirementForLine(

- const ComputedStyle& style,

- const RootInlineBox& lastLine) {

- // We may require a certain minimum number of lines per page in order to satisfy

+ const ComputedStyle& style, const RootInlineBox& lastLine) {

+ // We may require a certain minimum number of lines per page in order to

+ // satisfy

// orphans and widows, and that may affect the minimum page height.

ikilpatrick 2016/10/04 16:39:02 bad.

unsigned minimumLineCount =

std::max<unsigned>(style.orphans(), style.widows());

@@ -184,16 +182,14 @@ void InitialColumnHeightFinder::examineLine(const RootInlineBox& line) {

}

void InitialColumnHeightFinder::recordStrutBeforeOffset(

- LayoutUnit offsetInFlowThread,

- LayoutUnit strut) {

+ LayoutUnit offsetInFlowThread, LayoutUnit strut) {

ASSERT(columnSet().usedColumnCount() >= 1);

unsigned columnCount = columnSet().usedColumnCount();

ASSERT(m_shortestStruts.size() == columnCount);

unsigned index = groupAtOffset(offsetInFlowThread)

.columnIndexAtOffset(offsetInFlowThread - strut,

LayoutBox::AssociateWithLatterPage);

- if (index >= columnCount)

- return;

+ if (index >= columnCount) return;

m_shortestStruts[index] = std::min(m_shortestStruts[index], strut);

}

@@ -220,7 +216,8 @@ void InitialColumnHeightFinder::addContentRun(

if (!m_contentRuns.isEmpty() &&

endOffsetInFlowThread <= m_contentRuns.last().breakOffset())

return;

- // Append another item as long as we haven't exceeded used column count. What ends up in the

+ // Append another item as long as we haven't exceeded used column count. What

+ // ends up in the

// overflow area shouldn't affect column balancing.

ikilpatrick 2016/10/04 16:39:02 bad.

if (m_contentRuns.size() < columnSet().usedColumnCount())

m_contentRuns.append(ContentRun(endOffsetInFlowThread));

@@ -245,17 +242,19 @@ unsigned InitialColumnHeightFinder::contentRunIndexWithTallestColumns() const {

}

void InitialColumnHeightFinder::distributeImplicitBreaks() {

- // Insert a final content run to encompass all content. This will include overflow if we're at

+ // Insert a final content run to encompass all content. This will include

+ // overflow if we're at

// the end of the multicol container.

ikilpatrick 2016/10/04 16:39:02 bad.

addContentRun(logicalBottomInFlowThread());

unsigned columnCount = m_contentRuns.size();

- // If there is room for more breaks (to reach the used value of column-count), imagine that we

- // insert implicit breaks at suitable locations. At any given time, the content run with the

- // currently tallest columns will get another implicit break "inserted", which will increase its

- // column count by one and shrink its columns' height. Repeat until we have the desired total

- // number of breaks. The largest column height among the runs will then be the initial column

- // height for the balancer to use.

+ // If there is room for more breaks (to reach the used value of column-count),

+ // imagine that we insert implicit breaks at suitable locations. At any given

+ // time, the content run with the currently tallest columns will get another

+ // implicit break "inserted", which will increase its column count by one and

+ // shrink its columns' height. Repeat until we have the desired total number

+ // of breaks. The largest column height among the runs will then be the

+ // initial column height for the balancer to use.

while (columnCount < columnSet().usedColumnCount()) {

unsigned index = contentRunIndexWithTallestColumns();

m_contentRuns[index].assumeAnotherImplicitBreak();

@@ -264,11 +263,9 @@ void InitialColumnHeightFinder::distributeImplicitBreaks() {

}

MinimumSpaceShortageFinder::MinimumSpaceShortageFinder(

- const LayoutMultiColumnSet& columnSet,

- LayoutUnit logicalTopInFlowThread,

+ const LayoutMultiColumnSet& columnSet, LayoutUnit logicalTopInFlowThread,

LayoutUnit logicalBottomInFlowThread)

- : ColumnBalancer(columnSet,

- logicalTopInFlowThread,

+ : ColumnBalancer(columnSet, logicalTopInFlowThread,

logicalBottomInFlowThread),

m_minimumSpaceShortage(LayoutUnit::max()),

m_pendingStrut(LayoutUnit::min()),

@@ -277,8 +274,7 @@ MinimumSpaceShortageFinder::MinimumSpaceShortageFinder(

}

void MinimumSpaceShortageFinder::examineBoxAfterEntering(

- const LayoutBox& box,

- EBreak previousBreakAfterValue) {

+ const LayoutBox& box, EBreak previousBreakAfterValue) {

LayoutBox::PaginationBreakability breakability =

box.getPaginationBreakability();

@@ -291,15 +287,17 @@ void MinimumSpaceShortageFinder::examineBoxAfterEntering(

if (isFirstAfterBreak(flowThreadOffset())) {

// This box is first after a soft break.

LayoutUnit strut = box.paginationStrut();

- // Figure out how much more space we would need to prevent it from being pushed to the next column.

+ // Figure out how much more space we would need to prevent it from being

+ // pushed to the next column.

recordSpaceShortage(box.logicalHeight() - strut);

if (breakability != LayoutBox::ForbidBreaks &&

m_pendingStrut == LayoutUnit::min()) {

- // We now want to look for the first piece of unbreakable content (e.g. a line or a

- // block-displayed image) inside this block. That ought to be a good candidate for

- // minimum space shortage; a much better one than reporting space shortage for the

- // entire block (which we'll also do (further down), in case we couldn't find anything

- // more suitable).

+ // We now want to look for the first piece of unbreakable content

+ // (e.g. a line or a block-displayed image) inside this block. That

+ // ought to be a good candidate for minimum space shortage; a much

+ // better one than reporting space shortage for the entire block

+ // (which we'll also do (further down), in case we couldn't find

+ // anything more suitable).

m_pendingStrut = strut;

}

@@ -314,11 +312,12 @@ void MinimumSpaceShortageFinder::examineBoxAfterEntering(

if (isFirstAfterBreak(flowThreadOffset()) ||

group.columnLogicalTopForOffset(flowThreadOffset()) !=

group.columnLogicalTopForOffset(bottomInFlowThread)) {

- // If the child crosses a column boundary, record space shortage, in case nothing

- // inside it has already done so. The column balancer needs to know by how much it

- // has to stretch the columns to make more content fit. If no breaks are reported

- // (but do occur), the balancer will have no clue. Only measure the space after the

- // last column boundary, in case it crosses more than one.

+ // If the child crosses a column boundary, record space shortage, in case

+ // nothing inside it has already done so. The column balancer needs to

+ // know by how much it has to stretch the columns to make more content

+ // fit. If no breaks are reported (but do occur), the balancer will have

+ // no clue. Only measure the space after the last column boundary, in case

+ // it crosses more than one.

LayoutUnit spaceUsedInLastColumn =

bottomInFlowThread -

group.columnLogicalTopForOffset(bottomInFlowThread);

@@ -327,19 +326,17 @@ void MinimumSpaceShortageFinder::examineBoxAfterEntering(

}

// If this is an inner multicol container, look for space shortage inside it.

- if (!box.isLayoutBlockFlow())

- return;

+ if (!box.isLayoutBlockFlow()) return;

LayoutMultiColumnFlowThread* flowThread =

toLayoutBlockFlow(box).multiColumnFlowThread();

- if (!flowThread || flowThread->isLayoutPagedFlowThread())

- return;

+ if (!flowThread || flowThread->isLayoutPagedFlowThread()) return;

for (const LayoutMultiColumnSet* columnSet =

flowThread->firstMultiColumnSet();

columnSet; columnSet = columnSet->nextSiblingMultiColumnSet()) {

- // Establish an inner shortage finder for this column set in the inner multicol

- // container. We need to let it walk through all fragmentainer groups in one go, or we'd

- // miss the column boundaries between each fragmentainer group. We need to record space

- // shortage there too.

+ // Establish an inner shortage finder for this column set in the inner

+ // multicol container. We need to let it walk through all fragmentainer

+ // groups in one go, or we'd miss the column boundaries between each

+ // fragmentainer group. We need to record space shortage there too.

MinimumSpaceShortageFinder innerFinder(

*columnSet, columnSet->logicalTopInFlowThread(),

columnSet->logicalBottomInFlowThread());

@@ -352,9 +349,10 @@ void MinimumSpaceShortageFinder::examineBoxBeforeLeaving(const LayoutBox& box) {

box.getPaginationBreakability() != LayoutBox::ForbidBreaks)

return;

- // The previous break was before a breakable block. Here's the first piece of unbreakable

- // content after / inside that block. We want to record the distance from the top of the column

- // to the bottom of this box as space shortage.

+ // The previous break was before a breakable block. Here's the first piece of

+ // unbreakable content after / inside that block. We want to record the

+ // distance from the top of the column to the bottom of this box as space

+ // shortage.

LayoutUnit logicalOffsetFromCurrentColumn =

offsetFromColumnLogicalTop(flowThreadOffset());

recordSpaceShortage(logicalOffsetFromCurrentColumn + box.logicalHeight() -

@@ -367,9 +365,9 @@ void MinimumSpaceShortageFinder::examineLine(const RootInlineBox& line) {

LayoutUnit lineTopInFlowThread = flowThreadOffset() + lineTop;

LayoutUnit lineHeight = line.lineBottomWithLeading() - lineTop;

if (m_pendingStrut != LayoutUnit::min()) {

- // The previous break was before a breakable block. Here's the first line after / inside

- // that block. We want to record the distance from the top of the column to the bottom of

- // this box as space shortage.

+ // The previous break was before a breakable block. Here's the first line

+ // after / inside that block. We want to record the distance from the top of

+ // the column to the bottom of this box as space shortage.

LayoutUnit logicalOffsetFromCurrentColumn =

offsetFromColumnLogicalTop(lineTopInFlowThread);

recordSpaceShortage(logicalOffsetFromCurrentColumn + lineHeight -

@@ -383,9 +381,10 @@ void MinimumSpaceShortageFinder::examineLine(const RootInlineBox& line) {

if (isFirstAfterBreak(lineTopInFlowThread))

recordSpaceShortage(lineHeight - line.paginationStrut());

- // Even if the line box itself fits fine inside a column, some content may overflow the line

- // box bottom (due to restrictive line-height, for instance). We should check if some portion

- // of said overflow ends up in the next column. That counts as space shortage.

+ // Even if the line box itself fits fine inside a column, some content may

+ // overflow the line box bottom (due to restrictive line-height, for

+ // instance). We should check if some portion of said overflow ends up in the

+ // next column. That counts as space shortage.

const MultiColumnFragmentainerGroup& group =

groupAtOffset(lineTopInFlowThread);

LayoutUnit lineBottomWithOverflow =